feat(rubick): rename project and add production release bundle

.env.example

@@ -0,0 +1 @@
+BRAVE_API_KEY=your-brave-api-key-here

.gitignore

@@ -0,0 +1,41 @@
+# Local env
+.env
+.env.*
+!.env.example
+.python-version
+
+# OS/editor
+.DS_Store
+
+# Python
+__pycache__/
+*.py[cod]
+.venv/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+
+# Go
+.gocache/
+/bin/
+*.test
+*.out
+
+# Local binaries
+rubick
+msn-scraper
+news-scraper
+
+# Generated outputs
+dist/
+output/
+*.db
+*.db-shm
+*.db-wal
+output_*.json
+screener_*.json
+stocks_*.json
+test_*.json
+*.har
+network_*.txt
+response.html

Makefile

@@ -0,0 +1,49 @@
+APP_NAME := rubick
+BIN_DIR := bin
+APP_BIN := $(BIN_DIR)/$(APP_NAME)
+
+.PHONY: help setup build run test test-go test-py test-live e2e release clean
+
+help:
+	@echo "Targets:"
+	@echo "  setup      Install Go/Python dependencies"
+	@echo "  build      Build CLI binary into ./bin"
+	@echo "  run        Run compiled binary: make run ARGS='msn lookup BBCA'"
+	@echo "  test       Run Go and Python tests"
+	@echo "  test-go    Run Go tests"
+	@echo "  test-py    Run Python tests"
+	@echo "  test-live  Run live network tests (requires .env and RUN_LIVE_E2E=1)"
+	@echo "  e2e        Timestamped deterministic e2e run under output/<timestamp>"
+	@echo "  release    Build distributable bundle under dist/ (VERSION=vX.Y.Z make release)"
+	@echo "  clean      Remove local build artifacts"
+
+setup:
+	go mod download
+	uv sync
+
+build:
+	mkdir -p $(BIN_DIR)
+	go build -o $(APP_BIN) ./cmd/rubick
+
+run: build
+	./$(APP_BIN) $(ARGS)
+
+test: test-go test-py
+
+test-go:
+	go test -v ./...
+
+test-py:
+	uv run python -m unittest discover -s tests -p 'test_*.py'
+
+test-live:
+	set -a; source .env; set +a; RUN_LIVE_E2E=1 go test -v ./tests/go -run TestLive
+
+e2e: build
+	set -a; source .env; set +a; bash scripts/e2e_run.sh ./$(APP_BIN)
+
+release:
+	bash scripts/release_bundle.sh $(VERSION)
+
+clean:
+	rm -rf $(BIN_DIR)

README.md

@@ -0,0 +1,784 @@
+# Rubick
+
+Enterprise-ready, multi-language CLI platform for Indonesian market intelligence.
+
+This repository combines:
+- high-throughput data collection from MSN Finance (Go),
+- news discovery from Brave Search (Go),
+- article-body extraction using `newspaper` (Python),
+- structured export to JSON/CSV/XLSX (Python),
+- SQLite persistence for repeatable historical analysis.
+
+The system is built as one unified CLI with clear subcommands and strongly typed runtime boundaries so you can extend it safely without scattering code.
+
+## Why This Project Exists
+
+The goal is to solve a practical workflow problem:
+- collect Indonesian stock fundamentals and snapshots,
+- enrich stock context with real article text instead of headline-only snippets,
+- persist data in a durable local store,
+- export clean artifacts for analysis, reporting, and downstream automation.
+
+Common use cases:
+- analyst daily market snapshots,
+- watchlist intelligence pipelines,
+- historical trend extraction and spreadsheet exports,
+- scheduled ETL feeding BI/ML workloads.
+
+## Core Capabilities
+
+- Unified CLI (`rubick`) with domain commands: `msn`, `news`, `export`, `extractor`.
+- Live stock metadata and multi-endpoint stock fetch pipelines.
+- Controlled concurrency and rate limiting for network-bound tasks.
+- Python extractor process connected over Unix socket for fast IPC and language isolation.
+- SQLite-based persistence for resumable scraping runs.
+- Multiple export formats for both machine and human consumption.
+- Regression tests and live API e2e test coverage.
+
+## High-Level Architecture
+
+```mermaid
+flowchart LR
+    U[User / Scheduler] --> C[Unified CLI<br/>Go]
+
+    C --> M[MSN Workflows<br/>Go]
+    C --> N[News Workflow<br/>Go]
+    C --> E[Export Workflow<br/>Python]
+
+    M --> MSNAPI[MSN Finance APIs]
+    M --> DB[(SQLite)]
+
+    N --> BRAVE[Brave News API]
+    N --> FETCH[HTML Fetcher]
+    FETCH --> IPC[Unix Socket IPC]
+    IPC --> PX[Python Extractor<br/>newspaper]
+    N --> OUTJSON[News JSON Output]
+
+    E --> DB
+    E --> XLSX[XLSX / CSV / JSON Export Files]
+```
+
+## Runtime Data Flow
+
+### 1. MSN bulk ingestion (`msn fetch-all`)
+
+```mermaid
+sequenceDiagram
+    participant User
+    participant CLI as Go CLI
+    participant DB as SQLite
+    participant MSN as MSN API
+
+    User->>CLI: msn fetch-all --index idx30 --db output/run/stocks.db
+    CLI->>DB: start scrape_run + init progress
+    loop each stock (concurrency workers)
+        CLI->>MSN: fetch stock endpoints
+        MSN-->>CLI: payloads + statuses
+        CLI->>DB: save stock + history + news + ratios
+        CLI->>DB: update progress row
+    end
+    CLI->>DB: complete scrape_run
+    CLI-->>User: progress + summary
+```
+
+### 2. News enrichment (`news`)
+
+```mermaid
+sequenceDiagram
+    participant User
+    participant CLI as Go CLI
+    participant Brave as Brave API
+    participant Web as Article URL
+    participant Py as Python Extractor
+    participant Out as JSON File
+
+    User->>CLI: news "IHSG" --count 20
+    CLI->>Brave: search news
+    Brave-->>CLI: URL list
+    CLI->>Py: start extractor process + socket pool
+    loop each URL (workers)
+        CLI->>Web: GET page HTML
+        CLI->>Py: extract(url, html)
+        Py-->>CLI: text/status
+    end
+    CLI->>Out: write enriched JSON
+    CLI-->>User: extraction summary
+```
+
+## Repository Structure and Folder Contracts
+
+```text
+.
+├── cmd/
+│   └── rubick/      # canonical binary entrypoint
+├── internal/
+│   └── cli/                     # root command router + command implementations
+├── msn/                         # MSN domain library: client, db, types, limiter, stock universe
+├── scripts/                     # Python export scripts
+├── tests/
+│   ├── go/                      # Go CLI regression + live network e2e tests
+│   └── test_export_simple.py    # Python exporter tests
+├── extractor.py                 # Python unix-socket extraction service
+├── main.go                      # compatibility entrypoint for local dev only
+├── pyproject.toml               # Python deps and tooling
+├── go.mod / go.sum              # Go module deps
+└── README.md
+```
+
+Folder responsibilities:
+
+| Path | Responsibility | Extension Rule |
+|---|---|---|
+| `cmd/rubick` | binary entrypoint only | keep thin; no business logic |
+| `internal/cli` | command parsing, orchestration, runtime coordination | add new command handlers here |
+| `msn` | data-source domain package and persistence internals | keep API/service-specific logic here |
+| `scripts` | Python export implementations | each exporter should be independent CLI |
+| `tests/go` | end-to-end and CLI behavior tests | test via public CLI behavior, not internals |
+| `tests` | Python unit tests | one test module per script/component |
+
+## Language Boundary (Go + Python)
+
+Go is used for:
+- CLI UX,
+- concurrency and throughput,
+- networking and orchestration,
+- SQLite ingestion flows.
+
+Python is used for:
+- article extraction where ecosystem libraries are stronger,
+- export formatting (especially XLSX convenience).
+
+IPC contract:
+- transport: Unix domain socket,
+- framing: 4-byte big-endian length + JSON payload,
+- request shape: `{ "url": string, "html": string }`,
+- response shape: `{ "text": string, "status": "ok|failed", "error"?: string }`.
+
+Reliability safeguards already implemented:
+- per-run unique socket path to prevent collision,
+- deadline-aware socket calls,
+- full-frame read/write (`ReadFull` semantics),
+- unhealthy pooled connections are closed/replaced,
+- extractor process group termination and socket file cleanup.
+
+## Getting Started
+
+## Prerequisites
+
+- Go `1.25+`
+- Python `3.12+`
+- `uv` for Python environment/dependency management
+
+## Install
+
+```bash
+make setup
+make build
+```
+
+Manual equivalent:
+
+```bash
+go mod download
+uv sync
+mkdir -p bin
+go build -o bin/rubick ./cmd/rubick
+```
+
+## Environment
+
+Create `.env` for Brave-powered news commands:
+
+```bash
+cp .env.example .env
+# edit .env
+# BRAVE_API_KEY=your_key_here
+```
+
+## Running the CLI
+
+```bash
+# production/dev standard
+./bin/rubick <command> [options]
+```
+
+Developer-only shortcut (not recommended for operational runbooks):
+
+```bash
+go run ./cmd/rubick <command> [options]
+```
+
+## Command Catalog
+
+Root commands:
+
+| Command | Purpose | Output |
+|---|---|---|
+| `msn` | MSN finance workflows (`screener`, `fetch`, `fetch-all`, `lookup`) | JSON + SQLite |
+| `news` | Brave search + article extraction | JSON |
+| `export` | Python exports (`dashboard`, `history`, `simple`) | XLSX/CSV/JSON |
+| `extractor` | run extractor service directly (advanced/debug) | socket server |
+
+## Command Reference (Detailed)
+
+### `msn screener`
+
+Find stocks using preset screener filters.
+
+```bash
+./bin/rubick msn screener --region id --filter top-performers --limit 20 --output output/screener.json
+```
+
+Arguments:
+
+| Flag | Expected Value | Default | Validation | What It Does |
+|---|---|---|---|---|
+| `--region` | region code (`id`) | `id` | non-empty | target market region for screener query |
+| `--filter` | one preset from list below | `large-cap` | must map to known filter | selects screener criteria |
+| `--limit` | integer `>= 1` | `50` | strict integer and min bound | max rows returned |
+| `--output`, `-o` | file path | `screener_YYYYMMDD.json` | writable path | output JSON location |
+
+Supported filter presets:
+- `top-performers`
+- `worst-performers`
+- `high-dividend`
+- `low-pe`
+- `52w-high`
+- `52w-low`
+- `high-volume`
+- `large-cap`
+
+Expected output example:
+
+```json
+{
+  "filter": "top-performers",
+  "region": "id",
+  "generated_at": "2026-03-06T02:39:47Z",
+  "total": 20,
+  "stocks": [
+    {
+      "id": "bn91jc",
+      "symbol": "BBCA",
+      "name": "Bank Cntrl Asia",
+      "price": 9000.0,
+      "price_change_pct": 1.2
+    }
+  ]
+}
+```
+
+Variations:
+
+```bash
+# Small deterministic sample
+./bin/rubick msn screener --region id --filter large-cap --limit 3 -o output/run/screener_top3.json
+
+# Alternate filter
+./bin/rubick msn screener --filter low-pe --limit 50
+```
+
+### `msn lookup`
+
+Resolve ticker symbols to internal MSN IDs.
+
+```bash
+./bin/rubick msn lookup BBCA BBRI TLKM
+```
+
+Arguments:
+
+| Input | Expected Value | What It Does | Output |
+|---|---|---|---|
+| positional tickers | uppercase ticker symbols | maps tickers to static IDX dictionary | table printed to stdout |
+
+Example output:
+
+```text
+Ticker   MSN ID     Company Name
+--------------------------------------------------
+BBCA     bn91jc     Bank Cntrl Asia
+BBRI     bn6wly     Bank Rakyat Indonesia
+TLKM     bn4k6h     Telkom Indonesia
+--------------------------------------------------
+Found 3/3 tickers
+```
+
+### `msn fetch`
+
+Fetch comprehensive stock data for specific IDs/tickers or screener input.
+
+```bash
+./bin/rubick msn fetch --tickers BBCA,BBRI,TLKM --concurrency 5 --output output/fetch.json
+```
+
+Arguments:
+
+| Flag | Expected Value | Default | Validation | What It Does |
+|---|---|---|---|---|
+| `--input` | path to screener JSON | none | file must exist and parse | imports stock IDs from screener output |
+| `--ids` | comma-separated IDs | none | non-empty entries | fetch by explicit MSN IDs |
+| `--tickers` | comma-separated tickers | none | unknown tickers skipped with warning | resolves ticker to MSN ID |
+| `--concurrency` | integer `>= 1` | `5` | strict integer and min bound | worker parallelism |
+| `--output`, `-o` | file path | `stocks_YYYYMMDD.json` | writable path | output JSON |
+
+Behavior notes:
+- you must provide at least one source of IDs (`--input`, `--ids`, `--tickers`),
+- duplicate IDs are deduplicated before fetch,
+- fetch status is tracked per API subsection.
+
+Expected output (truncated):
+
+```json
+{
+  "generated_at": "2026-03-06T02:40:00Z",
+  "total": 2,
+  "stocks": [
+    {
+      "id": "bn91jc",
+      "symbol": "BBCA",
+      "fetch_status": {
+        "quote": "ok",
+        "profile": "ok",
+        "financials": "ok"
+      }
+    }
+  ]
+}
+```
+
+Variations:
+
+```bash
+# By explicit IDs
+./bin/rubick msn fetch --ids bn91jc,bn6wly -o output/run/fetch_ids.json
+
+# From screener output
+./bin/rubick msn fetch --input output/run/screener_top3.json --concurrency 2 -o output/run/fetch_from_screener.json
+```
+
+### `msn fetch-all`
+
+Bulk ingest index constituents into SQLite with progress tracking.
+
+```bash
+./bin/rubick msn fetch-all --index idx30 --db output/stocks.db --rps 20 --delay 100-500 --concurrency 3
+```
+
+Arguments:
+
+| Flag | Expected Value | Default | Validation | What It Does |
+|---|---|---|---|---|
+| `--db` | sqlite file path | `output/stocks.db` | writable path | target DB |
+| `--index` | `all` / `lq45` / `idx30` / `idx80` | `all` | must be known, unknown falls back to all | stock universe scope |
+| `--proxy` | proxy URL | empty | URL format checked by client path | route requests through proxy |
+| `--concurrency` | integer `>= 1` | `5` | strict integer | worker count |
+| `--rps` | float `> 0` | `25` | strict positive | global request throttling |
+| `--delay` | `min-max` milliseconds | `100-500` | `0 <= min <= max` | jitter between requests |
+| `--retry` | integer `>= 0` | `2` | strict integer | retry attempts per stock |
+| `--limit` | integer `>= 0` | `0` (all) | strict integer | process first N stocks |
+| `--resume` | no value | off | flag | continue incomplete run |
+
+What it writes:
+- `stocks`
+- `price_history`
+- `ratios_history`
+- `news`
+- `sentiment_history`
+- `scrape_runs`
+- `scrape_progress`
+
+Expected terminal progress:
+
+```text
+Fetch-All Configuration:
+  Database: output/run/stocks.db
+  Index: idx30
+  Concurrency: 2 workers
+  Rate limit: 10.0 req/sec
+  Delay: 100-150 ms
+Started run #1
+Pending: 3 stocks to process
+[1/3] ADRO - 8 APIs succeeded
+[2/3] ASII - 8 APIs succeeded
+[3/3] GOTO - 8 APIs succeeded
+=== Run #1 Completed ===
+```
+
+Variations:
+
+```bash
+# Deterministic mini run for test
+./bin/rubick msn fetch-all --index idx30 --limit 3 --db output/run/stocks.db --rps 10 --delay 100-150 --concurrency 2
+
+# Resume interrupted batch
+./bin/rubick msn fetch-all --index idx80 --db output/prod/stocks.db --resume
+```
+
+### `news`
+
+Search Brave News and extract full article text from each result.
+
+```bash
+./bin/rubick news "IHSG stock market" --from 2026-03-01 --to 2026-03-05 --count 20 --concurrency 10 --output output/news.json
+```
+
+Arguments:
+
+| Flag | Expected Value | Default | Validation | What It Does |
+|---|---|---|---|---|
+| positional `<query>` | free-text query | required | non-empty | base search query |
+| `--from` | `YYYY-MM-DD` | now - 7d | valid date | start date |
+| `--to` | `YYYY-MM-DD` | today | valid date and `from <= to` | end date |
+| `--count` | integer `>= 1` | `20` | strict integer | result count requested |
+| `--concurrency` | integer `>= 1` | `10` | strict integer | worker count for fetch/extract |
+| `--output`, `-o` | json path | `output_YYYYMMDD.json` | writable path | final enriched output |
+| `--stock` | no value | off | flag | transforms comma terms into IDX-centric boolean query |
+
+Environment:
+
+| Variable | Required | Used By | Purpose |
+|---|---|---|---|
+| `BRAVE_API_KEY` | yes for `news` | Go brave client | authenticate Brave Search API calls |
+
+Expected output sample:
+
+```json
+{
+  "query": "IHSG",
+  "generated_at": "2026-03-06T02:39:47Z",
+  "results": [
+    {
+      "title": "...",
+      "url": "https://...",
+      "description": "...",
+      "page_age": "1d",
+      "text": "full extracted body text ...",
+      "fetch_status": "ok",
+      "extract_status": "ok"
+    }
+  ]
+}
+```
+
+Variations:
+
+```bash
+# Plain query
+./bin/rubick news IHSG --count 5 -o output/run/news_plain.json
+
+# Stock-mode query builder
+./bin/rubick news "BBCA,Bank Central Asia" --stock --from 2026-03-01 --to 2026-03-05 --count 10 -o output/run/news_stock.json
+
+# Lower concurrency for constrained hosts
+./bin/rubick news IHSG --count 10 --concurrency 2
+```
+
+### `export dashboard`
+
+Create dashboard-oriented workbook from SQLite.
+
+```bash
+./bin/rubick export dashboard --db output/stocks.db --output output/dashboard.xlsx
+```
+
+Arguments:
+
+| Flag | Expected Value | Required | Purpose |
+|---|---|---|---|
+| `--db` | SQLite path | yes | source database |
+| `--output` | `.xlsx` path | yes | generated workbook |
+
+### `export history`
+
+Create history-oriented workbook from SQLite.
+
+```bash
+./bin/rubick export history --db output/stocks.db --output output/history.xlsx
+```
+
+Arguments:
+
+| Flag | Expected Value | Required | Purpose |
+|---|---|---|---|
+| `--db` | SQLite path | yes | source database |
+| `--output` | `.xlsx` path | yes | generated workbook |
+
+### `export simple`
+
+Lightweight table export for automation and quick inspection.
+
+```bash
+./bin/rubick export simple --db output/stocks.db --format csv --output output/simple_csv
+```
+
+Arguments:
+
+| Flag | Expected Value | Required | What It Does |
+|---|---|---|---|
+| `--db` | SQLite path | yes | source DB |
+| `--format` | `json` / `csv` / `xlsx` | yes | output encoding |
+| `--output`, `-o` | directory (json/csv) or file (xlsx) | yes | destination |
+| `--tables` | comma-separated table list | no | export subset |
+
+Default table set:
+- `stocks`
+- `price_history`
+- `ratios_history`
+- `news`
+- `sentiment_history`
+- `scrape_runs`
+- `scrape_progress`
+
+Variations:
+
+```bash
+# JSON folder export
+./bin/rubick export simple --db output/run/stocks.db --format json --output output/run/simple_json
+
+# XLSX single workbook
+./bin/rubick export simple --db output/run/stocks.db --format xlsx --output output/run/simple.xlsx
+
+# Table subset
+./bin/rubick export simple --db output/run/stocks.db --format csv --tables stocks,news --output output/run/simple_subset
+```
+
+### `extractor` (advanced)
+
+Run Python extractor server directly for debugging/local integration.
+
+```bash
+./bin/rubick extractor --socket /tmp/extractor.sock
+```
+
+Arguments:
+
+| Flag | Expected Value | Required | Purpose |
+|---|---|---|---|
+| `--socket` | unix socket path | yes | bind location |
+
+## Deterministic End-to-End Run (Timestamped)
+
+Use this for repeatable smoke validation and artifact capture:
+
+```bash
+TS=$(date +%Y%m%d-%H%M%S)
+mkdir -p output/$TS
+
+# 1) Small stock ingestion
+./bin/rubick msn fetch-all --index idx30 --limit 3 --db output/$TS/stocks.db --rps 10 --delay 100-150 --concurrency 2
+
+# 2) News extraction
+./bin/rubick news IHSG --from 2026-03-01 --to 2026-03-05 --count 2 --concurrency 2 --output output/$TS/news.json
+
+# 3) Exports
+./bin/rubick export simple --db output/$TS/stocks.db --format json --output output/$TS/simple_json
+./bin/rubick export simple --db output/$TS/stocks.db --format csv --output output/$TS/simple_csv
+./bin/rubick export simple --db output/$TS/stocks.db --format xlsx --output output/$TS/simple.xlsx
+./bin/rubick export dashboard --db output/$TS/stocks.db --output output/$TS/dashboard.xlsx
+./bin/rubick export history --db output/$TS/stocks.db --output output/$TS/history.xlsx
+```
+
+## Testing Strategy
+
+### Go tests
+
+```bash
+# Full suite (includes tests/go)
+go test -v ./...
+
+# Focused CLI regression + live tests
+go test -v ./tests/go
+```
+
+For CI and local repeatability, prefer:
+
+```bash
+make test
+```
+
+### Live network e2e tests
+
+```bash
+set -a; source .env; set +a
+RUN_LIVE_E2E=1 go test -v ./tests/go -run TestLive
+```
+
+Behavior note:
+- tests treat transient network errors (DNS timeout, temporary connectivity, 429) as skippable for live-only coverage.
+
+### Python tests
+
+```bash
+uv run python -m unittest discover -s tests -p 'test_*.py'
+```
+
+
+## Release Bundle
+
+Create a distributable artifact that includes:
+- compiled `rubick` binary,
+- `extractor.py`,
+- Python export scripts (`scripts/export_*.py`),
+- `pyproject.toml` and `uv.lock`,
+- `.env.example`, `README.md`, and install instructions.
+
+```bash
+# auto version from git tag/commit
+make release
+
+# explicit version
+VERSION=v1.0.0 make release
+```
+
+Output artifacts:
+- `dist/rubick_<version>_<os>_<arch>/`
+- `dist/rubick_<version>_<os>_<arch>.tar.gz`
+- `dist/rubick_<version>_<os>_<arch>.zip`
+
+Bundle runtime setup:
+
+```bash
+cd dist/rubick_<version>_<os>_<arch>
+uv sync --frozen
+./bin/rubick --help
+```
+
+## Build and Run Profiles
+
+| Profile | Command | When To Use |
+|---|---|---|
+| Local developer iteration | `go run ./cmd/rubick ...` | rapid code changes before rebuilding |
+| Normal local/CI usage | `./bin/rubick ...` | default path for scripts and tests |
+| Release artifact | `go build -o bin/rubick ./cmd/rubick` | reproducible deployable binary |
+
+## Automation Targets
+
+`Makefile` commands:
+
+| Target | Action |
+|---|---|
+| `make setup` | install Go + Python dependencies |
+| `make build` | compile `bin/rubick` |
+| `make run ARGS='...'` | run compiled binary with arguments |
+| `make test` | run Go + Python tests |
+| `make test-live` | run live e2e tests with `.env` |
+| `make e2e` | run deterministic timestamped end-to-end workflow |
+
+## Operational Characteristics
+
+### Performance
+
+- `msn fetch-all` throughput controlled by:
+  - worker count (`--concurrency`),
+  - global RPS (`--rps`),
+  - jitter (`--delay`),
+  - retries (`--retry`).
+- `news` throughput controlled by:
+  - Brave result count (`--count`),
+  - concurrent fetch/extract workers (`--concurrency`).
+
+Tuning guidance:
+- start conservative (`--concurrency 2`, `--rps 10`) and increase gradually,
+- use lower concurrency on unstable networks,
+- avoid high parallelism if extractor host is resource-constrained.
+
+### Reliability
+
+- resumable runs via `scrape_runs` and `scrape_progress`,
+- no socket-path collision due to per-process unique socket names,
+- pooled socket self-healing on I/O error,
+- explicit process-group shutdown for extractor.
+
+### Failure Modes and Recovery
+
+| Symptom | Likely Cause | Recovery |
+|---|---|---|
+| `failed to search` in `news` | missing/invalid `BRAVE_API_KEY` or API/network issue | check `.env`, retry with smaller `--count` |
+| extractor startup timeout | Python env/deps not ready | run `uv sync`, retry command |
+| `failed to open database` | invalid DB path/permissions | use writable path under `output/` |
+| high fail count in `fetch-all` | API throttling/network instability | reduce `--concurrency`, reduce `--rps`, increase retries |
+
+## Technical Implementation Notes
+
+### Internal command model
+
+- `cmd/rubick/main.go` delegates to `internal/cli.Run(args)`.
+- each top-level command has dedicated handler logic.
+- help-path exit code is `0`; invalid usage and command errors return non-zero.
+
+### Data model and storage
+
+SQLite tables persist both point-in-time and historical views. Export scripts consume the same DB, which makes the workflow reproducible and scriptable.
+
+### Security and secret handling
+
+- never hardcode API keys,
+- keep `.env` out of source control,
+- rotate `BRAVE_API_KEY` periodically,
+- prefer environment injection in CI/CD rather than plaintext files.
+
+## Extending the Codebase
+
+### Add a new data source command
+
+1. Add a new handler in `internal/cli`.
+2. Register command routing in `Run(args)`.
+3. Keep source-specific logic in a dedicated package (similar to `msn/`).
+4. Add CLI regression tests in `tests/go`.
+5. Add docs + deterministic sample in README.
+
+### Add a new Python-assisted feature
+
+1. Put Python implementation in `scripts/` or standalone server file.
+2. Keep wire contract small and explicit if IPC is needed.
+3. Add input/output schema tests in `tests/`.
+4. Expose feature through one unified CLI command, not ad-hoc scripts.
+
+### Go-only vs Python-only decisions
+
+Use Go when:
+- you need high-concurrency network orchestration,
+- strong type-safety and binary distribution matter.
+
+Use Python when:
+- library ecosystem is materially better for the task,
+- rapid iteration of parsing/formatting logic is needed.
+
+Hybrid rule:
+- keep orchestration in Go,
+- isolate Python to specialized components with strict IPC contracts,
+- document protocol and lifecycle clearly.
+
+## Example Production-Like Workflow
+
+```bash
+TS=$(date +%Y%m%d-%H%M%S)
+BASE=output/$TS
+mkdir -p $BASE
+
+# Collect core market dataset
+./bin/rubick msn fetch-all --index idx80 --db $BASE/stocks.db --rps 15 --delay 150-400 --concurrency 4
+
+# Enrich with news for macro keyword
+./bin/rubick news "IHSG OR Jakarta Composite Index" --from 2026-03-01 --to 2026-03-06 --count 30 --concurrency 6 --output $BASE/news_macro.json
+
+# Export for analyst consumption
+./bin/rubick export dashboard --db $BASE/stocks.db --output $BASE/dashboard.xlsx
+./bin/rubick export history --db $BASE/stocks.db --output $BASE/history.xlsx
+./bin/rubick export simple --db $BASE/stocks.db --format csv --output $BASE/csv
+```
+
+## Glossary
+
+| Term | Meaning |
+|---|---|
+| MSN ID | internal identifier used by MSN endpoints |
+| Screener | preset query to select stocks by criteria |
+| Fetch-all run | bulk ingestion execution tracked in DB |
+| Extractor | Python process that converts raw HTML to article text |
+| Stock mode query | boolean query generated from comma-separated stock terms |
+
+## License / Internal Policy
+
+Add your repository license and internal data-usage policy here if this project is used in production or shared environments.

TEST_REPORT.md

@@ -0,0 +1,87 @@
+# Unified CLI Test Report
+
+Date: 2026-03-06
+
+## Summary
+
+- Unified CLI commands tested: `msn`, `news`, `export`, `extractor`
+- Parser/validation tested with valid and invalid arguments
+- Error handling standardized: command modules return errors; root handles exit code
+- Remaining hard exit: only top-level `main()` calls `os.Exit(runRoot(...))`
+
+## Command Matrix (Representative)
+
+### Root
+
+- `go run .` -> usage printed, exit `1`
+- `go run . --help` -> usage printed, exit `1`
+- `go run . unknown` -> usage + `unknown command`, exit `1`
+
+### MSN
+
+- `go run . msn --help` -> MSN usage, exit `1`
+- `go run . msn badcmd` -> error unknown subcommand, exit `1`
+- `go run . msn lookup BBCA TLKM XXXX` -> success, resolves BBCA/TLKM, unknown marked not found, exit `0`
+
+#### `msn screener`
+- `--help` -> screener usage, exit `0`
+- `--region` (missing value) -> error, exit `1`
+- `--limit nope` -> parse error, exit `1`
+- `--filter invalid` -> validation error, exit `1`
+- valid invocation attempted -> DNS failure to `assets.msn.com` in this environment, exit `1`
+
+#### `msn fetch`
+- `--help` -> fetch usage, exit `0`
+- no id source -> validation error, exit `1`
+- `--input` missing value -> error, exit `1`
+- `--tickers` missing value -> error, exit `1`
+- `--concurrency nope` -> parse error, exit `1`
+- `--input` missing file -> FS error, exit `1`
+- valid with tickers -> success, output `/tmp/fetch_tickers.json`, exit `0`
+- valid with ids -> success, output `/tmp/fetch_ids.json`, exit `0`
+
+#### `msn fetch-all`
+- `--help` -> fetch-all usage, exit `0`
+- `--db` missing value -> error, exit `1`
+- `--delay oops` -> format error, exit `1`
+- `--rps nope` -> parse error, exit `1`
+- valid `--index weird --limit 1` -> fallback to all, success, `/tmp/fetchall_weird.db`, exit `0`
+- valid `--index idx30 --limit 1` -> success, `/tmp/fetchall_idx30.db`, exit `0`
+
+### News
+
+- `go run . news --help` -> news usage, exit `1`
+- valid news request attempted -> fails with missing `BRAVE_API_KEY` in current shell env, exit `1`
+- `--from bad-date` -> parse error, exit `1`
+- `--to bad-date` -> parse error, exit `1`
+- `--count nope` -> parse error, exit `1`
+- `--concurrency nope` -> parse error, exit `1`
+- `--output` missing value -> error, exit `1`
+
+### Export
+
+- `go run . export --help` -> usage, exit `1`
+- `go run . export badtarget` -> validation error, exit `1`
+- `go run . export dashboard --db /tmp/fetchall_idx30.db --output /tmp/dashboard_refactor.xlsx` -> success, exit `0`
+- `go run . export history --db /tmp/fetchall_idx30.db --output /tmp/history_refactor.xlsx` -> success, exit `0`
+
+### Extractor
+
+- `go run . extractor` -> usage, exit `1`
+- `go run . extractor --help` -> usage, exit `1`
+
+## Produced Artifacts
+
+- `/tmp/fetch_one.json`
+- `/tmp/fetch_tickers.json`
+- `/tmp/fetch_ids.json`
+- `/tmp/fetchall_weird.db`
+- `/tmp/fetchall_idx30.db`
+- `/tmp/dashboard_refactor.xlsx`
+- `/tmp/history_refactor.xlsx`
+
+## Notes
+
+- Network/API behavior is environment-dependent (DNS and API key availability).
+- `news` command requires `BRAVE_API_KEY` in the running shell environment.
+- CLI behavior now consistently reports parse/validation/runtime errors without deep `log.Fatal` exits.

extractor.py

@@ -0,0 +1,165 @@
+#!/usr/bin/env python3
+"""
+Article text extractor using newspaper4k.
+Runs as an asyncio Unix socket server for IPC with Go.
+"""
+
+import asyncio
+import argparse
+import json
+import signal
+import struct
+import sys
+import warnings
+from pathlib import Path
+
+from newspaper import Article
+
+# Suppress asyncio warnings on forced shutdown
+warnings.filterwarnings("ignore", category=RuntimeWarning, message=".*coroutine.*")
+
+# Protocol: 4-byte length prefix (big-endian uint32) + JSON payload
+HEADER_SIZE = 4
+
+
+async def extract_text(url: str, html: str) -> dict:
+    """Extract article text from HTML using newspaper4k."""
+    try:
+        article = Article(url)
+        article.download(input_html=html)
+        article.parse()
+
+        text = article.text.strip()
+        if not text:
+            return {"text": "", "status": "failed", "error": "empty_text"}
+
+        return {"text": text, "status": "ok"}
+    except Exception as e:
+        return {"text": "", "status": "failed", "error": str(e)}
+
+
+async def read_message(reader: asyncio.StreamReader) -> dict | None:
+    """Read a length-prefixed JSON message."""
+    header = await reader.readexactly(HEADER_SIZE)
+    if not header:
+        return None
+
+    length = struct.unpack(">I", header)[0]
+    data = await reader.readexactly(length)
+    return json.loads(data.decode("utf-8"))
+
+
+async def write_message(writer: asyncio.StreamWriter, msg: dict) -> None:
+    """Write a length-prefixed JSON message."""
+    data = json.dumps(msg).encode("utf-8")
+    header = struct.pack(">I", len(data))
+    writer.write(header + data)
+    await writer.drain()
+
+
+async def handle_client(reader: asyncio.StreamReader, writer: asyncio.StreamWriter):
+    """Handle a single client connection."""
+    try:
+        while True:
+            try:
+                msg = await read_message(reader)
+            except asyncio.IncompleteReadError:
+                break
+            except Exception:
+                break
+
+            if msg is None:
+                break
+
+            # Check for shutdown command
+            if msg.get("command") == "shutdown":
+                await write_message(writer, {"status": "ok", "message": "shutting_down"})
+                break
+
+            # Extract text
+            url = msg.get("url", "")
+            html = msg.get("html", "")
+            result = await extract_text(url, html)
+            await write_message(writer, result)
+
+    except Exception:
+        pass  # Silently handle errors on shutdown
+    finally:
+        try:
+            writer.close()
+            await writer.wait_closed()
+        except Exception:
+            pass
+
+
+async def run_server(socket_path: str):
+    """Run the Unix socket server."""
+    # Remove existing socket file if present
+    socket_file = Path(socket_path)
+    if socket_file.exists():
+        socket_file.unlink()
+
+    server = await asyncio.start_unix_server(handle_client, path=socket_path)
+
+    # Signal readiness to parent process
+    print(f"READY:{socket_path}", flush=True)
+
+    async with server:
+        try:
+            await server.serve_forever()
+        except asyncio.CancelledError:
+            pass
+        except Exception:
+            pass
+
+    # Cleanup socket file
+    if socket_file.exists():
+        socket_file.unlink()
+
+
+def main():
+    # Suppress task destroyed warnings
+    import logging
+    logging.getLogger("asyncio").setLevel(logging.CRITICAL)
+
+    parser = argparse.ArgumentParser(description="Article text extractor server")
+    parser.add_argument("--socket", required=True, help="Unix socket path")
+    args = parser.parse_args()
+
+    socket_file = Path(args.socket)
+
+    def cleanup():
+        if socket_file.exists():
+            socket_file.unlink()
+
+    # Handle signals for graceful shutdown
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+
+    for sig in (signal.SIGTERM, signal.SIGINT):
+        loop.add_signal_handler(sig, loop.stop)
+
+    try:
+        loop.run_until_complete(run_server(args.socket))
+    except (KeyboardInterrupt, RuntimeError):
+        pass
+    finally:
+        # Cancel all pending tasks
+        pending = asyncio.all_tasks(loop)
+        for task in pending:
+            task.cancel()
+
+        # Run until all tasks are cancelled
+        if pending:
+            try:
+                loop.run_until_complete(asyncio.gather(*pending, return_exceptions=True))
+            except RuntimeError:
+                # Event loop can be stopped by signal handlers during shutdown.
+                pass
+
+        loop.close()
+        cleanup()
+
+
+if __name__ == "__main__":
+    main()

go.mod

@@ -0,0 +1,27 @@
+module rubick
+
+go 1.25.5
+
+require (
+	github.com/enetx/g v1.0.210
+	github.com/enetx/surf v1.0.187
+	github.com/joho/godotenv v1.5.1
+	github.com/mattn/go-sqlite3 v1.14.34
+)
+
+require (
+	github.com/andybalholm/brotli v1.2.0 // indirect
+	github.com/enetx/http v1.0.25 // indirect
+	github.com/enetx/http2 v1.0.25 // indirect
+	github.com/enetx/http3 v1.0.7 // indirect
+	github.com/enetx/iter v0.0.0-20250912135656-f1583323588f // indirect
+	github.com/enetx/utls v0.0.0-20260115181616-c525a7d559c8 // indirect
+	github.com/klauspost/compress v1.18.4 // indirect
+	github.com/quic-go/qpack v0.6.0 // indirect
+	github.com/quic-go/quic-go v0.59.0 // indirect
+	github.com/wzshiming/socks5 v0.7.0 // indirect
+	golang.org/x/crypto v0.48.0 // indirect
+	golang.org/x/net v0.50.0 // indirect
+	golang.org/x/sys v0.41.0 // indirect
+	golang.org/x/text v0.34.0 // indirect
+)

go.sum

@@ -0,0 +1,48 @@
+github.com/andybalholm/brotli v1.2.0 h1:ukwgCxwYrmACq68yiUqwIWnGY0cTPox/M94sVwToPjQ=
+github.com/andybalholm/brotli v1.2.0/go.mod h1:rzTDkvFWvIrjDXZHkuS16NPggd91W3kUSvPlQ1pLaKY=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/enetx/g v1.0.210 h1:V5Z9iAUwgW5Ou1hOHG2Fl/0EkuUnGIthj0U4wLLTOA4=
+github.com/enetx/g v1.0.210/go.mod h1:6/HQeRy+tIJVGY+oRPQVJ/vOSruAi0aldFggurT6jBY=
+github.com/enetx/http v1.0.25 h1:WE1+KEnjXIHP+hxbnTmAZ0p87UEmiHaE4CAQDLzL5C4=
+github.com/enetx/http v1.0.25/go.mod h1:1f4mytfF/SfjATEJnynpwGS6aa1ALjb8DtmYgFVblY0=
+github.com/enetx/http2 v1.0.25 h1:PSZN0I7j6Rzo3+rA6UE08xZITitBFSS7miSTBxedKFo=
+github.com/enetx/http2 v1.0.25/go.mod h1:t54ex5HIS8V1+2j6cvEOv6umlrHsbUPFKQ54nYB58Nk=
+github.com/enetx/http3 v1.0.7 h1:daFhveKBtv8rRallCjaHErzzSHIrq07ovoSvVkvhcMM=
+github.com/enetx/http3 v1.0.7/go.mod h1:sqpVGZ9F1/wCiW6sjBUS2errKAh3SUYn6VlWE7LL6KM=
+github.com/enetx/iter v0.0.0-20250912135656-f1583323588f h1:GUW+4AWfECIEJ9oAxgEAVGCpaozMCjRiUYnuR6Q0bCQ=
+github.com/enetx/iter v0.0.0-20250912135656-f1583323588f/go.mod h1:oMZN8hGLUpi7QBlMEUqailocNy0NFAO/7Lu+Nwh9HMM=
+github.com/enetx/surf v1.0.187 h1:EQj9jj7RFXXYyicrNW3D77XAWyl8Y8vh4mPmHy8+L6I=
+github.com/enetx/surf v1.0.187/go.mod h1:nn2yuyWDc7r1qcJ68C4wtebN8v+KJdH8DINFcjOWtZE=
+github.com/enetx/utls v0.0.0-20260115181616-c525a7d559c8 h1:jN2LdG4CG7cXOMAkQVDencj67Gdt7FFwDP1UaPcYyV8=
+github.com/enetx/utls v0.0.0-20260115181616-c525a7d559c8/go.mod h1:jsHaW4RX6DteSbAHT/pW7iJxv7YXLf2NTr3k9PsmXoc=
+github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0=
+github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4=
+github.com/klauspost/compress v1.18.4 h1:RPhnKRAQ4Fh8zU2FY/6ZFDwTVTxgJ/EMydqSTzE9a2c=
+github.com/klauspost/compress v1.18.4/go.mod h1:R0h/fSBs8DE4ENlcrlib3PsXS61voFxhIs2DeRhCvJ4=
+github.com/mattn/go-sqlite3 v1.14.34 h1:3NtcvcUnFBPsuRcno8pUtupspG/GM+9nZ88zgJcp6Zk=
+github.com/mattn/go-sqlite3 v1.14.34/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/quic-go/qpack v0.6.0 h1:g7W+BMYynC1LbYLSqRt8PBg5Tgwxn214ZZR34VIOjz8=
+github.com/quic-go/qpack v0.6.0/go.mod h1:lUpLKChi8njB4ty2bFLX2x4gzDqXwUpaO1DP9qMDZII=
+github.com/quic-go/quic-go v0.59.0 h1:OLJkp1Mlm/aS7dpKgTc6cnpynnD2Xg7C1pwL6vy/SAw=
+github.com/quic-go/quic-go v0.59.0/go.mod h1:upnsH4Ju1YkqpLXC305eW3yDZ4NfnNbmQRCMWS58IKU=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
+github.com/wzshiming/socks5 v0.7.0 h1:euJ+U48WrvVngi+opC8vAnpZ5sK12y1C2hPvb1f48Rg=
+github.com/wzshiming/socks5 v0.7.0/go.mod h1:BvCAqlzocQN5xwLjBZDBbvWlrx8sCYSSbHEOf2wZgT0=
+github.com/xyproto/randomstring v1.0.5 h1:YtlWPoRdgMu3NZtP45drfy1GKoojuR7hmRcnhZqKjWU=
+github.com/xyproto/randomstring v1.0.5/go.mod h1:rgmS5DeNXLivK7YprL0pY+lTuhNQW3iGxZ18UQApw/E=
+go.uber.org/mock v0.5.2 h1:LbtPTcP8A5k9WPXj54PPPbjcI4Y6lhyOZXn+VS7wNko=
+go.uber.org/mock v0.5.2/go.mod h1:wLlUxC2vVTPTaE3UD51E0BGOAElKrILxhVSDYQLld5o=
+golang.org/x/crypto v0.48.0 h1:/VRzVqiRSggnhY7gNRxPauEQ5Drw9haKdM0jqfcCFts=
+golang.org/x/crypto v0.48.0/go.mod h1:r0kV5h3qnFPlQnBSrULhlsRfryS2pmewsg+XfMgkVos=
+golang.org/x/net v0.50.0 h1:ucWh9eiCGyDR3vtzso0WMQinm2Dnt8cFMuQa9K33J60=
+golang.org/x/net v0.50.0/go.mod h1:UgoSli3F/pBgdJBHCTc+tp3gmrU4XswgGRgtnwWTfyM=
+golang.org/x/sys v0.41.0 h1:Ivj+2Cp/ylzLiEU89QhWblYnOE9zerudt9Ftecq2C6k=
+golang.org/x/sys v0.41.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
+golang.org/x/text v0.34.0 h1:oL/Qq0Kdaqxa1KbNeMKwQq0reLCCaFtqu2eNuSeNHbk=
+golang.org/x/text v0.34.0/go.mod h1:homfLqTYRFyVYemLBFl5GgL/DWEiH5wcsQ5gSh1yziA=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

internal/cli/brave.go

@@ -0,0 +1,129 @@
+package cli
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/url"
+	"os"
+	"time"
+
+	"github.com/enetx/g"
+	"github.com/enetx/surf"
+)
+
+// BraveResult represents a single news result from Brave Search API
+type BraveResult struct {
+	Title       string `json:"title"`
+	URL         string `json:"url"`
+	Description string `json:"description"`
+	PageAge     string `json:"page_age"`
+}
+
+// BraveNewsResponse represents the Brave News Search API response
+type BraveNewsResponse struct {
+	Results []struct {
+		Title       string `json:"title"`
+		URL         string `json:"url"`
+		Description string `json:"description"`
+		Age         string `json:"age"`
+	} `json:"results"`
+}
+
+// SearchConfig holds search parameters
+type SearchConfig struct {
+	Query string
+	From  time.Time
+	To    time.Time
+	Count int
+}
+
+// SearchBrave queries the Brave News Search API
+// Uses dedicated News endpoint: GET /res/v1/news/search
+func SearchBrave(client *surf.Client, config SearchConfig) ([]BraveResult, error) {
+	apiKey := os.Getenv("BRAVE_API_KEY")
+	if apiKey == "" {
+		return nil, fmt.Errorf("BRAVE_API_KEY environment variable not set")
+	}
+
+	// Build query parameters
+	params := url.Values{}
+	params.Set("q", config.Query)
+	params.Set("count", fmt.Sprintf("%d", config.Count))
+	params.Set("freshness", fmt.Sprintf("%sto%s",
+		config.From.Format("2006-01-02"),
+		config.To.Format("2006-01-02"),
+	))
+
+	apiURL := fmt.Sprintf("https://api.search.brave.com/res/v1/news/search?%s", params.Encode())
+
+	// Use plain client for API calls (no Chrome impersonation which overrides headers)
+	apiClient := surf.NewClient()
+	defer apiClient.CloseIdleConnections()
+
+	resp := apiClient.Get(g.String(apiURL)).
+		SetHeaders("Accept", "application/json").
+		SetHeaders("X-Subscription-Token", apiKey).
+		// Jakarta, Indonesia location headers
+		SetHeaders("X-Loc-Lat", "-6.2088").
+		SetHeaders("X-Loc-Long", "106.8456").
+		SetHeaders("X-Loc-Timezone", "Asia/Jakarta").
+		SetHeaders("X-Loc-Country", "ID").
+		Do()
+
+	if resp.IsErr() {
+		return nil, fmt.Errorf("brave API request failed: %w", resp.Err())
+	}
+
+	r := resp.Ok()
+	if r.StatusCode != 200 {
+		body := r.Body.String().Ok().Std()
+		return nil, fmt.Errorf("brave API returned status %d: %s", r.StatusCode, body)
+	}
+
+	body := r.Body.String().Ok().Std()
+
+	var braveResp BraveNewsResponse
+	if err := json.Unmarshal([]byte(body), &braveResp); err != nil {
+		return nil, fmt.Errorf("failed to parse brave API response: %w", err)
+	}
+
+	if len(braveResp.Results) == 0 {
+		return []BraveResult{}, nil
+	}
+
+	results := make([]BraveResult, len(braveResp.Results))
+	for i, r := range braveResp.Results {
+		results[i] = BraveResult{
+			Title:       r.Title,
+			URL:         r.URL,
+			Description: r.Description,
+			PageAge:     r.Age,
+		}
+	}
+
+	return results, nil
+}
+
+// BuildStockQuery creates a boolean query for Indonesian stock news
+// Example: BuildStockQuery("MINA", "MINA Tbk") returns:
+// ("MINA" OR "MINA Tbk") AND (saham OR emiten OR "Bursa Efek Indonesia" OR BEI OR IDX)
+func BuildStockQuery(stockTerms ...string) string {
+	if len(stockTerms) == 0 {
+		return ""
+	}
+
+	// Build stock terms part
+	stockPart := "("
+	for i, term := range stockTerms {
+		if i > 0 {
+			stockPart += " OR "
+		}
+		stockPart += fmt.Sprintf(`"%s"`, term)
+	}
+	stockPart += ")"
+
+	// Indonesian stock market keywords
+	marketKeywords := `(saham OR emiten OR "Bursa Efek Indonesia" OR BEI OR IDX)`
+
+	return stockPart + " AND " + marketKeywords
+}

internal/cli/extractor.go

@@ -0,0 +1,282 @@
+package cli
+
+import (
+	"bufio"
+	"context"
+	"encoding/binary"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"sync"
+	"syscall"
+	"time"
+)
+
+// ExtractRequest is the request sent to Python extractor
+type ExtractRequest struct {
+	URL  string `json:"url"`
+	HTML string `json:"html"`
+}
+
+// ExtractResponse is the response from Python extractor
+type ExtractResponse struct {
+	Text   string `json:"text"`
+	Status string `json:"status"`
+	Error  string `json:"error,omitempty"`
+}
+
+// Extractor manages the Python extraction process and socket communication
+type Extractor struct {
+	socketPath string
+	cmd        *exec.Cmd
+	mu         sync.Mutex
+	connPool   chan net.Conn
+	poolSize   int
+	closed     bool
+}
+
+// NewExtractor creates and starts the Python extractor process
+func NewExtractor(poolSize int) (*Extractor, error) {
+	if poolSize < 1 {
+		poolSize = 1
+	}
+
+	socketPath := filepath.Join(os.TempDir(), fmt.Sprintf("stock-news-extractor-%d-%d.sock", os.Getpid(), time.Now().UnixNano()))
+
+	e := &Extractor{
+		socketPath: socketPath,
+		poolSize:   poolSize,
+		connPool:   make(chan net.Conn, poolSize),
+	}
+
+	if err := e.start(); err != nil {
+		return nil, err
+	}
+
+	return e, nil
+}
+
+// start launches the Python extractor process
+func (e *Extractor) start() error {
+	// Remove existing socket file if present
+	os.Remove(e.socketPath)
+
+	e.cmd = exec.Command("uv", "run", "python", "extractor.py", "--socket", e.socketPath)
+	e.cmd.Stderr = os.Stderr
+
+	// Create a new process group so we can kill all child processes
+	e.cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
+
+	stdout, err := e.cmd.StdoutPipe()
+	if err != nil {
+		return fmt.Errorf("failed to create stdout pipe: %w", err)
+	}
+
+	if err := e.cmd.Start(); err != nil {
+		return fmt.Errorf("failed to start python extractor: %w", err)
+	}
+
+	// Wait for ready signal from Python
+	scanner := bufio.NewScanner(stdout)
+	ready := make(chan bool, 1)
+	go func() {
+		for scanner.Scan() {
+			line := scanner.Text()
+			if strings.HasPrefix(line, "READY:") {
+				ready <- true
+				return
+			}
+		}
+		ready <- false
+	}()
+
+	select {
+	case ok := <-ready:
+		if !ok {
+			e.killProcessGroup()
+			return fmt.Errorf("python extractor failed to start")
+		}
+	case <-time.After(30 * time.Second):
+		e.killProcessGroup()
+		return fmt.Errorf("timeout waiting for python extractor to start")
+	}
+
+	// Initialize connection pool
+	for i := 0; i < e.poolSize; i++ {
+		conn, err := net.Dial("unix", e.socketPath)
+		if err != nil {
+			e.Close()
+			return fmt.Errorf("failed to connect to extractor: %w", err)
+		}
+		e.connPool <- conn
+	}
+
+	return nil
+}
+
+// killProcessGroup kills the entire process group
+func (e *Extractor) killProcessGroup() {
+	if e.cmd != nil && e.cmd.Process != nil {
+		// Kill the entire process group (negative PID)
+		pgid, err := syscall.Getpgid(e.cmd.Process.Pid)
+		if err == nil {
+			syscall.Kill(-pgid, syscall.SIGTERM)
+			time.Sleep(100 * time.Millisecond)
+			syscall.Kill(-pgid, syscall.SIGKILL)
+		}
+		e.cmd.Process.Kill()
+		e.cmd.Wait()
+	}
+}
+
+// Extract sends HTML to Python and returns extracted text
+func (e *Extractor) Extract(ctx context.Context, url, html string) (*ExtractResponse, error) {
+	// Get connection from pool
+	var conn net.Conn
+	select {
+	case conn = <-e.connPool:
+	case <-ctx.Done():
+		return nil, ctx.Err()
+	}
+
+	healthy := true
+	// Return connection to pool when done
+	defer func() {
+		if conn == nil {
+			return
+		}
+		if !e.closed && healthy {
+			e.connPool <- conn
+			return
+		}
+		_ = conn.Close()
+		if e.closed {
+			return
+		}
+		replacement, err := net.Dial("unix", e.socketPath)
+		if err != nil {
+			return
+		}
+		select {
+		case e.connPool <- replacement:
+		default:
+			_ = replacement.Close()
+		}
+	}()
+
+	if dl, ok := ctx.Deadline(); ok {
+		_ = conn.SetDeadline(dl)
+	} else {
+		_ = conn.SetDeadline(time.Now().Add(60 * time.Second))
+	}
+	defer conn.SetDeadline(time.Time{})
+
+	req := ExtractRequest{URL: url, HTML: html}
+	if err := writeMessage(conn, req); err != nil {
+		healthy = false
+		return nil, fmt.Errorf("failed to send request: %w", err)
+	}
+
+	var resp ExtractResponse
+	if err := readMessage(conn, &resp); err != nil {
+		healthy = false
+		return nil, fmt.Errorf("failed to read response: %w", err)
+	}
+
+	return &resp, nil
+}
+
+// Close shuts down the Python extractor
+func (e *Extractor) Close() error {
+	e.mu.Lock()
+	if e.closed {
+		e.mu.Unlock()
+		return nil
+	}
+	e.closed = true
+	e.mu.Unlock()
+
+	// Drain and close all connections in pool
+	done := make(chan struct{})
+	go func() {
+		for i := 0; i < e.poolSize; i++ {
+			select {
+			case conn := <-e.connPool:
+				conn.Close()
+			case <-time.After(time.Second):
+				// Timeout waiting for connection
+			}
+		}
+		close(done)
+	}()
+
+	select {
+	case <-done:
+	case <-time.After(5 * time.Second):
+		// Timeout waiting for pool drain
+	}
+
+	// Kill the process group
+	e.killProcessGroup()
+
+	// Clean up socket file
+	_ = os.Remove(e.socketPath)
+
+	return nil
+}
+
+// writeMessage writes a length-prefixed JSON message
+func writeMessage(conn net.Conn, msg interface{}) error {
+	data, err := json.Marshal(msg)
+	if err != nil {
+		return err
+	}
+
+	// Write 4-byte length prefix (big-endian)
+	header := make([]byte, 4)
+	binary.BigEndian.PutUint32(header, uint32(len(data)))
+
+	if err := writeAll(conn, header); err != nil {
+		return err
+	}
+	if err := writeAll(conn, data); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// readMessage reads a length-prefixed JSON message
+func readMessage(conn net.Conn, v interface{}) error {
+	// Read 4-byte length prefix
+	header := make([]byte, 4)
+	if _, err := io.ReadFull(conn, header); err != nil {
+		return err
+	}
+
+	length := binary.BigEndian.Uint32(header)
+
+	// Read JSON payload
+	data := make([]byte, length)
+	if _, err := io.ReadFull(conn, data); err != nil {
+		return err
+	}
+
+	return json.Unmarshal(data, v)
+}
+
+func writeAll(conn net.Conn, p []byte) error {
+	for len(p) > 0 {
+		n, err := conn.Write(p)
+		if err != nil {
+			return err
+		}
+		p = p[n:]
+	}
+	return nil
+}

internal/cli/main.go

@@ -0,0 +1,143 @@
+package cli
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+)
+
+func Run(args []string) int {
+	if len(args) == 0 {
+		printRootUsage()
+		return 1
+	}
+
+	if args[0] == "-h" || args[0] == "--help" || args[0] == "help" {
+		printRootUsage()
+		return 0
+	}
+
+	switch args[0] {
+	case "msn":
+		return runMSNCommand(args[1:])
+	case "news":
+		return runNewsCommand(args[1:])
+	case "export":
+		return runExportCommand(args[1:])
+	case "extractor":
+		return runExtractorCommand(args[1:])
+	default:
+		printRootUsage()
+		fmt.Fprintf(os.Stderr, "\nerror: unknown command: %s\n", args[0])
+		return 1
+	}
+}
+
+func printRootUsage() {
+	fmt.Fprintf(os.Stderr, `Rubick - Unified Market Intelligence CLI
+
+Usage:
+  rubick <command> [options]
+
+Commands:
+  msn        MSN finance workflows (screener, fetch, fetch-all, lookup)
+  news       Brave news search + Python text extraction
+  export     Python export tools (dashboard/history/simple)
+  extractor  Run raw Python extractor server (advanced)
+
+Examples:
+  # News mode with explicit command
+  rubick news "BBCA,Bank Central Asia" --stock --count 20
+
+  # MSN screener
+  rubick msn screener --region id --filter top-performers --limit 20 -o output/screener.json
+
+  # MSN fetch-all to SQLite
+  rubick msn fetch-all --index idx30 --db output/stocks.db --concurrency 3
+
+  # Export dashboard from SQLite
+  rubick export dashboard --db output/stocks.db --output output/dashboard.xlsx
+
+  # Export history workbook from SQLite
+  rubick export history --db output/stocks.db --output output/history.xlsx
+
+  # Export simple tables (json/csv/xlsx) from SQLite
+  rubick export simple --db output/stocks.db --format csv --output output/simple_csv
+
+  # Run extractor server directly
+  rubick extractor --socket /tmp/extractor.sock
+`)
+}
+
+func runExportCommand(args []string) int {
+	if len(args) == 0 {
+		fmt.Fprintf(os.Stderr, `Usage: rubick export <dashboard|history|simple> [script options]
+
+Examples:
+  rubick export dashboard --db output/stocks.db --output output/dashboard.xlsx
+  rubick export history --db output/stocks.db --output output/history.xlsx
+  rubick export simple --db output/stocks.db --format csv --output output/csv/
+`)
+		return 1
+	}
+
+	if args[0] == "-h" || args[0] == "--help" || args[0] == "help" {
+		fmt.Fprintf(os.Stderr, `Usage: rubick export <dashboard|history|simple> [script options]
+
+Examples:
+  rubick export dashboard --db output/stocks.db --output output/dashboard.xlsx
+  rubick export history --db output/stocks.db --output output/history.xlsx
+  rubick export simple --db output/stocks.db --format csv --output output/csv/
+`)
+		return 0
+	}
+
+	script := ""
+	switch args[0] {
+	case "dashboard":
+		script = "scripts/export_dashboard.py"
+	case "history":
+		script = "scripts/export_history.py"
+	case "simple":
+		script = "scripts/export_simple.py"
+	default:
+		fmt.Fprintf(os.Stderr, "Unknown export target: %s\n", args[0])
+		return 1
+	}
+
+	cmdArgs := append([]string{"run", "python", script}, args[1:]...)
+	return runPassthrough("uv", cmdArgs)
+}
+
+func runExtractorCommand(args []string) int {
+	if len(args) == 0 {
+		fmt.Fprintf(os.Stderr, "Usage: rubick extractor --socket /tmp/extractor.sock\n")
+		return 1
+	}
+
+	if args[0] == "-h" || args[0] == "--help" || args[0] == "help" {
+		fmt.Fprintf(os.Stderr, "Usage: rubick extractor --socket /tmp/extractor.sock\n")
+		return 0
+	}
+
+	cmdArgs := append([]string{"run", "python", "extractor.py"}, args...)
+	return runPassthrough("uv", cmdArgs)
+}
+
+func runPassthrough(bin string, args []string) int {
+	cmd := exec.Command(bin, args...)
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	cmd.Stdin = os.Stdin
+
+	if err := cmd.Run(); err != nil {
+		var exitErr *exec.ExitError
+		if errors.As(err, &exitErr) {
+			return exitErr.ExitCode()
+		}
+		fmt.Fprintf(os.Stderr, "failed to run %s: %v\n", bin, err)
+		return 1
+	}
+	return 0
+}

internal/cli/msn_cli.go

@@ -0,0 +1,904 @@
+package cli
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"log"
+	"os"
+	"os/signal"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"syscall"
+	"time"
+
+	"rubick/msn"
+)
+
+func runMSNCommand(args []string) int {
+	if len(args) == 0 {
+		printMSNUsage()
+		return 1
+	}
+
+	if args[0] == "-h" || args[0] == "--help" || args[0] == "help" {
+		printMSNUsage()
+		return 0
+	}
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	sigChan := make(chan os.Signal, 1)
+	signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
+	defer signal.Stop(sigChan)
+	go func() {
+		<-sigChan
+		log.Println("Shutting down...")
+		cancel()
+	}()
+
+	if err := executeMSNCommand(ctx, args); err != nil {
+		fmt.Fprintf(os.Stderr, "error: %v\n", err)
+		return 1
+	}
+	return 0
+}
+
+func executeMSNCommand(ctx context.Context, args []string) error {
+	subcommand := args[0]
+	subArgs := args[1:]
+
+	switch subcommand {
+	case "screener":
+		return runScreener(ctx, subArgs)
+	case "fetch":
+		return runFetch(ctx, subArgs)
+	case "fetch-all":
+		return runFetchAll(ctx, subArgs)
+	case "lookup":
+		return runLookup(subArgs)
+	default:
+		printMSNUsage()
+		return fmt.Errorf("unknown msn subcommand: %s", subcommand)
+	}
+}
+
+func printMSNUsage() {
+	fmt.Fprintf(os.Stderr, `MSN Stock Scraper - Fetch Indonesian stock data from MSN Finance
+
+Usage:
+  rubick msn <command> [options]
+
+Commands:
+  screener    Run stock screener to find stocks by criteria
+  fetch       Fetch comprehensive data for specific stocks
+  fetch-all   Fetch ALL Indonesian stocks to SQLite database
+  lookup      Look up MSN ID for ticker symbols
+
+Screener:
+  rubick msn screener --region id --filter top-performers --limit 20 -o stocks.json
+
+Fetch:
+  rubick msn fetch --tickers BBCA,BBRI,TLKM -o bank_stocks.json
+  rubick msn fetch --input stocks.json -o full_data.json
+
+Fetch-All:
+  rubick msn fetch-all --index idx30 --db output/stocks.db --concurrency 3
+
+Lookup:
+  rubick msn lookup BBCA BBRI TLKM
+`)
+}
+
+// Screener
+
+type ScreenerCLIConfig struct {
+	Region string
+	Filter string
+	Limit  int
+	Output string
+}
+
+func parseScreenerArgs(args []string) (ScreenerCLIConfig, error) {
+	cfg := ScreenerCLIConfig{
+		Region: "id",
+		Filter: "large-cap",
+		Limit:  50,
+		Output: fmt.Sprintf("screener_%s.json", time.Now().Format("20060102")),
+	}
+
+	for i := 0; i < len(args); i++ {
+		switch args[i] {
+		case "--region":
+			v, n, err := requireValue(args, i, "--region")
+			if err != nil {
+				return cfg, err
+			}
+			cfg.Region = v
+			i = n
+		case "--filter":
+			v, n, err := requireValue(args, i, "--filter")
+			if err != nil {
+				return cfg, err
+			}
+			cfg.Filter = v
+			i = n
+		case "--limit":
+			v, n, err := requireValue(args, i, "--limit")
+			if err != nil {
+				return cfg, err
+			}
+			limit, err := strconv.Atoi(v)
+			if err != nil {
+				return cfg, fmt.Errorf("invalid --limit value: %w", err)
+			}
+			cfg.Limit = limit
+			i = n
+		case "--output", "-o":
+			v, n, err := requireValue(args, i, "--output")
+			if err != nil {
+				return cfg, err
+			}
+			cfg.Output = v
+			i = n
+		default:
+			return cfg, fmt.Errorf("unknown option: %s", args[i])
+		}
+	}
+	if cfg.Limit < 1 {
+		return cfg, fmt.Errorf("--limit must be >= 1")
+	}
+	return cfg, nil
+}
+
+func runScreener(ctx context.Context, args []string) error {
+	if wantsHelp(args) {
+		printMSNScreenerUsage()
+		return nil
+	}
+
+	cfg, err := parseScreenerArgs(args)
+	if err != nil {
+		return err
+	}
+
+	filter, err := msn.ParseScreenerFilter(cfg.Filter)
+	if err != nil {
+		return fmt.Errorf("invalid filter: %w", err)
+	}
+
+	log.Printf("Running screener: region=%s filter=%s limit=%d", cfg.Region, cfg.Filter, cfg.Limit)
+	client := msn.NewMSNClient()
+	defer client.Close()
+
+	result, err := client.RunScreener(msn.ScreenerConfig{Region: cfg.Region, Filter: filter, Limit: cfg.Limit})
+	if err != nil {
+		return fmt.Errorf("screener failed: %w", err)
+	}
+
+	output := msn.ScreenerOutput{
+		Filter:      cfg.Filter,
+		Region:      cfg.Region,
+		GeneratedAt: time.Now().UTC().Format(time.RFC3339),
+		Total:       result.Total,
+		Stocks:      result.Value,
+	}
+	if err := saveJSON(output, cfg.Output); err != nil {
+		return fmt.Errorf("failed to save output: %w", err)
+	}
+
+	log.Printf("Output saved to %s", cfg.Output)
+	fmt.Println("\nTop 10 results:")
+	for i, stock := range result.Value {
+		if i >= 10 {
+			break
+		}
+		fmt.Printf("  %s (%s): %.2f (%.2f%%)\n", stock.Symbol, stock.ID, stock.Price, stock.PriceChangePct)
+	}
+	return nil
+}
+
+// Fetch
+
+type FetchCLIConfig struct {
+	Input       string
+	IDs         []string
+	Tickers     []string
+	Concurrency int
+	Output      string
+}
+
+func parseFetchArgs(args []string) (FetchCLIConfig, error) {
+	cfg := FetchCLIConfig{Concurrency: 5, Output: fmt.Sprintf("stocks_%s.json", time.Now().Format("20060102"))}
+
+	for i := 0; i < len(args); i++ {
+		switch args[i] {
+		case "--input":
+			v, n, err := requireValue(args, i, "--input")
+			if err != nil {
+				return cfg, err
+			}
+			cfg.Input = v
+			i = n
+		case "--ids":
+			v, n, err := requireValue(args, i, "--ids")
+			if err != nil {
+				return cfg, err
+			}
+			cfg.IDs = appendCSV(cfg.IDs, v, false)
+			i = n
+		case "--tickers":
+			v, n, err := requireValue(args, i, "--tickers")
+			if err != nil {
+				return cfg, err
+			}
+			cfg.Tickers = appendCSV(cfg.Tickers, v, true)
+			i = n
+		case "--concurrency":
+			v, n, err := requireValue(args, i, "--concurrency")
+			if err != nil {
+				return cfg, err
+			}
+			conc, err := strconv.Atoi(v)
+			if err != nil {
+				return cfg, fmt.Errorf("invalid --concurrency value: %w", err)
+			}
+			cfg.Concurrency = conc
+			i = n
+		case "--output", "-o":
+			v, n, err := requireValue(args, i, "--output")
+			if err != nil {
+				return cfg, err
+			}
+			cfg.Output = v
+			i = n
+		default:
+			return cfg, fmt.Errorf("unknown option: %s", args[i])
+		}
+	}
+	if cfg.Concurrency < 1 {
+		return cfg, fmt.Errorf("--concurrency must be >= 1")
+	}
+
+	return cfg, nil
+}
+
+func runFetch(ctx context.Context, args []string) error {
+	if wantsHelp(args) {
+		printMSNFetchUsage()
+		return nil
+	}
+
+	cfg, err := parseFetchArgs(args)
+	if err != nil {
+		return err
+	}
+
+	ids := make([]string, 0)
+	if cfg.Input != "" {
+		inputIDs, err := readScreenerOutput(cfg.Input)
+		if err != nil {
+			return fmt.Errorf("failed to read input file: %w", err)
+		}
+		ids = append(ids, inputIDs...)
+	}
+	ids = append(ids, cfg.IDs...)
+
+	for _, ticker := range cfg.Tickers {
+		id := msn.GetIDXStockID(ticker)
+		if id == "" {
+			log.Printf("Warning: Unknown ticker '%s', skipping", ticker)
+			continue
+		}
+		log.Printf("Resolved %s -> %s", ticker, id)
+		ids = append(ids, id)
+	}
+
+	if len(ids) == 0 {
+		return fmt.Errorf("no stock IDs provided. use --input, --ids, or --tickers")
+	}
+
+	ids = dedupe(ids)
+	log.Printf("Fetching data for %d stocks with concurrency %d", len(ids), cfg.Concurrency)
+
+	fetcher := msn.NewStockFetcher()
+	defer fetcher.Close()
+
+	stocks := fetcher.FetchStocks(ctx, ids, cfg.Concurrency)
+	output := msn.FetchOutput{GeneratedAt: time.Now().UTC().Format(time.RFC3339), Total: len(stocks), Stocks: stocks}
+	if err := saveJSON(output, cfg.Output); err != nil {
+		return fmt.Errorf("failed to save output: %w", err)
+	}
+
+	successCount := 0
+	for _, stock := range stocks {
+		apiSuccess := 0
+		for _, status := range stock.FetchStatus {
+			if status == "ok" {
+				apiSuccess++
+			}
+		}
+		if apiSuccess > 0 {
+			successCount++
+		}
+	}
+	log.Printf("Output saved to %s", cfg.Output)
+	log.Printf("Successfully fetched %d/%d stocks", successCount, len(stocks))
+	return nil
+}
+
+func readScreenerOutput(filename string) ([]string, error) {
+	data, err := os.ReadFile(filename)
+	if err != nil {
+		return nil, err
+	}
+
+	var output msn.ScreenerOutput
+	if err := json.Unmarshal(data, &output); err != nil {
+		return nil, err
+	}
+
+	ids := make([]string, len(output.Stocks))
+	for i, stock := range output.Stocks {
+		ids[i] = stock.ID
+	}
+	return ids, nil
+}
+
+func saveJSON(data any, filename string) error {
+	jsonData, err := json.MarshalIndent(data, "", "  ")
+	if err != nil {
+		return err
+	}
+	if dir := filepath.Dir(filename); dir != "." {
+		if err := os.MkdirAll(dir, 0o755); err != nil {
+			return err
+		}
+	}
+	return os.WriteFile(filename, jsonData, 0o644)
+}
+
+func runLookup(args []string) error {
+	if wantsHelp(args) {
+		printMSNLookupUsage()
+		return nil
+	}
+
+	if len(args) == 0 {
+		return fmt.Errorf("usage: rubick msn lookup <ticker1> [ticker2] ...")
+	}
+
+	fmt.Printf("%-8s %-10s %s\n", "Ticker", "MSN ID", "Company Name")
+	fmt.Println(strings.Repeat("-", 50))
+
+	found := 0
+	for _, ticker := range args {
+		ticker = strings.ToUpper(strings.TrimSpace(ticker))
+		stock, ok := msn.GetIDXStock(ticker)
+		if ok {
+			fmt.Printf("%-8s %-10s %s\n", ticker, stock.ID, stock.Name)
+			found++
+		} else {
+			fmt.Printf("%-8s %-10s %s\n", ticker, "-", "(not found)")
+		}
+	}
+	fmt.Println(strings.Repeat("-", 50))
+	fmt.Printf("Found %d/%d tickers\n", found, len(args))
+	return nil
+}
+
+// Fetch-all
+
+type FetchAllConfig struct {
+	DB          string
+	Index       string
+	Proxy       string
+	Concurrency int
+	RPS         float64
+	MinDelayMs  int
+	MaxDelayMs  int
+	Retry       int
+	Limit       int
+	Resume      bool
+}
+
+func parseFetchAllArgs(args []string) (FetchAllConfig, error) {
+	cfg := FetchAllConfig{
+		DB:          "output/stocks.db",
+		Index:       "all",
+		Concurrency: 5,
+		RPS:         25,
+		MinDelayMs:  100,
+		MaxDelayMs:  500,
+		Retry:       2,
+	}
+
+	for i := 0; i < len(args); i++ {
+		switch args[i] {
+		case "--db":
+			v, n, err := requireValue(args, i, "--db")
+			if err != nil {
+				return cfg, err
+			}
+			cfg.DB = v
+			i = n
+		case "--index":
+			v, n, err := requireValue(args, i, "--index")
+			if err != nil {
+				return cfg, err
+			}
+			cfg.Index = strings.ToLower(v)
+			i = n
+		case "--proxy":
+			v, n, err := requireValue(args, i, "--proxy")
+			if err != nil {
+				return cfg, err
+			}
+			cfg.Proxy = v
+			i = n
+		case "--concurrency":
+			v, n, err := requireValue(args, i, "--concurrency")
+			if err != nil {
+				return cfg, err
+			}
+			nval, err := strconv.Atoi(v)
+			if err != nil {
+				return cfg, fmt.Errorf("invalid --concurrency value: %w", err)
+			}
+			cfg.Concurrency = nval
+			i = n
+		case "--rps":
+			v, n, err := requireValue(args, i, "--rps")
+			if err != nil {
+				return cfg, err
+			}
+			fval, err := strconv.ParseFloat(v, 64)
+			if err != nil {
+				return cfg, fmt.Errorf("invalid --rps value: %w", err)
+			}
+			cfg.RPS = fval
+			i = n
+		case "--delay":
+			v, n, err := requireValue(args, i, "--delay")
+			if err != nil {
+				return cfg, err
+			}
+			minDelay, maxDelay, err := parseDelay(v)
+			if err != nil {
+				return cfg, err
+			}
+			cfg.MinDelayMs, cfg.MaxDelayMs = minDelay, maxDelay
+			i = n
+		case "--retry":
+			v, n, err := requireValue(args, i, "--retry")
+			if err != nil {
+				return cfg, err
+			}
+			nval, err := strconv.Atoi(v)
+			if err != nil {
+				return cfg, fmt.Errorf("invalid --retry value: %w", err)
+			}
+			cfg.Retry = nval
+			i = n
+		case "--limit":
+			v, n, err := requireValue(args, i, "--limit")
+			if err != nil {
+				return cfg, err
+			}
+			nval, err := strconv.Atoi(v)
+			if err != nil {
+				return cfg, fmt.Errorf("invalid --limit value: %w", err)
+			}
+			cfg.Limit = nval
+			i = n
+		case "--resume":
+			cfg.Resume = true
+		default:
+			return cfg, fmt.Errorf("unknown option: %s", args[i])
+		}
+	}
+	if cfg.Concurrency < 1 {
+		return cfg, fmt.Errorf("--concurrency must be >= 1")
+	}
+	if cfg.RPS <= 0 {
+		return cfg, fmt.Errorf("--rps must be > 0")
+	}
+	if cfg.MinDelayMs < 0 || cfg.MaxDelayMs < 0 || cfg.MinDelayMs > cfg.MaxDelayMs {
+		return cfg, fmt.Errorf("--delay must satisfy 0 <= min <= max")
+	}
+	if cfg.Retry < 0 {
+		return cfg, fmt.Errorf("--retry must be >= 0")
+	}
+	if cfg.Limit < 0 {
+		return cfg, fmt.Errorf("--limit must be >= 0")
+	}
+	return cfg, nil
+}
+
+func runFetchAll(ctx context.Context, args []string) error {
+	if wantsHelp(args) {
+		printMSNFetchAllUsage()
+		return nil
+	}
+
+	cfg, err := parseFetchAllArgs(args)
+	if err != nil {
+		return err
+	}
+
+	log.Printf("Fetch-All Configuration:")
+	log.Printf("  Database: %s", cfg.DB)
+	log.Printf("  Index: %s", cfg.Index)
+	log.Printf("  Concurrency: %d workers", cfg.Concurrency)
+	log.Printf("  Rate limit: %.1f req/sec", cfg.RPS)
+	log.Printf("  Delay: %d-%d ms", cfg.MinDelayMs, cfg.MaxDelayMs)
+	log.Printf("  Retry: %d attempts", cfg.Retry)
+	if cfg.Proxy != "" {
+		log.Printf("  Proxy: %s", cfg.Proxy)
+	}
+	if cfg.Limit > 0 {
+		log.Printf("  Limit: %d stocks", cfg.Limit)
+	}
+	if cfg.Resume {
+		log.Printf("  Resume: enabled")
+	}
+
+	db, err := msn.NewStockDB(cfg.DB)
+	if err != nil {
+		return fmt.Errorf("failed to open database: %w", err)
+	}
+	defer db.Close()
+
+	stocks := getStocksByIndex(cfg.Index)
+	if cfg.Limit > 0 && cfg.Limit < len(stocks) {
+		limited := make(map[string]msn.IDXStock)
+		count := 0
+		for ticker, stock := range stocks {
+			if count >= cfg.Limit {
+				break
+			}
+			limited[ticker] = stock
+			count++
+		}
+		stocks = limited
+	}
+
+	log.Printf("Stock list: %d stocks from '%s' index", len(stocks), cfg.Index)
+
+	var runID int64
+	if cfg.Resume {
+		runID, err = db.GetLastRunID()
+		if err != nil {
+			return fmt.Errorf("failed to get last run: %w", err)
+		}
+		if runID > 0 {
+			log.Printf("Resuming run #%d", runID)
+		} else {
+			log.Printf("No incomplete run found, starting fresh")
+			cfg.Resume = false
+		}
+	}
+
+	if !cfg.Resume {
+		cfgMap := map[string]any{
+			"index":       cfg.Index,
+			"concurrency": cfg.Concurrency,
+			"rps":         cfg.RPS,
+			"delay":       fmt.Sprintf("%d-%d", cfg.MinDelayMs, cfg.MaxDelayMs),
+			"retry":       cfg.Retry,
+			"proxy":       cfg.Proxy != "",
+		}
+		runID, err = db.StartScrapeRun(len(stocks), cfgMap)
+		if err != nil {
+			return fmt.Errorf("failed to start run: %w", err)
+		}
+		log.Printf("Started run #%d", runID)
+		if err := db.InitProgress(runID, stocks); err != nil {
+			return fmt.Errorf("failed to init progress: %w", err)
+		}
+	}
+
+	pendingStocks, err := db.GetPendingStocks(runID)
+	if err != nil {
+		return fmt.Errorf("failed to get pending stocks: %w", err)
+	}
+	log.Printf("Pending: %d stocks to process", len(pendingStocks))
+	if len(pendingStocks) == 0 {
+		log.Println("No pending stocks, run complete")
+		return nil
+	}
+
+	rateLimiter := msn.NewRateLimiter(msn.RateLimiterConfig{RequestsPerSecond: cfg.RPS, MinDelayMs: cfg.MinDelayMs, MaxDelayMs: cfg.MaxDelayMs})
+	client := msn.NewMSNClientWithConfig(msn.MSNClientConfig{Proxy: cfg.Proxy, RateLimiter: rateLimiter})
+	defer client.Close()
+
+	type workItem struct{ ID, Ticker string }
+	workChan := make(chan workItem, len(pendingStocks))
+	for _, s := range pendingStocks {
+		workChan <- workItem{ID: s.ID, Ticker: s.Ticker}
+	}
+	close(workChan)
+
+	var processed, successful, failed int
+	total := len(pendingStocks)
+	startTime := time.Now()
+
+	statusTicker := time.NewTicker(5 * time.Second)
+	defer statusTicker.Stop()
+	go func() {
+		for range statusTicker.C {
+			elapsed := time.Since(startTime)
+			rate := float64(processed) / elapsed.Seconds()
+			remaining := total - processed
+			eta := time.Duration(float64(remaining)/rate) * time.Second
+			log.Printf("Progress: %d/%d (%.1f%%) | Success: %d | Failed: %d | Rate: %.1f/s | ETA: %s",
+				processed, total, float64(processed)*100/float64(total), successful, failed, rate, eta.Round(time.Second))
+		}
+	}()
+
+	done := make(chan bool)
+	results := make(chan struct {
+		ticker  string
+		success bool
+		apis    int
+		err     string
+	}, cfg.Concurrency)
+
+	for w := 0; w < cfg.Concurrency; w++ {
+		go func() {
+			for {
+				select {
+				case <-ctx.Done():
+					return
+				case work, ok := <-workChan:
+					if !ok {
+						return
+					}
+					db.MarkProgressStarted(runID, work.ID)
+					var stockData *msn.StockData
+					var fetchErr error
+					for attempt := 0; attempt <= cfg.Retry; attempt++ {
+						stockData, fetchErr = client.FetchStockData(work.ID)
+						if fetchErr == nil {
+							break
+						}
+						if attempt < cfg.Retry {
+							time.Sleep(time.Duration(500*(attempt+1)) * time.Millisecond)
+						}
+					}
+					apisSuccess, apisFailed := 0, 0
+					if stockData != nil {
+						for _, status := range stockData.FetchStatus {
+							if status == "ok" {
+								apisSuccess++
+							} else {
+								apisFailed++
+							}
+						}
+						if err := db.SaveStockData(stockData); err != nil {
+							fetchErr = fmt.Errorf("save failed: %w", err)
+						}
+					}
+					status := "success"
+					errMsg := ""
+					if fetchErr != nil || apisSuccess == 0 {
+						status = "failed"
+						if fetchErr != nil {
+							errMsg = fetchErr.Error()
+						}
+					}
+					db.UpdateProgress(runID, work.ID, status, apisSuccess, apisFailed, errMsg)
+					results <- struct {
+						ticker  string
+						success bool
+						apis    int
+						err     string
+					}{work.Ticker, status == "success", apisSuccess, errMsg}
+				}
+			}
+		}()
+	}
+
+	go func() {
+		for processed < total {
+			select {
+			case <-ctx.Done():
+				done <- false
+				return
+			case r := <-results:
+				processed++
+				if r.success {
+					successful++
+					log.Printf("[%d/%d] %s - %d APIs succeeded", processed, total, r.ticker, r.apis)
+				} else {
+					failed++
+					log.Printf("[%d/%d] %s - FAILED: %s", processed, total, r.ticker, r.err)
+				}
+			}
+		}
+		done <- true
+	}()
+
+	completed := <-done
+	elapsed := time.Since(startTime)
+	if completed {
+		db.CompleteScrapeRun(runID, "completed")
+		log.Printf("\n=== Run #%d Completed ===", runID)
+	} else {
+		db.CompleteScrapeRun(runID, "interrupted")
+		log.Printf("\n=== Run #%d Interrupted ===", runID)
+	}
+	log.Printf("Total: %d | Success: %d | Failed: %d", processed, successful, failed)
+	log.Printf("Duration: %s | Rate: %.1f stocks/sec", elapsed.Round(time.Second), float64(processed)/elapsed.Seconds())
+	log.Printf("Database: %s", cfg.DB)
+
+	staleStocks, _ := db.GetStaleStocks(7)
+	if len(staleStocks) > 0 {
+		log.Printf("\nWarning: %d stocks not seen in 7+ days:", len(staleStocks))
+		for i, ticker := range staleStocks {
+			if i >= 10 {
+				log.Printf("  ... and %d more", len(staleStocks)-10)
+				break
+			}
+			log.Printf("  - %s", ticker)
+		}
+	}
+	return nil
+}
+
+// Helpers
+
+func requireValue(args []string, i int, flag string) (string, int, error) {
+	if i+1 >= len(args) {
+		return "", i, fmt.Errorf("%s requires a value", flag)
+	}
+	return args[i+1], i + 1, nil
+}
+
+func appendCSV(dst []string, csv string, upper bool) []string {
+	for _, part := range strings.Split(csv, ",") {
+		v := strings.TrimSpace(part)
+		if upper {
+			v = strings.ToUpper(v)
+		}
+		if v != "" {
+			dst = append(dst, v)
+		}
+	}
+	return dst
+}
+
+func dedupe(values []string) []string {
+	seen := make(map[string]bool, len(values))
+	out := make([]string, 0, len(values))
+	for _, v := range values {
+		if !seen[v] {
+			seen[v] = true
+			out = append(out, v)
+		}
+	}
+	return out
+}
+
+func parseDelay(v string) (int, int, error) {
+	parts := strings.Split(v, "-")
+	if len(parts) != 2 {
+		return 0, 0, fmt.Errorf("invalid --delay value (use format min-max)")
+	}
+	minDelay, err := strconv.Atoi(parts[0])
+	if err != nil {
+		return 0, 0, fmt.Errorf("invalid --delay min value: %w", err)
+	}
+	maxDelay, err := strconv.Atoi(parts[1])
+	if err != nil {
+		return 0, 0, fmt.Errorf("invalid --delay max value: %w", err)
+	}
+	if minDelay > maxDelay {
+		return 0, 0, fmt.Errorf("invalid --delay value: min must be <= max")
+	}
+	return minDelay, maxDelay, nil
+}
+
+func wantsHelp(args []string) bool {
+	for _, a := range args {
+		if a == "-h" || a == "--help" || a == "help" {
+			return true
+		}
+	}
+	return false
+}
+
+func printMSNScreenerUsage() {
+	fmt.Fprintf(os.Stderr, `Usage: rubick msn screener [options]
+
+Options:
+  --region <code>     Country code (default: id)
+  --filter <preset>   top-performers|worst-performers|high-dividend|low-pe|52w-high|52w-low|high-volume|large-cap
+  --limit <n>         Max results (default: 50)
+  --output, -o <file> Output JSON path
+`)
+}
+
+func printMSNFetchUsage() {
+	fmt.Fprintf(os.Stderr, `Usage: rubick msn fetch [options]
+
+Options:
+  --input <file>          Screener JSON input
+  --ids <id1,id2,...>     Comma-separated MSN IDs
+  --tickers <T1,T2,...>   Comma-separated ticker symbols
+  --concurrency <n>       Parallel workers (default: 5)
+  --output, -o <file>     Output JSON path
+`)
+}
+
+func printMSNFetchAllUsage() {
+	fmt.Fprintf(os.Stderr, `Usage: rubick msn fetch-all [options]
+
+Options:
+  --db <file>            SQLite database path (default: output/stocks.db)
+  --index <name>         all|lq45|idx30|idx80 (default: all)
+  --proxy <url>          Proxy URL (http://, https://, socks5://)
+  --concurrency <n>      Parallel workers (default: 5)
+  --rps <n>              Max requests/sec (default: 25)
+  --delay <min-max>      Random delay ms (default: 100-500)
+  --retry <n>            Retry attempts (default: 2)
+  --limit <n>            Process only N stocks
+  --resume               Resume incomplete run
+`)
+}
+
+func printMSNLookupUsage() {
+	fmt.Fprintf(os.Stderr, `Usage: rubick msn lookup <ticker1> [ticker2] ...
+`)
+}
+
+func getStocksByIndex(index string) map[string]msn.IDXStock {
+	allStocks := msn.GetAllIDXStocks()
+	switch index {
+	case "all":
+		return allStocks
+	case "lq45":
+		return filterStocks(allStocks, []string{
+			"ACES", "ADRO", "AKRA", "AMMN", "AMRT", "ANTM", "ASII", "BBCA",
+			"BBNI", "BBRI", "BBTN", "BMRI", "BRPT", "BUKA", "CPIN", "EMTK",
+			"ESSA", "EXCL", "GGRM", "GOTO", "HRUM", "ICBP", "INCO", "INDF",
+			"INKP", "INTP", "ITMG", "KLBF", "MAPI", "MBMA", "MDKA", "MEDC",
+			"PGAS", "PGEO", "PTBA", "SIDO", "SMGR", "TBIG", "TINS", "TLKM",
+			"TOWR", "UNTR", "UNVR", "WIKA",
+		})
+	case "idx30":
+		return filterStocks(allStocks, []string{
+			"ADRO", "AMRT", "ANTM", "ASII", "BBCA", "BBNI", "BBRI", "BMRI",
+			"BRPT", "CPIN", "EMTK", "EXCL", "GOTO", "ICBP", "INCO", "INDF",
+			"ITMG", "KLBF", "MDKA", "MEDC", "PGAS", "PTBA", "SMGR", "TBIG",
+			"TINS", "TLKM", "TOWR", "UNTR", "UNVR",
+		})
+	case "idx80":
+		return filterStocks(allStocks, []string{
+			"ACES", "ADRO", "AGII", "AKRA", "AMMN", "AMRT", "ANTM", "ARTO",
+			"ASII", "BBCA", "BBNI", "BBRI", "BBTN", "BFIN", "BMRI", "BRPT",
+			"BSDE", "BTPS", "BUKA", "CPIN", "CTRA", "DMAS", "EMTK", "ERAA",
+			"ESSA", "EXCL", "GGRM", "GOTO", "HEAL", "HMSP", "HRUM", "ICBP",
+			"INCO", "INDF", "INKP", "INTP", "ITMG", "JPFA", "JSMR", "KLBF",
+			"LPKR", "LPPF", "MAPI", "MBMA", "MDKA", "MEDC", "MIKA", "MNCN",
+			"PGAS", "PGEO", "PNBN", "PTBA", "PTPP", "PWON", "SCMA", "SIDO",
+			"SMGR", "SMRA", "SRTG", "TAPG", "TBIG", "TINS", "TKIM", "TLKM",
+			"TOWR", "TPIA", "UNTR", "UNVR", "WIKA", "WSKT",
+		})
+	default:
+		log.Printf("Unknown index '%s', using all stocks", index)
+		return allStocks
+	}
+}
+
+func filterStocks(all map[string]msn.IDXStock, tickers []string) map[string]msn.IDXStock {
+	result := make(map[string]msn.IDXStock)
+	for _, ticker := range tickers {
+		if stock, ok := all[ticker]; ok {
+			result[ticker] = stock
+		}
+	}
+	return result
+}

internal/cli/news_cli.go

@@ -0,0 +1,336 @@
+package cli
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"log"
+	"os"
+	"os/signal"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"sync"
+	"syscall"
+	"time"
+
+	"github.com/enetx/g"
+	"github.com/enetx/surf"
+	"github.com/joho/godotenv"
+)
+
+type NewsConfig struct {
+	Query       string
+	From        time.Time
+	To          time.Time
+	Count       int
+	Concurrency int
+	Output      string
+	StockMode   bool
+}
+
+type EnrichedResult struct {
+	Title         string `json:"title"`
+	URL           string `json:"url"`
+	Description   string `json:"description"`
+	PageAge       string `json:"page_age"`
+	Text          string `json:"text"`
+	FetchStatus   string `json:"fetch_status"`
+	ExtractStatus string `json:"extract_status"`
+}
+
+type OutputData struct {
+	Query       string           `json:"query"`
+	GeneratedAt string           `json:"generated_at"`
+	Results     []EnrichedResult `json:"results"`
+}
+
+func runNewsCommand(args []string) int {
+	godotenv.Load()
+
+	if len(args) == 0 {
+		printNewsUsage()
+		return 1
+	}
+	if args[0] == "-h" || args[0] == "--help" || args[0] == "help" {
+		printNewsUsage()
+		return 0
+	}
+
+	cfg, err := parseNewsArgs(args)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "error: %v\n", err)
+		return 1
+	}
+
+	if err := executeNews(cfg); err != nil {
+		fmt.Fprintf(os.Stderr, "error: %v\n", err)
+		return 1
+	}
+	return 0
+}
+
+func executeNews(config NewsConfig) error {
+	finalQuery := config.Query
+	if config.StockMode {
+		terms := strings.Split(config.Query, ",")
+		for i := range terms {
+			terms[i] = strings.TrimSpace(terms[i])
+		}
+		finalQuery = BuildStockQuery(terms...)
+		log.Printf("Stock mode query: %s", finalQuery)
+	}
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	sigChan := make(chan os.Signal, 1)
+	signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
+	defer signal.Stop(sigChan)
+	go func() {
+		<-sigChan
+		log.Println("Shutting down...")
+		cancel()
+	}()
+
+	client := surf.NewClient().Builder().Impersonate().Chrome().Build().Unwrap()
+	defer client.CloseIdleConnections()
+
+	log.Printf("Searching for: %s", finalQuery)
+	log.Printf("Date range: %s to %s, count: %d", config.From.Format("2006-01-02"), config.To.Format("2006-01-02"), config.Count)
+
+	searchResults, err := SearchBrave(client, SearchConfig{Query: finalQuery, From: config.From, To: config.To, Count: config.Count})
+	if err != nil {
+		return fmt.Errorf("failed to search: %w", err)
+	}
+	log.Printf("Found %d results", len(searchResults))
+	if len(searchResults) == 0 {
+		log.Println("No results found, exiting")
+		return nil
+	}
+
+	log.Println("Starting Python extractor...")
+	extractor, err := NewExtractor(config.Concurrency)
+	if err != nil {
+		return fmt.Errorf("failed to start extractor: %w", err)
+	}
+	defer extractor.Close()
+	log.Println("Python extractor ready")
+
+	results := processURLs(ctx, client, extractor, searchResults, config.Concurrency)
+	output := OutputData{Query: finalQuery, GeneratedAt: time.Now().UTC().Format(time.RFC3339), Results: results}
+	if err := saveOutput(output, config.Output); err != nil {
+		return fmt.Errorf("failed to save output: %w", err)
+	}
+
+	successCount := 0
+	for _, r := range results {
+		if r.ExtractStatus == "ok" {
+			successCount++
+		}
+	}
+	log.Printf("Output saved to %s", config.Output)
+	log.Printf("Successfully extracted %d/%d articles", successCount, len(results))
+	return nil
+}
+
+func printNewsUsage() {
+	fmt.Fprintf(os.Stderr, `Usage: rubick news <query> [options]
+
+Arguments:
+  <query>              Search query (required)
+                       For --stock mode: comma-separated stock terms
+
+Options:
+  --from <date>        Start date in YYYY-MM-DD format (default: 7 days ago)
+  --to <date>          End date in YYYY-MM-DD format (default: today)
+  --count <n>          Number of results to fetch (default: 20)
+  --concurrency <n>    Number of parallel workers (default: 10)
+  --output, -o <file>  Output file path (default: output_YYYYMMDD.json)
+  --stock              Auto-builds IDX-focused boolean query
+
+Environment:
+  BRAVE_API_KEY        Brave Search API key
+
+Examples:
+  rubick news "IHSG stock market"
+  rubick news "BBCA,Bank Central Asia" --stock --from 2026-02-01 --to 2026-02-10
+`)
+}
+
+func parseNewsArgs(args []string) (NewsConfig, error) {
+	query := args[0]
+	args = args[1:]
+
+	now := time.Now()
+	cfg := NewsConfig{
+		Query:       query,
+		From:        now.AddDate(0, 0, -7),
+		To:          now,
+		Count:       20,
+		Concurrency: 10,
+		Output:      fmt.Sprintf("output_%s.json", now.Format("20060102")),
+	}
+
+	for i := 0; i < len(args); i++ {
+		switch args[i] {
+		case "--from":
+			v, n, err := requireValue(args, i, "--from")
+			if err != nil {
+				return cfg, err
+			}
+			t, err := time.Parse("2006-01-02", v)
+			if err != nil {
+				return cfg, fmt.Errorf("invalid --from date: %w", err)
+			}
+			cfg.From = t
+			i = n
+		case "--to":
+			v, n, err := requireValue(args, i, "--to")
+			if err != nil {
+				return cfg, err
+			}
+			t, err := time.Parse("2006-01-02", v)
+			if err != nil {
+				return cfg, fmt.Errorf("invalid --to date: %w", err)
+			}
+			cfg.To = t
+			i = n
+		case "--count":
+			v, n, err := requireValue(args, i, "--count")
+			if err != nil {
+				return cfg, err
+			}
+			nval, err := strconv.Atoi(v)
+			if err != nil {
+				return cfg, fmt.Errorf("invalid --count value: %w", err)
+			}
+			cfg.Count = nval
+			i = n
+		case "--concurrency":
+			v, n, err := requireValue(args, i, "--concurrency")
+			if err != nil {
+				return cfg, err
+			}
+			nval, err := strconv.Atoi(v)
+			if err != nil {
+				return cfg, fmt.Errorf("invalid --concurrency value: %w", err)
+			}
+			cfg.Concurrency = nval
+			i = n
+		case "--output", "-o":
+			v, n, err := requireValue(args, i, "--output")
+			if err != nil {
+				return cfg, err
+			}
+			cfg.Output = v
+			i = n
+		case "--stock":
+			cfg.StockMode = true
+		default:
+			return cfg, fmt.Errorf("unknown option: %s", args[i])
+		}
+	}
+
+	if cfg.Count < 1 {
+		return cfg, fmt.Errorf("--count must be >= 1")
+	}
+	if cfg.Concurrency < 1 {
+		return cfg, fmt.Errorf("--concurrency must be >= 1")
+	}
+	if cfg.From.After(cfg.To) {
+		return cfg, fmt.Errorf("--from must be on or before --to")
+	}
+
+	return cfg, nil
+}
+
+func processURLs(ctx context.Context, client *surf.Client, extractor *Extractor, searchResults []BraveResult, concurrency int) []EnrichedResult {
+	results := make([]EnrichedResult, len(searchResults))
+	for i, sr := range searchResults {
+		results[i] = EnrichedResult{Title: sr.Title, URL: sr.URL, Description: sr.Description, PageAge: sr.PageAge, FetchStatus: "pending", ExtractStatus: "pending"}
+	}
+
+	work := make(chan int, len(searchResults))
+	for i := range searchResults {
+		work <- i
+	}
+	close(work)
+
+	var wg sync.WaitGroup
+	var mu sync.Mutex
+	for w := 0; w < concurrency; w++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			for {
+				select {
+				case <-ctx.Done():
+					return
+				case idx, ok := <-work:
+					if !ok {
+						return
+					}
+					result := processURL(ctx, client, extractor, searchResults[idx])
+					mu.Lock()
+					results[idx] = result
+					mu.Unlock()
+					log.Printf("[%d/%d] %s - fetch: %s, extract: %s", idx+1, len(searchResults), truncate(result.URL, 50), result.FetchStatus, result.ExtractStatus)
+				}
+			}
+		}()
+	}
+	wg.Wait()
+	return results
+}
+
+func processURL(ctx context.Context, client *surf.Client, extractor *Extractor, sr BraveResult) EnrichedResult {
+	result := EnrichedResult{Title: sr.Title, URL: sr.URL, Description: sr.Description, PageAge: sr.PageAge}
+	if err := ctx.Err(); err != nil {
+		result.FetchStatus = "cancelled"
+		result.ExtractStatus = "skipped"
+		return result
+	}
+	resp := client.Get(g.String(sr.URL)).Do()
+	if resp.IsErr() {
+		result.FetchStatus = "failed"
+		result.ExtractStatus = "skipped"
+		return result
+	}
+	r := resp.Ok()
+	if r.StatusCode != 200 {
+		result.FetchStatus = "failed"
+		result.ExtractStatus = "skipped"
+		return result
+	}
+	html := r.Body.String().Ok().Std()
+	result.FetchStatus = "ok"
+	extractResp, err := extractor.Extract(ctx, sr.URL, html)
+	if err != nil {
+		result.ExtractStatus = "failed"
+		return result
+	}
+	result.Text = extractResp.Text
+	result.ExtractStatus = extractResp.Status
+	return result
+}
+
+func saveOutput(output OutputData, filename string) error {
+	data, err := json.MarshalIndent(output, "", "  ")
+	if err != nil {
+		return err
+	}
+	if dir := filepath.Dir(filename); dir != "." {
+		if err := os.MkdirAll(dir, 0o755); err != nil {
+			return err
+		}
+	}
+	return os.WriteFile(filename, data, 0o644)
+}
+
+func truncate(s string, maxLen int) string {
+	if len(s) <= maxLen {
+		return s
+	}
+	return s[:maxLen-3] + "..."
+}

main.go

@@ -0,0 +1,11 @@
+package main
+
+import (
+	"os"
+
+	"rubick/internal/cli"
+)
+
+func main() {
+	os.Exit(cli.Run(os.Args[1:]))
+}

msn/bing_client.go

@@ -0,0 +1,324 @@
+package msn
+
+import (
+	"encoding/json"
+	"fmt"
+
+	"github.com/enetx/g"
+	"github.com/enetx/surf"
+)
+
+// BingClient is the client for Bing Finance APIs (ownership data)
+type BingClient struct {
+	client *surf.Client
+}
+
+// NewBingClient creates a new Bing API client with Chrome impersonation
+func NewBingClient() *BingClient {
+	client := surf.NewClient().
+		Builder().
+		Impersonate().
+		Chrome().
+		Build().
+		Unwrap()
+
+	return &BingClient{client: client}
+}
+
+// Close closes idle connections
+func (c *BingClient) Close() {
+	c.client.CloseIdleConnections()
+}
+
+// commonHeaders returns common headers for Bing API requests
+func (c *BingClient) commonHeaders() map[string]string {
+	return map[string]string{
+		"Accept":          "application/json",
+		"Accept-Language": "en-US,en;q=0.9",
+		"Origin":          "https://www.msn.com",
+		"Referer":         "https://www.msn.com/",
+	}
+}
+
+// GetTopShareHolders fetches top institutional shareholders
+func (c *BingClient) GetTopShareHolders(id string, count int) ([]Holder, error) {
+	if id == "" {
+		return nil, fmt.Errorf("no stock ID provided")
+	}
+	if count <= 0 {
+		count = 50
+	}
+
+	apiURL := fmt.Sprintf("%sGetSecurityTopShareHolders/%s?rangeStart=1&count=%d",
+		BingAPIBaseURL,
+		id,
+		count,
+	)
+
+	req := c.client.Get(g.String(apiURL))
+	for k, v := range c.commonHeaders() {
+		req = req.SetHeaders(k, v)
+	}
+
+	resp := req.Do()
+	if resp.IsErr() {
+		return nil, fmt.Errorf("top shareholders request failed: %w", resp.Err())
+	}
+
+	r := resp.Ok()
+	if r.StatusCode != 200 {
+		return nil, fmt.Errorf("top shareholders API returned status %d", r.StatusCode)
+	}
+
+	body := r.Body.String().Ok().Std()
+
+	var result OwnershipResponse
+	if err := json.Unmarshal([]byte(body), &result); err != nil {
+		return nil, fmt.Errorf("failed to parse top shareholders response: %w", err)
+	}
+
+	// Return whichever field has data
+	if len(result.SecurityOwnerships) > 0 {
+		return result.SecurityOwnerships, nil
+	}
+	return result.Records, nil
+}
+
+// GetTopBuyers fetches recent top buyers
+func (c *BingClient) GetTopBuyers(id string, count int) ([]Holder, error) {
+	if id == "" {
+		return nil, fmt.Errorf("no stock ID provided")
+	}
+	if count <= 0 {
+		count = 50
+	}
+
+	apiURL := fmt.Sprintf("%sGetSecurityTopBuyers/%s?rangeStart=1&count=%d",
+		BingAPIBaseURL,
+		id,
+		count,
+	)
+
+	req := c.client.Get(g.String(apiURL))
+	for k, v := range c.commonHeaders() {
+		req = req.SetHeaders(k, v)
+	}
+
+	resp := req.Do()
+	if resp.IsErr() {
+		return nil, fmt.Errorf("top buyers request failed: %w", resp.Err())
+	}
+
+	r := resp.Ok()
+	if r.StatusCode != 200 {
+		return nil, fmt.Errorf("top buyers API returned status %d", r.StatusCode)
+	}
+
+	body := r.Body.String().Ok().Std()
+
+	var result OwnershipResponse
+	if err := json.Unmarshal([]byte(body), &result); err != nil {
+		return nil, fmt.Errorf("failed to parse top buyers response: %w", err)
+	}
+
+	if len(result.SecurityOwnerships) > 0 {
+		return result.SecurityOwnerships, nil
+	}
+	return result.Records, nil
+}
+
+// GetTopSellers fetches recent top sellers
+func (c *BingClient) GetTopSellers(id string, count int) ([]Holder, error) {
+	if id == "" {
+		return nil, fmt.Errorf("no stock ID provided")
+	}
+	if count <= 0 {
+		count = 50
+	}
+
+	apiURL := fmt.Sprintf("%sGetSecurityTopSellers/%s?rangeStart=1&count=%d",
+		BingAPIBaseURL,
+		id,
+		count,
+	)
+
+	req := c.client.Get(g.String(apiURL))
+	for k, v := range c.commonHeaders() {
+		req = req.SetHeaders(k, v)
+	}
+
+	resp := req.Do()
+	if resp.IsErr() {
+		return nil, fmt.Errorf("top sellers request failed: %w", resp.Err())
+	}
+
+	r := resp.Ok()
+	if r.StatusCode != 200 {
+		return nil, fmt.Errorf("top sellers API returned status %d", r.StatusCode)
+	}
+
+	body := r.Body.String().Ok().Std()
+
+	var result OwnershipResponse
+	if err := json.Unmarshal([]byte(body), &result); err != nil {
+		return nil, fmt.Errorf("failed to parse top sellers response: %w", err)
+	}
+
+	if len(result.SecurityOwnerships) > 0 {
+		return result.SecurityOwnerships, nil
+	}
+	return result.Records, nil
+}
+
+// GetNewShareHolders fetches new institutional holders
+func (c *BingClient) GetNewShareHolders(id string, count int) ([]Holder, error) {
+	if id == "" {
+		return nil, fmt.Errorf("no stock ID provided")
+	}
+	if count <= 0 {
+		count = 50
+	}
+
+	apiURL := fmt.Sprintf("%sGetSecurityTopNewShareHolders/%s?rangeStart=1&count=%d",
+		BingAPIBaseURL,
+		id,
+		count,
+	)
+
+	req := c.client.Get(g.String(apiURL))
+	for k, v := range c.commonHeaders() {
+		req = req.SetHeaders(k, v)
+	}
+
+	resp := req.Do()
+	if resp.IsErr() {
+		return nil, fmt.Errorf("new shareholders request failed: %w", resp.Err())
+	}
+
+	r := resp.Ok()
+	if r.StatusCode != 200 {
+		return nil, fmt.Errorf("new shareholders API returned status %d", r.StatusCode)
+	}
+
+	body := r.Body.String().Ok().Std()
+
+	var result OwnershipResponse
+	if err := json.Unmarshal([]byte(body), &result); err != nil {
+		return nil, fmt.Errorf("failed to parse new shareholders response: %w", err)
+	}
+
+	if len(result.SecurityOwnerships) > 0 {
+		return result.SecurityOwnerships, nil
+	}
+	return result.Records, nil
+}
+
+// GetExitedShareHolders fetches exited institutional holders
+func (c *BingClient) GetExitedShareHolders(id string, count int) ([]Holder, error) {
+	if id == "" {
+		return nil, fmt.Errorf("no stock ID provided")
+	}
+	if count <= 0 {
+		count = 50
+	}
+
+	apiURL := fmt.Sprintf("%sGetSecurityTopExitedShareHolders/%s?rangeStart=1&count=%d",
+		BingAPIBaseURL,
+		id,
+		count,
+	)
+
+	req := c.client.Get(g.String(apiURL))
+	for k, v := range c.commonHeaders() {
+		req = req.SetHeaders(k, v)
+	}
+
+	resp := req.Do()
+	if resp.IsErr() {
+		return nil, fmt.Errorf("exited shareholders request failed: %w", resp.Err())
+	}
+
+	r := resp.Ok()
+	if r.StatusCode != 200 {
+		return nil, fmt.Errorf("exited shareholders API returned status %d", r.StatusCode)
+	}
+
+	body := r.Body.String().Ok().Std()
+
+	var result OwnershipResponse
+	if err := json.Unmarshal([]byte(body), &result); err != nil {
+		return nil, fmt.Errorf("failed to parse exited shareholders response: %w", err)
+	}
+
+	if len(result.SecurityOwnerships) > 0 {
+		return result.SecurityOwnerships, nil
+	}
+	return result.Records, nil
+}
+
+// IsInvestorDataAvailable checks if investor data exists for a stock
+func (c *BingClient) IsInvestorDataAvailable(id string) (bool, error) {
+	if id == "" {
+		return false, fmt.Errorf("no stock ID provided")
+	}
+
+	apiURL := fmt.Sprintf("%sIsInvestorDataAvailable/%s",
+		BingAPIBaseURL,
+		id,
+	)
+
+	req := c.client.Get(g.String(apiURL))
+	for k, v := range c.commonHeaders() {
+		req = req.SetHeaders(k, v)
+	}
+
+	resp := req.Do()
+	if resp.IsErr() {
+		return false, fmt.Errorf("investor data check request failed: %w", resp.Err())
+	}
+
+	r := resp.Ok()
+	if r.StatusCode != 200 {
+		return false, fmt.Errorf("investor data check API returned status %d", r.StatusCode)
+	}
+
+	body := r.Body.String().Ok().Std()
+
+	var available bool
+	if err := json.Unmarshal([]byte(body), &available); err != nil {
+		return false, fmt.Errorf("failed to parse investor data check response: %w", err)
+	}
+
+	return available, nil
+}
+
+// GetAllOwnership fetches all ownership data for a stock
+func (c *BingClient) GetAllOwnership(id string, count int) (*OwnershipData, error) {
+	ownership := &OwnershipData{}
+
+	// Skip IsInvestorDataAvailable check as it often returns 404 even when data exists
+	// Just try to fetch the data directly
+
+	// Fetch all ownership data sequentially
+	if holders, err := c.GetTopShareHolders(id, count); err == nil {
+		ownership.TopHolders = holders
+	}
+
+	if buyers, err := c.GetTopBuyers(id, count); err == nil {
+		ownership.TopBuyers = buyers
+	}
+
+	if sellers, err := c.GetTopSellers(id, count); err == nil {
+		ownership.TopSellers = sellers
+	}
+
+	if newHolders, err := c.GetNewShareHolders(id, count); err == nil {
+		ownership.NewHolders = newHolders
+	}
+
+	if exited, err := c.GetExitedShareHolders(id, count); err == nil {
+		ownership.ExitedHolders = exited
+	}
+
+	return ownership, nil
+}

msn/msn_client.go

@@ -0,0 +1,652 @@
+package msn
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/url"
+	"strings"
+	"time"
+
+	"github.com/enetx/g"
+	"github.com/enetx/surf"
+)
+
+// MSNClientConfig holds configuration for the MSN client
+type MSNClientConfig struct {
+	Proxy       string // Proxy URL (http://, https://, socks5://)
+	RateLimiter *RateLimiter
+}
+
+// MSNClient is the base client for MSN Finance APIs
+type MSNClient struct {
+	client      *surf.Client
+	proxy       string
+	rateLimiter *RateLimiter
+}
+
+// NewMSNClient creates a new MSN API client with Chrome impersonation
+func NewMSNClient() *MSNClient {
+	return NewMSNClientWithConfig(MSNClientConfig{})
+}
+
+// NewMSNClientWithConfig creates a new MSN API client with custom configuration
+func NewMSNClientWithConfig(config MSNClientConfig) *MSNClient {
+	builder := surf.NewClient().
+		Builder().
+		Impersonate().
+		Chrome()
+
+	// Add proxy if configured
+	if config.Proxy != "" {
+		builder = builder.Proxy(g.String(config.Proxy))
+	}
+
+	client := builder.Build().Unwrap()
+
+	return &MSNClient{
+		client:      client,
+		proxy:       config.Proxy,
+		rateLimiter: config.RateLimiter,
+	}
+}
+
+// waitForRateLimit waits for rate limiter if configured
+func (c *MSNClient) waitForRateLimit() {
+	if c.rateLimiter != nil {
+		c.rateLimiter.Wait()
+	}
+}
+
+// Close closes idle connections
+func (c *MSNClient) Close() {
+	c.client.CloseIdleConnections()
+}
+
+// commonHeaders returns common headers for MSN API requests
+func (c *MSNClient) commonHeaders() map[string]string {
+	return map[string]string{
+		"Accept":          "application/json",
+		"Accept-Language": "en-US,en;q=0.9,id;q=0.8",
+		"Origin":          "https://www.msn.com",
+		"Referer":         "https://www.msn.com/",
+	}
+}
+
+// GetQuotes fetches real-time quotes for given stock IDs
+func (c *MSNClient) GetQuotes(ids []string) ([]QuoteData, error) {
+	if len(ids) == 0 {
+		return nil, fmt.Errorf("no stock IDs provided")
+	}
+
+	c.waitForRateLimit()
+
+	apiURL := fmt.Sprintf("%sFinance/Quotes?apikey=%s&ids=%s&wrapodata=false",
+		MSNAssetsBaseURL,
+		MSNAPIKey,
+		strings.Join(ids, ","),
+	)
+
+	req := c.client.Get(g.String(apiURL))
+	for k, v := range c.commonHeaders() {
+		req = req.SetHeaders(k, v)
+	}
+
+	resp := req.Do()
+	if resp.IsErr() {
+		return nil, fmt.Errorf("quotes request failed: %w", resp.Err())
+	}
+
+	r := resp.Ok()
+	if r.StatusCode != 200 {
+		return nil, fmt.Errorf("quotes API returned status %d", r.StatusCode)
+	}
+
+	body := r.Body.String().Ok().Std()
+
+	var quotes []QuoteData
+	if err := json.Unmarshal([]byte(body), &quotes); err != nil {
+		return nil, fmt.Errorf("failed to parse quotes response: %w", err)
+	}
+
+	return quotes, nil
+}
+
+// GetQuoteSummary fetches detailed quote summary with multiple intents
+func (c *MSNClient) GetQuoteSummary(id string, intents []string) (map[string]json.RawMessage, error) {
+	if id == "" {
+		return nil, fmt.Errorf("no stock ID provided")
+	}
+
+	c.waitForRateLimit()
+
+	intentStr := strings.Join(intents, ",")
+	apiURL := fmt.Sprintf("%sFinance/QuoteSummary?apikey=%s&ids=%s&intents=%s&wrapodata=false",
+		MSNAssetsBaseURL,
+		MSNAPIKey,
+		id,
+		intentStr,
+	)
+
+	req := c.client.Get(g.String(apiURL))
+	for k, v := range c.commonHeaders() {
+		req = req.SetHeaders(k, v)
+	}
+
+	resp := req.Do()
+	if resp.IsErr() {
+		return nil, fmt.Errorf("quote summary request failed: %w", resp.Err())
+	}
+
+	r := resp.Ok()
+	if r.StatusCode != 200 {
+		return nil, fmt.Errorf("quote summary API returned status %d", r.StatusCode)
+	}
+
+	body := r.Body.String().Ok().Std()
+
+	var result []map[string]json.RawMessage
+	if err := json.Unmarshal([]byte(body), &result); err != nil {
+		return nil, fmt.Errorf("failed to parse quote summary response: %w", err)
+	}
+
+	if len(result) == 0 {
+		return nil, fmt.Errorf("empty quote summary response")
+	}
+
+	return result[0], nil
+}
+
+// GetCharts fetches historical chart data
+func (c *MSNClient) GetCharts(ids []string, chartType string) ([]ChartResponse, error) {
+	if len(ids) == 0 {
+		return nil, fmt.Errorf("no stock IDs provided")
+	}
+
+	c.waitForRateLimit()
+
+	apiURL := fmt.Sprintf("%sFinance/Charts?apikey=%s&cm=id-id&ids=%s&type=%s&wrapodata=false",
+		MSNAssetsBaseURL,
+		MSNAPIKey,
+		strings.Join(ids, ","),
+		chartType,
+	)
+
+	req := c.client.Get(g.String(apiURL))
+	for k, v := range c.commonHeaders() {
+		req = req.SetHeaders(k, v)
+	}
+
+	resp := req.Do()
+	if resp.IsErr() {
+		return nil, fmt.Errorf("charts request failed: %w", resp.Err())
+	}
+
+	r := resp.Ok()
+	if r.StatusCode != 200 {
+		return nil, fmt.Errorf("charts API returned status %d", r.StatusCode)
+	}
+
+	body := r.Body.String().Ok().Std()
+
+	var charts []ChartResponse
+	if err := json.Unmarshal([]byte(body), &charts); err != nil {
+		return nil, fmt.Errorf("failed to parse charts response: %w", err)
+	}
+
+	return charts, nil
+}
+
+// GetEquities fetches company information
+func (c *MSNClient) GetEquities(ids []string) ([]EquityData, error) {
+	if len(ids) == 0 {
+		return nil, fmt.Errorf("no stock IDs provided")
+	}
+
+	c.waitForRateLimit()
+
+	apiURL := fmt.Sprintf("%sFinance/Equities?apikey=%s&ids=%s&wrapodata=false",
+		MSNAssetsBaseURL,
+		MSNAPIKey,
+		strings.Join(ids, ","),
+	)
+
+	req := c.client.Get(g.String(apiURL))
+	for k, v := range c.commonHeaders() {
+		req = req.SetHeaders(k, v)
+	}
+
+	resp := req.Do()
+	if resp.IsErr() {
+		return nil, fmt.Errorf("equities request failed: %w", resp.Err())
+	}
+
+	r := resp.Ok()
+	if r.StatusCode != 200 {
+		return nil, fmt.Errorf("equities API returned status %d", r.StatusCode)
+	}
+
+	body := r.Body.String().Ok().Std()
+
+	var equities []EquityData
+	if err := json.Unmarshal([]byte(body), &equities); err != nil {
+		return nil, fmt.Errorf("failed to parse equities response: %w", err)
+	}
+
+	return equities, nil
+}
+
+// GetFinancialStatements fetches financial statements
+func (c *MSNClient) GetFinancialStatements(id string) (FinancialStatementsResponse, error) {
+	if id == "" {
+		return nil, fmt.Errorf("no stock ID provided")
+	}
+
+	c.waitForRateLimit()
+
+	// URL encode the filter parameter
+	filter := fmt.Sprintf("_p eq '%s'", id)
+	apiURL := fmt.Sprintf("%sFinance/Equities/financialstatements?apikey=%s&$filter=%s&wrapodata=false",
+		MSNAssetsBaseURL,
+		MSNAPIKey,
+		url.QueryEscape(filter),
+	)
+
+	req := c.client.Get(g.String(apiURL))
+	for k, v := range c.commonHeaders() {
+		req = req.SetHeaders(k, v)
+	}
+
+	resp := req.Do()
+	if resp.IsErr() {
+		return nil, fmt.Errorf("financial statements request failed: %w", resp.Err())
+	}
+
+	r := resp.Ok()
+	if r.StatusCode != 200 {
+		return nil, fmt.Errorf("financial statements API returned status %d", r.StatusCode)
+	}
+
+	body := r.Body.String().Ok().Std()
+
+	// Response is a direct array of FinancialStatement
+	var result FinancialStatementsResponse
+	if err := json.Unmarshal([]byte(body), &result); err != nil {
+		return nil, fmt.Errorf("failed to parse financial statements response: %w", err)
+	}
+
+	return result, nil
+}
+
+// GetEarnings fetches earnings events
+func (c *MSNClient) GetEarnings(ids []string) ([]EarningsEvent, error) {
+	if len(ids) == 0 {
+		return nil, fmt.Errorf("no stock IDs provided")
+	}
+
+	c.waitForRateLimit()
+
+	apiURL := fmt.Sprintf("%sFinance/Events/Earnings?apikey=%s&ids=%s&wrapodata=false",
+		MSNAssetsBaseURL,
+		MSNAPIKey,
+		strings.Join(ids, ","),
+	)
+
+	req := c.client.Get(g.String(apiURL))
+	for k, v := range c.commonHeaders() {
+		req = req.SetHeaders(k, v)
+	}
+
+	resp := req.Do()
+	if resp.IsErr() {
+		return nil, fmt.Errorf("earnings request failed: %w", resp.Err())
+	}
+
+	r := resp.Ok()
+	if r.StatusCode != 200 {
+		return nil, fmt.Errorf("earnings API returned status %d", r.StatusCode)
+	}
+
+	body := r.Body.String().Ok().Std()
+
+	// Parse the actual API response format
+	var apiResp EarningsAPIResponse
+	if err := json.Unmarshal([]byte(body), &apiResp); err != nil {
+		return nil, fmt.Errorf("failed to parse earnings response: %w", err)
+	}
+
+	// Convert quarterly earnings to EarningsEvent array
+	var earnings []EarningsEvent
+	for periodKey, data := range apiResp.History.Quarterly {
+		// Parse fiscal year and quarter from CiqFiscalPeriodType (e.g., "Q42025")
+		fiscalYear := 0
+		fiscalQuarter := 0
+		if len(data.CiqFiscalPeriodType) >= 6 {
+			// Format: Q{quarter}{year} e.g., Q42025
+			fmt.Sscanf(data.CiqFiscalPeriodType, "Q%d%d", &fiscalQuarter, &fiscalYear)
+		}
+		if fiscalYear == 0 && len(periodKey) >= 6 {
+			// Fallback: parse from period key (e.g., "202512")
+			fmt.Sscanf(periodKey[:4], "%d", &fiscalYear)
+			month := 0
+			fmt.Sscanf(periodKey[4:6], "%d", &month)
+			fiscalQuarter = (month-1)/3 + 1
+		}
+
+		// Parse event date
+		eventDate := ""
+		if data.EarningReleaseDate != "" {
+			// Extract date portion from ISO timestamp
+			if len(data.EarningReleaseDate) >= 10 {
+				eventDate = data.EarningReleaseDate[:10]
+			}
+		}
+
+		earnings = append(earnings, EarningsEvent{
+			ID:              fmt.Sprintf("%s_%s", apiResp.InstrumentID, periodKey),
+			EventDate:       eventDate,
+			FiscalYear:      fiscalYear,
+			FiscalQuarter:   fiscalQuarter,
+			EPSEstimate:     data.EpsForecast,
+			EPSActual:       data.EpsActual,
+			EPSSurprise:     data.EpsSurprise,
+			EPSSurprisePct:  data.EpsSurprisePercent,
+			RevenueEstimate: data.RevenueForecast,
+			RevenueActual:   data.RevenueActual,
+			RevenueSurprise: data.RevenueSurprise,
+		})
+	}
+
+	return earnings, nil
+}
+
+// GetSentiment fetches market sentiment
+func (c *MSNClient) GetSentiment(ids []string) ([]SentimentData, error) {
+	if len(ids) == 0 {
+		return nil, fmt.Errorf("no stock IDs provided")
+	}
+
+	c.waitForRateLimit()
+
+	apiURL := fmt.Sprintf("%sFinance/SentimentBrowser?apikey=%s&cm=id-id&it=web&scn=ANON&ids=%s&wrapodata=false&flightId=INeedDau",
+		MSNAssetsBaseURL,
+		MSNAPIKey,
+		strings.Join(ids, ","),
+	)
+
+	req := c.client.Get(g.String(apiURL))
+	for k, v := range c.commonHeaders() {
+		req = req.SetHeaders(k, v)
+	}
+
+	resp := req.Do()
+	if resp.IsErr() {
+		return nil, fmt.Errorf("sentiment request failed: %w", resp.Err())
+	}
+
+	r := resp.Ok()
+	if r.StatusCode != 200 {
+		return nil, fmt.Errorf("sentiment API returned status %d", r.StatusCode)
+	}
+
+	body := r.Body.String().Ok().Std()
+
+	var sentiment []SentimentData
+	if err := json.Unmarshal([]byte(body), &sentiment); err != nil {
+		return nil, fmt.Errorf("failed to parse sentiment response: %w", err)
+	}
+
+	return sentiment, nil
+}
+
+// GetKeyRatios fetches key financial ratios from api.msn.com
+func (c *MSNClient) GetKeyRatios(ids []string) ([]KeyRatios, error) {
+	if len(ids) == 0 {
+		return nil, fmt.Errorf("no stock IDs provided")
+	}
+
+	c.waitForRateLimit()
+
+	apiURL := fmt.Sprintf("%skeyratios?apikey=%s&ids=%s&wrapodata=false",
+		MSNAPIBaseURL,
+		MSNAPIKey,
+		strings.Join(ids, ","),
+	)
+
+	req := c.client.Get(g.String(apiURL))
+	for k, v := range c.commonHeaders() {
+		req = req.SetHeaders(k, v)
+	}
+
+	resp := req.Do()
+	if resp.IsErr() {
+		return nil, fmt.Errorf("key ratios request failed: %w", resp.Err())
+	}
+
+	r := resp.Ok()
+	if r.StatusCode != 200 {
+		return nil, fmt.Errorf("key ratios API returned status %d", r.StatusCode)
+	}
+
+	body := r.Body.String().Ok().Std()
+
+	var ratios []KeyRatios
+	if err := json.Unmarshal([]byte(body), &ratios); err != nil {
+		return nil, fmt.Errorf("failed to parse key ratios response: %w", err)
+	}
+
+	return ratios, nil
+}
+
+// GetInsights fetches AI-generated insights from api.msn.com
+func (c *MSNClient) GetInsights(id string) (*InsightData, error) {
+	if id == "" {
+		return nil, fmt.Errorf("no stock ID provided")
+	}
+
+	c.waitForRateLimit()
+
+	apiURL := fmt.Sprintf("%sinsights?apikey=%s&ids=%s&wrapodata=false",
+		MSNAPIBaseURL,
+		MSNAPIKey,
+		id,
+	)
+
+	req := c.client.Get(g.String(apiURL))
+	for k, v := range c.commonHeaders() {
+		req = req.SetHeaders(k, v)
+	}
+
+	resp := req.Do()
+	if resp.IsErr() {
+		return nil, fmt.Errorf("insights request failed: %w", resp.Err())
+	}
+
+	r := resp.Ok()
+	if r.StatusCode != 200 {
+		return nil, fmt.Errorf("insights API returned status %d", r.StatusCode)
+	}
+
+	body := r.Body.String().Ok().Std()
+
+	var insights []InsightData
+	if err := json.Unmarshal([]byte(body), &insights); err != nil {
+		return nil, fmt.Errorf("failed to parse insights response: %w", err)
+	}
+
+	if len(insights) == 0 {
+		return nil, nil
+	}
+
+	return &insights[0], nil
+}
+
+// GetNewsFeed fetches stock-related news
+func (c *MSNClient) GetNewsFeed(id string) ([]NewsItem, error) {
+	if id == "" {
+		return nil, fmt.Errorf("no stock ID provided")
+	}
+
+	c.waitForRateLimit()
+
+	// Use the stock-specific entity feed format from MSN website
+	apiURL := fmt.Sprintf("%sMSN/Feed/me?$top=30&apikey=%s&cm=id-id&contentType=article,video,slideshow&it=web&query=ef_stock_%s&queryType=entityfeed&responseSchema=cardview&scn=ANON&wrapodata=false",
+		MSNAssetsBaseURL,
+		MSNAPIKey,
+		id,
+	)
+
+	req := c.client.Get(g.String(apiURL))
+	for k, v := range c.commonHeaders() {
+		req = req.SetHeaders(k, v)
+	}
+
+	resp := req.Do()
+	if resp.IsErr() {
+		return nil, fmt.Errorf("news feed request failed: %w", resp.Err())
+	}
+
+	r := resp.Ok()
+	if r.StatusCode != 200 {
+		return nil, fmt.Errorf("news feed API returned status %d", r.StatusCode)
+	}
+
+	body := r.Body.String().Ok().Std()
+
+	var newsFeed NewsFeedResponse
+	if err := json.Unmarshal([]byte(body), &newsFeed); err != nil {
+		return nil, fmt.Errorf("failed to parse news feed response: %w", err)
+	}
+
+	// Use SubCards if available (cardview response), otherwise use Value
+	if len(newsFeed.SubCards) > 0 {
+		return newsFeed.SubCards, nil
+	}
+	return newsFeed.Value, nil
+}
+
+// GetAllCharts fetches all chart timeframes for a stock
+func (c *MSNClient) GetAllCharts(id string) (map[string][]ChartPoint, error) {
+	chartTypes := []string{"1D1M", "1M", "3M", "1Y", "3Y"}
+	result := make(map[string][]ChartPoint)
+
+	for _, chartType := range chartTypes {
+		charts, err := c.GetCharts([]string{id}, chartType)
+		if err != nil {
+			continue // Skip failed chart types
+		}
+		if len(charts) > 0 {
+			// Map chart type to friendlier names
+			typeName := chartType
+			switch chartType {
+			case "1D1M":
+				typeName = "1D"
+			}
+			result[typeName] = charts[0].Points
+		}
+	}
+
+	return result, nil
+}
+
+// FetchStockData fetches all data for a single stock
+func (c *MSNClient) FetchStockData(id string) (*StockData, error) {
+	stock := &StockData{
+		ID:          id,
+		FetchedAt:   time.Now().UTC().Format(time.RFC3339),
+		FetchStatus: make(map[string]string),
+		Charts:      make(map[string][]ChartPoint),
+	}
+
+	// Fetch quote
+	quotes, err := c.GetQuotes([]string{id})
+	if err != nil {
+		stock.FetchStatus["quote"] = fmt.Sprintf("failed: %v", err)
+	} else if len(quotes) > 0 {
+		stock.Quote = &quotes[0]
+		stock.Ticker = quotes[0].Symbol
+		stock.Name = quotes[0].ShortName
+		stock.Exchange = quotes[0].ExchangeID
+		stock.FetchStatus["quote"] = "ok"
+	}
+
+	// Fetch company info
+	equities, err := c.GetEquities([]string{id})
+	if err != nil {
+		stock.FetchStatus["company"] = fmt.Sprintf("failed: %v", err)
+	} else if len(equities) > 0 {
+		stock.Company = &equities[0]
+		stock.Sector = equities[0].Sector
+		stock.Industry = equities[0].Industry
+		if stock.Name == "" {
+			stock.Name = equities[0].ShortName
+		}
+		stock.FetchStatus["company"] = "ok"
+	}
+
+	// Fetch charts
+	charts, err := c.GetAllCharts(id)
+	if err != nil {
+		stock.FetchStatus["charts"] = fmt.Sprintf("failed: %v", err)
+	} else {
+		stock.Charts = charts
+		stock.FetchStatus["charts"] = "ok"
+	}
+
+	// Fetch key ratios
+	ratios, err := c.GetKeyRatios([]string{id})
+	if err != nil {
+		stock.FetchStatus["key_ratios"] = fmt.Sprintf("failed: %v", err)
+	} else if len(ratios) > 0 {
+		stock.KeyRatios = &ratios[0]
+		stock.FetchStatus["key_ratios"] = "ok"
+	}
+
+	// Fetch earnings
+	earnings, err := c.GetEarnings([]string{id})
+	if err != nil {
+		stock.FetchStatus["earnings"] = fmt.Sprintf("failed: %v", err)
+	} else {
+		stock.Earnings = earnings
+		stock.FetchStatus["earnings"] = "ok"
+	}
+
+	// Fetch sentiment
+	sentiment, err := c.GetSentiment([]string{id})
+	if err != nil {
+		stock.FetchStatus["sentiment"] = fmt.Sprintf("failed: %v", err)
+	} else if len(sentiment) > 0 {
+		stock.Sentiment = &sentiment[0]
+		stock.FetchStatus["sentiment"] = "ok"
+	}
+
+	// Fetch insights
+	insights, err := c.GetInsights(id)
+	if err != nil {
+		stock.FetchStatus["insights"] = fmt.Sprintf("failed: %v", err)
+	} else if insights != nil {
+		stock.Insights = insights
+		stock.FetchStatus["insights"] = "ok"
+	}
+
+	// Fetch financial statements
+	financials, err := c.GetFinancialStatements(id)
+	if err != nil {
+		stock.FetchStatus["financials"] = fmt.Sprintf("failed: %v", err)
+	} else if len(financials) > 0 {
+		stock.Financials = &FinancialData{
+			Statements: financials,
+		}
+		stock.FetchStatus["financials"] = "ok"
+	}
+
+	// Fetch news
+	news, err := c.GetNewsFeed(id)
+	if err != nil {
+		stock.FetchStatus["news"] = fmt.Sprintf("failed: %v", err)
+	} else {
+		stock.News = news
+		stock.FetchStatus["news"] = "ok"
+	}
+
+	return stock, nil
+}

msn/msn_screener.go

@@ -0,0 +1,228 @@
+package msn
+
+import (
+	"encoding/json"
+	"fmt"
+
+	"github.com/enetx/g"
+)
+
+// ScreenerFilter represents available screener filter presets
+type ScreenerFilter string
+
+const (
+	FilterTopPerformers   ScreenerFilter = "top-performers"
+	FilterWorstPerformers ScreenerFilter = "worst-performers"
+	FilterHighDividend    ScreenerFilter = "high-dividend"
+	FilterLowPE           ScreenerFilter = "low-pe"
+	Filter52WeekHigh      ScreenerFilter = "52w-high"
+	Filter52WeekLow       ScreenerFilter = "52w-low"
+	FilterHighVolume      ScreenerFilter = "high-volume"
+	FilterLargeMarketCap  ScreenerFilter = "large-cap"
+)
+
+// Filter key mappings for MSN Screener API
+var screenerFilterKeys = map[ScreenerFilter]string{
+	FilterTopPerformers:   "st_list_topperfs",
+	FilterWorstPerformers: "st_list_poorperfs",
+	FilterHighDividend:    "st_list_highdividend",
+	FilterLowPE:           "st_list_lowpe",
+	Filter52WeekHigh:      "st_list_52wkhi",
+	Filter52WeekLow:       "st_list_52wklow",
+	FilterHighVolume:      "st_list_highvol",
+	FilterLargeMarketCap:  "st_list_largecap",
+}
+
+// Region key mappings for MSN Screener API
+var screenerRegionKeys = map[string]string{
+	"id": "st_reg_id", // Indonesia
+	"us": "st_reg_us", // United States
+	"gb": "st_reg_gb", // United Kingdom
+	"de": "st_reg_de", // Germany
+	"jp": "st_reg_jp", // Japan
+	"hk": "st_reg_hk", // Hong Kong
+	"sg": "st_reg_sg", // Singapore
+	"au": "st_reg_au", // Australia
+	"in": "st_reg_in", // India
+	"cn": "st_reg_cn", // China
+}
+
+// ScreenerConfig holds screener configuration
+type ScreenerConfig struct {
+	Region    string         // Country code (e.g., "id" for Indonesia)
+	Filter    ScreenerFilter // Filter preset
+	Limit     int            // Max results
+	PageIndex int            // Page number (0-indexed)
+}
+
+// ScreenerAPIResponse is the raw response from Finance/Screener
+type ScreenerAPIResponse struct {
+	Count    int           `json:"count"`
+	MatchIDs []string      `json:"matchIds"`
+	Quote    []QuoteData   `json:"quote"`
+	Equity   []EquityData  `json:"equity"`
+	Fund     []interface{} `json:"fund"`
+}
+
+// RunScreener executes the stock screener with given configuration
+func (c *MSNClient) RunScreener(config ScreenerConfig) (*ScreenerResponse, error) {
+	if config.Region == "" {
+		config.Region = "id" // Default to Indonesia
+	}
+	if config.Limit <= 0 {
+		config.Limit = 50
+	}
+
+	// Build filter array
+	filters := buildScreenerFilters(config.Region, config.Filter)
+
+	req := ScreenerRequest{
+		Filter:          filters,
+		Order:           ScreenerOrder{Key: "st_1yr_asc_order", Dir: "desc"},
+		ReturnValueType: []string{"quote", "equity"},
+		ScreenerType:    "stock",
+		Limit:           config.Limit,
+	}
+
+	reqBody, err := json.Marshal(req)
+	if err != nil {
+		return nil, fmt.Errorf("failed to marshal screener request: %w", err)
+	}
+
+	c.waitForRateLimit()
+
+	apiURL := fmt.Sprintf("%sFinance/Screener?apikey=%s&wrapodata=false",
+		MSNAssetsBaseURL,
+		MSNAPIKey,
+	)
+
+	httpReq := c.client.Post(g.String(apiURL)).
+		SetHeaders("Content-Type", "text/plain;charset=UTF-8")
+	for k, v := range c.commonHeaders() {
+		httpReq = httpReq.SetHeaders(k, v)
+	}
+	httpReq = httpReq.Body(g.String(string(reqBody)))
+
+	resp := httpReq.Do()
+	if resp.IsErr() {
+		return nil, fmt.Errorf("screener request failed: %w", resp.Err())
+	}
+
+	r := resp.Ok()
+	if r.StatusCode != 200 {
+		body := r.Body.String().Ok().Std()
+		return nil, fmt.Errorf("screener API returned status %d: %s", r.StatusCode, body)
+	}
+
+	body := r.Body.String().Ok().Std()
+
+	var apiResp ScreenerAPIResponse
+	if err := json.Unmarshal([]byte(body), &apiResp); err != nil {
+		return nil, fmt.Errorf("failed to parse screener response: %w", err)
+	}
+
+	// Merge quote and equity data into ScreenerStock
+	stocks := mergeScreenerResults(apiResp)
+
+	return &ScreenerResponse{
+		Value:    stocks,
+		Total:    apiResp.Count,
+		Count:    apiResp.Count,
+		MatchIDs: apiResp.MatchIDs,
+	}, nil
+}
+
+// buildScreenerFilters creates filter array based on region and preset
+func buildScreenerFilters(region string, filter ScreenerFilter) []ScreenerFilterItem {
+	filters := make([]ScreenerFilterItem, 0, 2)
+
+	// Add filter preset
+	if filterKey, ok := screenerFilterKeys[filter]; ok {
+		filters = append(filters, ScreenerFilterItem{
+			Key:      filterKey,
+			KeyGroup: "st_list_",
+			IsRange:  false,
+		})
+	}
+
+	// Add region filter
+	if regionKey, ok := screenerRegionKeys[region]; ok {
+		filters = append(filters, ScreenerFilterItem{
+			Key:      regionKey,
+			KeyGroup: "st_reg_",
+			IsRange:  false,
+		})
+	}
+
+	return filters
+}
+
+// mergeScreenerResults combines quote and equity data into ScreenerStock slice
+func mergeScreenerResults(apiResp ScreenerAPIResponse) []ScreenerStock {
+	// Build equity map by instrumentId
+	equityMap := make(map[string]*EquityData)
+	for i := range apiResp.Equity {
+		eq := &apiResp.Equity[i]
+		// Use instrumentId from the "_p" field if available
+		if id := eq.ID; id != "" {
+			equityMap[id] = eq
+		}
+	}
+
+	stocks := make([]ScreenerStock, 0, len(apiResp.Quote))
+	for _, q := range apiResp.Quote {
+		stock := ScreenerStock{
+			ID:             q.InstrumentID,
+			InstrumentID:   q.InstrumentID,
+			Symbol:         q.Symbol,
+			ShortName:      q.ShortName,
+			DisplayName:    q.DisplayName,
+			ExchangeID:     q.ExchangeID,
+			ExchangeCode:   q.ExchangeCode,
+			Country:        q.Country,
+			Price:          q.Price,
+			PriceChange:    q.PriceChange,
+			PriceChangePct: q.PriceChangePct,
+			MarketCap:      q.MarketCap,
+			Volume:         q.AccumulatedVolume,
+			Price52wHigh:   q.Price52wHigh,
+			Price52wLow:    q.Price52wLow,
+			Return1Year:    q.Return1Year,
+			ReturnYTD:      q.ReturnYTD,
+		}
+
+		// Merge equity data if available
+		if eq, ok := equityMap[q.InstrumentID]; ok {
+			stock.Sector = eq.Sector
+			stock.Industry = eq.Industry
+		}
+
+		stocks = append(stocks, stock)
+	}
+
+	return stocks
+}
+
+// ParseScreenerFilter converts string to ScreenerFilter
+func ParseScreenerFilter(s string) (ScreenerFilter, error) {
+	switch s {
+	case "top-performers", "top":
+		return FilterTopPerformers, nil
+	case "worst-performers", "worst":
+		return FilterWorstPerformers, nil
+	case "high-dividend", "dividend":
+		return FilterHighDividend, nil
+	case "low-pe", "pe":
+		return FilterLowPE, nil
+	case "52w-high", "52high":
+		return Filter52WeekHigh, nil
+	case "52w-low", "52low":
+		return Filter52WeekLow, nil
+	case "high-volume", "volume":
+		return FilterHighVolume, nil
+	case "large-cap", "largecap":
+		return FilterLargeMarketCap, nil
+	default:
+		return "", fmt.Errorf("unknown filter: %s (valid: top-performers, worst-performers, high-dividend, low-pe, 52w-high, 52w-low, high-volume, large-cap)", s)
+	}
+}

msn/msn_stock.go

@@ -0,0 +1,353 @@
+package msn
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"sync"
+	"time"
+)
+
+// StockFetcher handles parallel fetching of stock data
+type StockFetcher struct {
+	msnClient  *MSNClient
+	bingClient *BingClient
+}
+
+// NewStockFetcher creates a new stock fetcher
+func NewStockFetcher() *StockFetcher {
+	return &StockFetcher{
+		msnClient:  NewMSNClient(),
+		bingClient: NewBingClient(),
+	}
+}
+
+// Close closes all clients
+func (f *StockFetcher) Close() {
+	f.msnClient.Close()
+	f.bingClient.Close()
+}
+
+// FetchResult holds the result of fetching a single stock
+type StockFetchResult struct {
+	Index int
+	Stock *StockData
+	Error error
+}
+
+// FetchStocks fetches data for multiple stocks in parallel
+func (f *StockFetcher) FetchStocks(ctx context.Context, ids []string, concurrency int) []StockData {
+	if concurrency <= 0 {
+		concurrency = 5
+	}
+
+	results := make([]StockData, len(ids))
+
+	// Create work channel
+	work := make(chan int, len(ids))
+	for i := range ids {
+		work <- i
+	}
+	close(work)
+
+	// Worker pool
+	var wg sync.WaitGroup
+	var mu sync.Mutex
+
+	for w := 0; w < concurrency; w++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+
+			for {
+				select {
+				case <-ctx.Done():
+					return
+				case idx, ok := <-work:
+					if !ok {
+						return
+					}
+
+					id := ids[idx]
+					stock := f.fetchSingleStock(ctx, id)
+
+					mu.Lock()
+					results[idx] = *stock
+					mu.Unlock()
+
+					// Count successful fetches
+					successCount := 0
+					for k, v := range stock.FetchStatus {
+						if v == "ok" {
+							successCount++
+						}
+						_ = k
+					}
+
+					log.Printf("[%d/%d] %s (%s) - %d/%d APIs succeeded",
+						idx+1, len(ids),
+						stock.Ticker,
+						stock.ID,
+						successCount,
+						len(stock.FetchStatus),
+					)
+				}
+			}
+		}()
+	}
+
+	wg.Wait()
+	return results
+}
+
+// fetchSingleStock fetches all data for a single stock
+func (f *StockFetcher) fetchSingleStock(ctx context.Context, id string) *StockData {
+	stock := &StockData{
+		ID:          id,
+		FetchedAt:   time.Now().UTC().Format(time.RFC3339),
+		FetchStatus: make(map[string]string),
+		Charts:      make(map[string][]ChartPoint),
+	}
+
+	// Use channels for parallel fetching within a single stock
+	type fetchResult struct {
+		name string
+		err  error
+		data interface{}
+	}
+
+	resultChan := make(chan fetchResult, 10)
+	var fetchWg sync.WaitGroup
+
+	// Fetch quote
+	fetchWg.Add(1)
+	go func() {
+		defer fetchWg.Done()
+		quotes, err := f.msnClient.GetQuotes([]string{id})
+		if err != nil {
+			resultChan <- fetchResult{name: "quote", err: err}
+			return
+		}
+		if len(quotes) > 0 {
+			resultChan <- fetchResult{name: "quote", data: &quotes[0]}
+		}
+	}()
+
+	// Fetch company info
+	fetchWg.Add(1)
+	go func() {
+		defer fetchWg.Done()
+		equities, err := f.msnClient.GetEquities([]string{id})
+		if err != nil {
+			resultChan <- fetchResult{name: "company", err: err}
+			return
+		}
+		if len(equities) > 0 {
+			resultChan <- fetchResult{name: "company", data: &equities[0]}
+		}
+	}()
+
+	// Fetch key ratios
+	fetchWg.Add(1)
+	go func() {
+		defer fetchWg.Done()
+		ratios, err := f.msnClient.GetKeyRatios([]string{id})
+		if err != nil {
+			resultChan <- fetchResult{name: "key_ratios", err: err}
+			return
+		}
+		if len(ratios) > 0 {
+			resultChan <- fetchResult{name: "key_ratios", data: &ratios[0]}
+		}
+	}()
+
+	// Fetch earnings
+	fetchWg.Add(1)
+	go func() {
+		defer fetchWg.Done()
+		earnings, err := f.msnClient.GetEarnings([]string{id})
+		if err != nil {
+			resultChan <- fetchResult{name: "earnings", err: err}
+			return
+		}
+		resultChan <- fetchResult{name: "earnings", data: earnings}
+	}()
+
+	// Fetch sentiment
+	fetchWg.Add(1)
+	go func() {
+		defer fetchWg.Done()
+		sentiment, err := f.msnClient.GetSentiment([]string{id})
+		if err != nil {
+			resultChan <- fetchResult{name: "sentiment", err: err}
+			return
+		}
+		if len(sentiment) > 0 {
+			resultChan <- fetchResult{name: "sentiment", data: &sentiment[0]}
+		}
+	}()
+
+	// Fetch insights
+	fetchWg.Add(1)
+	go func() {
+		defer fetchWg.Done()
+		insights, err := f.msnClient.GetInsights(id)
+		if err != nil {
+			resultChan <- fetchResult{name: "insights", err: err}
+			return
+		}
+		resultChan <- fetchResult{name: "insights", data: insights}
+	}()
+
+	// Fetch financial statements
+	fetchWg.Add(1)
+	go func() {
+		defer fetchWg.Done()
+		financials, err := f.msnClient.GetFinancialStatements(id)
+		if err != nil {
+			resultChan <- fetchResult{name: "financials", err: err}
+			return
+		}
+		resultChan <- fetchResult{name: "financials", data: financials}
+	}()
+
+	// Fetch news
+	fetchWg.Add(1)
+	go func() {
+		defer fetchWg.Done()
+		news, err := f.msnClient.GetNewsFeed(id)
+		if err != nil {
+			resultChan <- fetchResult{name: "news", err: err}
+			return
+		}
+		resultChan <- fetchResult{name: "news", data: news}
+	}()
+
+	// Fetch charts (all timeframes)
+	chartTypes := []string{"1D1M", "1M", "3M", "1Y", "3Y"}
+	for _, chartType := range chartTypes {
+		ct := chartType
+		fetchWg.Add(1)
+		go func() {
+			defer fetchWg.Done()
+			charts, err := f.msnClient.GetCharts([]string{id}, ct)
+			if err != nil {
+				return // Skip failed chart types silently
+			}
+			if len(charts) > 0 {
+				points := charts[0].ToChartPoints()
+				if len(points) > 0 {
+					typeName := ct
+					if ct == "1D1M" {
+						typeName = "1D"
+					}
+					resultChan <- fetchResult{name: "chart_" + typeName, data: points}
+				}
+			}
+		}()
+	}
+
+	// Fetch ownership data from Bing
+	fetchWg.Add(1)
+	go func() {
+		defer fetchWg.Done()
+		ownership, err := f.bingClient.GetAllOwnership(id, 20)
+		if err != nil {
+			resultChan <- fetchResult{name: "ownership", err: err}
+			return
+		}
+		resultChan <- fetchResult{name: "ownership", data: ownership}
+	}()
+
+	// Close result channel when all fetches complete
+	go func() {
+		fetchWg.Wait()
+		close(resultChan)
+	}()
+
+	// Collect results
+	for result := range resultChan {
+		if result.err != nil {
+			stock.FetchStatus[result.name] = fmt.Sprintf("failed: %v", result.err)
+			continue
+		}
+
+		switch result.name {
+		case "quote":
+			if quote, ok := result.data.(*QuoteData); ok && quote != nil {
+				stock.Quote = quote
+				stock.Ticker = quote.Symbol
+				stock.Name = quote.ShortName
+				stock.Exchange = quote.ExchangeID
+				stock.FetchStatus["quote"] = "ok"
+			}
+		case "company":
+			if equity, ok := result.data.(*EquityData); ok && equity != nil {
+				stock.Company = equity
+				stock.Sector = equity.Sector
+				stock.Industry = equity.Industry
+				if stock.Name == "" {
+					stock.Name = equity.ShortName
+				}
+				stock.FetchStatus["company"] = "ok"
+			}
+		case "key_ratios":
+			if ratios, ok := result.data.(*KeyRatios); ok && ratios != nil {
+				stock.KeyRatios = ratios
+				stock.FetchStatus["key_ratios"] = "ok"
+			}
+		case "earnings":
+			if earnings, ok := result.data.([]EarningsEvent); ok {
+				stock.Earnings = earnings
+				stock.FetchStatus["earnings"] = "ok"
+			}
+		case "sentiment":
+			if sentiment, ok := result.data.(*SentimentData); ok && sentiment != nil {
+				stock.Sentiment = sentiment
+				stock.FetchStatus["sentiment"] = "ok"
+			}
+		case "insights":
+			if insights, ok := result.data.(*InsightData); ok && insights != nil {
+				stock.Insights = insights
+				stock.FetchStatus["insights"] = "ok"
+			}
+		case "financials":
+			if financials, ok := result.data.(FinancialStatementsResponse); ok && len(financials) > 0 {
+				stock.Financials = &FinancialData{
+					Statements: financials,
+				}
+				stock.FetchStatus["financials"] = "ok"
+			}
+		case "news":
+			if news, ok := result.data.([]NewsItem); ok {
+				stock.News = news
+				stock.FetchStatus["news"] = "ok"
+			}
+		case "ownership":
+			if ownership, ok := result.data.(*OwnershipData); ok && ownership != nil {
+				stock.Ownership = ownership
+				stock.FetchStatus["ownership"] = "ok"
+			}
+		default:
+			// Handle chart results
+			if len(result.name) > 6 && result.name[:6] == "chart_" {
+				chartType := result.name[6:]
+				if points, ok := result.data.([]ChartPoint); ok {
+					stock.Charts[chartType] = points
+					stock.FetchStatus["charts"] = "ok"
+				}
+			}
+		}
+	}
+
+	return stock
+}
+
+// FetchStockByID fetches a single stock by ID
+func (f *StockFetcher) FetchStockByID(ctx context.Context, id string) (*StockData, error) {
+	stocks := f.FetchStocks(ctx, []string{id}, 1)
+	if len(stocks) == 0 {
+		return nil, fmt.Errorf("failed to fetch stock %s", id)
+	}
+	return &stocks[0], nil
+}

msn/msn_types.go

@@ -0,0 +1,550 @@
+package msn
+
+// MSN API Constants
+const (
+	MSNAssetsBaseURL = "https://assets.msn.com/service/"
+	MSNAPIBaseURL    = "https://api.msn.com/msn/v0/pages/finance/"
+	BingAPIBaseURL   = "https://services.bingapis.com/contentservices-finance.hedgefunddataprovider/api/v1/"
+
+	// Public API key from MSN Money website
+	MSNAPIKey = "0QfOX3Vn51YCzitbLaRkTTBadtWpgTN8NZLW0C1SEM"
+)
+
+// ScreenerRequest is the POST body for Finance/Screener
+// Uses the actual MSN API format with predefined filter keys
+type ScreenerRequest struct {
+	Filter          []ScreenerFilterItem `json:"filter"`
+	Order           ScreenerOrder        `json:"order"`
+	ReturnValueType []string             `json:"returnValueType"`
+	ScreenerType    string               `json:"screenerType"`
+	Limit           int                  `json:"limit"`
+}
+
+// ScreenerFilterItem represents a filter condition in the screener
+type ScreenerFilterItem struct {
+	Key      string `json:"key"`      // e.g., "st_list_topperfs", "st_reg_id"
+	KeyGroup string `json:"keyGroup"` // e.g., "st_list_", "st_reg_"
+	IsRange  bool   `json:"isRange"`
+}
+
+// ScreenerOrder represents sort order for screener results
+type ScreenerOrder struct {
+	Key string `json:"key"` // e.g., "st_1yr_asc_order"
+	Dir string `json:"dir"` // "asc" or "desc"
+}
+
+// ScreenerResponse from Finance/Screener
+type ScreenerResponse struct {
+	Value    []ScreenerStock `json:"value"`
+	Total    int             `json:"total"`
+	Count    int             `json:"count"`
+	MatchIDs []string        `json:"matchIds"`
+	Equity   []ScreenerStock `json:"equity"`
+	Quote    []QuoteData     `json:"quote"`
+}
+
+// ScreenerStock is a stock from screener results
+type ScreenerStock struct {
+	ID             string  `json:"id"`
+	InstrumentID   string  `json:"instrumentId,omitempty"`
+	Symbol         string  `json:"symbol"`
+	ShortName      string  `json:"shortName"`
+	DisplayName    string  `json:"displayName,omitempty"`
+	ExchangeID     string  `json:"exchangeId"`
+	ExchangeCode   string  `json:"exchangeCode,omitempty"`
+	Country        string  `json:"country,omitempty"`
+	Sector         string  `json:"sector,omitempty"`
+	Industry       string  `json:"industry,omitempty"`
+	Price          float64 `json:"price"`
+	PriceChange    float64 `json:"priceChange"`
+	PriceChangePct float64 `json:"priceChangePercent"`
+	MarketCap      float64 `json:"marketCap"`
+	Volume         float64 `json:"accumulatedVolume"`
+	Price52wHigh   float64 `json:"price52wHigh"`
+	Price52wLow    float64 `json:"price52wLow"`
+	Return1Year    float64 `json:"return1Year"`
+	ReturnYTD      float64 `json:"returnYTD"`
+}
+
+// QuoteResponse from Finance/Quotes
+type QuoteResponse []QuoteData
+
+// QuoteData represents real-time quote data
+type QuoteData struct {
+	ID                 string  `json:"id"`
+	InstrumentID       string  `json:"instrumentId"`
+	Symbol             string  `json:"symbol"`
+	ShortName          string  `json:"shortName"`
+	DisplayName        string  `json:"displayName"`
+	Price              float64 `json:"price"`
+	PriceChange        float64 `json:"priceChange"`
+	PriceChangePct     float64 `json:"priceChangePercent"`
+	PriceDayOpen       float64 `json:"priceDayOpen"`
+	PriceDayHigh       float64 `json:"priceDayHigh"`
+	PriceDayLow        float64 `json:"priceDayLow"`
+	PricePreviousClose float64 `json:"pricePreviousClose"`
+	PriceClose         float64 `json:"priceClose"`
+	Price52wHigh       float64 `json:"price52wHigh"`
+	Price52wLow        float64 `json:"price52wLow"`
+	AccumulatedVolume  float64 `json:"accumulatedVolume"`
+	AverageVolume      float64 `json:"averageVolume"`
+	MarketCap          float64 `json:"marketCap"`
+	MarketCapCurrency  string  `json:"marketCapCurrency"`
+	ExchangeID         string  `json:"exchangeId"`
+	ExchangeCode       string  `json:"exchangeCode"`
+	ExchangeName       string  `json:"exchangeName"`
+	Currency           string  `json:"currency"`
+	Country            string  `json:"country"`
+	Market             string  `json:"market"`
+	TimeLastTraded     string  `json:"timeLastTraded"`
+	TimeLastUpdated    string  `json:"timeLastUpdated"`
+	// Historical price changes
+	PriceChange1Week  float64 `json:"priceChange1Week"`
+	PriceChange1Month float64 `json:"priceChange1Month"`
+	PriceChange3Month float64 `json:"priceChange3Month"`
+	PriceChange6Month float64 `json:"priceChange6Month"`
+	PriceChangeYTD    float64 `json:"priceChangeYTD"`
+	PriceChange1Year  float64 `json:"priceChange1Year"`
+	// Historical returns (percentage)
+	Return1Week  float64 `json:"return1Week"`
+	Return1Month float64 `json:"return1Month"`
+	Return3Month float64 `json:"return3Month"`
+	Return6Month float64 `json:"return6Month"`
+	ReturnYTD    float64 `json:"returnYTD"`
+	Return1Year  float64 `json:"return1Year"`
+}
+
+// QuoteSummaryResponse from Finance/QuoteSummary
+type QuoteSummaryResponse []struct {
+	Quotes    []QuoteData     `json:"quotes"`
+	Exchanges []ExchangeData  `json:"exchanges"`
+	Details   []QuoteDetail   `json:"quoteDetails"`
+	ChartData []ChartResponse `json:"charts"`
+}
+
+// ExchangeData from Finance/Exchanges
+type ExchangeData struct {
+	ID       string `json:"id"`
+	Name     string `json:"name"`
+	Country  string `json:"country"`
+	Timezone string `json:"timeZone"`
+}
+
+// QuoteDetail provides extended quote information
+type QuoteDetail struct {
+	ID              string  `json:"id"`
+	Beta            float64 `json:"beta"`
+	TrailingPE      float64 `json:"trailingPE"`
+	ForwardPE       float64 `json:"forwardPE"`
+	PriceToBook     float64 `json:"priceToBook"`
+	PriceToSales    float64 `json:"priceToSales"`
+	EnterpriseValue float64 `json:"enterpriseValue"`
+	EBITDA          float64 `json:"ebitda"`
+	Revenue         float64 `json:"revenue"`
+	GrossProfit     float64 `json:"grossProfit"`
+	FreeCashFlow    float64 `json:"freeCashFlow"`
+	DebtToEquity    float64 `json:"debtToEquity"`
+	QuickRatio      float64 `json:"quickRatio"`
+	CurrentRatio    float64 `json:"currentRatio"`
+	ReturnOnEquity  float64 `json:"returnOnEquity"`
+	ReturnOnAssets  float64 `json:"returnOnAssets"`
+	ProfitMargin    float64 `json:"profitMargin"`
+	OperatingMargin float64 `json:"operatingMargin"`
+	GrossMargin     float64 `json:"grossMargin"`
+}
+
+// ChartResponse from Finance/Charts
+type ChartResponse struct {
+	ID        string          `json:"_p"`
+	ChartType string          `json:"chartType"` // "1D1M", "1M", "3M", "1Y", "3Y"
+	Symbol    string          `json:"symbol"`
+	Series    ChartSeriesData `json:"series"`
+	Points    []ChartPoint    `json:"-"` // Computed from Series
+}
+
+// ChartSeriesData is the raw series data from the API
+type ChartSeriesData struct {
+	TimeStamps []string  `json:"timeStamps"`
+	Prices     []float64 `json:"prices"`
+	OpenPrices []float64 `json:"openPrices"`
+	PricesHigh []float64 `json:"pricesHigh"`
+	PricesLow  []float64 `json:"pricesLow"`
+	Volumes    []float64 `json:"volumes"`
+	StartTime  string    `json:"startTime"`
+	EndTime    string    `json:"endTime"`
+	PriceHigh  float64   `json:"priceHigh"`
+	PriceLow   float64   `json:"priceLow"`
+}
+
+// ToChartPoints converts the series data into chart points
+func (c *ChartResponse) ToChartPoints() []ChartPoint {
+	if len(c.Series.TimeStamps) == 0 {
+		return nil
+	}
+
+	points := make([]ChartPoint, len(c.Series.TimeStamps))
+	for i, ts := range c.Series.TimeStamps {
+		point := ChartPoint{Time: ts}
+
+		if i < len(c.Series.Prices) {
+			point.Price = c.Series.Prices[i]
+			point.Close = c.Series.Prices[i]
+		}
+		if i < len(c.Series.OpenPrices) {
+			point.Open = c.Series.OpenPrices[i]
+		}
+		if i < len(c.Series.PricesHigh) {
+			point.High = c.Series.PricesHigh[i]
+		}
+		if i < len(c.Series.PricesLow) {
+			point.Low = c.Series.PricesLow[i]
+		}
+		if i < len(c.Series.Volumes) {
+			point.Volume = int64(c.Series.Volumes[i])
+		}
+		points[i] = point
+	}
+	return points
+}
+
+// ChartPoint is a single data point in a chart
+type ChartPoint struct {
+	Time   string  `json:"time"`
+	Price  float64 `json:"price"`
+	Open   float64 `json:"open"`
+	High   float64 `json:"high"`
+	Low    float64 `json:"low"`
+	Close  float64 `json:"close"`
+	Volume int64   `json:"volume"`
+}
+
+// EquityResponse from Finance/Equities
+type EquityResponse []EquityData
+
+// EquityData represents company information
+type EquityData struct {
+	ID          string    `json:"id"`
+	Symbol      string    `json:"symbol"`
+	ShortName   string    `json:"shortName"`
+	LongName    string    `json:"longName"`
+	Description string    `json:"description"`
+	Sector      string    `json:"sector"`
+	Industry    string    `json:"industry"`
+	Website     string    `json:"website"`
+	Employees   int       `json:"fullTimeEmployees"`
+	Address     string    `json:"address"`
+	City        string    `json:"city"`
+	Country     string    `json:"country"`
+	Phone       string    `json:"phone"`
+	Officers    []Officer `json:"officers"`
+}
+
+// Officer represents a company executive
+type Officer struct {
+	Name     string `json:"name"`
+	Title    string `json:"title"`
+	Age      int    `json:"age"`
+	YearBorn int    `json:"yearBorn"`
+	TotalPay int64  `json:"totalPay"`
+}
+
+// FinancialStatementsResponse from Finance/Equities/financialstatements
+// Response is an array of FinancialStatement objects
+type FinancialStatementsResponse []FinancialStatement
+
+// FinancialStatement represents comprehensive financial data
+type FinancialStatement struct {
+	UnderlyingInstrument InstrumentInfo   `json:"underlyingInstrument"`
+	BalanceSheets        *BalanceSheet    `json:"balanceSheets"`
+	CashFlow             *CashFlowData    `json:"cashFlow"`
+	IncomeStatements     *IncomeStatement `json:"incomeStatements"`
+}
+
+// InstrumentInfo contains basic stock information
+type InstrumentInfo struct {
+	InstrumentID string `json:"instrumentId"`
+	DisplayName  string `json:"displayName"`
+	ShortName    string `json:"shortName"`
+	ExchangeID   string `json:"exchangeId"`
+	ExchangeCode string `json:"exchangeCode"`
+	SecurityType string `json:"securityType"`
+	Symbol       string `json:"symbol"`
+}
+
+// BalanceSheet represents balance sheet data
+type BalanceSheet struct {
+	CurrentAssets      map[string]float64 `json:"currentAssets"`
+	LongTermAssets     map[string]float64 `json:"longTermAssets"`
+	CurrentLiabilities map[string]float64 `json:"currentLiabilities"`
+	Equity             map[string]float64 `json:"equity"`
+	Currency           string             `json:"currency"`
+	Source             string             `json:"source"`
+	SourceDate         string             `json:"sourceDate"`
+	ReportDate         string             `json:"reportDate"`
+	EndDate            string             `json:"endDate"`
+}
+
+// CashFlowData represents cash flow statement
+type CashFlowData struct {
+	Financing map[string]float64 `json:"financing"`
+	Investing map[string]float64 `json:"investing"`
+	Operating map[string]float64 `json:"operating"`
+	Currency  string             `json:"currency"`
+	Source    string             `json:"source"`
+	EndDate   string             `json:"endDate"`
+}
+
+// IncomeStatement represents income statement data
+type IncomeStatement struct {
+	Revenue  map[string]float64 `json:"revenue"`
+	Expenses map[string]float64 `json:"expenses"`
+	Currency string             `json:"currency"`
+	Source   string             `json:"source"`
+	EndDate  string             `json:"endDate"`
+}
+
+// KeyRatiosResponse from api.msn.com keyratios
+type KeyRatiosResponse []KeyRatios
+
+// KeyRatios represents financial ratios with historical data
+type KeyRatios struct {
+	StockID         string           `json:"stockId"`
+	ExchangeID      string           `json:"exchangeId"`
+	Market          string           `json:"market"`
+	Industry        string           `json:"industry"`
+	DisplayName     string           `json:"displayName"`
+	ShortName       string           `json:"shortName"`
+	Symbol          string           `json:"symbol"`
+	IndustryMetrics []IndustryMetric `json:"industryMetrics"`
+}
+
+// IndustryMetric represents financial metrics for a specific year
+type IndustryMetric struct {
+	Year                 string  `json:"year"`
+	FiscalPeriodType     string  `json:"fiscalPeriodType"`
+	RevenuePerShare      float64 `json:"revenuePerShare"`
+	EarningsPerShare     float64 `json:"earningsPerShare"`
+	FreeCashFlowPerShare float64 `json:"freeCashFlowPerShare"`
+	DividendPerShare     float64 `json:"dividendPerShare"`
+	BookValuePerShare    float64 `json:"bookValuePerShare"`
+	RevenueGrowthRate    float64 `json:"revenueGrowthRate"`
+	EarningsGrowthRate   float64 `json:"earningsGrowthRate"`
+	GrossMargin          float64 `json:"grossMargin"`
+	OperatingMargin      float64 `json:"operatingMargin"`
+	NetMargin            float64 `json:"netMargin"`
+	ROE                  float64 `json:"roe"`
+	ROIC                 float64 `json:"roic"`
+	ROA                  float64 `json:"returnOnAssetCurrent"`
+	DebtToEquityRatio    float64 `json:"debtToEquityRatio"`
+	DebtToEBITDA         float64 `json:"debtToEbitda"`
+	FinancialLeverage    float64 `json:"financialLeverage"`
+	QuickRatio           float64 `json:"quickRatio"`
+	CurrentRatio         float64 `json:"currentRatio"`
+	AssetTurnover        float64 `json:"assetTurnover"`
+	InventoryTurnover    float64 `json:"inventoryTurnover"`
+	ReceivableTurnover   float64 `json:"receivableTurnover"`
+	PayoutRatio          float64 `json:"payoutRatio"`
+	PriceToSalesRatio    float64 `json:"priceToSalesRatio"`
+	PriceToEarningsRatio float64 `json:"priceToEarningsRatio"`
+	PriceToCashFlowRatio float64 `json:"priceToCashFlowRatio"`
+	PriceToBookRatio     float64 `json:"priceToBookRatio"`
+	EVToEBITDA           float64 `json:"evEbitda"`
+}
+
+// EarningsAPIResponse represents the actual API response from Finance/Events/Earnings
+type EarningsAPIResponse struct {
+	History struct {
+		Quarterly map[string]EarningsData `json:"quarterly"`
+		Annual    map[string]EarningsData `json:"annual"`
+	} `json:"History"`
+	InstrumentID string `json:"InstrumentId"`
+	Symbol       string `json:"Symbol"`
+}
+
+// EarningsData represents a single earnings report from the API
+type EarningsData struct {
+	EpsActual           float64 `json:"EpsActual"`
+	EpsSurprise         float64 `json:"EpsSurprise"`
+	EpsSurprisePercent  float64 `json:"EpsSurprisePercent"`
+	EpsForecast         float64 `json:"EpsForecast"`
+	RevenueActual       float64 `json:"RevenueActual"`
+	RevenueSurprise     float64 `json:"RevenueSurprise"`
+	RevenueForecast     float64 `json:"RevenueForecast"`
+	EarningReleaseDate  string  `json:"EarningReleaseDate"`
+	CiqFiscalPeriodType string  `json:"CiqFiscalPeriodType"` // e.g., "Q42025", "Q12026"
+	CalendarPeriodType  string  `json:"CalendarPeriodType"`
+}
+
+// EarningsEvent represents a normalized earnings event for storage
+type EarningsEvent struct {
+	ID              string  `json:"id"`
+	EventDate       string  `json:"eventDate"`
+	FiscalYear      int     `json:"fiscalYear"`
+	FiscalQuarter   int     `json:"fiscalQuarter"`
+	EPSEstimate     float64 `json:"epsEstimate"`
+	EPSActual       float64 `json:"epsActual"`
+	EPSSurprise     float64 `json:"epsSurprise"`
+	EPSSurprisePct  float64 `json:"epsSurprisePercent"`
+	RevenueEstimate float64 `json:"revenueEstimate"`
+	RevenueActual   float64 `json:"revenueActual"`
+	RevenueSurprise float64 `json:"revenueSurprise"`
+}
+
+// SentimentResponse from Finance/SentimentBrowser
+type SentimentResponse []SentimentData
+
+// SentimentData represents market sentiment for a stock
+type SentimentData struct {
+	DisplayName         string               `json:"displayName"`
+	Market              string               `json:"market"`
+	InstrumentID        string               `json:"instrumentId"`
+	Symbol              string               `json:"symbol"`
+	SentimentStatistics []SentimentStatistic `json:"sentimentStatistics"`
+}
+
+// SentimentStatistic represents sentiment data for a time period
+type SentimentStatistic struct {
+	StartTime      int64   `json:"startTime"`
+	EndTime        int64   `json:"endTime"`
+	TimeRangeName  string  `json:"timeRangeName"`
+	TimeRangeEnum  string  `json:"timeRangeEnum"`
+	Bullish        int     `json:"bullish"`
+	Bearish        int     `json:"bearish"`
+	Neutral        int     `json:"neutral"`
+	BullishPercent float64 `json:"bullishPercent"`
+	BearishPercent float64 `json:"bearishPercent"`
+	NeutralPercent float64 `json:"neutralPercent"`
+	Scenario       string  `json:"scenairo"` // Note: API has typo "scenairo"
+}
+
+// InsightsResponse from api.msn.com insights
+type InsightsResponse []InsightData
+
+// InsightData represents AI-generated stock insights
+type InsightData struct {
+	ID          string   `json:"id"`
+	Summary     string   `json:"summary"`
+	Highlights  []string `json:"highlights"`
+	Risks       []string `json:"risks"`
+	LastUpdated string   `json:"lastUpdated"`
+}
+
+// NewsFeedResponse from MSN/Feed/me
+type NewsFeedResponse struct {
+	Value    []NewsItem `json:"value"`
+	SubCards []NewsItem `json:"subCards"`
+}
+
+// NewsItem represents a news article
+type NewsItem struct {
+	ID          string        `json:"id"`
+	Type        string        `json:"type"`
+	Title       string        `json:"title"`
+	URL         string        `json:"url"`
+	Description string        `json:"abstract"`
+	Provider    *NewsProvider `json:"provider"`
+	PublishTime string        `json:"publishedDateTime"`
+	Images      []NewsImage   `json:"images"`
+	ReadTimeMin int           `json:"readTimeMin"`
+}
+
+// NewsProvider represents a news provider
+type NewsProvider struct {
+	ID   string `json:"id"`
+	Name string `json:"name"`
+}
+
+// NewsImage represents a news article image
+type NewsImage struct {
+	URL    string `json:"url"`
+	Width  int    `json:"width"`
+	Height int    `json:"height"`
+}
+
+// Holder represents an institutional holder
+type Holder struct {
+	Name         string  `json:"investorName"`
+	Type         string  `json:"investorType"`
+	SharesHeld   int64   `json:"sharesHeld"`
+	SharesChange int64   `json:"sharesChange"`
+	SharesPct    float64 `json:"sharesPercent"`
+	Value        float64 `json:"value"`
+	ReportDate   string  `json:"reportDate"`
+}
+
+// OwnershipResponse from Bing API
+type OwnershipResponse struct {
+	Records            []Holder `json:"records"`
+	SecurityOwnerships []Holder `json:"securityOwnerships"`
+	Total              int      `json:"total"`
+}
+
+// OwnershipData aggregates all ownership information
+type OwnershipData struct {
+	TopHolders    []Holder `json:"top_holders"`
+	TopBuyers     []Holder `json:"top_buyers"`
+	TopSellers    []Holder `json:"top_sellers"`
+	NewHolders    []Holder `json:"new_holders"`
+	ExitedHolders []Holder `json:"exited_holders"`
+}
+
+// StockData is the complete stock information output
+type StockData struct {
+	ID       string `json:"id"`
+	Ticker   string `json:"ticker"`
+	Name     string `json:"name"`
+	Exchange string `json:"exchange"`
+	Sector   string `json:"sector"`
+	Industry string `json:"industry"`
+
+	// Real-time data
+	Quote *QuoteData `json:"quote,omitempty"`
+
+	// Historical Charts
+	Charts map[string][]ChartPoint `json:"charts,omitempty"`
+
+	// Fundamentals
+	Financials *FinancialData `json:"financials,omitempty"`
+	KeyRatios  *KeyRatios     `json:"key_ratios,omitempty"`
+
+	// Company Info
+	Company *EquityData `json:"company,omitempty"`
+
+	// Events
+	Earnings []EarningsEvent `json:"earnings,omitempty"`
+
+	// Analysis
+	Sentiment *SentimentData `json:"sentiment,omitempty"`
+	Insights  *InsightData   `json:"insights,omitempty"`
+
+	// Ownership (Bing API)
+	Ownership *OwnershipData `json:"ownership,omitempty"`
+
+	// News
+	News []NewsItem `json:"news,omitempty"`
+
+	// Metadata
+	FetchedAt   string            `json:"fetched_at"`
+	FetchStatus map[string]string `json:"fetch_status"`
+}
+
+// FinancialData aggregates all financial statements
+type FinancialData struct {
+	Statements []FinancialStatement `json:"statements,omitempty"`
+}
+
+// ScreenerOutput is the JSON output for screener command
+type ScreenerOutput struct {
+	Filter      string          `json:"filter"`
+	Region      string          `json:"region"`
+	GeneratedAt string          `json:"generated_at"`
+	Total       int             `json:"total"`
+	Stocks      []ScreenerStock `json:"stocks"`
+}
+
+// FetchOutput is the JSON output for fetch command
+type FetchOutput struct {
+	GeneratedAt string      `json:"generated_at"`
+	Total       int         `json:"total"`
+	Stocks      []StockData `json:"stocks"`
+}

msn/news_analysis.go

@@ -0,0 +1,194 @@
+package msn
+
+import (
+	"strings"
+)
+
+// News categories
+const (
+	CategoryEarnings        = "earnings"
+	CategoryDividend        = "dividend"
+	CategoryCorporateAction = "corporate_action"
+	CategoryRegulation      = "regulation"
+	CategoryRating          = "rating"
+	CategoryExpansion       = "expansion"
+	CategoryLeadership      = "leadership"
+	CategoryMarket          = "market"
+	CategoryGeneral         = "general"
+)
+
+// Sentiment types
+const (
+	SentimentPositive = "positive"
+	SentimentNegative = "negative"
+	SentimentNeutral  = "neutral"
+)
+
+// Category keywords (Indonesian + English)
+var categoryKeywords = map[string][]string{
+	CategoryEarnings: {
+		"laba", "rugi", "earnings", "profit", "net income", "pendapatan",
+		"revenue", "keuntungan", "kerugian", "loss", "income", "untung",
+		"quarterly", "kuartalan", "annual report", "laporan tahunan",
+		"eps", "earning per share",
+	},
+	CategoryDividend: {
+		"dividen", "dividend", "pembagian", "interim", "final dividend",
+		"cum date", "ex date", "payment date", "tanggal pembayaran",
+		"yield", "payout",
+	},
+	CategoryCorporateAction: {
+		"akuisisi", "merger", "acquisition", "rights issue", "stock split",
+		"reverse split", "buyback", "ipo", "penawaran umum", "private placement",
+		"tender offer", "spin off", "spinoff", "demerger", "konsolidasi",
+		"rights", "waran", "warrant", "obligasi", "bond", "sukuk",
+	},
+	CategoryRegulation: {
+		"ojk", "regulasi", "peraturan", "kebijakan", "regulation", "policy",
+		"compliance", "kepatuhan", "lisensi", "license", "izin", "permit",
+		"pemerintah", "government", "bapepam", "bei", "idx", "bursa",
+	},
+	CategoryRating: {
+		"rating", "peringkat", "upgrade", "downgrade", "outlook",
+		"stable", "positive", "negative", "credit rating", "moody",
+		"fitch", "s&p", "pefindo", "target price", "rekomendasi",
+		"buy", "sell", "hold", "analyst",
+	},
+	CategoryExpansion: {
+		"ekspansi", "expansion", "investasi", "investment", "proyek baru",
+		"new project", "pabrik", "factory", "plant", "cabang", "branch",
+		"pembangunan", "construction", "development", "joint venture", "jv",
+		"kerjasama", "partnership", "kontrak", "contract",
+	},
+	CategoryLeadership: {
+		"direktur", "director", "komisaris", "commissioner", "ceo", "cfo",
+		"president director", "management", "manajemen", "direksi",
+		"rups", "agm", "annual general meeting", "pengangkatan", "appointment",
+		"pengunduran", "resignation", "pergantian", "change",
+	},
+	CategoryMarket: {
+		"ihsg", "idx", "pasar modal", "bursa", "market", "saham",
+		"stock", "trading", "perdagangan", "volume", "kapitalisasi",
+		"market cap", "blue chip", "lq45", "idx80", "kompas100",
+	},
+}
+
+// Positive sentiment keywords
+var positiveKeywords = []string{
+	// Indonesian
+	"naik", "untung", "tumbuh", "positif", "optimis", "meningkat",
+	"surplus", "berhasil", "sukses", "cemerlang", "bagus", "baik",
+	"membaik", "melonjak", "meroket", "tertinggi", "rekor",
+	"peningkatan", "pertumbuhan", "keuntungan", "laba bersih",
+	"ekspansi", "pemulihan", "recovery",
+	// English
+	"rise", "gain", "growth", "positive", "optimistic", "increase",
+	"surplus", "success", "excellent", "good", "improve", "surge",
+	"soar", "highest", "record", "profit", "expansion", "recovery",
+	"bullish", "upgrade", "beat", "exceed", "outperform",
+}
+
+// Negative sentiment keywords
+var negativeKeywords = []string{
+	// Indonesian
+	"turun", "rugi", "anjlok", "negatif", "pesimis", "menurun",
+	"defisit", "gagal", "buruk", "memburuk", "jatuh", "tertekan",
+	"terendah", "penurunan", "kerugian", "merosot", "melemah",
+	"default", "bangkrut", "pailit", "koreksi", "tekanan",
+	// English
+	"fall", "loss", "plunge", "negative", "pessimistic", "decrease",
+	"deficit", "fail", "bad", "worsen", "drop", "pressure",
+	"lowest", "decline", "weak", "default", "bankrupt", "correction",
+	"bearish", "downgrade", "miss", "underperform", "concern", "risk",
+}
+
+// Critical news keywords (alerts)
+var criticalKeywords = []string{
+	// Indonesian
+	"suspend", "suspensi", "fraud", "penipuan", "korupsi", "corruption",
+	"default", "gagal bayar", "bangkrut", "pailit", "bankruptcy",
+	"delisting", "pencabutan", "investigasi", "investigation",
+	"skandal", "scandal", "illegal", "ilegal", "pelanggaran", "violation",
+	"tuntutan", "lawsuit", "gugatan", "denda", "fine", "sanksi", "sanction",
+	"pkpu", "penundaan", "moratorium", "restrukturisasi utang",
+	// English
+	"suspend", "fraud", "corruption", "default", "bankrupt", "bankruptcy",
+	"delisting", "investigation", "scandal", "illegal", "violation",
+	"lawsuit", "fine", "sanction", "debt restructuring", "warning",
+	"material adverse", "going concern", "audit opinion", "disclaimer",
+}
+
+// categorizeNews determines the category of a news article
+func categorizeNews(title, abstract string) string {
+	text := strings.ToLower(title + " " + abstract)
+
+	// Check each category
+	maxScore := 0
+	bestCategory := CategoryGeneral
+
+	for category, keywords := range categoryKeywords {
+		score := 0
+		for _, keyword := range keywords {
+			if strings.Contains(text, keyword) {
+				score++
+			}
+		}
+		if score > maxScore {
+			maxScore = score
+			bestCategory = category
+		}
+	}
+
+	return bestCategory
+}
+
+// scoreNewsSentiment analyzes sentiment of a news article
+func scoreNewsSentiment(title, abstract string) (sentiment string, score float64) {
+	text := strings.ToLower(title + " " + abstract)
+
+	positiveScore := 0
+	negativeScore := 0
+
+	for _, keyword := range positiveKeywords {
+		if strings.Contains(text, keyword) {
+			positiveScore++
+		}
+	}
+
+	for _, keyword := range negativeKeywords {
+		if strings.Contains(text, keyword) {
+			negativeScore++
+		}
+	}
+
+	totalScore := positiveScore + negativeScore
+	if totalScore == 0 {
+		return SentimentNeutral, 0.0
+	}
+
+	// Calculate score from -1 (very negative) to +1 (very positive)
+	score = float64(positiveScore-negativeScore) / float64(totalScore)
+
+	if score > 0.2 {
+		sentiment = SentimentPositive
+	} else if score < -0.2 {
+		sentiment = SentimentNegative
+	} else {
+		sentiment = SentimentNeutral
+	}
+
+	return sentiment, score
+}
+
+// isNewsCritical checks if news contains critical/alert-worthy content
+func isNewsCritical(title, abstract string) bool {
+	text := strings.ToLower(title + " " + abstract)
+
+	for _, keyword := range criticalKeywords {
+		if strings.Contains(text, keyword) {
+			return true
+		}
+	}
+
+	return false
+}

msn/rate_limiter.go

@@ -0,0 +1,97 @@
+package msn
+
+import (
+	"math/rand"
+	"sync"
+	"time"
+)
+
+// RateLimiter implements a token bucket rate limiter with random delay
+type RateLimiter struct {
+	mu           sync.Mutex
+	tokens       float64
+	maxTokens    float64
+	refillRate   float64 // tokens per second
+	lastRefill   time.Time
+	minDelayMs   int // minimum delay in milliseconds
+	maxDelayMs   int // maximum delay in milliseconds
+	requestCount int64
+}
+
+// RateLimiterConfig holds rate limiter configuration
+type RateLimiterConfig struct {
+	RequestsPerSecond float64 // target RPS
+	MinDelayMs        int     // minimum random delay
+	MaxDelayMs        int     // maximum random delay
+}
+
+// NewRateLimiter creates a new rate limiter
+func NewRateLimiter(config RateLimiterConfig) *RateLimiter {
+	if config.RequestsPerSecond <= 0 {
+		config.RequestsPerSecond = 10 // default 10 RPS
+	}
+
+	return &RateLimiter{
+		tokens:     config.RequestsPerSecond, // start with full bucket
+		maxTokens:  config.RequestsPerSecond,
+		refillRate: config.RequestsPerSecond,
+		lastRefill: time.Now(),
+		minDelayMs: config.MinDelayMs,
+		maxDelayMs: config.MaxDelayMs,
+	}
+}
+
+// Wait blocks until a token is available and applies random delay
+func (r *RateLimiter) Wait() {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+
+	// Refill tokens based on elapsed time
+	now := time.Now()
+	elapsed := now.Sub(r.lastRefill).Seconds()
+	r.tokens += elapsed * r.refillRate
+	if r.tokens > r.maxTokens {
+		r.tokens = r.maxTokens
+	}
+	r.lastRefill = now
+
+	// Wait if no tokens available
+	if r.tokens < 1 {
+		waitTime := time.Duration((1-r.tokens)/r.refillRate*1000) * time.Millisecond
+		r.mu.Unlock()
+		time.Sleep(waitTime)
+		r.mu.Lock()
+		r.tokens = 0
+	} else {
+		r.tokens--
+	}
+
+	r.requestCount++
+
+	// Apply random delay if configured
+	if r.maxDelayMs > 0 {
+		delayRange := r.maxDelayMs - r.minDelayMs
+		if delayRange <= 0 {
+			delayRange = 1
+		}
+		delay := r.minDelayMs + rand.Intn(delayRange)
+		r.mu.Unlock()
+		time.Sleep(time.Duration(delay) * time.Millisecond)
+		r.mu.Lock()
+	}
+}
+
+// RequestCount returns the total number of requests made
+func (r *RateLimiter) RequestCount() int64 {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	return r.requestCount
+}
+
+// SetRPS dynamically adjusts the rate limit
+func (r *RateLimiter) SetRPS(rps float64) {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	r.maxTokens = rps
+	r.refillRate = rps
+}

pyproject.toml

@@ -0,0 +1,12 @@
+[project]
+name = "rubick"
+version = "0.1.0"
+description = "Add your description here"
+requires-python = ">=3.12"
+dependencies = [
+    "lxml-html-clean>=0.4.3",
+    "newspaper4k>=0.9.4.1",
+    "openpyxl>=3.1.5",
+    "pandas>=3.0.0",
+    "xlsxwriter>=3.2.9",
+]

scripts/e2e_run.sh

@@ -0,0 +1,31 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+APP_BIN="${1:-./bin/rubick}"
+if [[ ! -x "$APP_BIN" ]]; then
+  echo "error: binary not executable: $APP_BIN" >&2
+  exit 1
+fi
+
+TS="$(date +%Y%m%d-%H%M%S)"
+OUT="output/$TS"
+mkdir -p "$OUT"
+
+echo "timestamp=$TS" > "$OUT/RUN_INFO.txt"
+
+echo "[1/5] msn fetch-all"
+"$APP_BIN" msn fetch-all --index idx30 --limit 3 --db "$OUT/stocks.db" --rps 10 --delay 100-150 --concurrency 2
+
+echo "[2/5] news plain"
+"$APP_BIN" news IHSG --from 2026-03-01 --to 2026-03-05 --count 2 --concurrency 2 --output "$OUT/news_plain.json"
+
+echo "[3/5] export simple csv"
+"$APP_BIN" export simple --db "$OUT/stocks.db" --format csv --output "$OUT/csv"
+
+echo "[4/5] export dashboard"
+"$APP_BIN" export dashboard --db "$OUT/stocks.db" --output "$OUT/dashboard.xlsx"
+
+echo "[5/5] export history"
+"$APP_BIN" export history --db "$OUT/stocks.db" --output "$OUT/history.xlsx"
+
+echo "E2E completed: $OUT"

scripts/export_history.py

@@ -0,0 +1,626 @@
+#!/usr/bin/env python3
+"""
+History Excel Export Script - Professional Edition
+
+Exports historical data (price history, ratio history, sentiment history) to Excel
+with proper tables and conditional formatting. No charts - tables only.
+
+Usage:
+    uv run python scripts/export_history.py --db output/stocks.db --output output/history.xlsx
+"""
+
+import argparse
+import sqlite3
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+import xlsxwriter
+from xlsxwriter.utility import xl_range
+
+# Color palette - matches export_dashboard.py
+COLORS = {
+    'primary_dark': '#1F4E79',
+    'primary': '#2E75B6',
+    'primary_light': '#5B9BD5',
+    'success_dark': '#375623',
+    'success': '#70AD47',
+    'success_light': '#C6EFCE',
+    'success_text': '#006100',
+    'danger_dark': '#833C0C',
+    'danger': '#C00000',
+    'danger_light': '#FFC7CE',
+    'danger_text': '#9C0006',
+    'warning_dark': '#7F6000',
+    'warning': '#FFC000',
+    'warning_light': '#FFEB9C',
+    'warning_text': '#9C5700',
+    'white': '#FFFFFF',
+    'light_gray': '#F2F2F2',
+    'dark_gray': '#404040',
+}
+
+TABLE_STYLE = 'Table Style Medium 2'
+
+
+def safe_float(value, default=None) -> Optional[float]:
+    """Safely convert to float."""
+    if value is None:
+        return default
+    try:
+        return float(value)
+    except (ValueError, TypeError):
+        return default
+
+
+class HistoryExporter:
+    """Professional History Excel Exporter."""
+
+    def __init__(self, workbook: xlsxwriter.Workbook, conn: sqlite3.Connection,
+                 start_date: str = None, end_date: str = None, stock_id: str = None):
+        self.wb = workbook
+        self.conn = conn
+        self.start_date = start_date
+        self.end_date = end_date
+        self.stock_id = stock_id
+        self._setup_formats()
+
+    def _setup_formats(self):
+        """Setup formatting styles - matches export_dashboard.py."""
+        self.fmt_title = self.wb.add_format({
+            'bold': True, 'font_size': 18, 'font_color': COLORS['primary_dark'],
+            'bottom': 2, 'bottom_color': COLORS['primary_dark']
+        })
+        self.fmt_subtitle = self.wb.add_format({
+            'bold': True, 'font_size': 12, 'font_color': COLORS['primary']
+        })
+        self.fmt_section = self.wb.add_format({
+            'bold': True, 'font_size': 14, 'font_color': COLORS['white'],
+            'bg_color': COLORS['primary_dark'], 'align': 'center', 'valign': 'vcenter'
+        })
+        self.fmt_header = self.wb.add_format({
+            'bold': True, 'font_color': COLORS['white'],
+            'bg_color': COLORS['primary_dark'], 'align': 'center', 'valign': 'vcenter',
+            'border': 1, 'text_wrap': True
+        })
+        self.fmt_num = self.wb.add_format({'num_format': '#,##0.00', 'align': 'right'})
+        self.fmt_num_0 = self.wb.add_format({'num_format': '#,##0', 'align': 'right'})
+        self.fmt_pct = self.wb.add_format({'num_format': '0.00"%"', 'align': 'right'})
+        self.fmt_pct_signed = self.wb.add_format({'num_format': '+0.00%;-0.00%;0.00%', 'align': 'right'})
+        self.fmt_date = self.wb.add_format({'num_format': 'yyyy-mm-dd', 'align': 'center'})
+        self.fmt_kpi_value = self.wb.add_format({
+            'bold': True, 'font_size': 24, 'font_color': COLORS['primary_dark'],
+            'align': 'center', 'valign': 'vcenter'
+        })
+        self.fmt_kpi_label = self.wb.add_format({
+            'font_size': 10, 'font_color': COLORS['dark_gray'],
+            'align': 'center', 'valign': 'vcenter', 'bold': True
+        })
+        self.fmt_kpi_box = self.wb.add_format({
+            'bg_color': COLORS['light_gray'], 'border': 1, 'border_color': COLORS['primary_light']
+        })
+
+    def _add_table(self, ws, start_row: int, start_col: int, data: list,
+                   columns: list, table_name: str, total_row: bool = False) -> int:
+        """Add a proper Excel Table with filtering and sorting."""
+        if not data:
+            ws.write(start_row, start_col, "No data available")
+            return start_row + 1
+
+        end_row = start_row + len(data)
+        end_col = start_col + len(columns) - 1
+
+        # Build table columns
+        table_columns = []
+        for col_def in columns:
+            col_opt = {'header': col_def['header']}
+            if col_def.get('total_function'):
+                col_opt['total_function'] = col_def['total_function']
+            if col_def.get('total_string'):
+                col_opt['total_string'] = col_def['total_string']
+            if col_def.get('format'):
+                col_opt['format'] = col_def['format']
+            table_columns.append(col_opt)
+
+        # Write data
+        for row_idx, row_data in enumerate(data):
+            for col_idx, col_def in enumerate(columns):
+                key = col_def.get('key')
+                value = row_data.get(key) if key else None
+
+                transform = col_def.get('transform')
+                if transform and value is not None:
+                    value = transform(value)
+
+                fmt = col_def.get('format')
+                ws.write(start_row + 1 + row_idx, start_col + col_idx, value, fmt)
+
+        # Add table
+        table_range = xl_range(start_row, start_col, end_row, end_col)
+        ws.add_table(table_range, {
+            'name': table_name,
+            'style': TABLE_STYLE,
+            'columns': table_columns,
+            'total_row': total_row,
+            'autofilter': True,
+        })
+
+        # Set column widths
+        for col_idx, col_def in enumerate(columns):
+            width = col_def.get('width', 12)
+            ws.set_column(start_col + col_idx, start_col + col_idx, width)
+
+        return end_row + (2 if total_row else 1)
+
+    def _get_stocks(self) -> list:
+        """Get all stocks."""
+        cursor = self.conn.execute("""
+            SELECT id, ticker, name, exchange_code as exchange
+            FROM stocks ORDER BY ticker
+        """)
+        return [dict(row) for row in cursor.fetchall()]
+
+    def _get_price_history(self) -> list:
+        """Get price history with filters."""
+        query = """
+            SELECT ph.*, s.ticker, s.name
+            FROM price_history ph
+            JOIN stocks s ON ph.stock_id = s.id
+            WHERE 1=1
+        """
+        params = []
+
+        if self.stock_id:
+            query += " AND ph.stock_id = ?"
+            params.append(self.stock_id)
+        if self.start_date:
+            query += " AND ph.scrape_date >= ?"
+            params.append(self.start_date)
+        if self.end_date:
+            query += " AND ph.scrape_date <= ?"
+            params.append(self.end_date)
+
+        query += " ORDER BY s.ticker, ph.scrape_date DESC"
+        return [dict(row) for row in self.conn.execute(query, params).fetchall()]
+
+    def _get_ratios_history(self) -> list:
+        """Get ratios history with filters."""
+        query = """
+            SELECT rh.*, s.ticker, s.name
+            FROM ratios_history rh
+            JOIN stocks s ON rh.stock_id = s.id
+            WHERE 1=1
+        """
+        params = []
+
+        if self.stock_id:
+            query += " AND rh.stock_id = ?"
+            params.append(self.stock_id)
+        if self.start_date:
+            query += " AND rh.scrape_date >= ?"
+            params.append(self.start_date)
+        if self.end_date:
+            query += " AND rh.scrape_date <= ?"
+            params.append(self.end_date)
+
+        query += " ORDER BY s.ticker, rh.scrape_date DESC"
+        return [dict(row) for row in self.conn.execute(query, params).fetchall()]
+
+    def _get_sentiment_history(self) -> list:
+        """Get sentiment history with filters."""
+        query = """
+            SELECT sh.*, s.ticker, s.name
+            FROM sentiment_history sh
+            JOIN stocks s ON sh.stock_id = s.id
+            WHERE 1=1
+        """
+        params = []
+
+        if self.stock_id:
+            query += " AND sh.stock_id = ?"
+            params.append(self.stock_id)
+        if self.start_date:
+            query += " AND sh.scrape_date >= ?"
+            params.append(self.start_date)
+        if self.end_date:
+            query += " AND sh.scrape_date <= ?"
+            params.append(self.end_date)
+
+        query += " ORDER BY s.ticker, sh.scrape_date DESC"
+        return [dict(row) for row in self.conn.execute(query, params).fetchall()]
+
+    def _get_scrape_runs(self) -> list:
+        """Get scrape runs."""
+        cursor = self.conn.execute("""
+            SELECT * FROM scrape_runs ORDER BY started_at DESC
+        """)
+        return [dict(row) for row in cursor.fetchall()]
+
+    def create_summary_sheet(self, stocks: list, price_history: list,
+                             ratios_history: list, sentiment_history: list,
+                             scrape_runs: list):
+        """Create summary sheet."""
+        ws = self.wb.add_worksheet("Summary")
+
+        # Title
+        ws.merge_range('A1:F1', "Historical Data Summary", self.fmt_title)
+        ws.set_row(0, 30)
+        ws.write('A2', f"Generated: {datetime.now().strftime('%Y-%m-%d %H:%M')}", self.fmt_subtitle)
+
+        # KPI cards
+        row = 4
+        kpis = [
+            ("Total Stocks", str(len(stocks))),
+            ("Price Records", str(len(price_history))),
+            ("Ratio Records", str(len(ratios_history))),
+            ("Sentiment Records", str(len(sentiment_history))),
+            ("Scrape Runs", str(len(scrape_runs))),
+        ]
+
+        col = 0
+        for label, value in kpis:
+            ws.merge_range(row, col, row + 1, col + 1, '', self.fmt_kpi_box)
+            ws.write(row, col, label, self.fmt_kpi_label)
+            ws.write(row + 1, col, value, self.fmt_kpi_value)
+            col += 2
+
+        # Date range
+        row = 7
+        ws.write(row, 0, "Data Date Range:", self.fmt_subtitle)
+
+        if price_history:
+            dates = [p['scrape_date'] for p in price_history if p.get('scrape_date')]
+            if dates:
+                ws.write(row + 1, 0, f"From: {min(dates)}")
+                ws.write(row + 2, 0, f"To: {max(dates)}")
+
+        # Scrape runs summary table
+        row = 11
+        ws.merge_range(row, 0, row, 5, "Recent Scrape Runs", self.fmt_section)
+        row += 1
+
+        run_data = []
+        for r in scrape_runs[:10]:
+            started = r.get('started_at', '')
+            finished = r.get('finished_at', '')
+
+            duration = ''
+            if started and finished:
+                try:
+                    start_dt = datetime.fromisoformat(started.replace('Z', '+00:00'))
+                    finish_dt = datetime.fromisoformat(finished.replace('Z', '+00:00'))
+                    delta = finish_dt - start_dt
+                    duration = str(delta)
+                except:
+                    pass
+
+            run_data.append({
+                'id': r.get('id'),
+                'status': r.get('status'),
+                'index': r.get('index_name'),
+                'total': r.get('total_stocks'),
+                'success': r.get('success'),
+                'failed': r.get('failed'),
+                'duration': duration,
+            })
+
+        run_cols = [
+            {'header': 'Run ID', 'key': 'id', 'width': 8},
+            {'header': 'Status', 'key': 'status', 'width': 12},
+            {'header': 'Index', 'key': 'index', 'width': 10},
+            {'header': 'Total', 'key': 'total', 'width': 8, 'format': self.fmt_num_0},
+            {'header': 'Success', 'key': 'success', 'width': 8, 'format': self.fmt_num_0},
+            {'header': 'Failed', 'key': 'failed', 'width': 8, 'format': self.fmt_num_0},
+            {'header': 'Duration', 'key': 'duration', 'width': 15},
+        ]
+
+        self._add_table(ws, row, 0, run_data, run_cols, 'ScrapeRuns')
+
+        ws.set_column('A:G', 12)
+
+    def create_price_history_sheet(self, data: list):
+        """Create price history sheet."""
+        ws = self.wb.add_worksheet("Price History")
+
+        ws.merge_range('A1:N1', "Price History", self.fmt_title)
+        ws.set_row(0, 25)
+
+        row = 3
+        price_data = [{
+            'ticker': p['ticker'],
+            'name': p['name'],
+            'date': p.get('scrape_date', ''),
+            'price': safe_float(p.get('price')),
+            'change': safe_float(p.get('price_change')),
+            'change_pct': safe_float(p.get('price_change_pct'), 0) / 100 if p.get('price_change_pct') else None,
+            'open': safe_float(p.get('price_open')),
+            'high': safe_float(p.get('price_high')),
+            'low': safe_float(p.get('price_low')),
+            'volume': safe_float(p.get('volume')),
+            'market_cap': safe_float(p.get('market_cap')),
+            'high_52w': safe_float(p.get('price_52w_high')),
+            'low_52w': safe_float(p.get('price_52w_low')),
+            'ytd_pct': safe_float(p.get('price_change_ytd'), 0) / 100 if p.get('price_change_ytd') else None,
+        } for p in data]
+
+        price_cols = [
+            {'header': 'Ticker', 'key': 'ticker', 'width': 8},
+            {'header': 'Name', 'key': 'name', 'width': 22},
+            {'header': 'Date', 'key': 'date', 'width': 11},
+            {'header': 'Price', 'key': 'price', 'width': 10, 'format': self.fmt_num},
+            {'header': 'Change', 'key': 'change', 'width': 10, 'format': self.fmt_num},
+            {'header': 'Chg%', 'key': 'change_pct', 'width': 8, 'format': self.fmt_pct_signed},
+            {'header': 'Open', 'key': 'open', 'width': 10, 'format': self.fmt_num},
+            {'header': 'High', 'key': 'high', 'width': 10, 'format': self.fmt_num},
+            {'header': 'Low', 'key': 'low', 'width': 10, 'format': self.fmt_num},
+            {'header': 'Volume', 'key': 'volume', 'width': 14, 'format': self.fmt_num_0},
+            {'header': 'Market Cap', 'key': 'market_cap', 'width': 15, 'format': self.fmt_num_0},
+            {'header': '52W High', 'key': 'high_52w', 'width': 10, 'format': self.fmt_num},
+            {'header': '52W Low', 'key': 'low_52w', 'width': 10, 'format': self.fmt_num},
+            {'header': 'YTD%', 'key': 'ytd_pct', 'width': 8, 'format': self.fmt_pct_signed},
+        ]
+
+        self._add_table(ws, row, 0, price_data, price_cols, 'PriceHistory')
+
+        # Conditional formatting on change %
+        if price_data:
+            data_end = row + len(price_data)
+            ws.conditional_format(row + 1, 5, data_end, 5, {
+                'type': '3_color_scale',
+                'min_color': '#F8696B',
+                'mid_color': '#FFEB84',
+                'max_color': '#63BE7B',
+            })
+
+        ws.freeze_panes(4, 2)
+
+    def create_ratios_history_sheet(self, data: list):
+        """Create ratios history sheet."""
+        ws = self.wb.add_worksheet("Ratios History")
+
+        ws.merge_range('A1:W1', "Financial Ratios History", self.fmt_title)
+        ws.set_row(0, 25)
+
+        row = 3
+        ratio_data = [{
+            'ticker': r['ticker'],
+            'name': r['name'],
+            'date': r.get('scrape_date', ''),
+            'year': r.get('year', ''),
+            'pe': safe_float(r.get('pe_ratio')),
+            'pb': safe_float(r.get('pb_ratio')),
+            'ps': safe_float(r.get('ps_ratio')),
+            'pcf': safe_float(r.get('pcf_ratio')),
+            'ev_ebitda': safe_float(r.get('ev_ebitda')),
+            'roe': safe_float(r.get('roe')),
+            'roa': safe_float(r.get('roa')),
+            'roic': safe_float(r.get('roic')),
+            'gross': safe_float(r.get('gross_margin')),
+            'op_margin': safe_float(r.get('operating_margin')),
+            'net_margin': safe_float(r.get('net_margin')),
+            'de': safe_float(r.get('debt_to_equity')),
+            'current': safe_float(r.get('current_ratio')),
+            'quick': safe_float(r.get('quick_ratio')),
+            'div_yield': safe_float(r.get('dividend_yield')),
+            'payout': safe_float(r.get('payout_ratio')),
+            'eps': safe_float(r.get('eps')),
+            'bvps': safe_float(r.get('bvps')),
+            'rev_gr': safe_float(r.get('revenue_growth')),
+        } for r in data]
+
+        ratio_cols = [
+            {'header': 'Ticker', 'key': 'ticker', 'width': 8},
+            {'header': 'Name', 'key': 'name', 'width': 20},
+            {'header': 'Date', 'key': 'date', 'width': 11},
+            {'header': 'Year', 'key': 'year', 'width': 6},
+            {'header': 'P/E', 'key': 'pe', 'width': 7, 'format': self.fmt_num},
+            {'header': 'P/B', 'key': 'pb', 'width': 7, 'format': self.fmt_num},
+            {'header': 'P/S', 'key': 'ps', 'width': 7, 'format': self.fmt_num},
+            {'header': 'P/CF', 'key': 'pcf', 'width': 7, 'format': self.fmt_num},
+            {'header': 'EV/EBITDA', 'key': 'ev_ebitda', 'width': 9, 'format': self.fmt_num},
+            {'header': 'ROE%', 'key': 'roe', 'width': 7, 'format': self.fmt_num},
+            {'header': 'ROA%', 'key': 'roa', 'width': 7, 'format': self.fmt_num},
+            {'header': 'ROIC%', 'key': 'roic', 'width': 7, 'format': self.fmt_num},
+            {'header': 'Gross%', 'key': 'gross', 'width': 8, 'format': self.fmt_num},
+            {'header': 'Op%', 'key': 'op_margin', 'width': 7, 'format': self.fmt_num},
+            {'header': 'Net%', 'key': 'net_margin', 'width': 7, 'format': self.fmt_num},
+            {'header': 'D/E', 'key': 'de', 'width': 7, 'format': self.fmt_num},
+            {'header': 'Current', 'key': 'current', 'width': 8, 'format': self.fmt_num},
+            {'header': 'Quick', 'key': 'quick', 'width': 7, 'format': self.fmt_num},
+            {'header': 'Yield%', 'key': 'div_yield', 'width': 7, 'format': self.fmt_num},
+            {'header': 'Payout%', 'key': 'payout', 'width': 8, 'format': self.fmt_num},
+            {'header': 'EPS', 'key': 'eps', 'width': 8, 'format': self.fmt_num},
+            {'header': 'BVPS', 'key': 'bvps', 'width': 9, 'format': self.fmt_num},
+            {'header': 'RevGr%', 'key': 'rev_gr', 'width': 8, 'format': self.fmt_num},
+        ]
+
+        self._add_table(ws, row, 0, ratio_data, ratio_cols, 'RatiosHistory')
+
+        # Conditional formatting on ROE
+        if ratio_data:
+            data_end = row + len(ratio_data)
+            ws.conditional_format(row + 1, 9, data_end, 9, {
+                'type': 'data_bar',
+                'bar_color': COLORS['success'],
+                'bar_solid': True,
+            })
+
+        ws.freeze_panes(4, 2)
+
+    def create_sentiment_history_sheet(self, data: list):
+        """Create sentiment history sheet."""
+        ws = self.wb.add_worksheet("Sentiment History")
+
+        ws.merge_range('A1:K1', "Sentiment History", self.fmt_title)
+        ws.set_row(0, 25)
+
+        row = 3
+        sent_data = [{
+            'ticker': s['ticker'],
+            'name': s['name'],
+            'date': s.get('scrape_date', ''),
+            'time_range': s.get('time_range', ''),
+            'bullish': safe_float(s.get('bullish_pct')),
+            'bearish': safe_float(s.get('bearish_pct')),
+            'neutral': safe_float(s.get('neutral_pct')),
+            'bull_count': safe_float(s.get('bullish')),
+            'bear_count': safe_float(s.get('bearish')),
+            'neut_count': safe_float(s.get('neutral')),
+            'net': (safe_float(s.get('bullish_pct'), 0) - safe_float(s.get('bearish_pct'), 0)),
+        } for s in data]
+
+        sent_cols = [
+            {'header': 'Ticker', 'key': 'ticker', 'width': 8},
+            {'header': 'Name', 'key': 'name', 'width': 22},
+            {'header': 'Date', 'key': 'date', 'width': 11},
+            {'header': 'Period', 'key': 'time_range', 'width': 15},
+            {'header': 'Bull%', 'key': 'bullish', 'width': 8, 'format': self.fmt_num},
+            {'header': 'Bear%', 'key': 'bearish', 'width': 8, 'format': self.fmt_num},
+            {'header': 'Neut%', 'key': 'neutral', 'width': 8, 'format': self.fmt_num},
+            {'header': 'Bulls', 'key': 'bull_count', 'width': 8, 'format': self.fmt_num_0},
+            {'header': 'Bears', 'key': 'bear_count', 'width': 8, 'format': self.fmt_num_0},
+            {'header': 'Neutral', 'key': 'neut_count', 'width': 8, 'format': self.fmt_num_0},
+            {'header': 'Net', 'key': 'net', 'width': 8, 'format': self.fmt_num},
+        ]
+
+        self._add_table(ws, row, 0, sent_data, sent_cols, 'SentimentHistory')
+
+        # Conditional formatting
+        if sent_data:
+            data_end = row + len(sent_data)
+            # Bullish data bar
+            ws.conditional_format(row + 1, 4, data_end, 4, {
+                'type': 'data_bar',
+                'bar_color': COLORS['success'],
+                'bar_solid': True,
+            })
+            # Bearish data bar
+            ws.conditional_format(row + 1, 5, data_end, 5, {
+                'type': 'data_bar',
+                'bar_color': COLORS['danger'],
+                'bar_solid': True,
+            })
+            # Net sentiment 3-color
+            ws.conditional_format(row + 1, 10, data_end, 10, {
+                'type': '3_color_scale',
+                'min_color': '#F8696B',
+                'mid_color': '#FFEB84',
+                'max_color': '#63BE7B',
+            })
+
+        ws.freeze_panes(4, 2)
+
+    def create_price_pivot_sheet(self, stocks: list, price_history: list):
+        """Create price pivot table (dates as rows, stocks as columns)."""
+        ws = self.wb.add_worksheet("Price Pivot")
+
+        ws.merge_range('A1:C1', "Price Matrix (Pivot)", self.fmt_title)
+        ws.set_row(0, 25)
+
+        if not price_history or not stocks:
+            ws.write(3, 0, "No data available")
+            return
+
+        # Get unique dates (limit to 365)
+        dates = sorted(set(p['scrape_date'] for p in price_history if p.get('scrape_date')),
+                       reverse=True)[:365]
+
+        if not dates:
+            ws.write(3, 0, "No date data available")
+            return
+
+        # Limit to 100 stocks
+        stock_list = stocks[:100]
+
+        # Build price lookup
+        price_lookup = {}
+        for p in price_history:
+            key = (p['stock_id'], p['scrape_date'])
+            price_lookup[key] = p.get('price')
+
+        # Header row with tickers
+        row = 3
+        ws.write(row, 0, "Date", self.fmt_header)
+        for col, stock in enumerate(stock_list, 1):
+            ws.write(row, col, stock['ticker'], self.fmt_header)
+
+        # Data rows
+        for row_idx, date in enumerate(dates):
+            ws.write(row + 1 + row_idx, 0, date)
+            for col_idx, stock in enumerate(stock_list, 1):
+                price = price_lookup.get((stock['id'], date))
+                if price:
+                    ws.write(row + 1 + row_idx, col_idx, price, self.fmt_num)
+
+        ws.freeze_panes(4, 1)
+        ws.set_column(0, 0, 12)
+        ws.set_column(1, 100, 10)
+
+    def generate(self):
+        """Generate all history sheets."""
+        print("Loading data...")
+        stocks = self._get_stocks()
+        price_history = self._get_price_history()
+        ratios_history = self._get_ratios_history()
+        sentiment_history = self._get_sentiment_history()
+        scrape_runs = self._get_scrape_runs()
+
+        print("Creating Summary sheet...")
+        self.create_summary_sheet(stocks, price_history, ratios_history,
+                                  sentiment_history, scrape_runs)
+
+        print("Creating Price History sheet...")
+        self.create_price_history_sheet(price_history)
+
+        print("Creating Ratios History sheet...")
+        self.create_ratios_history_sheet(ratios_history)
+
+        print("Creating Sentiment History sheet...")
+        self.create_sentiment_history_sheet(sentiment_history)
+
+        if stocks and price_history:
+            print("Creating Price Pivot sheet...")
+            self.create_price_pivot_sheet(stocks, price_history)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Export historical stock data to professional Excel"
+    )
+    parser.add_argument('--db', required=True, help='Path to SQLite database')
+    parser.add_argument('--output', '-o', required=True, help='Output Excel file path')
+    parser.add_argument('--start-date', help='Start date filter (YYYY-MM-DD)')
+    parser.add_argument('--end-date', help='End date filter (YYYY-MM-DD)')
+    parser.add_argument('--stock', help='Filter by stock ID')
+
+    args = parser.parse_args()
+
+    if not Path(args.db).exists():
+        print(f"Error: Database not found: {args.db}")
+        return 1
+
+    conn = sqlite3.connect(args.db)
+    conn.row_factory = sqlite3.Row
+
+    workbook = xlsxwriter.Workbook(args.output, {
+        'constant_memory': False,
+        'strings_to_urls': True,
+    })
+
+    exporter = HistoryExporter(
+        workbook, conn,
+        start_date=args.start_date,
+        end_date=args.end_date,
+        stock_id=args.stock
+    )
+    exporter.generate()
+
+    workbook.close()
+    conn.close()
+
+    print(f"\nHistory exported to: {args.output}")
+    return 0
+
+
+if __name__ == "__main__":
+    exit(main())

scripts/export_simple.py

@@ -0,0 +1,81 @@
+#!/usr/bin/env python3
+"""Simple table export from SQLite to JSON/CSV/XLSX."""
+
+import argparse
+import json
+import sqlite3
+from pathlib import Path
+
+import pandas as pd
+
+DEFAULT_TABLES = [
+    "stocks",
+    "price_history",
+    "ratios_history",
+    "news",
+    "sentiment_history",
+    "scrape_runs",
+    "scrape_progress",
+]
+
+
+def load_table(conn: sqlite3.Connection, table: str) -> pd.DataFrame:
+    return pd.read_sql_query(f"SELECT * FROM {table}", conn)
+
+
+def export_json(conn: sqlite3.Connection, outdir: Path, tables: list[str]) -> int:
+    outdir.mkdir(parents=True, exist_ok=True)
+    for table in tables:
+        df = load_table(conn, table)
+        data = json.loads(df.to_json(orient="records", date_format="iso"))
+        (outdir / f"{table}.json").write_text(json.dumps(data, indent=2), encoding="utf-8")
+    return 0
+
+
+def export_csv(conn: sqlite3.Connection, outdir: Path, tables: list[str]) -> int:
+    outdir.mkdir(parents=True, exist_ok=True)
+    for table in tables:
+        df = load_table(conn, table)
+        df.to_csv(outdir / f"{table}.csv", index=False)
+    return 0
+
+
+def export_xlsx(conn: sqlite3.Connection, outfile: Path, tables: list[str]) -> int:
+    outfile.parent.mkdir(parents=True, exist_ok=True)
+    with pd.ExcelWriter(outfile, engine="openpyxl") as writer:
+        for table in tables:
+            df = load_table(conn, table)
+            sheet = table[:31] if table else "sheet"
+            df.to_excel(writer, sheet_name=sheet, index=False)
+    return 0
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Simple SQLite table exporter")
+    parser.add_argument("--db", required=True, help="SQLite database path")
+    parser.add_argument("--format", required=True, choices=["json", "csv", "xlsx"], help="Export format")
+    parser.add_argument("--output", "-o", required=True, help="Output path (dir for json/csv, file for xlsx)")
+    parser.add_argument("--tables", help="Comma-separated tables (default: common tables)")
+    args = parser.parse_args()
+
+    db_path = Path(args.db)
+    if not db_path.exists():
+        print(f"Error: Database not found: {db_path}")
+        return 1
+
+    tables = [t.strip() for t in args.tables.split(",")] if args.tables else DEFAULT_TABLES
+    tables = [t for t in tables if t]
+
+    conn = sqlite3.connect(db_path)
+    try:
+        if args.format == "json":
+            return export_json(conn, Path(args.output), tables)
+        if args.format == "csv":
+            return export_csv(conn, Path(args.output), tables)
+        return export_xlsx(conn, Path(args.output), tables)
+    finally:
+        conn.close()
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scripts/release_bundle.sh

@@ -0,0 +1,65 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+VERSION="${1:-}"
+if [[ -z "$VERSION" ]]; then
+  if git describe --tags --always >/dev/null 2>&1; then
+    VERSION="$(git describe --tags --always)"
+  else
+    VERSION="0.0.0-$(date +%Y%m%d%H%M%S)"
+  fi
+fi
+
+APP_NAME="rubick"
+OS="$(uname -s | tr '[:upper:]' '[:lower:]')"
+ARCH="$(uname -m)"
+
+case "$ARCH" in
+  x86_64) ARCH="amd64" ;;
+  aarch64|arm64) ARCH="arm64" ;;
+esac
+
+DIST_DIR="dist"
+PKG_BASENAME="${APP_NAME}_${VERSION}_${OS}_${ARCH}"
+PKG_DIR="${DIST_DIR}/${PKG_BASENAME}"
+
+rm -rf "$PKG_DIR"
+mkdir -p "$PKG_DIR/bin" "$PKG_DIR/scripts"
+
+# Build binary
+GOOS="$OS" GOARCH="$ARCH" go build -o "$PKG_DIR/bin/$APP_NAME" ./cmd/rubick
+
+# Runtime Python assets
+cp extractor.py "$PKG_DIR/"
+cp scripts/export_dashboard.py scripts/export_history.py scripts/export_simple.py "$PKG_DIR/scripts/"
+cp pyproject.toml uv.lock .env.example README.md "$PKG_DIR/"
+
+cat > "$PKG_DIR/INSTALL.md" <<'DOC'
+# Rubick Bundle Install
+
+1. Ensure Python 3.12+ and uv are installed.
+2. In this bundle directory, run:
+
+```bash
+uv sync --frozen
+```
+
+3. Run the binary:
+
+```bash
+./bin/rubick --help
+```
+
+4. For live news queries, create `.env` with `BRAVE_API_KEY`.
+DOC
+
+# Checksums
+( cd "$PKG_DIR" && shasum -a 256 bin/$APP_NAME extractor.py scripts/*.py pyproject.toml uv.lock > SHA256SUMS )
+
+# Archives
+( cd "$DIST_DIR" && tar -czf "${PKG_BASENAME}.tar.gz" "$PKG_BASENAME" )
+( cd "$DIST_DIR" && zip -qr "${PKG_BASENAME}.zip" "$PKG_BASENAME" )
+
+echo "release_bundle=$PKG_DIR"
+echo "archive_tar=${DIST_DIR}/${PKG_BASENAME}.tar.gz"
+echo "archive_zip=${DIST_DIR}/${PKG_BASENAME}.zip"

tests/go/cli_test.go

@@ -0,0 +1,141 @@
+package gotests
+
+import (
+	"bytes"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+var (
+	repoRootPath string
+	testBinPath  string
+)
+
+func repoRoot() string {
+	return repoRootPath
+}
+
+func TestMain(m *testing.M) {
+	root, err := filepath.Abs("../..")
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "resolve repo root: %v\n", err)
+		os.Exit(1)
+	}
+	repoRootPath = root
+
+	binDir := filepath.Join(root, ".bin")
+	if err := os.MkdirAll(binDir, 0o755); err != nil {
+		fmt.Fprintf(os.Stderr, "create .bin dir: %v\n", err)
+		os.Exit(1)
+	}
+
+	testBinPath = filepath.Join(binDir, "rubick-test")
+	build := exec.Command("go", "build", "-o", testBinPath, "./cmd/rubick")
+	build.Dir = root
+	build.Stdout = os.Stdout
+	build.Stderr = os.Stderr
+	if err := build.Run(); err != nil {
+		fmt.Fprintf(os.Stderr, "build test binary: %v\n", err)
+		os.Exit(1)
+	}
+
+	code := m.Run()
+	_ = os.Remove(testBinPath)
+	os.Exit(code)
+}
+
+func runCLI(t *testing.T, args ...string) (int, string) {
+	t.Helper()
+	cmd := exec.Command(testBinPath, args...)
+	cmd.Dir = repoRoot()
+
+	var buf bytes.Buffer
+	cmd.Stdout = &buf
+	cmd.Stderr = &buf
+
+	err := cmd.Run()
+	if err == nil {
+		return 0, buf.String()
+	}
+	if ee, ok := err.(*exec.ExitError); ok {
+		return ee.ExitCode(), buf.String()
+	}
+	t.Fatalf("failed to run command %v: %v", args, err)
+	return -1, ""
+}
+
+func runCLILive(t *testing.T, env map[string]string, args ...string) (int, string) {
+	t.Helper()
+	cmd := exec.Command(testBinPath, args...)
+	cmd.Dir = repoRoot()
+	cmd.Env = os.Environ()
+	for k, v := range env {
+		cmd.Env = append(cmd.Env, k+"="+v)
+	}
+
+	var buf bytes.Buffer
+	cmd.Stdout = &buf
+	cmd.Stderr = &buf
+
+	err := cmd.Run()
+	if err == nil {
+		return 0, buf.String()
+	}
+	if ee, ok := err.(*exec.ExitError); ok {
+		return ee.ExitCode(), buf.String()
+	}
+	t.Fatalf("failed to run command %v: %v", args, err)
+	return -1, ""
+}
+
+func TestCLIHelpExitCodes(t *testing.T) {
+	cases := [][]string{
+		{"--help"},
+		{"msn", "--help"},
+		{"msn", "screener", "--help"},
+		{"msn", "fetch", "--help"},
+		{"msn", "fetch-all", "--help"},
+		{"msn", "lookup", "--help"},
+		{"news", "--help"},
+		{"export", "--help"},
+		{"extractor", "--help"},
+	}
+
+	for _, c := range cases {
+		code, out := runCLI(t, c...)
+		if code != 0 {
+			t.Fatalf("expected exit 0 for %v, got %d\n%s", c, code, out)
+		}
+	}
+}
+
+func TestCLIErrorExitCodes(t *testing.T) {
+	cases := [][]string{
+		{"unknown"},
+		{"msn"},
+		{"news"},
+		{"export"},
+		{"extractor"},
+	}
+
+	for _, c := range cases {
+		code, _ := runCLI(t, c...)
+		if code == 0 {
+			t.Fatalf("expected non-zero exit for %v", c)
+		}
+	}
+}
+
+func TestCLILookup(t *testing.T) {
+	code, out := runCLI(t, "msn", "lookup", "BBCA")
+	if code != 0 {
+		t.Fatalf("expected success, got %d\n%s", code, out)
+	}
+	if !strings.Contains(out, "BBCA") {
+		t.Fatalf("expected output to contain BBCA, got:\n%s", out)
+	}
+}

tests/go/live_e2e_test.go

@@ -0,0 +1,67 @@
+package gotests
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func isTransientNetworkErr(out string) bool {
+	s := strings.ToLower(out)
+	patterns := []string{
+		"no such host", "timeout", "tempor", "connection reset", "connection refused", "429",
+	}
+	for _, p := range patterns {
+		if strings.Contains(s, p) {
+			return true
+		}
+	}
+	return false
+}
+
+func TestLiveMSNScreener(t *testing.T) {
+	if os.Getenv("RUN_LIVE_E2E") != "1" {
+		t.Skip("set RUN_LIVE_E2E=1 to run live tests")
+	}
+
+	outFile := filepath.Join(repoRoot(), "output", "live_test_screener.json")
+	code, out := runCLILive(t, nil,
+		"msn", "screener",
+		"--region", "id",
+		"--filter", "large-cap",
+		"--limit", "1",
+		"--output", outFile,
+	)
+	if code != 0 {
+		if isTransientNetworkErr(out) {
+			t.Skipf("transient/live network issue: %s", out)
+		}
+		t.Fatalf("live screener failed: %s", out)
+	}
+}
+
+func TestLiveNewsQuery(t *testing.T) {
+	if os.Getenv("RUN_LIVE_E2E") != "1" {
+		t.Skip("set RUN_LIVE_E2E=1 to run live tests")
+	}
+	if os.Getenv("BRAVE_API_KEY") == "" {
+		t.Skip("BRAVE_API_KEY not set")
+	}
+
+	outFile := filepath.Join(repoRoot(), "output", "live_test_news.json")
+	code, out := runCLILive(t, nil,
+		"news", "IHSG",
+		"--from", "2026-03-04",
+		"--to", "2026-03-06",
+		"--count", "1",
+		"--concurrency", "1",
+		"--output", outFile,
+	)
+	if code != 0 {
+		if isTransientNetworkErr(out) {
+			t.Skipf("transient/live network issue: %s", out)
+		}
+		t.Fatalf("live news failed: %s", out)
+	}
+}

tests/test_export_simple.py

@@ -0,0 +1,49 @@
+import json
+import sqlite3
+import tempfile
+import unittest
+from pathlib import Path
+
+from scripts.export_simple import export_csv, export_json, export_xlsx
+
+
+class ExportSimpleTests(unittest.TestCase):
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory()
+        self.base = Path(self.tmp.name)
+        self.db = self.base / "test.db"
+        conn = sqlite3.connect(self.db)
+        conn.execute("CREATE TABLE stocks (id TEXT, ticker TEXT)")
+        conn.execute("INSERT INTO stocks VALUES ('1','BBCA')")
+        conn.commit()
+        conn.close()
+
+    def tearDown(self):
+        self.tmp.cleanup()
+
+    def test_export_json(self):
+        conn = sqlite3.connect(self.db)
+        out = self.base / "json"
+        export_json(conn, out, ["stocks"])
+        conn.close()
+        data = json.loads((out / "stocks.json").read_text())
+        self.assertEqual(data[0]["ticker"], "BBCA")
+
+    def test_export_csv(self):
+        conn = sqlite3.connect(self.db)
+        out = self.base / "csv"
+        export_csv(conn, out, ["stocks"])
+        conn.close()
+        text = (out / "stocks.csv").read_text()
+        self.assertIn("BBCA", text)
+
+    def test_export_xlsx(self):
+        conn = sqlite3.connect(self.db)
+        out = self.base / "out.xlsx"
+        export_xlsx(conn, out, ["stocks"])
+        conn.close()
+        self.assertTrue(out.exists())
+
+
+if __name__ == "__main__":
+    unittest.main()

uv.lock

@@ -0,0 +1,806 @@
+version = 1
+revision = 3
+requires-python = ">=3.12"
+resolution-markers = [
+    "python_full_version >= '3.14' and sys_platform == 'win32'",
+    "python_full_version >= '3.14' and sys_platform == 'emscripten'",
+    "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32'",
+    "python_full_version < '3.14' and sys_platform == 'win32'",
+    "python_full_version < '3.14' and sys_platform == 'emscripten'",
+    "python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32'",
+]
+
+[[package]]
+name = "beautifulsoup4"
+version = "4.14.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "soupsieve" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c3/b0/1c6a16426d389813b48d95e26898aff79abbde42ad353958ad95cc8c9b21/beautifulsoup4-4.14.3.tar.gz", hash = "sha256:6292b1c5186d356bba669ef9f7f051757099565ad9ada5dd630bd9de5fa7fb86", size = 627737, upload-time = "2025-11-30T15:08:26.084Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1a/39/47f9197bdd44df24d67ac8893641e16f386c984a0619ef2ee4c51fbbc019/beautifulsoup4-4.14.3-py3-none-any.whl", hash = "sha256:0918bfe44902e6ad8d57732ba310582e98da931428d231a5ecb9e7c703a735bb", size = 107721, upload-time = "2025-11-30T15:08:24.087Z" },
+]
+
+[[package]]
+name = "brotli"
+version = "1.2.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f7/16/c92ca344d646e71a43b8bb353f0a6490d7f6e06210f8554c8f874e454285/brotli-1.2.0.tar.gz", hash = "sha256:e310f77e41941c13340a95976fe66a8a95b01e783d430eeaf7a2f87e0a57dd0a", size = 7388632, upload-time = "2025-11-05T18:39:42.86Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/11/ee/b0a11ab2315c69bb9b45a2aaed022499c9c24a205c3a49c3513b541a7967/brotli-1.2.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:35d382625778834a7f3061b15423919aa03e4f5da34ac8e02c074e4b75ab4f84", size = 861543, upload-time = "2025-11-05T18:38:24.183Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/2f/29c1459513cd35828e25531ebfcbf3e92a5e49f560b1777a9af7203eb46e/brotli-1.2.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7a61c06b334bd99bc5ae84f1eeb36bfe01400264b3c352f968c6e30a10f9d08b", size = 444288, upload-time = "2025-11-05T18:38:25.139Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/6f/feba03130d5fceadfa3a1bb102cb14650798c848b1df2a808356f939bb16/brotli-1.2.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:acec55bb7c90f1dfc476126f9711a8e81c9af7fb617409a9ee2953115343f08d", size = 1528071, upload-time = "2025-11-05T18:38:26.081Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/38/f3abb554eee089bd15471057ba85f47e53a44a462cfce265d9bf7088eb09/brotli-1.2.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:260d3692396e1895c5034f204f0db022c056f9e2ac841593a4cf9426e2a3faca", size = 1626913, upload-time = "2025-11-05T18:38:27.284Z" },
+    { url = "https://files.pythonhosted.org/packages/03/a7/03aa61fbc3c5cbf99b44d158665f9b0dd3d8059be16c460208d9e385c837/brotli-1.2.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:072e7624b1fc4d601036ab3f4f27942ef772887e876beff0301d261210bca97f", size = 1419762, upload-time = "2025-11-05T18:38:28.295Z" },
+    { url = "https://files.pythonhosted.org/packages/21/1b/0374a89ee27d152a5069c356c96b93afd1b94eae83f1e004b57eb6ce2f10/brotli-1.2.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:adedc4a67e15327dfdd04884873c6d5a01d3e3b6f61406f99b1ed4865a2f6d28", size = 1484494, upload-time = "2025-11-05T18:38:29.29Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/57/69d4fe84a67aef4f524dcd075c6eee868d7850e85bf01d778a857d8dbe0a/brotli-1.2.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:7a47ce5c2288702e09dc22a44d0ee6152f2c7eda97b3c8482d826a1f3cfc7da7", size = 1593302, upload-time = "2025-11-05T18:38:30.639Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/3b/39e13ce78a8e9a621c5df3aeb5fd181fcc8caba8c48a194cd629771f6828/brotli-1.2.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:af43b8711a8264bb4e7d6d9a6d004c3a2019c04c01127a868709ec29962b6036", size = 1487913, upload-time = "2025-11-05T18:38:31.618Z" },
+    { url = "https://files.pythonhosted.org/packages/62/28/4d00cb9bd76a6357a66fcd54b4b6d70288385584063f4b07884c1e7286ac/brotli-1.2.0-cp312-cp312-win32.whl", hash = "sha256:e99befa0b48f3cd293dafeacdd0d191804d105d279e0b387a32054c1180f3161", size = 334362, upload-time = "2025-11-05T18:38:32.939Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/4e/bc1dcac9498859d5e353c9b153627a3752868a9d5f05ce8dedd81a2354ab/brotli-1.2.0-cp312-cp312-win_amd64.whl", hash = "sha256:b35c13ce241abdd44cb8ca70683f20c0c079728a36a996297adb5334adfc1c44", size = 369115, upload-time = "2025-11-05T18:38:33.765Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/d4/4ad5432ac98c73096159d9ce7ffeb82d151c2ac84adcc6168e476bb54674/brotli-1.2.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:9e5825ba2c9998375530504578fd4d5d1059d09621a02065d1b6bfc41a8e05ab", size = 861523, upload-time = "2025-11-05T18:38:34.67Z" },
+    { url = "https://files.pythonhosted.org/packages/91/9f/9cc5bd03ee68a85dc4bc89114f7067c056a3c14b3d95f171918c088bf88d/brotli-1.2.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:0cf8c3b8ba93d496b2fae778039e2f5ecc7cff99df84df337ca31d8f2252896c", size = 444289, upload-time = "2025-11-05T18:38:35.6Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/b6/fe84227c56a865d16a6614e2c4722864b380cb14b13f3e6bef441e73a85a/brotli-1.2.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c8565e3cdc1808b1a34714b553b262c5de5fbda202285782173ec137fd13709f", size = 1528076, upload-time = "2025-11-05T18:38:36.639Z" },
+    { url = "https://files.pythonhosted.org/packages/55/de/de4ae0aaca06c790371cf6e7ee93a024f6b4bb0568727da8c3de112e726c/brotli-1.2.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:26e8d3ecb0ee458a9804f47f21b74845cc823fd1bb19f02272be70774f56e2a6", size = 1626880, upload-time = "2025-11-05T18:38:37.623Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/16/a1b22cbea436642e071adcaf8d4b350a2ad02f5e0ad0da879a1be16188a0/brotli-1.2.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:67a91c5187e1eec76a61625c77a6c8c785650f5b576ca732bd33ef58b0dff49c", size = 1419737, upload-time = "2025-11-05T18:38:38.729Z" },
+    { url = "https://files.pythonhosted.org/packages/46/63/c968a97cbb3bdbf7f974ef5a6ab467a2879b82afbc5ffb65b8acbb744f95/brotli-1.2.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4ecdb3b6dc36e6d6e14d3a1bdc6c1057c8cbf80db04031d566eb6080ce283a48", size = 1484440, upload-time = "2025-11-05T18:38:39.916Z" },
+    { url = "https://files.pythonhosted.org/packages/06/9d/102c67ea5c9fc171f423e8399e585dabea29b5bc79b05572891e70013cdd/brotli-1.2.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:3e1b35d56856f3ed326b140d3c6d9db91740f22e14b06e840fe4bb1923439a18", size = 1593313, upload-time = "2025-11-05T18:38:41.24Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/4a/9526d14fa6b87bc827ba1755a8440e214ff90de03095cacd78a64abe2b7d/brotli-1.2.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:54a50a9dad16b32136b2241ddea9e4df159b41247b2ce6aac0b3276a66a8f1e5", size = 1487945, upload-time = "2025-11-05T18:38:42.277Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/e8/3fe1ffed70cbef83c5236166acaed7bb9c766509b157854c80e2f766b38c/brotli-1.2.0-cp313-cp313-win32.whl", hash = "sha256:1b1d6a4efedd53671c793be6dd760fcf2107da3a52331ad9ea429edf0902f27a", size = 334368, upload-time = "2025-11-05T18:38:43.345Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/91/e739587be970a113b37b821eae8097aac5a48e5f0eca438c22e4c7dd8648/brotli-1.2.0-cp313-cp313-win_amd64.whl", hash = "sha256:b63daa43d82f0cdabf98dee215b375b4058cce72871fd07934f179885aad16e8", size = 369116, upload-time = "2025-11-05T18:38:44.609Z" },
+    { url = "https://files.pythonhosted.org/packages/17/e1/298c2ddf786bb7347a1cd71d63a347a79e5712a7c0cba9e3c3458ebd976f/brotli-1.2.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:6c12dad5cd04530323e723787ff762bac749a7b256a5bece32b2243dd5c27b21", size = 863080, upload-time = "2025-11-05T18:38:45.503Z" },
+    { url = "https://files.pythonhosted.org/packages/84/0c/aac98e286ba66868b2b3b50338ffbd85a35c7122e9531a73a37a29763d38/brotli-1.2.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:3219bd9e69868e57183316ee19c84e03e8f8b5a1d1f2667e1aa8c2f91cb061ac", size = 445453, upload-time = "2025-11-05T18:38:46.433Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/f1/0ca1f3f99ae300372635ab3fe2f7a79fa335fee3d874fa7f9e68575e0e62/brotli-1.2.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:963a08f3bebd8b75ac57661045402da15991468a621f014be54e50f53a58d19e", size = 1528168, upload-time = "2025-11-05T18:38:47.371Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/a6/2ebfc8f766d46df8d3e65b880a2e220732395e6d7dc312c1e1244b0f074a/brotli-1.2.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9322b9f8656782414b37e6af884146869d46ab85158201d82bab9abbcb971dc7", size = 1627098, upload-time = "2025-11-05T18:38:48.385Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/2f/0976d5b097ff8a22163b10617f76b2557f15f0f39d6a0fe1f02b1a53e92b/brotli-1.2.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:cf9cba6f5b78a2071ec6fb1e7bd39acf35071d90a81231d67e92d637776a6a63", size = 1419861, upload-time = "2025-11-05T18:38:49.372Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/97/d76df7176a2ce7616ff94c1fb72d307c9a30d2189fe877f3dd99af00ea5a/brotli-1.2.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7547369c4392b47d30a3467fe8c3330b4f2e0f7730e45e3103d7d636678a808b", size = 1484594, upload-time = "2025-11-05T18:38:50.655Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/93/14cf0b1216f43df5609f5b272050b0abd219e0b54ea80b47cef9867b45e7/brotli-1.2.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:fc1530af5c3c275b8524f2e24841cbe2599d74462455e9bae5109e9ff42e9361", size = 1593455, upload-time = "2025-11-05T18:38:51.624Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/73/3183c9e41ca755713bdf2cc1d0810df742c09484e2e1ddd693bee53877c1/brotli-1.2.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:d2d085ded05278d1c7f65560aae97b3160aeb2ea2c0b3e26204856beccb60888", size = 1488164, upload-time = "2025-11-05T18:38:53.079Z" },
+    { url = "https://files.pythonhosted.org/packages/64/6a/0c78d8f3a582859236482fd9fa86a65a60328a00983006bcf6d83b7b2253/brotli-1.2.0-cp314-cp314-win32.whl", hash = "sha256:832c115a020e463c2f67664560449a7bea26b0c1fdd690352addad6d0a08714d", size = 339280, upload-time = "2025-11-05T18:38:54.02Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/10/56978295c14794b2c12007b07f3e41ba26acda9257457d7085b0bb3bb90c/brotli-1.2.0-cp314-cp314-win_amd64.whl", hash = "sha256:e7c0af964e0b4e3412a0ebf341ea26ec767fa0b4cf81abb5e897c9338b5ad6a3", size = 375639, upload-time = "2025-11-05T18:38:55.67Z" },
+]
+
+[[package]]
+name = "certifi"
+version = "2026.1.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e0/2d/a891ca51311197f6ad14a7ef42e2399f36cf2f9bd44752b3dc4eab60fdc5/certifi-2026.1.4.tar.gz", hash = "sha256:ac726dd470482006e014ad384921ed6438c457018f4b3d204aea4281258b2120", size = 154268, upload-time = "2026-01-04T02:42:41.825Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e6/ad/3cc14f097111b4de0040c83a525973216457bbeeb63739ef1ed275c1c021/certifi-2026.1.4-py3-none-any.whl", hash = "sha256:9943707519e4add1115f44c2bc244f782c0249876bf51b6599fee1ffbedd685c", size = 152900, upload-time = "2026-01-04T02:42:40.15Z" },
+]
+
+[[package]]
+name = "charset-normalizer"
+version = "3.4.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/13/69/33ddede1939fdd074bce5434295f38fae7136463422fe4fd3e0e89b98062/charset_normalizer-3.4.4.tar.gz", hash = "sha256:94537985111c35f28720e43603b8e7b43a6ecfb2ce1d3058bbe955b73404e21a", size = 129418, upload-time = "2025-10-14T04:42:32.879Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f3/85/1637cd4af66fa687396e757dec650f28025f2a2f5a5531a3208dc0ec43f2/charset_normalizer-3.4.4-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:0a98e6759f854bd25a58a73fa88833fba3b7c491169f86ce1180c948ab3fd394", size = 208425, upload-time = "2025-10-14T04:40:53.353Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/6a/04130023fef2a0d9c62d0bae2649b69f7b7d8d24ea5536feef50551029df/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b5b290ccc2a263e8d185130284f8501e3e36c5e02750fc6b6bdeb2e9e96f1e25", size = 148162, upload-time = "2025-10-14T04:40:54.558Z" },
+    { url = "https://files.pythonhosted.org/packages/78/29/62328d79aa60da22c9e0b9a66539feae06ca0f5a4171ac4f7dc285b83688/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:74bb723680f9f7a6234dcf67aea57e708ec1fbdf5699fb91dfd6f511b0a320ef", size = 144558, upload-time = "2025-10-14T04:40:55.677Z" },
+    { url = "https://files.pythonhosted.org/packages/86/bb/b32194a4bf15b88403537c2e120b817c61cd4ecffa9b6876e941c3ee38fe/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f1e34719c6ed0b92f418c7c780480b26b5d9c50349e9a9af7d76bf757530350d", size = 161497, upload-time = "2025-10-14T04:40:57.217Z" },
+    { url = "https://files.pythonhosted.org/packages/19/89/a54c82b253d5b9b111dc74aca196ba5ccfcca8242d0fb64146d4d3183ff1/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2437418e20515acec67d86e12bf70056a33abdacb5cb1655042f6538d6b085a8", size = 159240, upload-time = "2025-10-14T04:40:58.358Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/10/d20b513afe03acc89ec33948320a5544d31f21b05368436d580dec4e234d/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:11d694519d7f29d6cd09f6ac70028dba10f92f6cdd059096db198c283794ac86", size = 153471, upload-time = "2025-10-14T04:40:59.468Z" },
+    { url = "https://files.pythonhosted.org/packages/61/fa/fbf177b55bdd727010f9c0a3c49eefa1d10f960e5f09d1d887bf93c2e698/charset_normalizer-3.4.4-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ac1c4a689edcc530fc9d9aa11f5774b9e2f33f9a0c6a57864e90908f5208d30a", size = 150864, upload-time = "2025-10-14T04:41:00.623Z" },
+    { url = "https://files.pythonhosted.org/packages/05/12/9fbc6a4d39c0198adeebbde20b619790e9236557ca59fc40e0e3cebe6f40/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:21d142cc6c0ec30d2efee5068ca36c128a30b0f2c53c1c07bd78cb6bc1d3be5f", size = 150647, upload-time = "2025-10-14T04:41:01.754Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/1f/6a9a593d52e3e8c5d2b167daf8c6b968808efb57ef4c210acb907c365bc4/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:5dbe56a36425d26d6cfb40ce79c314a2e4dd6211d51d6d2191c00bed34f354cc", size = 145110, upload-time = "2025-10-14T04:41:03.231Z" },
+    { url = "https://files.pythonhosted.org/packages/30/42/9a52c609e72471b0fc54386dc63c3781a387bb4fe61c20231a4ebcd58bdd/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:5bfbb1b9acf3334612667b61bd3002196fe2a1eb4dd74d247e0f2a4d50ec9bbf", size = 162839, upload-time = "2025-10-14T04:41:04.715Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/5b/c0682bbf9f11597073052628ddd38344a3d673fda35a36773f7d19344b23/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:d055ec1e26e441f6187acf818b73564e6e6282709e9bcb5b63f5b23068356a15", size = 150667, upload-time = "2025-10-14T04:41:05.827Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/24/a41afeab6f990cf2daf6cb8c67419b63b48cf518e4f56022230840c9bfb2/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:af2d8c67d8e573d6de5bc30cdb27e9b95e49115cd9baad5ddbd1a6207aaa82a9", size = 160535, upload-time = "2025-10-14T04:41:06.938Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/e5/6a4ce77ed243c4a50a1fecca6aaaab419628c818a49434be428fe24c9957/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:780236ac706e66881f3b7f2f32dfe90507a09e67d1d454c762cf642e6e1586e0", size = 154816, upload-time = "2025-10-14T04:41:08.101Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/ef/89297262b8092b312d29cdb2517cb1237e51db8ecef2e9af5edbe7b683b1/charset_normalizer-3.4.4-cp312-cp312-win32.whl", hash = "sha256:5833d2c39d8896e4e19b689ffc198f08ea58116bee26dea51e362ecc7cd3ed26", size = 99694, upload-time = "2025-10-14T04:41:09.23Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/2d/1e5ed9dd3b3803994c155cd9aacb60c82c331bad84daf75bcb9c91b3295e/charset_normalizer-3.4.4-cp312-cp312-win_amd64.whl", hash = "sha256:a79cfe37875f822425b89a82333404539ae63dbdddf97f84dcbc3d339aae9525", size = 107131, upload-time = "2025-10-14T04:41:10.467Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/d9/0ed4c7098a861482a7b6a95603edce4c0d9db2311af23da1fb2b75ec26fc/charset_normalizer-3.4.4-cp312-cp312-win_arm64.whl", hash = "sha256:376bec83a63b8021bb5c8ea75e21c4ccb86e7e45ca4eb81146091b56599b80c3", size = 100390, upload-time = "2025-10-14T04:41:11.915Z" },
+    { url = "https://files.pythonhosted.org/packages/97/45/4b3a1239bbacd321068ea6e7ac28875b03ab8bc0aa0966452db17cd36714/charset_normalizer-3.4.4-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:e1f185f86a6f3403aa2420e815904c67b2f9ebc443f045edd0de921108345794", size = 208091, upload-time = "2025-10-14T04:41:13.346Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/62/73a6d7450829655a35bb88a88fca7d736f9882a27eacdca2c6d505b57e2e/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b39f987ae8ccdf0d2642338faf2abb1862340facc796048b604ef14919e55ed", size = 147936, upload-time = "2025-10-14T04:41:14.461Z" },
+    { url = "https://files.pythonhosted.org/packages/89/c5/adb8c8b3d6625bef6d88b251bbb0d95f8205831b987631ab0c8bb5d937c2/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3162d5d8ce1bb98dd51af660f2121c55d0fa541b46dff7bb9b9f86ea1d87de72", size = 144180, upload-time = "2025-10-14T04:41:15.588Z" },
+    { url = "https://files.pythonhosted.org/packages/91/ed/9706e4070682d1cc219050b6048bfd293ccf67b3d4f5a4f39207453d4b99/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:81d5eb2a312700f4ecaa977a8235b634ce853200e828fbadf3a9c50bab278328", size = 161346, upload-time = "2025-10-14T04:41:16.738Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/0d/031f0d95e4972901a2f6f09ef055751805ff541511dc1252ba3ca1f80cf5/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5bd2293095d766545ec1a8f612559f6b40abc0eb18bb2f5d1171872d34036ede", size = 158874, upload-time = "2025-10-14T04:41:17.923Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/83/6ab5883f57c9c801ce5e5677242328aa45592be8a00644310a008d04f922/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a8a8b89589086a25749f471e6a900d3f662d1d3b6e2e59dcecf787b1cc3a1894", size = 153076, upload-time = "2025-10-14T04:41:19.106Z" },
+    { url = "https://files.pythonhosted.org/packages/75/1e/5ff781ddf5260e387d6419959ee89ef13878229732732ee73cdae01800f2/charset_normalizer-3.4.4-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bc7637e2f80d8530ee4a78e878bce464f70087ce73cf7c1caf142416923b98f1", size = 150601, upload-time = "2025-10-14T04:41:20.245Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/57/71be810965493d3510a6ca79b90c19e48696fb1ff964da319334b12677f0/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f8bf04158c6b607d747e93949aa60618b61312fe647a6369f88ce2ff16043490", size = 150376, upload-time = "2025-10-14T04:41:21.398Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/d5/c3d057a78c181d007014feb7e9f2e65905a6c4ef182c0ddf0de2924edd65/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:554af85e960429cf30784dd47447d5125aaa3b99a6f0683589dbd27e2f45da44", size = 144825, upload-time = "2025-10-14T04:41:22.583Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/8c/d0406294828d4976f275ffbe66f00266c4b3136b7506941d87c00cab5272/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:74018750915ee7ad843a774364e13a3db91682f26142baddf775342c3f5b1133", size = 162583, upload-time = "2025-10-14T04:41:23.754Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/24/e2aa1f18c8f15c4c0e932d9287b8609dd30ad56dbe41d926bd846e22fb8d/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:c0463276121fdee9c49b98908b3a89c39be45d86d1dbaa22957e38f6321d4ce3", size = 150366, upload-time = "2025-10-14T04:41:25.27Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/5b/1e6160c7739aad1e2df054300cc618b06bf784a7a164b0f238360721ab86/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:362d61fd13843997c1c446760ef36f240cf81d3ebf74ac62652aebaf7838561e", size = 160300, upload-time = "2025-10-14T04:41:26.725Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/10/f882167cd207fbdd743e55534d5d9620e095089d176d55cb22d5322f2afd/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9a26f18905b8dd5d685d6d07b0cdf98a79f3c7a918906af7cc143ea2e164c8bc", size = 154465, upload-time = "2025-10-14T04:41:28.322Z" },
+    { url = "https://files.pythonhosted.org/packages/89/66/c7a9e1b7429be72123441bfdbaf2bc13faab3f90b933f664db506dea5915/charset_normalizer-3.4.4-cp313-cp313-win32.whl", hash = "sha256:9b35f4c90079ff2e2edc5b26c0c77925e5d2d255c42c74fdb70fb49b172726ac", size = 99404, upload-time = "2025-10-14T04:41:29.95Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/26/b9924fa27db384bdcd97ab83b4f0a8058d96ad9626ead570674d5e737d90/charset_normalizer-3.4.4-cp313-cp313-win_amd64.whl", hash = "sha256:b435cba5f4f750aa6c0a0d92c541fb79f69a387c91e61f1795227e4ed9cece14", size = 107092, upload-time = "2025-10-14T04:41:31.188Z" },
+    { url = "https://files.pythonhosted.org/packages/af/8f/3ed4bfa0c0c72a7ca17f0380cd9e4dd842b09f664e780c13cff1dcf2ef1b/charset_normalizer-3.4.4-cp313-cp313-win_arm64.whl", hash = "sha256:542d2cee80be6f80247095cc36c418f7bddd14f4a6de45af91dfad36d817bba2", size = 100408, upload-time = "2025-10-14T04:41:32.624Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/35/7051599bd493e62411d6ede36fd5af83a38f37c4767b92884df7301db25d/charset_normalizer-3.4.4-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:da3326d9e65ef63a817ecbcc0df6e94463713b754fe293eaa03da99befb9a5bd", size = 207746, upload-time = "2025-10-14T04:41:33.773Z" },
+    { url = "https://files.pythonhosted.org/packages/10/9a/97c8d48ef10d6cd4fcead2415523221624bf58bcf68a802721a6bc807c8f/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8af65f14dc14a79b924524b1e7fffe304517b2bff5a58bf64f30b98bbc5079eb", size = 147889, upload-time = "2025-10-14T04:41:34.897Z" },
+    { url = "https://files.pythonhosted.org/packages/10/bf/979224a919a1b606c82bd2c5fa49b5c6d5727aa47b4312bb27b1734f53cd/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:74664978bb272435107de04e36db5a9735e78232b85b77d45cfb38f758efd33e", size = 143641, upload-time = "2025-10-14T04:41:36.116Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/33/0ad65587441fc730dc7bd90e9716b30b4702dc7b617e6ba4997dc8651495/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:752944c7ffbfdd10c074dc58ec2d5a8a4cd9493b314d367c14d24c17684ddd14", size = 160779, upload-time = "2025-10-14T04:41:37.229Z" },
+    { url = "https://files.pythonhosted.org/packages/67/ed/331d6b249259ee71ddea93f6f2f0a56cfebd46938bde6fcc6f7b9a3d0e09/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d1f13550535ad8cff21b8d757a3257963e951d96e20ec82ab44bc64aeb62a191", size = 159035, upload-time = "2025-10-14T04:41:38.368Z" },
+    { url = "https://files.pythonhosted.org/packages/67/ff/f6b948ca32e4f2a4576aa129d8bed61f2e0543bf9f5f2b7fc3758ed005c9/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ecaae4149d99b1c9e7b88bb03e3221956f68fd6d50be2ef061b2381b61d20838", size = 152542, upload-time = "2025-10-14T04:41:39.862Z" },
+    { url = "https://files.pythonhosted.org/packages/16/85/276033dcbcc369eb176594de22728541a925b2632f9716428c851b149e83/charset_normalizer-3.4.4-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:cb6254dc36b47a990e59e1068afacdcd02958bdcce30bb50cc1700a8b9d624a6", size = 149524, upload-time = "2025-10-14T04:41:41.319Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/f2/6a2a1f722b6aba37050e626530a46a68f74e63683947a8acff92569f979a/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c8ae8a0f02f57a6e61203a31428fa1d677cbe50c93622b4149d5c0f319c1d19e", size = 150395, upload-time = "2025-10-14T04:41:42.539Z" },
+    { url = "https://files.pythonhosted.org/packages/60/bb/2186cb2f2bbaea6338cad15ce23a67f9b0672929744381e28b0592676824/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:47cc91b2f4dd2833fddaedd2893006b0106129d4b94fdb6af1f4ce5a9965577c", size = 143680, upload-time = "2025-10-14T04:41:43.661Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/a5/bf6f13b772fbb2a90360eb620d52ed8f796f3c5caee8398c3b2eb7b1c60d/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:82004af6c302b5d3ab2cfc4cc5f29db16123b1a8417f2e25f9066f91d4411090", size = 162045, upload-time = "2025-10-14T04:41:44.821Z" },
+    { url = "https://files.pythonhosted.org/packages/df/c5/d1be898bf0dc3ef9030c3825e5d3b83f2c528d207d246cbabe245966808d/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:2b7d8f6c26245217bd2ad053761201e9f9680f8ce52f0fcd8d0755aeae5b2152", size = 149687, upload-time = "2025-10-14T04:41:46.442Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/42/90c1f7b9341eef50c8a1cb3f098ac43b0508413f33affd762855f67a410e/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:799a7a5e4fb2d5898c60b640fd4981d6a25f1c11790935a44ce38c54e985f828", size = 160014, upload-time = "2025-10-14T04:41:47.631Z" },
+    { url = "https://files.pythonhosted.org/packages/76/be/4d3ee471e8145d12795ab655ece37baed0929462a86e72372fd25859047c/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:99ae2cffebb06e6c22bdc25801d7b30f503cc87dbd283479e7b606f70aff57ec", size = 154044, upload-time = "2025-10-14T04:41:48.81Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/6f/8f7af07237c34a1defe7defc565a9bc1807762f672c0fde711a4b22bf9c0/charset_normalizer-3.4.4-cp314-cp314-win32.whl", hash = "sha256:f9d332f8c2a2fcbffe1378594431458ddbef721c1769d78e2cbc06280d8155f9", size = 99940, upload-time = "2025-10-14T04:41:49.946Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/51/8ade005e5ca5b0d80fb4aff72a3775b325bdc3d27408c8113811a7cbe640/charset_normalizer-3.4.4-cp314-cp314-win_amd64.whl", hash = "sha256:8a6562c3700cce886c5be75ade4a5db4214fda19fede41d9792d100288d8f94c", size = 107104, upload-time = "2025-10-14T04:41:51.051Z" },
+    { url = "https://files.pythonhosted.org/packages/da/5f/6b8f83a55bb8278772c5ae54a577f3099025f9ade59d0136ac24a0df4bde/charset_normalizer-3.4.4-cp314-cp314-win_arm64.whl", hash = "sha256:de00632ca48df9daf77a2c65a484531649261ec9f25489917f09e455cb09ddb2", size = 100743, upload-time = "2025-10-14T04:41:52.122Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/4c/925909008ed5a988ccbb72dcc897407e5d6d3bd72410d69e051fc0c14647/charset_normalizer-3.4.4-py3-none-any.whl", hash = "sha256:7a32c560861a02ff789ad905a2fe94e3f840803362c84fecf1851cb4cf3dc37f", size = 53402, upload-time = "2025-10-14T04:42:31.76Z" },
+]
+
+[[package]]
+name = "click"
+version = "8.3.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/3d/fa/656b739db8587d7b5dfa22e22ed02566950fbfbcdc20311993483657a5c0/click-8.3.1.tar.gz", hash = "sha256:12ff4785d337a1bb490bb7e9c2b1ee5da3112e94a8622f26a6c77f5d2fc6842a", size = 295065, upload-time = "2025-11-15T20:45:42.706Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/98/78/01c019cdb5d6498122777c1a43056ebb3ebfeef2076d9d026bfe15583b2b/click-8.3.1-py3-none-any.whl", hash = "sha256:981153a64e25f12d547d3426c367a4857371575ee7ad18df2a6183ab0545b2a6", size = 108274, upload-time = "2025-11-15T20:45:41.139Z" },
+]
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
+]
+
+[[package]]
+name = "et-xmlfile"
+version = "2.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d3/38/af70d7ab1ae9d4da450eeec1fa3918940a5fafb9055e934af8d6eb0c2313/et_xmlfile-2.0.0.tar.gz", hash = "sha256:dab3f4764309081ce75662649be815c4c9081e88f0837825f90fd28317d4da54", size = 17234, upload-time = "2024-10-25T17:25:40.039Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c1/8b/5fe2cc11fee489817272089c4203e679c63b570a5aaeb18d852ae3cbba6a/et_xmlfile-2.0.0-py3-none-any.whl", hash = "sha256:7a91720bc756843502c3b7504c77b8fe44217c85c537d85037f0f536151b2caa", size = 18059, upload-time = "2024-10-25T17:25:39.051Z" },
+]
+
+[[package]]
+name = "feedparser"
+version = "6.0.12"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "sgmllib3k" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/dc/79/db7edb5e77d6dfbc54d7d9df72828be4318275b2e580549ff45a962f6461/feedparser-6.0.12.tar.gz", hash = "sha256:64f76ce90ae3e8ef5d1ede0f8d3b50ce26bcce71dd8ae5e82b1cd2d4a5f94228", size = 286579, upload-time = "2025-09-10T13:33:59.486Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/4e/eb/c96d64137e29ae17d83ad2552470bafe3a7a915e85434d9942077d7fd011/feedparser-6.0.12-py3-none-any.whl", hash = "sha256:6bbff10f5a52662c00a2e3f86a38928c37c48f77b3c511aedcd51de933549324", size = 81480, upload-time = "2025-09-10T13:33:58.022Z" },
+]
+
+[[package]]
+name = "filelock"
+version = "3.21.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/73/71/74364ff065ca78914d8bd90b312fe78ddc5e11372d38bc9cb7104f887ce1/filelock-3.21.2.tar.gz", hash = "sha256:cfd218cfccf8b947fce7837da312ec3359d10ef2a47c8602edd59e0bacffb708", size = 31486, upload-time = "2026-02-13T01:27:15.223Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/98/73/3a18f1e1276810e81477c431009b55eeccebbd7301d28a350b77aacf3c33/filelock-3.21.2-py3-none-any.whl", hash = "sha256:d6cd4dbef3e1bb63bc16500fc5aa100f16e405bbff3fb4231711851be50c1560", size = 21479, upload-time = "2026-02-13T01:27:13.611Z" },
+]
+
+[[package]]
+name = "idna"
+version = "3.11"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6f/6d/0703ccc57f3a7233505399edb88de3cbd678da106337b9fcde432b65ed60/idna-3.11.tar.gz", hash = "sha256:795dafcc9c04ed0c1fb032c2aa73654d8e8c5023a7df64a53f39190ada629902", size = 194582, upload-time = "2025-10-12T14:55:20.501Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0e/61/66938bbb5fc52dbdf84594873d5b51fb1f7c7794e9c0f5bd885f30bc507b/idna-3.11-py3-none-any.whl", hash = "sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea", size = 71008, upload-time = "2025-10-12T14:55:18.883Z" },
+]
+
+[[package]]
+name = "joblib"
+version = "1.5.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/41/f2/d34e8b3a08a9cc79a50b2208a93dce981fe615b64d5a4d4abee421d898df/joblib-1.5.3.tar.gz", hash = "sha256:8561a3269e6801106863fd0d6d84bb737be9e7631e33aaed3fb9ce5953688da3", size = 331603, upload-time = "2025-12-15T08:41:46.427Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7b/91/984aca2ec129e2757d1e4e3c81c3fcda9d0f85b74670a094cc443d9ee949/joblib-1.5.3-py3-none-any.whl", hash = "sha256:5fc3c5039fc5ca8c0276333a188bbd59d6b7ab37fe6632daa76bc7f9ec18e713", size = 309071, upload-time = "2025-12-15T08:41:44.973Z" },
+]
+
+[[package]]
+name = "lxml"
+version = "6.0.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/aa/88/262177de60548e5a2bfc46ad28232c9e9cbde697bd94132aeb80364675cb/lxml-6.0.2.tar.gz", hash = "sha256:cd79f3367bd74b317dda655dc8fcfa304d9eb6e4fb06b7168c5cf27f96e0cd62", size = 4073426, upload-time = "2025-09-22T04:04:59.287Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f3/c8/8ff2bc6b920c84355146cd1ab7d181bc543b89241cfb1ebee824a7c81457/lxml-6.0.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:a59f5448ba2ceccd06995c95ea59a7674a10de0810f2ce90c9006f3cbc044456", size = 8661887, upload-time = "2025-09-22T04:01:17.265Z" },
+    { url = "https://files.pythonhosted.org/packages/37/6f/9aae1008083bb501ef63284220ce81638332f9ccbfa53765b2b7502203cf/lxml-6.0.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:e8113639f3296706fbac34a30813929e29247718e88173ad849f57ca59754924", size = 4667818, upload-time = "2025-09-22T04:01:19.688Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/ca/31fb37f99f37f1536c133476674c10b577e409c0a624384147653e38baf2/lxml-6.0.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:a8bef9b9825fa8bc816a6e641bb67219489229ebc648be422af695f6e7a4fa7f", size = 4950807, upload-time = "2025-09-22T04:01:21.487Z" },
+    { url = "https://files.pythonhosted.org/packages/da/87/f6cb9442e4bada8aab5ae7e1046264f62fdbeaa6e3f6211b93f4c0dd97f1/lxml-6.0.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:65ea18d710fd14e0186c2f973dc60bb52039a275f82d3c44a0e42b43440ea534", size = 5109179, upload-time = "2025-09-22T04:01:23.32Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/20/a7760713e65888db79bbae4f6146a6ae5c04e4a204a3c48896c408cd6ed2/lxml-6.0.2-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c371aa98126a0d4c739ca93ceffa0fd7a5d732e3ac66a46e74339acd4d334564", size = 5023044, upload-time = "2025-09-22T04:01:25.118Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/b0/7e64e0460fcb36471899f75831509098f3fd7cd02a3833ac517433cb4f8f/lxml-6.0.2-cp312-cp312-manylinux_2_26_i686.manylinux_2_28_i686.whl", hash = "sha256:700efd30c0fa1a3581d80a748157397559396090a51d306ea59a70020223d16f", size = 5359685, upload-time = "2025-09-22T04:01:27.398Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/e1/e5df362e9ca4e2f48ed6411bd4b3a0ae737cc842e96877f5bf9428055ab4/lxml-6.0.2-cp312-cp312-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c33e66d44fe60e72397b487ee92e01da0d09ba2d66df8eae42d77b6d06e5eba0", size = 5654127, upload-time = "2025-09-22T04:01:29.629Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/d1/232b3309a02d60f11e71857778bfcd4acbdb86c07db8260caf7d008b08f8/lxml-6.0.2-cp312-cp312-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:90a345bbeaf9d0587a3aaffb7006aa39ccb6ff0e96a57286c0cb2fd1520ea192", size = 5253958, upload-time = "2025-09-22T04:01:31.535Z" },
+    { url = "https://files.pythonhosted.org/packages/35/35/d955a070994725c4f7d80583a96cab9c107c57a125b20bb5f708fe941011/lxml-6.0.2-cp312-cp312-manylinux_2_31_armv7l.whl", hash = "sha256:064fdadaf7a21af3ed1dcaa106b854077fbeada827c18f72aec9346847cd65d0", size = 4711541, upload-time = "2025-09-22T04:01:33.801Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/be/667d17363b38a78c4bd63cfd4b4632029fd68d2c2dc81f25ce9eb5224dd5/lxml-6.0.2-cp312-cp312-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:fbc74f42c3525ac4ffa4b89cbdd00057b6196bcefe8bce794abd42d33a018092", size = 5267426, upload-time = "2025-09-22T04:01:35.639Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/47/62c70aa4a1c26569bc958c9ca86af2bb4e1f614e8c04fb2989833874f7ae/lxml-6.0.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6ddff43f702905a4e32bc24f3f2e2edfe0f8fde3277d481bffb709a4cced7a1f", size = 5064917, upload-time = "2025-09-22T04:01:37.448Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/55/6ceddaca353ebd0f1908ef712c597f8570cc9c58130dbb89903198e441fd/lxml-6.0.2-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:6da5185951d72e6f5352166e3da7b0dc27aa70bd1090b0eb3f7f7212b53f1bb8", size = 4788795, upload-time = "2025-09-22T04:01:39.165Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/e8/fd63e15da5e3fd4c2146f8bbb3c14e94ab850589beab88e547b2dbce22e1/lxml-6.0.2-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:57a86e1ebb4020a38d295c04fc79603c7899e0df71588043eb218722dabc087f", size = 5676759, upload-time = "2025-09-22T04:01:41.506Z" },
+    { url = "https://files.pythonhosted.org/packages/76/47/b3ec58dc5c374697f5ba37412cd2728f427d056315d124dd4b61da381877/lxml-6.0.2-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:2047d8234fe735ab77802ce5f2297e410ff40f5238aec569ad7c8e163d7b19a6", size = 5255666, upload-time = "2025-09-22T04:01:43.363Z" },
+    { url = "https://files.pythonhosted.org/packages/19/93/03ba725df4c3d72afd9596eef4a37a837ce8e4806010569bedfcd2cb68fd/lxml-6.0.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:6f91fd2b2ea15a6800c8e24418c0775a1694eefc011392da73bc6cef2623b322", size = 5277989, upload-time = "2025-09-22T04:01:45.215Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/80/c06de80bfce881d0ad738576f243911fccf992687ae09fd80b734712b39c/lxml-6.0.2-cp312-cp312-win32.whl", hash = "sha256:3ae2ce7d6fedfb3414a2b6c5e20b249c4c607f72cb8d2bb7cc9c6ec7c6f4e849", size = 3611456, upload-time = "2025-09-22T04:01:48.243Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/d7/0cdfb6c3e30893463fb3d1e52bc5f5f99684a03c29a0b6b605cfae879cd5/lxml-6.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:72c87e5ee4e58a8354fb9c7c84cbf95a1c8236c127a5d1b7683f04bed8361e1f", size = 4011793, upload-time = "2025-09-22T04:01:50.042Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/7b/93c73c67db235931527301ed3785f849c78991e2e34f3fd9a6663ffda4c5/lxml-6.0.2-cp312-cp312-win_arm64.whl", hash = "sha256:61cb10eeb95570153e0c0e554f58df92ecf5109f75eacad4a95baa709e26c3d6", size = 3672836, upload-time = "2025-09-22T04:01:52.145Z" },
+    { url = "https://files.pythonhosted.org/packages/53/fd/4e8f0540608977aea078bf6d79f128e0e2c2bba8af1acf775c30baa70460/lxml-6.0.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:9b33d21594afab46f37ae58dfadd06636f154923c4e8a4d754b0127554eb2e77", size = 8648494, upload-time = "2025-09-22T04:01:54.242Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/f4/2a94a3d3dfd6c6b433501b8d470a1960a20ecce93245cf2db1706adf6c19/lxml-6.0.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:6c8963287d7a4c5c9a432ff487c52e9c5618667179c18a204bdedb27310f022f", size = 4661146, upload-time = "2025-09-22T04:01:56.282Z" },
+    { url = "https://files.pythonhosted.org/packages/25/2e/4efa677fa6b322013035d38016f6ae859d06cac67437ca7dc708a6af7028/lxml-6.0.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:1941354d92699fb5ffe6ed7b32f9649e43c2feb4b97205f75866f7d21aa91452", size = 4946932, upload-time = "2025-09-22T04:01:58.989Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/0f/526e78a6d38d109fdbaa5049c62e1d32fdd70c75fb61c4eadf3045d3d124/lxml-6.0.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:bb2f6ca0ae2d983ded09357b84af659c954722bbf04dea98030064996d156048", size = 5100060, upload-time = "2025-09-22T04:02:00.812Z" },
+    { url = "https://files.pythonhosted.org/packages/81/76/99de58d81fa702cc0ea7edae4f4640416c2062813a00ff24bd70ac1d9c9b/lxml-6.0.2-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:eb2a12d704f180a902d7fa778c6d71f36ceb7b0d317f34cdc76a5d05aa1dd1df", size = 5019000, upload-time = "2025-09-22T04:02:02.671Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/35/9e57d25482bc9a9882cb0037fdb9cc18f4b79d85df94fa9d2a89562f1d25/lxml-6.0.2-cp313-cp313-manylinux_2_26_i686.manylinux_2_28_i686.whl", hash = "sha256:6ec0e3f745021bfed19c456647f0298d60a24c9ff86d9d051f52b509663feeb1", size = 5348496, upload-time = "2025-09-22T04:02:04.904Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/8e/cb99bd0b83ccc3e8f0f528e9aa1f7a9965dfec08c617070c5db8d63a87ce/lxml-6.0.2-cp313-cp313-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:846ae9a12d54e368933b9759052d6206a9e8b250291109c48e350c1f1f49d916", size = 5643779, upload-time = "2025-09-22T04:02:06.689Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/34/9e591954939276bb679b73773836c6684c22e56d05980e31d52a9a8deb18/lxml-6.0.2-cp313-cp313-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ef9266d2aa545d7374938fb5c484531ef5a2ec7f2d573e62f8ce722c735685fd", size = 5244072, upload-time = "2025-09-22T04:02:08.587Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/27/b29ff065f9aaca443ee377aff699714fcbffb371b4fce5ac4ca759e436d5/lxml-6.0.2-cp313-cp313-manylinux_2_31_armv7l.whl", hash = "sha256:4077b7c79f31755df33b795dc12119cb557a0106bfdab0d2c2d97bd3cf3dffa6", size = 4718675, upload-time = "2025-09-22T04:02:10.783Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/9f/f756f9c2cd27caa1a6ef8c32ae47aadea697f5c2c6d07b0dae133c244fbe/lxml-6.0.2-cp313-cp313-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a7c5d5e5f1081955358533be077166ee97ed2571d6a66bdba6ec2f609a715d1a", size = 5255171, upload-time = "2025-09-22T04:02:12.631Z" },
+    { url = "https://files.pythonhosted.org/packages/61/46/bb85ea42d2cb1bd8395484fd72f38e3389611aa496ac7772da9205bbda0e/lxml-6.0.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:8f8d0cbd0674ee89863a523e6994ac25fd5be9c8486acfc3e5ccea679bad2679", size = 5057175, upload-time = "2025-09-22T04:02:14.718Z" },
+    { url = "https://files.pythonhosted.org/packages/95/0c/443fc476dcc8e41577f0af70458c50fe299a97bb6b7505bb1ae09aa7f9ac/lxml-6.0.2-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:2cbcbf6d6e924c28f04a43f3b6f6e272312a090f269eff68a2982e13e5d57659", size = 4785688, upload-time = "2025-09-22T04:02:16.957Z" },
+    { url = "https://files.pythonhosted.org/packages/48/78/6ef0b359d45bb9697bc5a626e1992fa5d27aa3f8004b137b2314793b50a0/lxml-6.0.2-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:dfb874cfa53340009af6bdd7e54ebc0d21012a60a4e65d927c2e477112e63484", size = 5660655, upload-time = "2025-09-22T04:02:18.815Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/ea/e1d33808f386bc1339d08c0dcada6e4712d4ed8e93fcad5f057070b7988a/lxml-6.0.2-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:fb8dae0b6b8b7f9e96c26fdd8121522ce5de9bb5538010870bd538683d30e9a2", size = 5247695, upload-time = "2025-09-22T04:02:20.593Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/47/eba75dfd8183673725255247a603b4ad606f4ae657b60c6c145b381697da/lxml-6.0.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:358d9adae670b63e95bc59747c72f4dc97c9ec58881d4627fe0120da0f90d314", size = 5269841, upload-time = "2025-09-22T04:02:22.489Z" },
+    { url = "https://files.pythonhosted.org/packages/76/04/5c5e2b8577bc936e219becb2e98cdb1aca14a4921a12995b9d0c523502ae/lxml-6.0.2-cp313-cp313-win32.whl", hash = "sha256:e8cd2415f372e7e5a789d743d133ae474290a90b9023197fd78f32e2dc6873e2", size = 3610700, upload-time = "2025-09-22T04:02:24.465Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/0a/4643ccc6bb8b143e9f9640aa54e38255f9d3b45feb2cbe7ae2ca47e8782e/lxml-6.0.2-cp313-cp313-win_amd64.whl", hash = "sha256:b30d46379644fbfc3ab81f8f82ae4de55179414651f110a1514f0b1f8f6cb2d7", size = 4010347, upload-time = "2025-09-22T04:02:26.286Z" },
+    { url = "https://files.pythonhosted.org/packages/31/ef/dcf1d29c3f530577f61e5fe2f1bd72929acf779953668a8a47a479ae6f26/lxml-6.0.2-cp313-cp313-win_arm64.whl", hash = "sha256:13dcecc9946dca97b11b7c40d29fba63b55ab4170d3c0cf8c0c164343b9bfdcf", size = 3671248, upload-time = "2025-09-22T04:02:27.918Z" },
+    { url = "https://files.pythonhosted.org/packages/03/15/d4a377b385ab693ce97b472fe0c77c2b16ec79590e688b3ccc71fba19884/lxml-6.0.2-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:b0c732aa23de8f8aec23f4b580d1e52905ef468afb4abeafd3fec77042abb6fe", size = 8659801, upload-time = "2025-09-22T04:02:30.113Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/e8/c128e37589463668794d503afaeb003987373c5f94d667124ffd8078bbd9/lxml-6.0.2-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:4468e3b83e10e0317a89a33d28f7aeba1caa4d1a6fd457d115dd4ffe90c5931d", size = 4659403, upload-time = "2025-09-22T04:02:32.119Z" },
+    { url = "https://files.pythonhosted.org/packages/00/ce/74903904339decdf7da7847bb5741fc98a5451b42fc419a86c0c13d26fe2/lxml-6.0.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:abd44571493973bad4598a3be7e1d807ed45aa2adaf7ab92ab7c62609569b17d", size = 4966974, upload-time = "2025-09-22T04:02:34.155Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/d3/131dec79ce61c5567fecf82515bd9bc36395df42501b50f7f7f3bd065df0/lxml-6.0.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:370cd78d5855cfbffd57c422851f7d3864e6ae72d0da615fca4dad8c45d375a5", size = 5102953, upload-time = "2025-09-22T04:02:36.054Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/ea/a43ba9bb750d4ffdd885f2cd333572f5bb900cd2408b67fdda07e85978a0/lxml-6.0.2-cp314-cp314-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:901e3b4219fa04ef766885fb40fa516a71662a4c61b80c94d25336b4934b71c0", size = 5055054, upload-time = "2025-09-22T04:02:38.154Z" },
+    { url = "https://files.pythonhosted.org/packages/60/23/6885b451636ae286c34628f70a7ed1fcc759f8d9ad382d132e1c8d3d9bfd/lxml-6.0.2-cp314-cp314-manylinux_2_26_i686.manylinux_2_28_i686.whl", hash = "sha256:a4bf42d2e4cf52c28cc1812d62426b9503cdb0c87a6de81442626aa7d69707ba", size = 5352421, upload-time = "2025-09-22T04:02:40.413Z" },
+    { url = "https://files.pythonhosted.org/packages/48/5b/fc2ddfc94ddbe3eebb8e9af6e3fd65e2feba4967f6a4e9683875c394c2d8/lxml-6.0.2-cp314-cp314-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b2c7fdaa4d7c3d886a42534adec7cfac73860b89b4e5298752f60aa5984641a0", size = 5673684, upload-time = "2025-09-22T04:02:42.288Z" },
+    { url = "https://files.pythonhosted.org/packages/29/9c/47293c58cc91769130fbf85531280e8cc7868f7fbb6d92f4670071b9cb3e/lxml-6.0.2-cp314-cp314-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:98a5e1660dc7de2200b00d53fa00bcd3c35a3608c305d45a7bbcaf29fa16e83d", size = 5252463, upload-time = "2025-09-22T04:02:44.165Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/da/ba6eceb830c762b48e711ded880d7e3e89fc6c7323e587c36540b6b23c6b/lxml-6.0.2-cp314-cp314-manylinux_2_31_armv7l.whl", hash = "sha256:dc051506c30b609238d79eda75ee9cab3e520570ec8219844a72a46020901e37", size = 4698437, upload-time = "2025-09-22T04:02:46.524Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/24/7be3f82cb7990b89118d944b619e53c656c97dc89c28cfb143fdb7cd6f4d/lxml-6.0.2-cp314-cp314-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:8799481bbdd212470d17513a54d568f44416db01250f49449647b5ab5b5dccb9", size = 5269890, upload-time = "2025-09-22T04:02:48.812Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/bd/dcfb9ea1e16c665efd7538fc5d5c34071276ce9220e234217682e7d2c4a5/lxml-6.0.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:9261bb77c2dab42f3ecd9103951aeca2c40277701eb7e912c545c1b16e0e4917", size = 5097185, upload-time = "2025-09-22T04:02:50.746Z" },
+    { url = "https://files.pythonhosted.org/packages/21/04/a60b0ff9314736316f28316b694bccbbabe100f8483ad83852d77fc7468e/lxml-6.0.2-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:65ac4a01aba353cfa6d5725b95d7aed6356ddc0a3cd734de00124d285b04b64f", size = 4745895, upload-time = "2025-09-22T04:02:52.968Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/bd/7d54bd1846e5a310d9c715921c5faa71cf5c0853372adf78aee70c8d7aa2/lxml-6.0.2-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:b22a07cbb82fea98f8a2fd814f3d1811ff9ed76d0fc6abc84eb21527596e7cc8", size = 5695246, upload-time = "2025-09-22T04:02:54.798Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/32/5643d6ab947bc371da21323acb2a6e603cedbe71cb4c99c8254289ab6f4e/lxml-6.0.2-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:d759cdd7f3e055d6bc8d9bec3ad905227b2e4c785dc16c372eb5b5e83123f48a", size = 5260797, upload-time = "2025-09-22T04:02:57.058Z" },
+    { url = "https://files.pythonhosted.org/packages/33/da/34c1ec4cff1eea7d0b4cd44af8411806ed943141804ac9c5d565302afb78/lxml-6.0.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:945da35a48d193d27c188037a05fec5492937f66fb1958c24fc761fb9d40d43c", size = 5277404, upload-time = "2025-09-22T04:02:58.966Z" },
+    { url = "https://files.pythonhosted.org/packages/82/57/4eca3e31e54dc89e2c3507e1cd411074a17565fa5ffc437c4ae0a00d439e/lxml-6.0.2-cp314-cp314-win32.whl", hash = "sha256:be3aaa60da67e6153eb15715cc2e19091af5dc75faef8b8a585aea372507384b", size = 3670072, upload-time = "2025-09-22T04:03:38.05Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/e0/c96cf13eccd20c9421ba910304dae0f619724dcf1702864fd59dd386404d/lxml-6.0.2-cp314-cp314-win_amd64.whl", hash = "sha256:fa25afbadead523f7001caf0c2382afd272c315a033a7b06336da2637d92d6ed", size = 4080617, upload-time = "2025-09-22T04:03:39.835Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/5d/b3f03e22b3d38d6f188ef044900a9b29b2fe0aebb94625ce9fe244011d34/lxml-6.0.2-cp314-cp314-win_arm64.whl", hash = "sha256:063eccf89df5b24e361b123e257e437f9e9878f425ee9aae3144c77faf6da6d8", size = 3754930, upload-time = "2025-09-22T04:03:41.565Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/5c/42c2c4c03554580708fc738d13414801f340c04c3eff90d8d2d227145275/lxml-6.0.2-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:6162a86d86893d63084faaf4ff937b3daea233e3682fb4474db07395794fa80d", size = 8910380, upload-time = "2025-09-22T04:03:01.645Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/4f/12df843e3e10d18d468a7557058f8d3733e8b6e12401f30b1ef29360740f/lxml-6.0.2-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:414aaa94e974e23a3e92e7ca5b97d10c0cf37b6481f50911032c69eeb3991bba", size = 4775632, upload-time = "2025-09-22T04:03:03.814Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/0c/9dc31e6c2d0d418483cbcb469d1f5a582a1cd00a1f4081953d44051f3c50/lxml-6.0.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:48461bd21625458dd01e14e2c38dd0aea69addc3c4f960c30d9f59d7f93be601", size = 4975171, upload-time = "2025-09-22T04:03:05.651Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/2b/9b870c6ca24c841bdd887504808f0417aa9d8d564114689266f19ddf29c8/lxml-6.0.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:25fcc59afc57d527cfc78a58f40ab4c9b8fd096a9a3f964d2781ffb6eb33f4ed", size = 5110109, upload-time = "2025-09-22T04:03:07.452Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/0c/4f5f2a4dd319a178912751564471355d9019e220c20d7db3fb8307ed8582/lxml-6.0.2-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5179c60288204e6ddde3f774a93350177e08876eaf3ab78aa3a3649d43eb7d37", size = 5041061, upload-time = "2025-09-22T04:03:09.297Z" },
+    { url = "https://files.pythonhosted.org/packages/12/64/554eed290365267671fe001a20d72d14f468ae4e6acef1e179b039436967/lxml-6.0.2-cp314-cp314t-manylinux_2_26_i686.manylinux_2_28_i686.whl", hash = "sha256:967aab75434de148ec80597b75062d8123cadf2943fb4281f385141e18b21338", size = 5306233, upload-time = "2025-09-22T04:03:11.651Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/31/1d748aa275e71802ad9722df32a7a35034246b42c0ecdd8235412c3396ef/lxml-6.0.2-cp314-cp314t-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:d100fcc8930d697c6561156c6810ab4a508fb264c8b6779e6e61e2ed5e7558f9", size = 5604739, upload-time = "2025-09-22T04:03:13.592Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/41/2c11916bcac09ed561adccacceaedd2bf0e0b25b297ea92aab99fd03d0fa/lxml-6.0.2-cp314-cp314t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2ca59e7e13e5981175b8b3e4ab84d7da57993eeff53c07764dcebda0d0e64ecd", size = 5225119, upload-time = "2025-09-22T04:03:15.408Z" },
+    { url = "https://files.pythonhosted.org/packages/99/05/4e5c2873d8f17aa018e6afde417c80cc5d0c33be4854cce3ef5670c49367/lxml-6.0.2-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:957448ac63a42e2e49531b9d6c0fa449a1970dbc32467aaad46f11545be9af1d", size = 4633665, upload-time = "2025-09-22T04:03:17.262Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/c9/dcc2da1bebd6275cdc723b515f93edf548b82f36a5458cca3578bc899332/lxml-6.0.2-cp314-cp314t-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b7fc49c37f1786284b12af63152fe1d0990722497e2d5817acfe7a877522f9a9", size = 5234997, upload-time = "2025-09-22T04:03:19.14Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/e2/5172e4e7468afca64a37b81dba152fc5d90e30f9c83c7c3213d6a02a5ce4/lxml-6.0.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e19e0643cc936a22e837f79d01a550678da8377d7d801a14487c10c34ee49c7e", size = 5090957, upload-time = "2025-09-22T04:03:21.436Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/b3/15461fd3e5cd4ddcb7938b87fc20b14ab113b92312fc97afe65cd7c85de1/lxml-6.0.2-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:1db01e5cf14345628e0cbe71067204db658e2fb8e51e7f33631f5f4735fefd8d", size = 4764372, upload-time = "2025-09-22T04:03:23.27Z" },
+    { url = "https://files.pythonhosted.org/packages/05/33/f310b987c8bf9e61c4dd8e8035c416bd3230098f5e3cfa69fc4232de7059/lxml-6.0.2-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:875c6b5ab39ad5291588aed6925fac99d0097af0dd62f33c7b43736043d4a2ec", size = 5634653, upload-time = "2025-09-22T04:03:25.767Z" },
+    { url = "https://files.pythonhosted.org/packages/70/ff/51c80e75e0bc9382158133bdcf4e339b5886c6ee2418b5199b3f1a61ed6d/lxml-6.0.2-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:cdcbed9ad19da81c480dfd6dd161886db6096083c9938ead313d94b30aadf272", size = 5233795, upload-time = "2025-09-22T04:03:27.62Z" },
+    { url = "https://files.pythonhosted.org/packages/56/4d/4856e897df0d588789dd844dbed9d91782c4ef0b327f96ce53c807e13128/lxml-6.0.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:80dadc234ebc532e09be1975ff538d154a7fa61ea5031c03d25178855544728f", size = 5257023, upload-time = "2025-09-22T04:03:30.056Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/85/86766dfebfa87bea0ab78e9ff7a4b4b45225df4b4d3b8cc3c03c5cd68464/lxml-6.0.2-cp314-cp314t-win32.whl", hash = "sha256:da08e7bb297b04e893d91087df19638dc7a6bb858a954b0cc2b9f5053c922312", size = 3911420, upload-time = "2025-09-22T04:03:32.198Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/1a/b248b355834c8e32614650b8008c69ffeb0ceb149c793961dd8c0b991bb3/lxml-6.0.2-cp314-cp314t-win_amd64.whl", hash = "sha256:252a22982dca42f6155125ac76d3432e548a7625d56f5a273ee78a5057216eca", size = 4406837, upload-time = "2025-09-22T04:03:34.027Z" },
+    { url = "https://files.pythonhosted.org/packages/92/aa/df863bcc39c5e0946263454aba394de8a9084dbaff8ad143846b0d844739/lxml-6.0.2-cp314-cp314t-win_arm64.whl", hash = "sha256:bb4c1847b303835d89d785a18801a883436cdfd5dc3d62947f9c49e24f0f5a2c", size = 3822205, upload-time = "2025-09-22T04:03:36.249Z" },
+]
+
+[package.optional-dependencies]
+html-clean = [
+    { name = "lxml-html-clean" },
+]
+
+[[package]]
+name = "lxml-html-clean"
+version = "0.4.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "lxml" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d9/cb/c9c5bb2a9c47292e236a808dd233a03531f53b626f36259dcd32b49c76da/lxml_html_clean-0.4.3.tar.gz", hash = "sha256:c9df91925b00f836c807beab127aac82575110eacff54d0a75187914f1bd9d8c", size = 21498, upload-time = "2025-10-02T20:49:24.895Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/10/4a/63a9540e3ca73709f4200564a737d63a4c8c9c4dd032bab8535f507c190a/lxml_html_clean-0.4.3-py3-none-any.whl", hash = "sha256:63fd7b0b9c3a2e4176611c2ca5d61c4c07ffca2de76c14059a81a2825833731e", size = 14177, upload-time = "2025-10-02T20:49:23.749Z" },
+]
+
+[[package]]
+name = "newspaper4k"
+version = "0.9.4.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "beautifulsoup4" },
+    { name = "brotli" },
+    { name = "feedparser" },
+    { name = "lxml", extra = ["html-clean"] },
+    { name = "nltk" },
+    { name = "pillow" },
+    { name = "python-dateutil" },
+    { name = "pyyaml" },
+    { name = "requests" },
+    { name = "tldextract" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b7/cc/cf743a3d06b10907cec76a675fe0857445907ded0e64ec4624483c1467ce/newspaper4k-0.9.4.1.tar.gz", hash = "sha256:5b1a92dfb04d6d379f9484fad4ad44741deb9ac3d55a6c178badf2a0d4bba903", size = 3971874, upload-time = "2025-11-18T06:08:56.543Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/63/e8/7e6c6a6e626fec2ec25f7b69fa0c446d1ca8a7fad121b61f2672e5779b76/newspaper4k-0.9.4.1-py3-none-any.whl", hash = "sha256:fab18fdb0637da0ea2452e18c5986c4af2263ba3016ff684f1c522f696bd39bd", size = 306153, upload-time = "2025-11-18T06:08:54.9Z" },
+]
+
+[[package]]
+name = "nltk"
+version = "3.9.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "click" },
+    { name = "joblib" },
+    { name = "regex" },
+    { name = "tqdm" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f9/76/3a5e4312c19a028770f86fd7c058cf9f4ec4321c6cf7526bab998a5b683c/nltk-3.9.2.tar.gz", hash = "sha256:0f409e9b069ca4177c1903c3e843eef90c7e92992fa4931ae607da6de49e1419", size = 2887629, upload-time = "2025-10-01T07:19:23.764Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/60/90/81ac364ef94209c100e12579629dc92bf7a709a84af32f8c551b02c07e94/nltk-3.9.2-py3-none-any.whl", hash = "sha256:1e209d2b3009110635ed9709a67a1a3e33a10f799490fa71cf4bec218c11c88a", size = 1513404, upload-time = "2025-10-01T07:19:21.648Z" },
+]
+
+[[package]]
+name = "numpy"
+version = "2.4.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/57/fd/0005efbd0af48e55eb3c7208af93f2862d4b1a56cd78e84309a2d959208d/numpy-2.4.2.tar.gz", hash = "sha256:659a6107e31a83c4e33f763942275fd278b21d095094044eb35569e86a21ddae", size = 20723651, upload-time = "2026-01-31T23:13:10.135Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/51/6e/6f394c9c77668153e14d4da83bcc247beb5952f6ead7699a1a2992613bea/numpy-2.4.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:21982668592194c609de53ba4933a7471880ccbaadcc52352694a59ecc860b3a", size = 16667963, upload-time = "2026-01-31T23:10:52.147Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/f8/55483431f2b2fd015ae6ed4fe62288823ce908437ed49db5a03d15151678/numpy-2.4.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:40397bda92382fcec844066efb11f13e1c9a3e2a8e8f318fb72ed8b6db9f60f1", size = 14693571, upload-time = "2026-01-31T23:10:54.789Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/20/18026832b1845cdc82248208dd929ca14c9d8f2bac391f67440707fff27c/numpy-2.4.2-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:b3a24467af63c67829bfaa61eecf18d5432d4f11992688537be59ecd6ad32f5e", size = 5203469, upload-time = "2026-01-31T23:10:57.343Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/33/2eb97c8a77daaba34eaa3fa7241a14ac5f51c46a6bd5911361b644c4a1e2/numpy-2.4.2-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:805cc8de9fd6e7a22da5aed858e0ab16be5a4db6c873dde1d7451c541553aa27", size = 6550820, upload-time = "2026-01-31T23:10:59.429Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/91/b97fdfd12dc75b02c44e26c6638241cc004d4079a0321a69c62f51470c4c/numpy-2.4.2-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6d82351358ffbcdcd7b686b90742a9b86632d6c1c051016484fa0b326a0a1548", size = 15663067, upload-time = "2026-01-31T23:11:01.291Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/c6/a18e59f3f0b8071cc85cbc8d80cd02d68aa9710170b2553a117203d46936/numpy-2.4.2-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9e35d3e0144137d9fdae62912e869136164534d64a169f86438bc9561b6ad49f", size = 16619782, upload-time = "2026-01-31T23:11:03.669Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/83/9751502164601a79e18847309f5ceec0b1446d7b6aa12305759b72cf98b2/numpy-2.4.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:adb6ed2ad29b9e15321d167d152ee909ec73395901b70936f029c3bc6d7f4460", size = 17013128, upload-time = "2026-01-31T23:11:05.913Z" },
+    { url = "https://files.pythonhosted.org/packages/61/c4/c4066322256ec740acc1c8923a10047818691d2f8aec254798f3dd90f5f2/numpy-2.4.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:8906e71fd8afcb76580404e2a950caef2685df3d2a57fe82a86ac8d33cc007ba", size = 18345324, upload-time = "2026-01-31T23:11:08.248Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/af/6157aa6da728fa4525a755bfad486ae7e3f76d4c1864138003eb84328497/numpy-2.4.2-cp312-cp312-win32.whl", hash = "sha256:ec055f6dae239a6299cace477b479cca2fc125c5675482daf1dd886933a1076f", size = 5960282, upload-time = "2026-01-31T23:11:10.497Z" },
+    { url = "https://files.pythonhosted.org/packages/92/0f/7ceaaeaacb40567071e94dbf2c9480c0ae453d5bb4f52bea3892c39dc83c/numpy-2.4.2-cp312-cp312-win_amd64.whl", hash = "sha256:209fae046e62d0ce6435fcfe3b1a10537e858249b3d9b05829e2a05218296a85", size = 12314210, upload-time = "2026-01-31T23:11:12.176Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/a3/56c5c604fae6dd40fa2ed3040d005fca97e91bd320d232ac9931d77ba13c/numpy-2.4.2-cp312-cp312-win_arm64.whl", hash = "sha256:fbde1b0c6e81d56f5dccd95dd4a711d9b95df1ae4009a60887e56b27e8d903fa", size = 10220171, upload-time = "2026-01-31T23:11:14.684Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/22/815b9fe25d1d7ae7d492152adbc7226d3eff731dffc38fe970589fcaaa38/numpy-2.4.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:25f2059807faea4b077a2b6837391b5d830864b3543627f381821c646f31a63c", size = 16663696, upload-time = "2026-01-31T23:11:17.516Z" },
+    { url = "https://files.pythonhosted.org/packages/09/f0/817d03a03f93ba9c6c8993de509277d84e69f9453601915e4a69554102a1/numpy-2.4.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:bd3a7a9f5847d2fb8c2c6d1c862fa109c31a9abeca1a3c2bd5a64572955b2979", size = 14688322, upload-time = "2026-01-31T23:11:19.883Z" },
+    { url = "https://files.pythonhosted.org/packages/da/b4/f805ab79293c728b9a99438775ce51885fd4f31b76178767cfc718701a39/numpy-2.4.2-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:8e4549f8a3c6d13d55041925e912bfd834285ef1dd64d6bc7d542583355e2e98", size = 5198157, upload-time = "2026-01-31T23:11:22.375Z" },
+    { url = "https://files.pythonhosted.org/packages/74/09/826e4289844eccdcd64aac27d13b0fd3f32039915dd5b9ba01baae1f436c/numpy-2.4.2-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:aea4f66ff44dfddf8c2cffd66ba6538c5ec67d389285292fe428cb2c738c8aef", size = 6546330, upload-time = "2026-01-31T23:11:23.958Z" },
+    { url = "https://files.pythonhosted.org/packages/19/fb/cbfdbfa3057a10aea5422c558ac57538e6acc87ec1669e666d32ac198da7/numpy-2.4.2-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c3cd545784805de05aafe1dde61752ea49a359ccba9760c1e5d1c88a93bbf2b7", size = 15660968, upload-time = "2026-01-31T23:11:25.713Z" },
+    { url = "https://files.pythonhosted.org/packages/04/dc/46066ce18d01645541f0186877377b9371b8fa8017fa8262002b4ef22612/numpy-2.4.2-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d0d9b7c93578baafcbc5f0b83eaf17b79d345c6f36917ba0c67f45226911d499", size = 16607311, upload-time = "2026-01-31T23:11:28.117Z" },
+    { url = "https://files.pythonhosted.org/packages/14/d9/4b5adfc39a43fa6bf918c6d544bc60c05236cc2f6339847fc5b35e6cb5b0/numpy-2.4.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f74f0f7779cc7ae07d1810aab8ac6b1464c3eafb9e283a40da7309d5e6e48fbb", size = 17012850, upload-time = "2026-01-31T23:11:30.888Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/20/adb6e6adde6d0130046e6fdfb7675cc62bc2f6b7b02239a09eb58435753d/numpy-2.4.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:c7ac672d699bf36275c035e16b65539931347d68b70667d28984c9fb34e07fa7", size = 18334210, upload-time = "2026-01-31T23:11:33.214Z" },
+    { url = "https://files.pythonhosted.org/packages/78/0e/0a73b3dff26803a8c02baa76398015ea2a5434d9b8265a7898a6028c1591/numpy-2.4.2-cp313-cp313-win32.whl", hash = "sha256:8e9afaeb0beff068b4d9cd20d322ba0ee1cecfb0b08db145e4ab4dd44a6b5110", size = 5958199, upload-time = "2026-01-31T23:11:35.385Z" },
+    { url = "https://files.pythonhosted.org/packages/43/bc/6352f343522fcb2c04dbaf94cb30cca6fd32c1a750c06ad6231b4293708c/numpy-2.4.2-cp313-cp313-win_amd64.whl", hash = "sha256:7df2de1e4fba69a51c06c28f5a3de36731eb9639feb8e1cf7e4a7b0daf4cf622", size = 12310848, upload-time = "2026-01-31T23:11:38.001Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/8d/6da186483e308da5da1cc6918ce913dcfe14ffde98e710bfeff2a6158d4e/numpy-2.4.2-cp313-cp313-win_arm64.whl", hash = "sha256:0fece1d1f0a89c16b03442eae5c56dc0be0c7883b5d388e0c03f53019a4bfd71", size = 10221082, upload-time = "2026-01-31T23:11:40.392Z" },
+    { url = "https://files.pythonhosted.org/packages/25/a1/9510aa43555b44781968935c7548a8926274f815de42ad3997e9e83680dd/numpy-2.4.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:5633c0da313330fd20c484c78cdd3f9b175b55e1a766c4a174230c6b70ad8262", size = 14815866, upload-time = "2026-01-31T23:11:42.495Z" },
+    { url = "https://files.pythonhosted.org/packages/36/30/6bbb5e76631a5ae46e7923dd16ca9d3f1c93cfa8d4ed79a129814a9d8db3/numpy-2.4.2-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:d9f64d786b3b1dd742c946c42d15b07497ed14af1a1f3ce840cce27daa0ce913", size = 5325631, upload-time = "2026-01-31T23:11:44.7Z" },
+    { url = "https://files.pythonhosted.org/packages/46/00/3a490938800c1923b567b3a15cd17896e68052e2145d8662aaf3e1ffc58f/numpy-2.4.2-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:b21041e8cb6a1eb5312dd1d2f80a94d91efffb7a06b70597d44f1bd2dfc315ab", size = 6646254, upload-time = "2026-01-31T23:11:46.341Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/e9/fac0890149898a9b609caa5af7455a948b544746e4b8fe7c212c8edd71f8/numpy-2.4.2-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:00ab83c56211a1d7c07c25e3217ea6695e50a3e2f255053686b081dc0b091a82", size = 15720138, upload-time = "2026-01-31T23:11:48.082Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/5c/08887c54e68e1e28df53709f1893ce92932cc6f01f7c3d4dc952f61ffd4e/numpy-2.4.2-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2fb882da679409066b4603579619341c6d6898fc83a8995199d5249f986e8e8f", size = 16655398, upload-time = "2026-01-31T23:11:50.293Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/89/253db0fa0e66e9129c745e4ef25631dc37d5f1314dad2b53e907b8538e6d/numpy-2.4.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:66cb9422236317f9d44b67b4d18f44efe6e9c7f8794ac0462978513359461554", size = 17079064, upload-time = "2026-01-31T23:11:52.927Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/d5/cbade46ce97c59c6c3da525e8d95b7abe8a42974a1dc5c1d489c10433e88/numpy-2.4.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:0f01dcf33e73d80bd8dc0f20a71303abbafa26a19e23f6b68d1aa9990af90257", size = 18379680, upload-time = "2026-01-31T23:11:55.22Z" },
+    { url = "https://files.pythonhosted.org/packages/40/62/48f99ae172a4b63d981babe683685030e8a3df4f246c893ea5c6ef99f018/numpy-2.4.2-cp313-cp313t-win32.whl", hash = "sha256:52b913ec40ff7ae845687b0b34d8d93b60cb66dcee06996dd5c99f2fc9328657", size = 6082433, upload-time = "2026-01-31T23:11:58.096Z" },
+    { url = "https://files.pythonhosted.org/packages/07/38/e054a61cfe48ad9f1ed0d188e78b7e26859d0b60ef21cd9de4897cdb5326/numpy-2.4.2-cp313-cp313t-win_amd64.whl", hash = "sha256:5eea80d908b2c1f91486eb95b3fb6fab187e569ec9752ab7d9333d2e66bf2d6b", size = 12451181, upload-time = "2026-01-31T23:11:59.782Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/a4/a05c3a6418575e185dd84d0b9680b6bb2e2dc3e4202f036b7b4e22d6e9dc/numpy-2.4.2-cp313-cp313t-win_arm64.whl", hash = "sha256:fd49860271d52127d61197bb50b64f58454e9f578cb4b2c001a6de8b1f50b0b1", size = 10290756, upload-time = "2026-01-31T23:12:02.438Z" },
+    { url = "https://files.pythonhosted.org/packages/18/88/b7df6050bf18fdcfb7046286c6535cabbdd2064a3440fca3f069d319c16e/numpy-2.4.2-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:444be170853f1f9d528428eceb55f12918e4fda5d8805480f36a002f1415e09b", size = 16663092, upload-time = "2026-01-31T23:12:04.521Z" },
+    { url = "https://files.pythonhosted.org/packages/25/7a/1fee4329abc705a469a4afe6e69b1ef7e915117747886327104a8493a955/numpy-2.4.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:d1240d50adff70c2a88217698ca844723068533f3f5c5fa6ee2e3220e3bdb000", size = 14698770, upload-time = "2026-01-31T23:12:06.96Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/0b/f9e49ba6c923678ad5bc38181c08ac5e53b7a5754dbca8e581aa1a56b1ff/numpy-2.4.2-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:7cdde6de52fb6664b00b056341265441192d1291c130e99183ec0d4b110ff8b1", size = 5208562, upload-time = "2026-01-31T23:12:09.632Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/12/d7de8f6f53f9bb76997e5e4c069eda2051e3fe134e9181671c4391677bb2/numpy-2.4.2-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:cda077c2e5b780200b6b3e09d0b42205a3d1c68f30c6dceb90401c13bff8fe74", size = 6543710, upload-time = "2026-01-31T23:12:11.969Z" },
+    { url = "https://files.pythonhosted.org/packages/09/63/c66418c2e0268a31a4cf8a8b512685748200f8e8e8ec6c507ce14e773529/numpy-2.4.2-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d30291931c915b2ab5717c2974bb95ee891a1cf22ebc16a8006bd59cd210d40a", size = 15677205, upload-time = "2026-01-31T23:12:14.33Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/6c/7f237821c9642fb2a04d2f1e88b4295677144ca93285fd76eff3bcba858d/numpy-2.4.2-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bba37bc29d4d85761deed3954a1bc62be7cf462b9510b51d367b769a8c8df325", size = 16611738, upload-time = "2026-01-31T23:12:16.525Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/a7/39c4cdda9f019b609b5c473899d87abff092fc908cfe4d1ecb2fcff453b0/numpy-2.4.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:b2f0073ed0868db1dcd86e052d37279eef185b9c8db5bf61f30f46adac63c909", size = 17028888, upload-time = "2026-01-31T23:12:19.306Z" },
+    { url = "https://files.pythonhosted.org/packages/da/b3/e84bb64bdfea967cc10950d71090ec2d84b49bc691df0025dddb7c26e8e3/numpy-2.4.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:7f54844851cdb630ceb623dcec4db3240d1ac13d4990532446761baede94996a", size = 18339556, upload-time = "2026-01-31T23:12:21.816Z" },
+    { url = "https://files.pythonhosted.org/packages/88/f5/954a291bc1192a27081706862ac62bb5920fbecfbaa302f64682aa90beed/numpy-2.4.2-cp314-cp314-win32.whl", hash = "sha256:12e26134a0331d8dbd9351620f037ec470b7c75929cb8a1537f6bfe411152a1a", size = 6006899, upload-time = "2026-01-31T23:12:24.14Z" },
+    { url = "https://files.pythonhosted.org/packages/05/cb/eff72a91b2efdd1bc98b3b8759f6a1654aa87612fc86e3d87d6fe4f948c4/numpy-2.4.2-cp314-cp314-win_amd64.whl", hash = "sha256:068cdb2d0d644cdb45670810894f6a0600797a69c05f1ac478e8d31670b8ee75", size = 12443072, upload-time = "2026-01-31T23:12:26.33Z" },
+    { url = "https://files.pythonhosted.org/packages/37/75/62726948db36a56428fce4ba80a115716dc4fad6a3a4352487f8bb950966/numpy-2.4.2-cp314-cp314-win_arm64.whl", hash = "sha256:6ed0be1ee58eef41231a5c943d7d1375f093142702d5723ca2eb07db9b934b05", size = 10494886, upload-time = "2026-01-31T23:12:28.488Z" },
+    { url = "https://files.pythonhosted.org/packages/36/2f/ee93744f1e0661dc267e4b21940870cabfae187c092e1433b77b09b50ac4/numpy-2.4.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:98f16a80e917003a12c0580f97b5f875853ebc33e2eaa4bccfc8201ac6869308", size = 14818567, upload-time = "2026-01-31T23:12:30.709Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/24/6535212add7d76ff938d8bdc654f53f88d35cddedf807a599e180dcb8e66/numpy-2.4.2-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:20abd069b9cda45874498b245c8015b18ace6de8546bf50dfa8cea1696ed06ef", size = 5328372, upload-time = "2026-01-31T23:12:32.962Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/9d/c48f0a035725f925634bf6b8994253b43f2047f6778a54147d7e213bc5a7/numpy-2.4.2-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:e98c97502435b53741540a5717a6749ac2ada901056c7db951d33e11c885cc7d", size = 6649306, upload-time = "2026-01-31T23:12:34.797Z" },
+    { url = "https://files.pythonhosted.org/packages/81/05/7c73a9574cd4a53a25907bad38b59ac83919c0ddc8234ec157f344d57d9a/numpy-2.4.2-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:da6cad4e82cb893db4b69105c604d805e0c3ce11501a55b5e9f9083b47d2ffe8", size = 15722394, upload-time = "2026-01-31T23:12:36.565Z" },
+    { url = "https://files.pythonhosted.org/packages/35/fa/4de10089f21fc7d18442c4a767ab156b25c2a6eaf187c0db6d9ecdaeb43f/numpy-2.4.2-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9e4424677ce4b47fe73c8b5556d876571f7c6945d264201180db2dc34f676ab5", size = 16653343, upload-time = "2026-01-31T23:12:39.188Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/f9/d33e4ffc857f3763a57aa85650f2e82486832d7492280ac21ba9efda80da/numpy-2.4.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:2b8f157c8a6f20eb657e240f8985cc135598b2b46985c5bccbde7616dc9c6b1e", size = 17078045, upload-time = "2026-01-31T23:12:42.041Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/b8/54bdb43b6225badbea6389fa038c4ef868c44f5890f95dd530a218706da3/numpy-2.4.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5daf6f3914a733336dab21a05cdec343144600e964d2fcdabaac0c0269874b2a", size = 18380024, upload-time = "2026-01-31T23:12:44.331Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/55/6e1a61ded7af8df04016d81b5b02daa59f2ea9252ee0397cb9f631efe9e5/numpy-2.4.2-cp314-cp314t-win32.whl", hash = "sha256:8c50dd1fc8826f5b26a5ee4d77ca55d88a895f4e4819c7ecc2a9f5905047a443", size = 6153937, upload-time = "2026-01-31T23:12:47.229Z" },
+    { url = "https://files.pythonhosted.org/packages/45/aa/fa6118d1ed6d776b0983f3ceac9b1a5558e80df9365b1c3aa6d42bf9eee4/numpy-2.4.2-cp314-cp314t-win_amd64.whl", hash = "sha256:fcf92bee92742edd401ba41135185866f7026c502617f422eb432cfeca4fe236", size = 12631844, upload-time = "2026-01-31T23:12:48.997Z" },
+    { url = "https://files.pythonhosted.org/packages/32/0a/2ec5deea6dcd158f254a7b372fb09cfba5719419c8d66343bab35237b3fb/numpy-2.4.2-cp314-cp314t-win_arm64.whl", hash = "sha256:1f92f53998a17265194018d1cc321b2e96e900ca52d54c7c77837b71b9465181", size = 10565379, upload-time = "2026-01-31T23:12:51.345Z" },
+]
+
+[[package]]
+name = "openpyxl"
+version = "3.1.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "et-xmlfile" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/3d/f9/88d94a75de065ea32619465d2f77b29a0469500e99012523b91cc4141cd1/openpyxl-3.1.5.tar.gz", hash = "sha256:cf0e3cf56142039133628b5acffe8ef0c12bc902d2aadd3e0fe5878dc08d1050", size = 186464, upload-time = "2024-06-28T14:03:44.161Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c0/da/977ded879c29cbd04de313843e76868e6e13408a94ed6b987245dc7c8506/openpyxl-3.1.5-py2.py3-none-any.whl", hash = "sha256:5282c12b107bffeef825f4617dc029afaf41d0ea60823bbb665ef3079dc79de2", size = 250910, upload-time = "2024-06-28T14:03:41.161Z" },
+]
+
+[[package]]
+name = "pandas"
+version = "3.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy" },
+    { name = "python-dateutil" },
+    { name = "tzdata", marker = "sys_platform == 'emscripten' or sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/de/da/b1dc0481ab8d55d0f46e343cfe67d4551a0e14fcee52bd38ca1bd73258d8/pandas-3.0.0.tar.gz", hash = "sha256:0facf7e87d38f721f0af46fe70d97373a37701b1c09f7ed7aeeb292ade5c050f", size = 4633005, upload-time = "2026-01-21T15:52:04.726Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0b/38/db33686f4b5fa64d7af40d96361f6a4615b8c6c8f1b3d334eee46ae6160e/pandas-3.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:9803b31f5039b3c3b10cc858c5e40054adb4b29b4d81cb2fd789f4121c8efbcd", size = 10334013, upload-time = "2026-01-21T15:50:34.771Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/7b/9254310594e9774906bacdd4e732415e1f86ab7dbb4b377ef9ede58cd8ec/pandas-3.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:14c2a4099cd38a1d18ff108168ea417909b2dea3bd1ebff2ccf28ddb6a74d740", size = 9874154, upload-time = "2026-01-21T15:50:36.67Z" },
+    { url = "https://files.pythonhosted.org/packages/63/d4/726c5a67a13bc66643e66d2e9ff115cead482a44fc56991d0c4014f15aaf/pandas-3.0.0-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d257699b9a9960e6125686098d5714ac59d05222bef7a5e6af7a7fd87c650801", size = 10384433, upload-time = "2026-01-21T15:50:39.132Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/2e/9211f09bedb04f9832122942de8b051804b31a39cfbad199a819bb88d9f3/pandas-3.0.0-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:69780c98f286076dcafca38d8b8eee1676adf220199c0a39f0ecbf976b68151a", size = 10864519, upload-time = "2026-01-21T15:50:41.043Z" },
+    { url = "https://files.pythonhosted.org/packages/00/8d/50858522cdc46ac88b9afdc3015e298959a70a08cd21e008a44e9520180c/pandas-3.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:4a66384f017240f3858a4c8a7cf21b0591c3ac885cddb7758a589f0f71e87ebb", size = 11394124, upload-time = "2026-01-21T15:50:43.377Z" },
+    { url = "https://files.pythonhosted.org/packages/86/3f/83b2577db02503cd93d8e95b0f794ad9d4be0ba7cb6c8bcdcac964a34a42/pandas-3.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:be8c515c9bc33989d97b89db66ea0cececb0f6e3c2a87fcc8b69443a6923e95f", size = 11920444, upload-time = "2026-01-21T15:50:45.932Z" },
+    { url = "https://files.pythonhosted.org/packages/64/2d/4f8a2f192ed12c90a0aab47f5557ece0e56b0370c49de9454a09de7381b2/pandas-3.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:a453aad8c4f4e9f166436994a33884442ea62aa8b27d007311e87521b97246e1", size = 9730970, upload-time = "2026-01-21T15:50:47.962Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/64/ff571be435cf1e643ca98d0945d76732c0b4e9c37191a89c8550b105eed1/pandas-3.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:da768007b5a33057f6d9053563d6b74dd6d029c337d93c6d0d22a763a5c2ecc0", size = 9041950, upload-time = "2026-01-21T15:50:50.422Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/fa/7f0ac4ca8877c57537aaff2a842f8760e630d8e824b730eb2e859ffe96ca/pandas-3.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:b78d646249b9a2bc191040988c7bb524c92fa8534fb0898a0741d7e6f2ffafa6", size = 10307129, upload-time = "2026-01-21T15:50:52.877Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/11/28a221815dcea4c0c9414dfc845e34a84a6a7dabc6da3194498ed5ba4361/pandas-3.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:bc9cba7b355cb4162442a88ce495e01cb605f17ac1e27d6596ac963504e0305f", size = 9850201, upload-time = "2026-01-21T15:50:54.807Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/da/53bbc8c5363b7e5bd10f9ae59ab250fc7a382ea6ba08e4d06d8694370354/pandas-3.0.0-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3c9a1a149aed3b6c9bf246033ff91e1b02d529546c5d6fb6b74a28fea0cf4c70", size = 10354031, upload-time = "2026-01-21T15:50:57.463Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/a3/51e02ebc2a14974170d51e2410dfdab58870ea9bcd37cda15bd553d24dc4/pandas-3.0.0-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:95683af6175d884ee89471842acfca29172a85031fccdabc35e50c0984470a0e", size = 10861165, upload-time = "2026-01-21T15:50:59.32Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/fe/05a51e3cac11d161472b8297bd41723ea98013384dd6d76d115ce3482f9b/pandas-3.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:1fbbb5a7288719e36b76b4f18d46ede46e7f916b6c8d9915b756b0a6c3f792b3", size = 11359359, upload-time = "2026-01-21T15:51:02.014Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/56/ba620583225f9b85a4d3e69c01df3e3870659cc525f67929b60e9f21dcd1/pandas-3.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8e8b9808590fa364416b49b2a35c1f4cf2785a6c156935879e57f826df22038e", size = 11912907, upload-time = "2026-01-21T15:51:05.175Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/8c/c6638d9f67e45e07656b3826405c5cc5f57f6fd07c8b2572ade328c86e22/pandas-3.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:98212a38a709feb90ae658cb6227ea3657c22ba8157d4b8f913cd4c950de5e7e", size = 9732138, upload-time = "2026-01-21T15:51:07.569Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/bf/bd1335c3bf1770b6d8fed2799993b11c4971af93bb1b729b9ebbc02ca2ec/pandas-3.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:177d9df10b3f43b70307a149d7ec49a1229a653f907aa60a48f1877d0e6be3be", size = 9033568, upload-time = "2026-01-21T15:51:09.484Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/c6/f5e2171914d5e29b9171d495344097d54e3ffe41d2d85d8115baba4dc483/pandas-3.0.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:2713810ad3806767b89ad3b7b69ba153e1c6ff6d9c20f9c2140379b2a98b6c98", size = 10741936, upload-time = "2026-01-21T15:51:11.693Z" },
+    { url = "https://files.pythonhosted.org/packages/51/88/9a0164f99510a1acb9f548691f022c756c2314aad0d8330a24616c14c462/pandas-3.0.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:15d59f885ee5011daf8335dff47dcb8a912a27b4ad7826dc6cbe809fd145d327", size = 10393884, upload-time = "2026-01-21T15:51:14.197Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/53/b34d78084d88d8ae2b848591229da8826d1e65aacf00b3abe34023467648/pandas-3.0.0-cp313-cp313t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:24e6547fb64d2c92665dd2adbfa4e85fa4fd70a9c070e7cfb03b629a0bbab5eb", size = 10310740, upload-time = "2026-01-21T15:51:16.093Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/d3/bee792e7c3d6930b74468d990604325701412e55d7aaf47460a22311d1a5/pandas-3.0.0-cp313-cp313t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:48ee04b90e2505c693d3f8e8f524dab8cb8aaf7ddcab52c92afa535e717c4812", size = 10700014, upload-time = "2026-01-21T15:51:18.818Z" },
+    { url = "https://files.pythonhosted.org/packages/55/db/2570bc40fb13aaed1cbc3fbd725c3a60ee162477982123c3adc8971e7ac1/pandas-3.0.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:66f72fb172959af42a459e27a8d8d2c7e311ff4c1f7db6deb3b643dbc382ae08", size = 11323737, upload-time = "2026-01-21T15:51:20.784Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/2e/297ac7f21c8181b62a4cccebad0a70caf679adf3ae5e83cb676194c8acc3/pandas-3.0.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:4a4a400ca18230976724a5066f20878af785f36c6756e498e94c2a5e5d57779c", size = 11771558, upload-time = "2026-01-21T15:51:22.977Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/46/e1c6876d71c14332be70239acce9ad435975a80541086e5ffba2f249bcf6/pandas-3.0.0-cp313-cp313t-win_amd64.whl", hash = "sha256:940eebffe55528074341a5a36515f3e4c5e25e958ebbc764c9502cfc35ba3faa", size = 10473771, upload-time = "2026-01-21T15:51:25.285Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/db/0270ad9d13c344b7a36fa77f5f8344a46501abf413803e885d22864d10bf/pandas-3.0.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:597c08fb9fef0edf1e4fa2f9828dd27f3d78f9b8c9b4a748d435ffc55732310b", size = 10312075, upload-time = "2026-01-21T15:51:28.5Z" },
+    { url = "https://files.pythonhosted.org/packages/09/9f/c176f5e9717f7c91becfe0f55a52ae445d3f7326b4a2cf355978c51b7913/pandas-3.0.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:447b2d68ac5edcbf94655fe909113a6dba6ef09ad7f9f60c80477825b6c489fe", size = 9900213, upload-time = "2026-01-21T15:51:30.955Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/e7/63ad4cc10b257b143e0a5ebb04304ad806b4e1a61c5da25f55896d2ca0f4/pandas-3.0.0-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:debb95c77ff3ed3ba0d9aa20c3a2f19165cc7956362f9873fce1ba0a53819d70", size = 10428768, upload-time = "2026-01-21T15:51:33.018Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/0e/4e4c2d8210f20149fd2248ef3fff26623604922bd564d915f935a06dd63d/pandas-3.0.0-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fedabf175e7cd82b69b74c30adbaa616de301291a5231138d7242596fc296a8d", size = 10882954, upload-time = "2026-01-21T15:51:35.287Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/60/c9de8ac906ba1f4d2250f8a951abe5135b404227a55858a75ad26f84db47/pandas-3.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:412d1a89aab46889f3033a386912efcdfa0f1131c5705ff5b668dda88305e986", size = 11430293, upload-time = "2026-01-21T15:51:37.57Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/69/806e6637c70920e5787a6d6896fd707f8134c2c55cd761e7249a97b7dc5a/pandas-3.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:e979d22316f9350c516479dd3a92252be2937a9531ed3a26ec324198a99cdd49", size = 11952452, upload-time = "2026-01-21T15:51:39.618Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/de/918621e46af55164c400ab0ef389c9d969ab85a43d59ad1207d4ddbe30a5/pandas-3.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:083b11415b9970b6e7888800c43c82e81a06cd6b06755d84804444f0007d6bb7", size = 9851081, upload-time = "2026-01-21T15:51:41.758Z" },
+    { url = "https://files.pythonhosted.org/packages/91/a1/3562a18dd0bd8c73344bfa26ff90c53c72f827df119d6d6b1dacc84d13e3/pandas-3.0.0-cp314-cp314-win_arm64.whl", hash = "sha256:5db1e62cb99e739fa78a28047e861b256d17f88463c76b8dafc7c1338086dca8", size = 9174610, upload-time = "2026-01-21T15:51:44.312Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/26/430d91257eaf366f1737d7a1c158677caaf6267f338ec74e3a1ec444111c/pandas-3.0.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:697b8f7d346c68274b1b93a170a70974cdc7d7354429894d5927c1effdcccd73", size = 10761999, upload-time = "2026-01-21T15:51:46.899Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/1a/954eb47736c2b7f7fe6a9d56b0cb6987773c00faa3c6451a43db4beb3254/pandas-3.0.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:8cb3120f0d9467ed95e77f67a75e030b67545bcfa08964e349252d674171def2", size = 10410279, upload-time = "2026-01-21T15:51:48.89Z" },
+    { url = "https://files.pythonhosted.org/packages/20/fc/b96f3a5a28b250cd1b366eb0108df2501c0f38314a00847242abab71bb3a/pandas-3.0.0-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:33fd3e6baa72899746b820c31e4b9688c8e1b7864d7aec2de7ab5035c285277a", size = 10330198, upload-time = "2026-01-21T15:51:51.015Z" },
+    { url = "https://files.pythonhosted.org/packages/90/b3/d0e2952f103b4fbef1ef22d0c2e314e74fc9064b51cee30890b5e3286ee6/pandas-3.0.0-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a8942e333dc67ceda1095227ad0febb05a3b36535e520154085db632c40ad084", size = 10728513, upload-time = "2026-01-21T15:51:53.387Z" },
+    { url = "https://files.pythonhosted.org/packages/76/81/832894f286df828993dc5fd61c63b231b0fb73377e99f6c6c369174cf97e/pandas-3.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:783ac35c4d0fe0effdb0d67161859078618b1b6587a1af15928137525217a721", size = 11345550, upload-time = "2026-01-21T15:51:55.329Z" },
+    { url = "https://files.pythonhosted.org/packages/34/a0/ed160a00fb4f37d806406bc0a79a8b62fe67f29d00950f8d16203ff3409b/pandas-3.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:125eb901e233f155b268bbef9abd9afb5819db74f0e677e89a61b246228c71ac", size = 11799386, upload-time = "2026-01-21T15:51:57.457Z" },
+    { url = "https://files.pythonhosted.org/packages/36/c8/2ac00d7255252c5e3cf61b35ca92ca25704b0188f7454ca4aec08a33cece/pandas-3.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:b86d113b6c109df3ce0ad5abbc259fe86a1bd4adfd4a31a89da42f84f65509bb", size = 10873041, upload-time = "2026-01-21T15:52:00.034Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/3f/a80ac00acbc6b35166b42850e98a4f466e2c0d9c64054161ba9620f95680/pandas-3.0.0-cp314-cp314t-win_arm64.whl", hash = "sha256:1c39eab3ad38f2d7a249095f0a3d8f8c22cc0f847e98ccf5bbe732b272e2d9fa", size = 9441003, upload-time = "2026-01-21T15:52:02.281Z" },
+]
+
+[[package]]
+name = "pillow"
+version = "12.1.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/1f/42/5c74462b4fd957fcd7b13b04fb3205ff8349236ea74c7c375766d6c82288/pillow-12.1.1.tar.gz", hash = "sha256:9ad8fa5937ab05218e2b6a4cff30295ad35afd2f83ac592e68c0d871bb0fdbc4", size = 46980264, upload-time = "2026-02-11T04:23:07.146Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/07/d3/8df65da0d4df36b094351dce696f2989bec731d4f10e743b1c5f4da4d3bf/pillow-12.1.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:ab323b787d6e18b3d91a72fc99b1a2c28651e4358749842b8f8dfacd28ef2052", size = 5262803, upload-time = "2026-02-11T04:20:47.653Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/71/5026395b290ff404b836e636f51d7297e6c83beceaa87c592718747e670f/pillow-12.1.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:adebb5bee0f0af4909c30db0d890c773d1a92ffe83da908e2e9e720f8edf3984", size = 4657601, upload-time = "2026-02-11T04:20:49.328Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/2e/1001613d941c67442f745aff0f7cc66dd8df9a9c084eb497e6a543ee6f7e/pillow-12.1.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:bb66b7cc26f50977108790e2456b7921e773f23db5630261102233eb355a3b79", size = 6234995, upload-time = "2026-02-11T04:20:51.032Z" },
+    { url = "https://files.pythonhosted.org/packages/07/26/246ab11455b2549b9233dbd44d358d033a2f780fa9007b61a913c5b2d24e/pillow-12.1.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:aee2810642b2898bb187ced9b349e95d2a7272930796e022efaf12e99dccd293", size = 8045012, upload-time = "2026-02-11T04:20:52.882Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/8b/07587069c27be7535ac1fe33874e32de118fbd34e2a73b7f83436a88368c/pillow-12.1.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a0b1cd6232e2b618adcc54d9882e4e662a089d5768cd188f7c245b4c8c44a397", size = 6349638, upload-time = "2026-02-11T04:20:54.444Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/79/6df7b2ee763d619cda2fb4fea498e5f79d984dae304d45a8999b80d6cf5c/pillow-12.1.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7aac39bcf8d4770d089588a2e1dd111cbaa42df5a94be3114222057d68336bd0", size = 7041540, upload-time = "2026-02-11T04:20:55.97Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/5e/2ba19e7e7236d7529f4d873bdaf317a318896bac289abebd4bb00ef247f0/pillow-12.1.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ab174cd7d29a62dd139c44bf74b698039328f45cb03b4596c43473a46656b2f3", size = 6462613, upload-time = "2026-02-11T04:20:57.542Z" },
+    { url = "https://files.pythonhosted.org/packages/03/03/31216ec124bb5c3dacd74ce8efff4cc7f52643653bad4825f8f08c697743/pillow-12.1.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:339ffdcb7cbeaa08221cd401d517d4b1fe7a9ed5d400e4a8039719238620ca35", size = 7166745, upload-time = "2026-02-11T04:20:59.196Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/e7/7c4552d80052337eb28653b617eafdef39adfb137c49dd7e831b8dc13bc5/pillow-12.1.1-cp312-cp312-win32.whl", hash = "sha256:5d1f9575a12bed9e9eedd9a4972834b08c97a352bd17955ccdebfeca5913fa0a", size = 6328823, upload-time = "2026-02-11T04:21:01.385Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/17/688626d192d7261bbbf98846fc98995726bddc2c945344b65bec3a29d731/pillow-12.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:21329ec8c96c6e979cd0dfd29406c40c1d52521a90544463057d2aaa937d66a6", size = 7033367, upload-time = "2026-02-11T04:21:03.536Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/fe/a0ef1f73f939b0eca03ee2c108d0043a87468664770612602c63266a43c4/pillow-12.1.1-cp312-cp312-win_arm64.whl", hash = "sha256:af9a332e572978f0218686636610555ae3defd1633597be015ed50289a03c523", size = 2453811, upload-time = "2026-02-11T04:21:05.116Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/11/6db24d4bd7685583caeae54b7009584e38da3c3d4488ed4cd25b439de486/pillow-12.1.1-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:d242e8ac078781f1de88bf823d70c1a9b3c7950a44cdf4b7c012e22ccbcd8e4e", size = 4062689, upload-time = "2026-02-11T04:21:06.804Z" },
+    { url = "https://files.pythonhosted.org/packages/33/c0/ce6d3b1fe190f0021203e0d9b5b99e57843e345f15f9ef22fcd43842fd21/pillow-12.1.1-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:02f84dfad02693676692746df05b89cf25597560db2857363a208e393429f5e9", size = 4138535, upload-time = "2026-02-11T04:21:08.452Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/c6/d5eb6a4fb32a3f9c21a8c7613ec706534ea1cf9f4b3663e99f0d83f6fca8/pillow-12.1.1-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:e65498daf4b583091ccbb2556c7000abf0f3349fcd57ef7adc9a84a394ed29f6", size = 3601364, upload-time = "2026-02-11T04:21:10.194Z" },
+    { url = "https://files.pythonhosted.org/packages/14/a1/16c4b823838ba4c9c52c0e6bbda903a3fe5a1bdbf1b8eb4fff7156f3e318/pillow-12.1.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:6c6db3b84c87d48d0088943bf33440e0c42370b99b1c2a7989216f7b42eede60", size = 5262561, upload-time = "2026-02-11T04:21:11.742Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/ad/ad9dc98ff24f485008aa5cdedaf1a219876f6f6c42a4626c08bc4e80b120/pillow-12.1.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:8b7e5304e34942bf62e15184219a7b5ad4ff7f3bb5cca4d984f37df1a0e1aee2", size = 4657460, upload-time = "2026-02-11T04:21:13.786Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/1b/f1a4ea9a895b5732152789326202a82464d5254759fbacae4deea3069334/pillow-12.1.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:18e5bddd742a44b7e6b1e773ab5db102bd7a94c32555ba656e76d319d19c3850", size = 6232698, upload-time = "2026-02-11T04:21:15.949Z" },
+    { url = "https://files.pythonhosted.org/packages/95/f4/86f51b8745070daf21fd2e5b1fe0eb35d4db9ca26e6d58366562fb56a743/pillow-12.1.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fc44ef1f3de4f45b50ccf9136999d71abb99dca7706bc75d222ed350b9fd2289", size = 8041706, upload-time = "2026-02-11T04:21:17.723Z" },
+    { url = "https://files.pythonhosted.org/packages/29/9b/d6ecd956bb1266dd1045e995cce9b8d77759e740953a1c9aad9502a0461e/pillow-12.1.1-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5a8eb7ed8d4198bccbd07058416eeec51686b498e784eda166395a23eb99138e", size = 6346621, upload-time = "2026-02-11T04:21:19.547Z" },
+    { url = "https://files.pythonhosted.org/packages/71/24/538bff45bde96535d7d998c6fed1a751c75ac7c53c37c90dc2601b243893/pillow-12.1.1-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:47b94983da0c642de92ced1702c5b6c292a84bd3a8e1d1702ff923f183594717", size = 7038069, upload-time = "2026-02-11T04:21:21.378Z" },
+    { url = "https://files.pythonhosted.org/packages/94/0e/58cb1a6bc48f746bc4cb3adb8cabff73e2742c92b3bf7a220b7cf69b9177/pillow-12.1.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:518a48c2aab7ce596d3bf79d0e275661b846e86e4d0e7dec34712c30fe07f02a", size = 6460040, upload-time = "2026-02-11T04:21:23.148Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/57/9045cb3ff11eeb6c1adce3b2d60d7d299d7b273a2e6c8381a524abfdc474/pillow-12.1.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a550ae29b95c6dc13cf69e2c9dc5747f814c54eeb2e32d683e5e93af56caa029", size = 7164523, upload-time = "2026-02-11T04:21:25.01Z" },
+    { url = "https://files.pythonhosted.org/packages/73/f2/9be9cb99f2175f0d4dbadd6616ce1bf068ee54a28277ea1bf1fbf729c250/pillow-12.1.1-cp313-cp313-win32.whl", hash = "sha256:a003d7422449f6d1e3a34e3dd4110c22148336918ddbfc6a32581cd54b2e0b2b", size = 6332552, upload-time = "2026-02-11T04:21:27.238Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/eb/b0834ad8b583d7d9d42b80becff092082a1c3c156bb582590fcc973f1c7c/pillow-12.1.1-cp313-cp313-win_amd64.whl", hash = "sha256:344cf1e3dab3be4b1fa08e449323d98a2a3f819ad20f4b22e77a0ede31f0faa1", size = 7040108, upload-time = "2026-02-11T04:21:29.462Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/7d/fc09634e2aabdd0feabaff4a32f4a7d97789223e7c2042fd805ea4b4d2c2/pillow-12.1.1-cp313-cp313-win_arm64.whl", hash = "sha256:5c0dd1636633e7e6a0afe7bf6a51a14992b7f8e60de5789018ebbdfae55b040a", size = 2453712, upload-time = "2026-02-11T04:21:31.072Z" },
+    { url = "https://files.pythonhosted.org/packages/19/2a/b9d62794fc8a0dd14c1943df68347badbd5511103e0d04c035ffe5cf2255/pillow-12.1.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0330d233c1a0ead844fc097a7d16c0abff4c12e856c0b325f231820fee1f39da", size = 5264880, upload-time = "2026-02-11T04:21:32.865Z" },
+    { url = "https://files.pythonhosted.org/packages/26/9d/e03d857d1347fa5ed9247e123fcd2a97b6220e15e9cb73ca0a8d91702c6e/pillow-12.1.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:5dae5f21afb91322f2ff791895ddd8889e5e947ff59f71b46041c8ce6db790bc", size = 4660616, upload-time = "2026-02-11T04:21:34.97Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/ec/8a6d22afd02570d30954e043f09c32772bfe143ba9285e2fdb11284952cd/pillow-12.1.1-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:2e0c664be47252947d870ac0d327fea7e63985a08794758aa8af5b6cb6ec0c9c", size = 6269008, upload-time = "2026-02-11T04:21:36.623Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/1d/6d875422c9f28a4a361f495a5f68d9de4a66941dc2c619103ca335fa6446/pillow-12.1.1-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:691ab2ac363b8217f7d31b3497108fb1f50faab2f75dfb03284ec2f217e87bf8", size = 8073226, upload-time = "2026-02-11T04:21:38.585Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/cd/134b0b6ee5eda6dc09e25e24b40fdafe11a520bc725c1d0bbaa5e00bf95b/pillow-12.1.1-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e9e8064fb1cc019296958595f6db671fba95209e3ceb0c4734c9baf97de04b20", size = 6380136, upload-time = "2026-02-11T04:21:40.562Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/a9/7628f013f18f001c1b98d8fffe3452f306a70dc6aba7d931019e0492f45e/pillow-12.1.1-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:472a8d7ded663e6162dafdf20015c486a7009483ca671cece7a9279b512fcb13", size = 7067129, upload-time = "2026-02-11T04:21:42.521Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/f8/66ab30a2193b277785601e82ee2d49f68ea575d9637e5e234faaa98efa4c/pillow-12.1.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:89b54027a766529136a06cfebeecb3a04900397a3590fd252160b888479517bf", size = 6491807, upload-time = "2026-02-11T04:21:44.22Z" },
+    { url = "https://files.pythonhosted.org/packages/da/0b/a877a6627dc8318fdb84e357c5e1a758c0941ab1ddffdafd231983788579/pillow-12.1.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:86172b0831b82ce4f7877f280055892b31179e1576aa00d0df3bb1bbf8c3e524", size = 7190954, upload-time = "2026-02-11T04:21:46.114Z" },
+    { url = "https://files.pythonhosted.org/packages/83/43/6f732ff85743cf746b1361b91665d9f5155e1483817f693f8d57ea93147f/pillow-12.1.1-cp313-cp313t-win32.whl", hash = "sha256:44ce27545b6efcf0fdbdceb31c9a5bdea9333e664cda58a7e674bb74608b3986", size = 6336441, upload-time = "2026-02-11T04:21:48.22Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/44/e865ef3986611bb75bfabdf94a590016ea327833f434558801122979cd0e/pillow-12.1.1-cp313-cp313t-win_amd64.whl", hash = "sha256:a285e3eb7a5a45a2ff504e31f4a8d1b12ef62e84e5411c6804a42197c1cf586c", size = 7045383, upload-time = "2026-02-11T04:21:50.015Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/c6/f4fb24268d0c6908b9f04143697ea18b0379490cb74ba9e8d41b898bd005/pillow-12.1.1-cp313-cp313t-win_arm64.whl", hash = "sha256:cc7d296b5ea4d29e6570dabeaed58d31c3fea35a633a69679fb03d7664f43fb3", size = 2456104, upload-time = "2026-02-11T04:21:51.633Z" },
+    { url = "https://files.pythonhosted.org/packages/03/d0/bebb3ffbf31c5a8e97241476c4cf8b9828954693ce6744b4a2326af3e16b/pillow-12.1.1-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:417423db963cb4be8bac3fc1204fe61610f6abeed1580a7a2cbb2fbda20f12af", size = 4062652, upload-time = "2026-02-11T04:21:53.19Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/c0/0e16fb0addda4851445c28f8350d8c512f09de27bbb0d6d0bbf8b6709605/pillow-12.1.1-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:b957b71c6b2387610f556a7eb0828afbe40b4a98036fc0d2acfa5a44a0c2036f", size = 4138823, upload-time = "2026-02-11T04:22:03.088Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/fb/6170ec655d6f6bb6630a013dd7cf7bc218423d7b5fa9071bf63dc32175ae/pillow-12.1.1-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:097690ba1f2efdeb165a20469d59d8bb03c55fb6621eb2041a060ae8ea3e9642", size = 3601143, upload-time = "2026-02-11T04:22:04.909Z" },
+    { url = "https://files.pythonhosted.org/packages/59/04/dc5c3f297510ba9a6837cbb318b87dd2b8f73eb41a43cc63767f65cb599c/pillow-12.1.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:2815a87ab27848db0321fb78c7f0b2c8649dee134b7f2b80c6a45c6831d75ccd", size = 5266254, upload-time = "2026-02-11T04:22:07.656Z" },
+    { url = "https://files.pythonhosted.org/packages/05/30/5db1236b0d6313f03ebf97f5e17cda9ca060f524b2fcc875149a8360b21c/pillow-12.1.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:f7ed2c6543bad5a7d5530eb9e78c53132f93dfa44a28492db88b41cdab885202", size = 4657499, upload-time = "2026-02-11T04:22:09.613Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/18/008d2ca0eb612e81968e8be0bbae5051efba24d52debf930126d7eaacbba/pillow-12.1.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:652a2c9ccfb556235b2b501a3a7cf3742148cd22e04b5625c5fe057ea3e3191f", size = 6232137, upload-time = "2026-02-11T04:22:11.434Z" },
+    { url = "https://files.pythonhosted.org/packages/70/f1/f14d5b8eeb4b2cd62b9f9f847eb6605f103df89ef619ac68f92f748614ea/pillow-12.1.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d6e4571eedf43af33d0fc233a382a76e849badbccdf1ac438841308652a08e1f", size = 8042721, upload-time = "2026-02-11T04:22:13.321Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/d6/17824509146e4babbdabf04d8171491fa9d776f7061ff6e727522df9bd03/pillow-12.1.1-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b574c51cf7d5d62e9be37ba446224b59a2da26dc4c1bb2ecbe936a4fb1a7cb7f", size = 6347798, upload-time = "2026-02-11T04:22:15.449Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/ee/c85a38a9ab92037a75615aba572c85ea51e605265036e00c5b67dfafbfe2/pillow-12.1.1-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a37691702ed687799de29a518d63d4682d9016932db66d4e90c345831b02fb4e", size = 7039315, upload-time = "2026-02-11T04:22:17.24Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/f3/bc8ccc6e08a148290d7523bde4d9a0d6c981db34631390dc6e6ec34cacf6/pillow-12.1.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:f95c00d5d6700b2b890479664a06e754974848afaae5e21beb4d83c106923fd0", size = 6462360, upload-time = "2026-02-11T04:22:19.111Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/ab/69a42656adb1d0665ab051eec58a41f169ad295cf81ad45406963105408f/pillow-12.1.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:559b38da23606e68681337ad74622c4dbba02254fc9cb4488a305dd5975c7eeb", size = 7165438, upload-time = "2026-02-11T04:22:21.041Z" },
+    { url = "https://files.pythonhosted.org/packages/02/46/81f7aa8941873f0f01d4b55cc543b0a3d03ec2ee30d617a0448bf6bd6dec/pillow-12.1.1-cp314-cp314-win32.whl", hash = "sha256:03edcc34d688572014ff223c125a3f77fb08091e4607e7745002fc214070b35f", size = 6431503, upload-time = "2026-02-11T04:22:22.833Z" },
+    { url = "https://files.pythonhosted.org/packages/40/72/4c245f7d1044b67affc7f134a09ea619d4895333d35322b775b928180044/pillow-12.1.1-cp314-cp314-win_amd64.whl", hash = "sha256:50480dcd74fa63b8e78235957d302d98d98d82ccbfac4c7e12108ba9ecbdba15", size = 7176748, upload-time = "2026-02-11T04:22:24.64Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/ad/8a87bdbe038c5c698736e3348af5c2194ffb872ea52f11894c95f9305435/pillow-12.1.1-cp314-cp314-win_arm64.whl", hash = "sha256:5cb1785d97b0c3d1d1a16bc1d710c4a0049daefc4935f3a8f31f827f4d3d2e7f", size = 2544314, upload-time = "2026-02-11T04:22:26.685Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/9d/efd18493f9de13b87ede7c47e69184b9e859e4427225ea962e32e56a49bc/pillow-12.1.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:1f90cff8aa76835cba5769f0b3121a22bd4eb9e6884cfe338216e557a9a548b8", size = 5268612, upload-time = "2026-02-11T04:22:29.884Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/f1/4f42eb2b388eb2ffc660dcb7f7b556c1015c53ebd5f7f754965ef997585b/pillow-12.1.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1f1be78ce9466a7ee64bfda57bdba0f7cc499d9794d518b854816c41bf0aa4e9", size = 4660567, upload-time = "2026-02-11T04:22:31.799Z" },
+    { url = "https://files.pythonhosted.org/packages/01/54/df6ef130fa43e4b82e32624a7b821a2be1c5653a5fdad8469687a7db4e00/pillow-12.1.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:42fc1f4677106188ad9a55562bbade416f8b55456f522430fadab3cef7cd4e60", size = 6269951, upload-time = "2026-02-11T04:22:33.921Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/48/618752d06cc44bb4aae8ce0cd4e6426871929ed7b46215638088270d9b34/pillow-12.1.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:98edb152429ab62a1818039744d8fbb3ccab98a7c29fc3d5fcef158f3f1f68b7", size = 8074769, upload-time = "2026-02-11T04:22:35.877Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/bd/f1d71eb39a72fa088d938655afba3e00b38018d052752f435838961127d8/pillow-12.1.1-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d470ab1178551dd17fdba0fef463359c41aaa613cdcd7ff8373f54be629f9f8f", size = 6381358, upload-time = "2026-02-11T04:22:37.698Z" },
+    { url = "https://files.pythonhosted.org/packages/64/ef/c784e20b96674ed36a5af839305f55616f8b4f8aa8eeccf8531a6e312243/pillow-12.1.1-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6408a7b064595afcab0a49393a413732a35788f2a5092fdc6266952ed67de586", size = 7068558, upload-time = "2026-02-11T04:22:39.597Z" },
+    { url = "https://files.pythonhosted.org/packages/73/cb/8059688b74422ae61278202c4e1ad992e8a2e7375227be0a21c6b87ca8d5/pillow-12.1.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:5d8c41325b382c07799a3682c1c258469ea2ff97103c53717b7893862d0c98ce", size = 6493028, upload-time = "2026-02-11T04:22:42.73Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/da/e3c008ed7d2dd1f905b15949325934510b9d1931e5df999bb15972756818/pillow-12.1.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:c7697918b5be27424e9ce568193efd13d925c4481dd364e43f5dff72d33e10f8", size = 7191940, upload-time = "2026-02-11T04:22:44.543Z" },
+    { url = "https://files.pythonhosted.org/packages/01/4a/9202e8d11714c1fc5951f2e1ef362f2d7fbc595e1f6717971d5dd750e969/pillow-12.1.1-cp314-cp314t-win32.whl", hash = "sha256:d2912fd8114fc5545aa3a4b5576512f64c55a03f3ebcca4c10194d593d43ea36", size = 6438736, upload-time = "2026-02-11T04:22:46.347Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/ca/cbce2327eb9885476b3957b2e82eb12c866a8b16ad77392864ad601022ce/pillow-12.1.1-cp314-cp314t-win_amd64.whl", hash = "sha256:4ceb838d4bd9dab43e06c363cab2eebf63846d6a4aeaea283bbdfd8f1a8ed58b", size = 7182894, upload-time = "2026-02-11T04:22:48.114Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/d2/de599c95ba0a973b94410477f8bf0b6f0b5e67360eb89bcb1ad365258beb/pillow-12.1.1-cp314-cp314t-win_arm64.whl", hash = "sha256:7b03048319bfc6170e93bd60728a1af51d3dd7704935feb228c4d4faab35d334", size = 2546446, upload-time = "2026-02-11T04:22:50.342Z" },
+]
+
+[[package]]
+name = "python-dateutil"
+version = "2.9.0.post0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "six" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432, upload-time = "2024-03-01T18:36:20.211Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892, upload-time = "2024-03-01T18:36:18.57Z" },
+]
+
+[[package]]
+name = "pyyaml"
+version = "6.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/33/422b98d2195232ca1826284a76852ad5a86fe23e31b009c9886b2d0fb8b2/pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196", size = 182063, upload-time = "2025-09-25T21:32:11.445Z" },
+    { url = "https://files.pythonhosted.org/packages/89/a0/6cf41a19a1f2f3feab0e9c0b74134aa2ce6849093d5517a0c550fe37a648/pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0", size = 173973, upload-time = "2025-09-25T21:32:12.492Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28", size = 775116, upload-time = "2025-09-25T21:32:13.652Z" },
+    { url = "https://files.pythonhosted.org/packages/65/30/d7353c338e12baef4ecc1b09e877c1970bd3382789c159b4f89d6a70dc09/pyyaml-6.0.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c", size = 844011, upload-time = "2025-09-25T21:32:15.21Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc", size = 807870, upload-time = "2025-09-25T21:32:16.431Z" },
+    { url = "https://files.pythonhosted.org/packages/05/c0/b3be26a015601b822b97d9149ff8cb5ead58c66f981e04fedf4e762f4bd4/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e", size = 761089, upload-time = "2025-09-25T21:32:17.56Z" },
+    { url = "https://files.pythonhosted.org/packages/be/8e/98435a21d1d4b46590d5459a22d88128103f8da4c2d4cb8f14f2a96504e1/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea", size = 790181, upload-time = "2025-09-25T21:32:18.834Z" },
+    { url = "https://files.pythonhosted.org/packages/74/93/7baea19427dcfbe1e5a372d81473250b379f04b1bd3c4c5ff825e2327202/pyyaml-6.0.3-cp312-cp312-win32.whl", hash = "sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5", size = 137658, upload-time = "2025-09-25T21:32:20.209Z" },
+    { url = "https://files.pythonhosted.org/packages/86/bf/899e81e4cce32febab4fb42bb97dcdf66bc135272882d1987881a4b519e9/pyyaml-6.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b", size = 154003, upload-time = "2025-09-25T21:32:21.167Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/08/67bd04656199bbb51dbed1439b7f27601dfb576fb864099c7ef0c3e55531/pyyaml-6.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd", size = 140344, upload-time = "2025-09-25T21:32:22.617Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/11/0fd08f8192109f7169db964b5707a2f1e8b745d4e239b784a5a1dd80d1db/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", size = 181669, upload-time = "2025-09-25T21:32:23.673Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", size = 173252, upload-time = "2025-09-25T21:32:25.149Z" },
+    { url = "https://files.pythonhosted.org/packages/50/31/b20f376d3f810b9b2371e72ef5adb33879b25edb7a6d072cb7ca0c486398/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", size = 767081, upload-time = "2025-09-25T21:32:26.575Z" },
+    { url = "https://files.pythonhosted.org/packages/49/1e/a55ca81e949270d5d4432fbbd19dfea5321eda7c41a849d443dc92fd1ff7/pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5", size = 841159, upload-time = "2025-09-25T21:32:27.727Z" },
+    { url = "https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6", size = 801626, upload-time = "2025-09-25T21:32:28.878Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/11/ba845c23988798f40e52ba45f34849aa8a1f2d4af4b798588010792ebad6/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6", size = 753613, upload-time = "2025-09-25T21:32:30.178Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/e0/7966e1a7bfc0a45bf0a7fb6b98ea03fc9b8d84fa7f2229e9659680b69ee3/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be", size = 794115, upload-time = "2025-09-25T21:32:31.353Z" },
+    { url = "https://files.pythonhosted.org/packages/de/94/980b50a6531b3019e45ddeada0626d45fa85cbe22300844a7983285bed3b/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", size = 137427, upload-time = "2025-09-25T21:32:32.58Z" },
+    { url = "https://files.pythonhosted.org/packages/97/c9/39d5b874e8b28845e4ec2202b5da735d0199dbe5b8fb85f91398814a9a46/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", size = 154090, upload-time = "2025-09-25T21:32:33.659Z" },
+    { url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246, upload-time = "2025-09-25T21:32:34.663Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac", size = 181814, upload-time = "2025-09-25T21:32:35.712Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310", size = 173809, upload-time = "2025-09-25T21:32:36.789Z" },
+    { url = "https://files.pythonhosted.org/packages/92/b5/47e807c2623074914e29dabd16cbbdd4bf5e9b2db9f8090fa64411fc5382/pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7", size = 766454, upload-time = "2025-09-25T21:32:37.966Z" },
+    { url = "https://files.pythonhosted.org/packages/02/9e/e5e9b168be58564121efb3de6859c452fccde0ab093d8438905899a3a483/pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788", size = 836355, upload-time = "2025-09-25T21:32:39.178Z" },
+    { url = "https://files.pythonhosted.org/packages/88/f9/16491d7ed2a919954993e48aa941b200f38040928474c9e85ea9e64222c3/pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5", size = 794175, upload-time = "2025-09-25T21:32:40.865Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/3f/5989debef34dc6397317802b527dbbafb2b4760878a53d4166579111411e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764", size = 755228, upload-time = "2025-09-25T21:32:42.084Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/ce/af88a49043cd2e265be63d083fc75b27b6ed062f5f9fd6cdc223ad62f03e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35", size = 789194, upload-time = "2025-09-25T21:32:43.362Z" },
+    { url = "https://files.pythonhosted.org/packages/23/20/bb6982b26a40bb43951265ba29d4c246ef0ff59c9fdcdf0ed04e0687de4d/pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac", size = 156429, upload-time = "2025-09-25T21:32:57.844Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/f4/a4541072bb9422c8a883ab55255f918fa378ecf083f5b85e87fc2b4eda1b/pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3", size = 143912, upload-time = "2025-09-25T21:32:59.247Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/f9/07dd09ae774e4616edf6cda684ee78f97777bdd15847253637a6f052a62f/pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3", size = 189108, upload-time = "2025-09-25T21:32:44.377Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/78/8d08c9fb7ce09ad8c38ad533c1191cf27f7ae1effe5bb9400a46d9437fcf/pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba", size = 183641, upload-time = "2025-09-25T21:32:45.407Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/5b/3babb19104a46945cf816d047db2788bcaf8c94527a805610b0289a01c6b/pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c", size = 831901, upload-time = "2025-09-25T21:32:48.83Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/cc/dff0684d8dc44da4d22a13f35f073d558c268780ce3c6ba1b87055bb0b87/pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702", size = 861132, upload-time = "2025-09-25T21:32:50.149Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/5e/f77dc6b9036943e285ba76b49e118d9ea929885becb0a29ba8a7c75e29fe/pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c", size = 839261, upload-time = "2025-09-25T21:32:51.808Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/88/a9db1376aa2a228197c58b37302f284b5617f56a5d959fd1763fb1675ce6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065", size = 805272, upload-time = "2025-09-25T21:32:52.941Z" },
+    { url = "https://files.pythonhosted.org/packages/da/92/1446574745d74df0c92e6aa4a7b0b3130706a4142b2d1a5869f2eaa423c6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65", size = 829923, upload-time = "2025-09-25T21:32:54.537Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/7a/1c7270340330e575b92f397352af856a8c06f230aa3e76f86b39d01b416a/pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9", size = 174062, upload-time = "2025-09-25T21:32:55.767Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" },
+]
+
+[[package]]
+name = "regex"
+version = "2026.1.15"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/0b/86/07d5056945f9ec4590b518171c4254a5925832eb727b56d3c38a7476f316/regex-2026.1.15.tar.gz", hash = "sha256:164759aa25575cbc0651bef59a0b18353e54300d79ace8084c818ad8ac72b7d5", size = 414811, upload-time = "2026-01-14T23:18:02.775Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/92/81/10d8cf43c807d0326efe874c1b79f22bfb0fb226027b0b19ebc26d301408/regex-2026.1.15-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:4c8fcc5793dde01641a35905d6731ee1548f02b956815f8f1cab89e515a5bdf1", size = 489398, upload-time = "2026-01-14T23:14:43.741Z" },
+    { url = "https://files.pythonhosted.org/packages/90/b0/7c2a74e74ef2a7c32de724658a69a862880e3e4155cba992ba04d1c70400/regex-2026.1.15-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:bfd876041a956e6a90ad7cdb3f6a630c07d491280bfeed4544053cd434901681", size = 291339, upload-time = "2026-01-14T23:14:45.183Z" },
+    { url = "https://files.pythonhosted.org/packages/19/4d/16d0773d0c818417f4cc20aa0da90064b966d22cd62a8c46765b5bd2d643/regex-2026.1.15-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:9250d087bc92b7d4899ccd5539a1b2334e44eee85d848c4c1aef8e221d3f8c8f", size = 289003, upload-time = "2026-01-14T23:14:47.25Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/e4/1fc4599450c9f0863d9406e944592d968b8d6dfd0d552a7d569e43bceada/regex-2026.1.15-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c8a154cf6537ebbc110e24dabe53095e714245c272da9c1be05734bdad4a61aa", size = 798656, upload-time = "2026-01-14T23:14:48.77Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/e6/59650d73a73fa8a60b3a590545bfcf1172b4384a7df2e7fe7b9aab4e2da9/regex-2026.1.15-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8050ba2e3ea1d8731a549e83c18d2f0999fbc99a5f6bd06b4c91449f55291804", size = 864252, upload-time = "2026-01-14T23:14:50.528Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/ab/1d0f4d50a1638849a97d731364c9a80fa304fec46325e48330c170ee8e80/regex-2026.1.15-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0bf065240704cb8951cc04972cf107063917022511273e0969bdb34fc173456c", size = 912268, upload-time = "2026-01-14T23:14:52.952Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/df/0d722c030c82faa1d331d1921ee268a4e8fb55ca8b9042c9341c352f17fa/regex-2026.1.15-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c32bef3e7aeee75746748643667668ef941d28b003bfc89994ecf09a10f7a1b5", size = 803589, upload-time = "2026-01-14T23:14:55.182Z" },
+    { url = "https://files.pythonhosted.org/packages/66/23/33289beba7ccb8b805c6610a8913d0131f834928afc555b241caabd422a9/regex-2026.1.15-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d5eaa4a4c5b1906bd0d2508d68927f15b81821f85092e06f1a34a4254b0e1af3", size = 775700, upload-time = "2026-01-14T23:14:56.707Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/65/bf3a42fa6897a0d3afa81acb25c42f4b71c274f698ceabd75523259f6688/regex-2026.1.15-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:86c1077a3cc60d453d4084d5b9649065f3bf1184e22992bd322e1f081d3117fb", size = 787928, upload-time = "2026-01-14T23:14:58.312Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/f5/13bf65864fc314f68cdd6d8ca94adcab064d4d39dbd0b10fef29a9da48fc/regex-2026.1.15-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:2b091aefc05c78d286657cd4db95f2e6313375ff65dcf085e42e4c04d9c8d410", size = 858607, upload-time = "2026-01-14T23:15:00.657Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/31/040e589834d7a439ee43fb0e1e902bc81bd58a5ba81acffe586bb3321d35/regex-2026.1.15-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:57e7d17f59f9ebfa9667e6e5a1c0127b96b87cb9cede8335482451ed00788ba4", size = 763729, upload-time = "2026-01-14T23:15:02.248Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/84/6921e8129687a427edf25a34a5594b588b6d88f491320b9de5b6339a4fcb/regex-2026.1.15-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:c6c4dcdfff2c08509faa15d36ba7e5ef5fcfab25f1e8f85a0c8f45bc3a30725d", size = 850697, upload-time = "2026-01-14T23:15:03.878Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/87/3d06143d4b128f4229158f2de5de6c8f2485170c7221e61bf381313314b2/regex-2026.1.15-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:cf8ff04c642716a7f2048713ddc6278c5fd41faa3b9cab12607c7abecd012c22", size = 789849, upload-time = "2026-01-14T23:15:06.102Z" },
+    { url = "https://files.pythonhosted.org/packages/77/69/c50a63842b6bd48850ebc7ab22d46e7a2a32d824ad6c605b218441814639/regex-2026.1.15-cp312-cp312-win32.whl", hash = "sha256:82345326b1d8d56afbe41d881fdf62f1926d7264b2fc1537f99ae5da9aad7913", size = 266279, upload-time = "2026-01-14T23:15:07.678Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/36/39d0b29d087e2b11fd8191e15e81cce1b635fcc845297c67f11d0d19274d/regex-2026.1.15-cp312-cp312-win_amd64.whl", hash = "sha256:4def140aa6156bc64ee9912383d4038f3fdd18fee03a6f222abd4de6357ce42a", size = 277166, upload-time = "2026-01-14T23:15:09.257Z" },
+    { url = "https://files.pythonhosted.org/packages/28/32/5b8e476a12262748851fa8ab1b0be540360692325975b094e594dfebbb52/regex-2026.1.15-cp312-cp312-win_arm64.whl", hash = "sha256:c6c565d9a6e1a8d783c1948937ffc377dd5771e83bd56de8317c450a954d2056", size = 270415, upload-time = "2026-01-14T23:15:10.743Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/2e/6870bb16e982669b674cce3ee9ff2d1d46ab80528ee6bcc20fb2292efb60/regex-2026.1.15-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:e69d0deeb977ffe7ed3d2e4439360089f9c3f217ada608f0f88ebd67afb6385e", size = 489164, upload-time = "2026-01-14T23:15:13.962Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/67/9774542e203849b0286badf67199970a44ebdb0cc5fb739f06e47ada72f8/regex-2026.1.15-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:3601ffb5375de85a16f407854d11cca8fe3f5febbe3ac78fb2866bb220c74d10", size = 291218, upload-time = "2026-01-14T23:15:15.647Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/87/b0cda79f22b8dee05f774922a214da109f9a4c0eca5da2c9d72d77ea062c/regex-2026.1.15-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:4c5ef43b5c2d4114eb8ea424bb8c9cec01d5d17f242af88b2448f5ee81caadbc", size = 288895, upload-time = "2026-01-14T23:15:17.788Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/6a/0041f0a2170d32be01ab981d6346c83a8934277d82c780d60b127331f264/regex-2026.1.15-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:968c14d4f03e10b2fd960f1d5168c1f0ac969381d3c1fcc973bc45fb06346599", size = 798680, upload-time = "2026-01-14T23:15:19.342Z" },
+    { url = "https://files.pythonhosted.org/packages/58/de/30e1cfcdbe3e891324aa7568b7c968771f82190df5524fabc1138cb2d45a/regex-2026.1.15-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:56a5595d0f892f214609c9f76b41b7428bed439d98dc961efafdd1354d42baae", size = 864210, upload-time = "2026-01-14T23:15:22.005Z" },
+    { url = "https://files.pythonhosted.org/packages/64/44/4db2f5c5ca0ccd40ff052ae7b1e9731352fcdad946c2b812285a7505ca75/regex-2026.1.15-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0bf650f26087363434c4e560011f8e4e738f6f3e029b85d4904c50135b86cfa5", size = 912358, upload-time = "2026-01-14T23:15:24.569Z" },
+    { url = "https://files.pythonhosted.org/packages/79/b6/e6a5665d43a7c42467138c8a2549be432bad22cbd206f5ec87162de74bd7/regex-2026.1.15-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:18388a62989c72ac24de75f1449d0fb0b04dfccd0a1a7c1c43af5eb503d890f6", size = 803583, upload-time = "2026-01-14T23:15:26.526Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/53/7cd478222169d85d74d7437e74750005e993f52f335f7c04ff7adfda3310/regex-2026.1.15-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:6d220a2517f5893f55daac983bfa9fe998a7dbcaee4f5d27a88500f8b7873788", size = 775782, upload-time = "2026-01-14T23:15:29.352Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/b5/75f9a9ee4b03a7c009fe60500fe550b45df94f0955ca29af16333ef557c5/regex-2026.1.15-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:c9c08c2fbc6120e70abff5d7f28ffb4d969e14294fb2143b4b5c7d20e46d1714", size = 787978, upload-time = "2026-01-14T23:15:31.295Z" },
+    { url = "https://files.pythonhosted.org/packages/72/b3/79821c826245bbe9ccbb54f6eadb7879c722fd3e0248c17bfc90bf54e123/regex-2026.1.15-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:7ef7d5d4bd49ec7364315167a4134a015f61e8266c6d446fc116a9ac4456e10d", size = 858550, upload-time = "2026-01-14T23:15:33.558Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/85/2ab5f77a1c465745bfbfcb3ad63178a58337ae8d5274315e2cc623a822fa/regex-2026.1.15-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:6e42844ad64194fa08d5ccb75fe6a459b9b08e6d7296bd704460168d58a388f3", size = 763747, upload-time = "2026-01-14T23:15:35.206Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/84/c27df502d4bfe2873a3e3a7cf1bdb2b9cc10284d1a44797cf38bed790470/regex-2026.1.15-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:cfecdaa4b19f9ca534746eb3b55a5195d5c95b88cac32a205e981ec0a22b7d31", size = 850615, upload-time = "2026-01-14T23:15:37.523Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/b7/658a9782fb253680aa8ecb5ccbb51f69e088ed48142c46d9f0c99b46c575/regex-2026.1.15-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:08df9722d9b87834a3d701f3fca570b2be115654dbfd30179f30ab2f39d606d3", size = 789951, upload-time = "2026-01-14T23:15:39.582Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/2a/5928af114441e059f15b2f63e188bd00c6529b3051c974ade7444b85fcda/regex-2026.1.15-cp313-cp313-win32.whl", hash = "sha256:d426616dae0967ca225ab12c22274eb816558f2f99ccb4a1d52ca92e8baf180f", size = 266275, upload-time = "2026-01-14T23:15:42.108Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/16/5bfbb89e435897bff28cf0352a992ca719d9e55ebf8b629203c96b6ce4f7/regex-2026.1.15-cp313-cp313-win_amd64.whl", hash = "sha256:febd38857b09867d3ed3f4f1af7d241c5c50362e25ef43034995b77a50df494e", size = 277145, upload-time = "2026-01-14T23:15:44.244Z" },
+    { url = "https://files.pythonhosted.org/packages/56/c1/a09ff7392ef4233296e821aec5f78c51be5e91ffde0d163059e50fd75835/regex-2026.1.15-cp313-cp313-win_arm64.whl", hash = "sha256:8e32f7896f83774f91499d239e24cebfadbc07639c1494bb7213983842348337", size = 270411, upload-time = "2026-01-14T23:15:45.858Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/38/0cfd5a78e5c6db00e6782fdae70458f89850ce95baa5e8694ab91d89744f/regex-2026.1.15-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:ec94c04149b6a7b8120f9f44565722c7ae31b7a6d2275569d2eefa76b83da3be", size = 492068, upload-time = "2026-01-14T23:15:47.616Z" },
+    { url = "https://files.pythonhosted.org/packages/50/72/6c86acff16cb7c959c4355826bbf06aad670682d07c8f3998d9ef4fee7cd/regex-2026.1.15-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:40c86d8046915bb9aeb15d3f3f15b6fd500b8ea4485b30e1bbc799dab3fe29f8", size = 292756, upload-time = "2026-01-14T23:15:49.307Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/58/df7fb69eadfe76526ddfce28abdc0af09ffe65f20c2c90932e89d705153f/regex-2026.1.15-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:726ea4e727aba21643205edad8f2187ec682d3305d790f73b7a51c7587b64bdd", size = 291114, upload-time = "2026-01-14T23:15:51.484Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/6c/a4011cd1cf96b90d2cdc7e156f91efbd26531e822a7fbb82a43c1016678e/regex-2026.1.15-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1cb740d044aff31898804e7bf1181cc72c03d11dfd19932b9911ffc19a79070a", size = 807524, upload-time = "2026-01-14T23:15:53.102Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/25/a53ffb73183f69c3e9f4355c4922b76d2840aee160af6af5fac229b6201d/regex-2026.1.15-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:05d75a668e9ea16f832390d22131fe1e8acc8389a694c8febc3e340b0f810b93", size = 873455, upload-time = "2026-01-14T23:15:54.956Z" },
+    { url = "https://files.pythonhosted.org/packages/66/0b/8b47fc2e8f97d9b4a851736f3890a5f786443aa8901061c55f24c955f45b/regex-2026.1.15-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d991483606f3dbec93287b9f35596f41aa2e92b7c2ebbb935b63f409e243c9af", size = 915007, upload-time = "2026-01-14T23:15:57.041Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/fa/97de0d681e6d26fabe71968dbee06dd52819e9a22fdce5dac7256c31ed84/regex-2026.1.15-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:194312a14819d3e44628a44ed6fea6898fdbecb0550089d84c403475138d0a09", size = 812794, upload-time = "2026-01-14T23:15:58.916Z" },
+    { url = "https://files.pythonhosted.org/packages/22/38/e752f94e860d429654aa2b1c51880bff8dfe8f084268258adf9151cf1f53/regex-2026.1.15-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:fe2fda4110a3d0bc163c2e0664be44657431440722c5c5315c65155cab92f9e5", size = 781159, upload-time = "2026-01-14T23:16:00.817Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/a7/d739ffaef33c378fc888302a018d7f81080393d96c476b058b8c64fd2b0d/regex-2026.1.15-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:124dc36c85d34ef2d9164da41a53c1c8c122cfb1f6e1ec377a1f27ee81deb794", size = 795558, upload-time = "2026-01-14T23:16:03.267Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/c4/542876f9a0ac576100fc73e9c75b779f5c31e3527576cfc9cb3009dcc58a/regex-2026.1.15-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:a1774cd1981cd212506a23a14dba7fdeaee259f5deba2df6229966d9911e767a", size = 868427, upload-time = "2026-01-14T23:16:05.646Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/0f/d5655bea5b22069e32ae85a947aa564912f23758e112cdb74212848a1a1b/regex-2026.1.15-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:b5f7d8d2867152cdb625e72a530d2ccb48a3d199159144cbdd63870882fb6f80", size = 769939, upload-time = "2026-01-14T23:16:07.542Z" },
+    { url = "https://files.pythonhosted.org/packages/20/06/7e18a4fa9d326daeda46d471a44ef94201c46eaa26dbbb780b5d92cbfdda/regex-2026.1.15-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:492534a0ab925d1db998defc3c302dae3616a2fc3fe2e08db1472348f096ddf2", size = 854753, upload-time = "2026-01-14T23:16:10.395Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/67/dc8946ef3965e166f558ef3b47f492bc364e96a265eb4a2bb3ca765c8e46/regex-2026.1.15-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:c661fc820cfb33e166bf2450d3dadbda47c8d8981898adb9b6fe24e5e582ba60", size = 799559, upload-time = "2026-01-14T23:16:12.347Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/61/1bba81ff6d50c86c65d9fd84ce9699dd106438ee4cdb105bf60374ee8412/regex-2026.1.15-cp313-cp313t-win32.whl", hash = "sha256:99ad739c3686085e614bf77a508e26954ff1b8f14da0e3765ff7abbf7799f952", size = 268879, upload-time = "2026-01-14T23:16:14.049Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/5e/cef7d4c5fb0ea3ac5c775fd37db5747f7378b29526cc83f572198924ff47/regex-2026.1.15-cp313-cp313t-win_amd64.whl", hash = "sha256:32655d17905e7ff8ba5c764c43cb124e34a9245e45b83c22e81041e1071aee10", size = 280317, upload-time = "2026-01-14T23:16:15.718Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/52/4317f7a5988544e34ab57b4bde0f04944c4786128c933fb09825924d3e82/regex-2026.1.15-cp313-cp313t-win_arm64.whl", hash = "sha256:b2a13dd6a95e95a489ca242319d18fc02e07ceb28fa9ad146385194d95b3c829", size = 271551, upload-time = "2026-01-14T23:16:17.533Z" },
+    { url = "https://files.pythonhosted.org/packages/52/0a/47fa888ec7cbbc7d62c5f2a6a888878e76169170ead271a35239edd8f0e8/regex-2026.1.15-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:d920392a6b1f353f4aa54328c867fec3320fa50657e25f64abf17af054fc97ac", size = 489170, upload-time = "2026-01-14T23:16:19.835Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/c4/d000e9b7296c15737c9301708e9e7fbdea009f8e93541b6b43bdb8219646/regex-2026.1.15-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:b5a28980a926fa810dbbed059547b02783952e2efd9c636412345232ddb87ff6", size = 291146, upload-time = "2026-01-14T23:16:21.541Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/b6/921cc61982e538682bdf3bdf5b2c6ab6b34368da1f8e98a6c1ddc503c9cf/regex-2026.1.15-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:621f73a07595d83f28952d7bd1e91e9d1ed7625fb7af0064d3516674ec93a2a2", size = 288986, upload-time = "2026-01-14T23:16:23.381Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/33/eb7383dde0bbc93f4fb9d03453aab97e18ad4024ac7e26cef8d1f0a2cff0/regex-2026.1.15-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3d7d92495f47567a9b1669c51fc8d6d809821849063d168121ef801bbc213846", size = 799098, upload-time = "2026-01-14T23:16:25.088Z" },
+    { url = "https://files.pythonhosted.org/packages/27/56/b664dccae898fc8d8b4c23accd853f723bde0f026c747b6f6262b688029c/regex-2026.1.15-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8dd16fba2758db7a3780a051f245539c4451ca20910f5a5e6ea1c08d06d4a76b", size = 864980, upload-time = "2026-01-14T23:16:27.297Z" },
+    { url = "https://files.pythonhosted.org/packages/16/40/0999e064a170eddd237bae9ccfcd8f28b3aa98a38bf727a086425542a4fc/regex-2026.1.15-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:1e1808471fbe44c1a63e5f577a1d5f02fe5d66031dcbdf12f093ffc1305a858e", size = 911607, upload-time = "2026-01-14T23:16:29.235Z" },
+    { url = "https://files.pythonhosted.org/packages/07/78/c77f644b68ab054e5a674fb4da40ff7bffb2c88df58afa82dbf86573092d/regex-2026.1.15-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0751a26ad39d4f2ade8fe16c59b2bf5cb19eb3d2cd543e709e583d559bd9efde", size = 803358, upload-time = "2026-01-14T23:16:31.369Z" },
+    { url = "https://files.pythonhosted.org/packages/27/31/d4292ea8566eaa551fafc07797961c5963cf5235c797cc2ae19b85dfd04d/regex-2026.1.15-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0f0c7684c7f9ca241344ff95a1de964f257a5251968484270e91c25a755532c5", size = 775833, upload-time = "2026-01-14T23:16:33.141Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/b2/cff3bf2fea4133aa6fb0d1e370b37544d18c8350a2fa118c7e11d1db0e14/regex-2026.1.15-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:74f45d170a21df41508cb67165456538425185baaf686281fa210d7e729abc34", size = 788045, upload-time = "2026-01-14T23:16:35.005Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/99/2cb9b69045372ec877b6f5124bda4eb4253bc58b8fe5848c973f752bc52c/regex-2026.1.15-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:f1862739a1ffb50615c0fde6bae6569b5efbe08d98e59ce009f68a336f64da75", size = 859374, upload-time = "2026-01-14T23:16:36.919Z" },
+    { url = "https://files.pythonhosted.org/packages/09/16/710b0a5abe8e077b1729a562d2f297224ad079f3a66dce46844c193416c8/regex-2026.1.15-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:453078802f1b9e2b7303fb79222c054cb18e76f7bdc220f7530fdc85d319f99e", size = 763940, upload-time = "2026-01-14T23:16:38.685Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/d1/7585c8e744e40eb3d32f119191969b91de04c073fca98ec14299041f6e7e/regex-2026.1.15-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:a30a68e89e5a218b8b23a52292924c1f4b245cb0c68d1cce9aec9bbda6e2c160", size = 850112, upload-time = "2026-01-14T23:16:40.646Z" },
+    { url = "https://files.pythonhosted.org/packages/af/d6/43e1dd85df86c49a347aa57c1f69d12c652c7b60e37ec162e3096194a278/regex-2026.1.15-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:9479cae874c81bf610d72b85bb681a94c95722c127b55445285fb0e2c82db8e1", size = 789586, upload-time = "2026-01-14T23:16:42.799Z" },
+    { url = "https://files.pythonhosted.org/packages/93/38/77142422f631e013f316aaae83234c629555729a9fbc952b8a63ac91462a/regex-2026.1.15-cp314-cp314-win32.whl", hash = "sha256:d639a750223132afbfb8f429c60d9d318aeba03281a5f1ab49f877456448dcf1", size = 271691, upload-time = "2026-01-14T23:16:44.671Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/a9/ab16b4649524ca9e05213c1cdbb7faa85cc2aa90a0230d2f796cbaf22736/regex-2026.1.15-cp314-cp314-win_amd64.whl", hash = "sha256:4161d87f85fa831e31469bfd82c186923070fc970b9de75339b68f0c75b51903", size = 280422, upload-time = "2026-01-14T23:16:46.607Z" },
+    { url = "https://files.pythonhosted.org/packages/be/2a/20fd057bf3521cb4791f69f869635f73e0aaf2b9ad2d260f728144f9047c/regex-2026.1.15-cp314-cp314-win_arm64.whl", hash = "sha256:91c5036ebb62663a6b3999bdd2e559fd8456d17e2b485bf509784cd31a8b1705", size = 273467, upload-time = "2026-01-14T23:16:48.967Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/77/0b1e81857060b92b9cad239104c46507dd481b3ff1fa79f8e7f865aae38a/regex-2026.1.15-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:ee6854c9000a10938c79238de2379bea30c82e4925a371711af45387df35cab8", size = 492073, upload-time = "2026-01-14T23:16:51.154Z" },
+    { url = "https://files.pythonhosted.org/packages/70/f3/f8302b0c208b22c1e4f423147e1913fd475ddd6230565b299925353de644/regex-2026.1.15-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:2c2b80399a422348ce5de4fe40c418d6299a0fa2803dd61dc0b1a2f28e280fcf", size = 292757, upload-time = "2026-01-14T23:16:53.08Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/f0/ef55de2460f3b4a6da9d9e7daacd0cb79d4ef75c64a2af316e68447f0df0/regex-2026.1.15-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:dca3582bca82596609959ac39e12b7dad98385b4fefccb1151b937383cec547d", size = 291122, upload-time = "2026-01-14T23:16:55.383Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/55/bb8ccbacabbc3a11d863ee62a9f18b160a83084ea95cdfc5d207bfc3dd75/regex-2026.1.15-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ef71d476caa6692eea743ae5ea23cde3260677f70122c4d258ca952e5c2d4e84", size = 807761, upload-time = "2026-01-14T23:16:57.251Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/84/f75d937f17f81e55679a0509e86176e29caa7298c38bd1db7ce9c0bf6075/regex-2026.1.15-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c243da3436354f4af6c3058a3f81a97d47ea52c9bd874b52fd30274853a1d5df", size = 873538, upload-time = "2026-01-14T23:16:59.349Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/d9/0da86327df70349aa8d86390da91171bd3ca4f0e7c1d1d453a9c10344da3/regex-2026.1.15-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:8355ad842a7c7e9e5e55653eade3b7d1885ba86f124dd8ab1f722f9be6627434", size = 915066, upload-time = "2026-01-14T23:17:01.607Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/5e/f660fb23fc77baa2a61aa1f1fe3a4eea2bbb8a286ddec148030672e18834/regex-2026.1.15-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f192a831d9575271a22d804ff1a5355355723f94f31d9eef25f0d45a152fdc1a", size = 812938, upload-time = "2026-01-14T23:17:04.366Z" },
+    { url = "https://files.pythonhosted.org/packages/69/33/a47a29bfecebbbfd1e5cd3f26b28020a97e4820f1c5148e66e3b7d4b4992/regex-2026.1.15-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:166551807ec20d47ceaeec380081f843e88c8949780cd42c40f18d16168bed10", size = 781314, upload-time = "2026-01-14T23:17:06.378Z" },
+    { url = "https://files.pythonhosted.org/packages/65/ec/7ec2bbfd4c3f4e494a24dec4c6943a668e2030426b1b8b949a6462d2c17b/regex-2026.1.15-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:f9ca1cbdc0fbfe5e6e6f8221ef2309988db5bcede52443aeaee9a4ad555e0dac", size = 795652, upload-time = "2026-01-14T23:17:08.521Z" },
+    { url = "https://files.pythonhosted.org/packages/46/79/a5d8651ae131fe27d7c521ad300aa7f1c7be1dbeee4d446498af5411b8a9/regex-2026.1.15-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:b30bcbd1e1221783c721483953d9e4f3ab9c5d165aa709693d3f3946747b1aea", size = 868550, upload-time = "2026-01-14T23:17:10.573Z" },
+    { url = "https://files.pythonhosted.org/packages/06/b7/25635d2809664b79f183070786a5552dd4e627e5aedb0065f4e3cf8ee37d/regex-2026.1.15-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:2a8d7b50c34578d0d3bf7ad58cde9652b7d683691876f83aedc002862a35dc5e", size = 769981, upload-time = "2026-01-14T23:17:12.871Z" },
+    { url = "https://files.pythonhosted.org/packages/16/8b/fc3fcbb2393dcfa4a6c5ffad92dc498e842df4581ea9d14309fcd3c55fb9/regex-2026.1.15-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:9d787e3310c6a6425eb346be4ff2ccf6eece63017916fd77fe8328c57be83521", size = 854780, upload-time = "2026-01-14T23:17:14.837Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/38/dde117c76c624713c8a2842530be9c93ca8b606c0f6102d86e8cd1ce8bea/regex-2026.1.15-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:619843841e220adca114118533a574a9cd183ed8a28b85627d2844c500a2b0db", size = 799778, upload-time = "2026-01-14T23:17:17.369Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/0d/3a6cfa9ae99606afb612d8fb7a66b245a9d5ff0f29bb347c8a30b6ad561b/regex-2026.1.15-cp314-cp314t-win32.whl", hash = "sha256:e90b8db97f6f2c97eb045b51a6b2c5ed69cedd8392459e0642d4199b94fabd7e", size = 274667, upload-time = "2026-01-14T23:17:19.301Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/b2/297293bb0742fd06b8d8e2572db41a855cdf1cae0bf009b1cb74fe07e196/regex-2026.1.15-cp314-cp314t-win_amd64.whl", hash = "sha256:5ef19071f4ac9f0834793af85bd04a920b4407715624e40cb7a0631a11137cdf", size = 284386, upload-time = "2026-01-14T23:17:21.231Z" },
+    { url = "https://files.pythonhosted.org/packages/95/e4/a3b9480c78cf8ee86626cb06f8d931d74d775897d44201ccb813097ae697/regex-2026.1.15-cp314-cp314t-win_arm64.whl", hash = "sha256:ca89c5e596fc05b015f27561b3793dc2fa0917ea0d7507eebb448efd35274a70", size = 274837, upload-time = "2026-01-14T23:17:23.146Z" },
+]
+
+[[package]]
+name = "requests"
+version = "2.32.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "certifi" },
+    { name = "charset-normalizer" },
+    { name = "idna" },
+    { name = "urllib3" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c9/74/b3ff8e6c8446842c3f5c837e9c3dfcfe2018ea6ecef224c710c85ef728f4/requests-2.32.5.tar.gz", hash = "sha256:dbba0bac56e100853db0ea71b82b4dfd5fe2bf6d3754a8893c3af500cec7d7cf", size = 134517, upload-time = "2025-08-18T20:46:02.573Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/db/4254e3eabe8020b458f1a747140d32277ec7a271daf1d235b70dc0b4e6e3/requests-2.32.5-py3-none-any.whl", hash = "sha256:2462f94637a34fd532264295e186976db0f5d453d1cdd31473c85a6a161affb6", size = 64738, upload-time = "2025-08-18T20:46:00.542Z" },
+]
+
+[[package]]
+name = "requests-file"
+version = "3.0.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "requests" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/3c/f8/5dc70102e4d337063452c82e1f0d95e39abfe67aa222ed8a5ddeb9df8de8/requests_file-3.0.1.tar.gz", hash = "sha256:f14243d7796c588f3521bd423c5dea2ee4cc730e54a3cac9574d78aca1272576", size = 6967, upload-time = "2025-10-20T18:56:42.279Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e1/d5/de8f089119205a09da657ed4784c584ede8381a0ce6821212a6d4ca47054/requests_file-3.0.1-py2.py3-none-any.whl", hash = "sha256:d0f5eb94353986d998f80ac63c7f146a307728be051d4d1cd390dbdb59c10fa2", size = 4514, upload-time = "2025-10-20T18:56:41.184Z" },
+]
+
+[[package]]
+name = "sgmllib3k"
+version = "1.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/9e/bd/3704a8c3e0942d711c1299ebf7b9091930adae6675d7c8f476a7ce48653c/sgmllib3k-1.0.0.tar.gz", hash = "sha256:7868fb1c8bfa764c1ac563d3cf369c381d1325d36124933a726f29fcdaa812e9", size = 5750, upload-time = "2010-08-24T14:33:52.445Z" }
+
+[[package]]
+name = "six"
+version = "1.17.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031, upload-time = "2024-12-04T17:35:28.174Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload-time = "2024-12-04T17:35:26.475Z" },
+]
+
+[[package]]
+name = "soupsieve"
+version = "2.8.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/7b/ae/2d9c981590ed9999a0d91755b47fc74f74de286b0f5cee14c9269041e6c4/soupsieve-2.8.3.tar.gz", hash = "sha256:3267f1eeea4251fb42728b6dfb746edc9acaffc4a45b27e19450b676586e8349", size = 118627, upload-time = "2026-01-20T04:27:02.457Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/46/2c/1462b1d0a634697ae9e55b3cecdcb64788e8b7d63f54d923fcd0bb140aed/soupsieve-2.8.3-py3-none-any.whl", hash = "sha256:ed64f2ba4eebeab06cc4962affce381647455978ffc1e36bb79a545b91f45a95", size = 37016, upload-time = "2026-01-20T04:27:01.012Z" },
+]
+
+[[package]]
+name = "rubick"
+version = "0.1.0"
+source = { virtual = "." }
+dependencies = [
+    { name = "lxml-html-clean" },
+    { name = "newspaper4k" },
+    { name = "openpyxl" },
+    { name = "pandas" },
+    { name = "xlsxwriter" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "lxml-html-clean", specifier = ">=0.4.3" },
+    { name = "newspaper4k", specifier = ">=0.9.4.1" },
+    { name = "openpyxl", specifier = ">=3.1.5" },
+    { name = "pandas", specifier = ">=3.0.0" },
+    { name = "xlsxwriter", specifier = ">=3.2.9" },
+]
+
+[[package]]
+name = "tldextract"
+version = "5.3.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "filelock" },
+    { name = "idna" },
+    { name = "requests" },
+    { name = "requests-file" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/65/7b/644fbbb49564a6cb124a8582013315a41148dba2f72209bba14a84242bf0/tldextract-5.3.1.tar.gz", hash = "sha256:a72756ca170b2510315076383ea2993478f7da6f897eef1f4a5400735d5057fb", size = 126105, upload-time = "2025-12-28T23:58:05.532Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/6d/42/0e49d6d0aac449ca71952ec5bae764af009754fcb2e76a5cc097543747b3/tldextract-5.3.1-py3-none-any.whl", hash = "sha256:6bfe36d518de569c572062b788e16a659ccaceffc486d243af0484e8ecf432d9", size = 105886, upload-time = "2025-12-28T23:58:04.071Z" },
+]
+
+[[package]]
+name = "tqdm"
+version = "4.67.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/09/a9/6ba95a270c6f1fbcd8dac228323f2777d886cb206987444e4bce66338dd4/tqdm-4.67.3.tar.gz", hash = "sha256:7d825f03f89244ef73f1d4ce193cb1774a8179fd96f31d7e1dcde62092b960bb", size = 169598, upload-time = "2026-02-03T17:35:53.048Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/16/e1/3079a9ff9b8e11b846c6ac5c8b5bfb7ff225eee721825310c91b3b50304f/tqdm-4.67.3-py3-none-any.whl", hash = "sha256:ee1e4c0e59148062281c49d80b25b67771a127c85fc9676d3be5f243206826bf", size = 78374, upload-time = "2026-02-03T17:35:50.982Z" },
+]
+
+[[package]]
+name = "typing-extensions"
+version = "4.15.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload-time = "2025-08-25T13:49:26.313Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" },
+]
+
+[[package]]
+name = "tzdata"
+version = "2025.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/5e/a7/c202b344c5ca7daf398f3b8a477eeb205cf3b6f32e7ec3a6bac0629ca975/tzdata-2025.3.tar.gz", hash = "sha256:de39c2ca5dc7b0344f2eba86f49d614019d29f060fc4ebc8a417896a620b56a7", size = 196772, upload-time = "2025-12-13T17:45:35.667Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c7/b0/003792df09decd6849a5e39c28b513c06e84436a54440380862b5aeff25d/tzdata-2025.3-py2.py3-none-any.whl", hash = "sha256:06a47e5700f3081aab02b2e513160914ff0694bce9947d6b76ebd6bf57cfc5d1", size = 348521, upload-time = "2025-12-13T17:45:33.889Z" },
+]
+
+[[package]]
+name = "urllib3"
+version = "2.6.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c7/24/5f1b3bdffd70275f6661c76461e25f024d5a38a46f04aaca912426a2b1d3/urllib3-2.6.3.tar.gz", hash = "sha256:1b62b6884944a57dbe321509ab94fd4d3b307075e0c2eae991ac71ee15ad38ed", size = 435556, upload-time = "2026-01-07T16:24:43.925Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/39/08/aaaad47bc4e9dc8c725e68f9d04865dbcb2052843ff09c97b08904852d84/urllib3-2.6.3-py3-none-any.whl", hash = "sha256:bf272323e553dfb2e87d9bfd225ca7b0f467b919d7bbd355436d3fd37cb0acd4", size = 131584, upload-time = "2026-01-07T16:24:42.685Z" },
+]
+
+[[package]]
+name = "xlsxwriter"
+version = "3.2.9"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/46/2c/c06ef49dc36e7954e55b802a8b231770d286a9758b3d936bd1e04ce5ba88/xlsxwriter-3.2.9.tar.gz", hash = "sha256:254b1c37a368c444eac6e2f867405cc9e461b0ed97a3233b2ac1e574efb4140c", size = 215940, upload-time = "2025-09-16T00:16:21.63Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3a/0c/3662f4a66880196a590b202f0db82d919dd2f89e99a27fadef91c4a33d41/xlsxwriter-3.2.9-py3-none-any.whl", hash = "sha256:9a5db42bc5dff014806c58a20b9eae7322a134abb6fce3c92c181bfb275ec5b3", size = 175315, upload-time = "2025-09-16T00:16:20.108Z" },
+]