fa-inrdata-api 0.1.0__py3-none-any.whl

fa_inrdata_api/__init__.py

@@ -0,0 +1,39 @@
+from .core import (
+    PriceRow,
+    ScheduleFASummary,
+    Ticker,
+    TickerInfo,
+    date_range,
+    max_value,
+    min_value,
+    price_action,
+    schedule_fa_summary,
+    supported_tickers,
+    supported_years_for_ticker,
+    ticker_metadata,
+    value_at_year_end,
+    value_at_year_start,
+    value_on_date,
+    warm_cache,
+)
+
+__all__ = [
+    "PriceRow",
+    "ScheduleFASummary",
+    "Ticker",
+    "TickerInfo",
+    "date_range",
+    "max_value",
+    "min_value",
+    "price_action",
+    "schedule_fa_summary",
+    "supported_tickers",
+    "supported_years_for_ticker",
+    "ticker_metadata",
+    "value_at_year_end",
+    "value_at_year_start",
+    "value_on_date",
+    "warm_cache",
+]
+
+__version__ = "0.1.0"

fa_inrdata_api/core.py

@@ -0,0 +1,459 @@
+"""
+Read-only API over the jdecodes/fa-inrdata GitHub dataset.
+
+Data source: https://github.com/jdecodes/fa-inrdata/tree/main/data
+Each ticker has one CSV per completed calendar year at
+    data/{TICKER}/{YEAR}.csv
+with columns: date, close, sbi_tt, close_inr
+
+DISCLAIMER: This is an unofficial, community-maintained package, not
+affiliated with SBI or Yahoo Finance. Data may be inaccurate or
+incomplete. Verify against an official source before relying on this
+for tax or financial decisions.
+"""
+
+from __future__ import annotations
+
+import csv
+import io
+import json
+import re
+import urllib.error
+import urllib.request
+import warnings
+from bisect import bisect_right
+from dataclasses import dataclass
+from datetime import date, datetime
+from pathlib import Path
+
+warnings.warn(
+    "fa_inrdata_api is an UNOFFICIAL, community-maintained package. "
+    "Data may be inaccurate or incomplete. Verify against an official "
+    "source before relying on this for tax or financial decisions.",
+    UserWarning,
+    stacklevel=2,
+)
+
+RAW_BASE = "https://raw.githubusercontent.com/jdecodes/fa-inrdata/main"
+TICKERS_URL = f"{RAW_BASE}/tickers.csv"
+MANIFEST_URL = f"{RAW_BASE}/manifest.json"
+DATA_URL_TEMPLATE = RAW_BASE + "/data/{ticker}/{year}.csv"
+
+CACHE_DIR = Path.home() / ".cache" / "fa_inrdata_api"
+
+_DATE_RE_FMT = "%Y-%m-%d"
+_DATE_RE = re.compile(r"^\d{4}-\d{2}-\d{2}$")
+
+
+# --------------------------------------------------------------------------
+# Data types
+# --------------------------------------------------------------------------
+
+
+@dataclass(frozen=True)
+class TickerInfo:
+    ticker: str
+    name: str
+    address: str
+    zip: str
+    country: str
+
+
+@dataclass(frozen=True)
+class PriceRow:
+    date: str  # YYYY-MM-DD
+    close: float  # native currency (e.g. USD) close
+    sbi_tt: float  # SBI TT buying rate applied
+    close_inr: float  # close converted to INR
+
+
+@dataclass(frozen=True)
+class ScheduleFASummary:
+    ticker: str
+    year: int
+    initial: PriceRow  # first trading day of the year
+    peak: PriceRow  # highest close_inr in the year
+    closing: PriceRow  # last trading day of the year
+
+
+# --------------------------------------------------------------------------
+# Internal helpers
+# --------------------------------------------------------------------------
+
+
+def _http_get(url: str, timeout: int = 10) -> str:
+    try:
+        with urllib.request.urlopen(url, timeout=timeout) as resp:
+            return resp.read().decode()
+    except urllib.error.HTTPError as e:
+        raise ValueError(f"No data found at {url} (HTTP {e.code})") from e
+    except urllib.error.URLError as e:
+        raise ConnectionError(f"Could not reach {url}: {e.reason}") from e
+
+
+def _cache_path(*parts: str) -> Path:
+    return CACHE_DIR.joinpath(*parts)
+
+
+def _read_cache(path: Path) -> str | None:
+    if path.exists():
+        return path.read_text()
+    return None
+
+
+def _write_cache(path: Path, text: str) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(text)
+
+
+def _parse_date(value: str | date) -> date:
+    """
+    Strict date validation, matching sbi_tt_rates' behavior.
+
+    Accepts:
+    - a real datetime.date (including datetime.datetime, which is a
+      date subclass) object — the preferred input
+    - a string strictly in 'YYYY-MM-DD' format, zero-padded
+      (e.g. '2025-01-07', not '2025-1-7')
+
+    Rejects everything else with a clear error, rather than letting a
+    permissive strptime silently accept ambiguous formats.
+    """
+    if isinstance(value, date):
+        return value
+
+    if not isinstance(value, str):
+        raise TypeError(
+            f"Expected a datetime.date object or a 'YYYY-MM-DD' string, "
+            f"got {type(value).__name__}: {value!r}"
+        )
+
+    if not _DATE_RE.match(value):
+        raise ValueError(
+            f"Invalid date format: {value!r}. Expected zero-padded "
+            f"'YYYY-MM-DD' (e.g. '2025-01-07'), not e.g. '2025-1-7'."
+        )
+
+    try:
+        return datetime.strptime(value, _DATE_RE_FMT).date()
+    except ValueError as e:
+        raise ValueError(f"Invalid date: {value!r} is not a real calendar date.") from e
+
+
+def _load_manifest(refresh: bool = False) -> dict | None:
+    """Fetch manifest.json (ticker -> [years]). Returns None if it 404s
+    (e.g. not yet published upstream) so callers can fall back gracefully."""
+    cache_path = _cache_path("manifest.json")
+    text = None if refresh else _read_cache(cache_path)
+    if text is None:
+        try:
+            text = _http_get(MANIFEST_URL)
+        except (ValueError, ConnectionError):
+            return None
+        _write_cache(cache_path, text)
+    try:
+        return json.loads(text)
+    except json.JSONDecodeError:
+        return None
+
+
+def _load_ticker_rows(refresh: bool = False) -> list[dict]:
+    cache_path = _cache_path("tickers.csv")
+    text = None if refresh else _read_cache(cache_path)
+    if text is None:
+        text = _http_get(TICKERS_URL)
+        _write_cache(cache_path, text)
+    return list(csv.DictReader(io.StringIO(text)))
+
+
+def _load_price_rows(ticker: str, year: int, refresh: bool = False) -> list[PriceRow]:
+    ticker = ticker.upper()
+    cache_path = _cache_path(ticker, f"{year}.csv")
+    text = None if refresh else _read_cache(cache_path)
+    if text is None:
+        url = DATA_URL_TEMPLATE.format(ticker=ticker, year=year)
+        try:
+            text = _http_get(url)
+        except ValueError as e:
+            raise ValueError(
+                f"No data for ticker={ticker!r}, year={year}. "
+                f"Call supported_years_for_ticker({ticker!r}) to see what's "
+                f"available."
+            ) from e
+        _write_cache(cache_path, text)
+
+    rows = []
+    for r in csv.DictReader(io.StringIO(text)):
+        rows.append(
+            PriceRow(
+                date=r["date"],
+                close=float(r["close"]),
+                sbi_tt=float(r["sbi_tt"]),
+                close_inr=float(r["close_inr"]),
+            )
+        )
+    rows.sort(key=lambda row: row.date)
+    return rows
+
+
+# --------------------------------------------------------------------------
+# Public API
+# --------------------------------------------------------------------------
+
+
+def warm_cache(refresh: bool = False) -> None:
+    """
+    Eagerly fetch and cache tickers.csv + manifest.json.
+
+    Not required — every function fetches+caches lazily on first call
+    anyway — but calling this once (e.g. the first cell of a notebook,
+    or right after pip install) avoids the first real call paying for
+    both downloads, and surfaces network/auth issues up front instead
+    of mid-analysis.
+    """
+    _load_ticker_rows(refresh=refresh)
+    _load_manifest(refresh=refresh)
+
+
+def supported_tickers(refresh: bool = False) -> list[str]:
+    """Return the sorted list of tickers this dataset covers."""
+    rows = _load_ticker_rows(refresh=refresh)
+    return sorted(r["ticker"] for r in rows)
+
+
+def ticker_metadata(ticker: str, refresh: bool = False) -> TickerInfo:
+    """Return name/address/zip/country for a ticker (from tickers.csv)."""
+    ticker = ticker.upper()
+    rows = _load_ticker_rows(refresh=refresh)
+    for r in rows:
+        if r["ticker"].upper() == ticker:
+            return TickerInfo(
+                ticker=r["ticker"],
+                name=r["name"],
+                address=r["address"],
+                zip=r["zip"],
+                country=r["country"],
+            )
+    raise ValueError(f"Unsupported ticker: {ticker!r}. Call supported_tickers() for the full list.")
+
+
+def supported_years_for_ticker(ticker: str, refresh: bool = False) -> list[int]:
+    """
+    Return years for which ticker/{year}.csv exists, per manifest.json
+    (the single source of truth — no probing, no guessing).
+    """
+    ticker = ticker.upper()
+    manifest = _load_manifest(refresh=refresh)
+    if manifest is None:
+        raise RuntimeError(
+            f"manifest.json is unavailable at {MANIFEST_URL} "
+            f"(network issue, or not published upstream)."
+        )
+
+    years = manifest.get("tickers", {}).get(ticker)
+    if years is None:
+        raise ValueError(
+            f"No manifest entry for ticker={ticker!r}. Call "
+            f"supported_tickers() for the full list, or the ticker may "
+            f"not have any generated data yet."
+        )
+    return sorted(years)
+
+
+def price_action(ticker: str, year: int, refresh: bool = False) -> list[PriceRow]:
+    """Full year of (date, close, sbi_tt, close_inr) rows, sorted by date."""
+    return _load_price_rows(ticker, year, refresh=refresh)
+
+
+def date_range(ticker: str, year: int) -> tuple[str, str]:
+    """First and last trading-day dates present for ticker/year."""
+    rows = price_action(ticker, year)
+    if not rows:
+        raise ValueError(f"No rows for ticker={ticker!r}, year={year}")
+    return rows[0].date, rows[-1].date
+
+
+def value_at_year_start(ticker: str, year: int) -> PriceRow:
+    """First trading day's row for the year (initial investment value)."""
+    rows = price_action(ticker, year)
+    if not rows:
+        raise ValueError(f"No rows for ticker={ticker!r}, year={year}")
+    return rows[0]
+
+
+def value_at_year_end(ticker: str, year: int) -> PriceRow:
+    """Last trading day's row for the year (closing balance value)."""
+    rows = price_action(ticker, year)
+    if not rows:
+        raise ValueError(f"No rows for ticker={ticker!r}, year={year}")
+    return rows[-1]
+
+
+def value_on_date(ticker: str, target_date: str | date) -> PriceRow:
+    """
+    Row for target_date, falling back to the nearest prior trading day
+    if the exact date isn't a trading day (weekends/holidays).
+
+    target_date: prefer a datetime.date object; a strict zero-padded
+    'YYYY-MM-DD' string is also accepted.
+    """
+    d = _parse_date(target_date)
+    rows = price_action(ticker, d.year)
+    dates = [r.date for r in rows]
+    target_str = d.isoformat()
+
+    idx = bisect_right(dates, target_str) - 1
+    if idx < 0:
+        raise ValueError(
+            f"No trading day on or before {target_str} in ticker={ticker!r} year={d.year} data."
+        )
+    return rows[idx]
+
+
+def max_value(
+    ticker: str,
+    year: int,
+    start_date: str | date | None = None,
+    end_date: str | date | None = None,
+) -> PriceRow:
+    """
+    Peak close_inr row for the year, or within [start_date, end_date] if
+    given (both inclusive; either may be omitted to leave that side open).
+
+    start_date/end_date: prefer datetime.date objects; strict zero-padded
+    'YYYY-MM-DD' strings are also accepted.
+    """
+    rows = price_action(ticker, year)
+    rows = _window(rows, start_date, end_date)
+    if not rows:
+        raise ValueError(f"No rows in requested window for {ticker!r}/{year}")
+    return max(rows, key=lambda r: r.close_inr)
+
+
+def min_value(
+    ticker: str,
+    year: int,
+    start_date: str | date | None = None,
+    end_date: str | date | None = None,
+) -> PriceRow:
+    """Lowest close_inr row for the year, or within a window. See max_value."""
+    rows = price_action(ticker, year)
+    rows = _window(rows, start_date, end_date)
+    if not rows:
+        raise ValueError(f"No rows in requested window for {ticker!r}/{year}")
+    return min(rows, key=lambda r: r.close_inr)
+
+
+def _window(
+    rows: list[PriceRow],
+    start_date: str | date | None,
+    end_date: str | date | None,
+) -> list[PriceRow]:
+    if start_date is None and end_date is None:
+        return rows
+    lo = _parse_date(start_date).isoformat() if start_date else None
+    hi = _parse_date(end_date).isoformat() if end_date else None
+    return [r for r in rows if (lo is None or r.date >= lo) and (hi is None or r.date <= hi)]
+
+
+def schedule_fa_summary(ticker: str, year: int) -> ScheduleFASummary:
+    """
+    One-shot convenience call for the values Schedule FA actually needs:
+    initial value, peak value, and closing value for the year.
+    """
+    rows = price_action(ticker, year)
+    if not rows:
+        raise ValueError(f"No rows for ticker={ticker!r}, year={year}")
+    return ScheduleFASummary(
+        ticker=ticker.upper(),
+        year=year,
+        initial=rows[0],
+        peak=max(rows, key=lambda r: r.close_inr),
+        closing=rows[-1],
+    )
+
+
+# --------------------------------------------------------------------------
+# Object-oriented convenience wrapper
+# --------------------------------------------------------------------------
+
+
+class Ticker:
+    """
+    Thin object wrapper so repeated (ticker, year) pairs don't have to be
+    passed to every call. Every method here just delegates to the plain
+    functions above — no separate logic, so behavior is identical either
+    way. Prefer this when working with one ticker+year across several
+    calls; prefer the plain functions when looping over many tickers/years,
+    since the object buys nothing there.
+
+    >>> t = Ticker("AAPL", 2025)
+    >>> t.schedule_fa_summary()
+    >>> t.max_value()
+
+    >>> t2 = Ticker("AAPL")           # year not known yet
+    >>> t2.supported_years()
+    >>> t2.for_year(2025).schedule_fa_summary()
+    """
+
+    def __init__(self, symbol: str, year: int | None = None):
+        self.symbol = symbol.upper()
+        self.year = year
+
+    def __repr__(self) -> str:
+        return f"Ticker({self.symbol!r}, year={self.year!r})"
+
+    def for_year(self, year: int) -> "Ticker":
+        """Return a copy of this Ticker scoped to a different year."""
+        return Ticker(self.symbol, year)
+
+    def _require_year(self) -> int:
+        if self.year is None:
+            raise ValueError(
+                f"{self!r} has no year set. Pass year=... to Ticker(...) "
+                f"or call .for_year(year) first."
+            )
+        return self.year
+
+    # -- ticker-level, no year required --
+
+    def metadata(self, refresh: bool = False) -> TickerInfo:
+        return ticker_metadata(self.symbol, refresh=refresh)
+
+    def supported_years(self, refresh: bool = False) -> list[int]:
+        return supported_years_for_ticker(self.symbol, refresh=refresh)
+
+    def value_on(self, target_date: str | date) -> PriceRow:
+        """Doesn't need self.year — the year is derived from target_date."""
+        return value_on_date(self.symbol, target_date)
+
+    # -- year-scoped, require self.year --
+
+    def price_action(self, refresh: bool = False) -> list[PriceRow]:
+        return price_action(self.symbol, self._require_year(), refresh=refresh)
+
+    def date_range(self) -> tuple[str, str]:
+        return date_range(self.symbol, self._require_year())
+
+    def value_at_start(self) -> PriceRow:
+        return value_at_year_start(self.symbol, self._require_year())
+
+    def value_at_end(self) -> PriceRow:
+        return value_at_year_end(self.symbol, self._require_year())
+
+    def max_value(
+        self,
+        start_date: str | date | None = None,
+        end_date: str | date | None = None,
+    ) -> PriceRow:
+        return max_value(self.symbol, self._require_year(), start_date, end_date)
+
+    def min_value(
+        self,
+        start_date: str | date | None = None,
+        end_date: str | date | None = None,
+    ) -> PriceRow:
+        return min_value(self.symbol, self._require_year(), start_date, end_date)
+
+    def schedule_fa_summary(self) -> ScheduleFASummary:
+        return schedule_fa_summary(self.symbol, self._require_year())

fa_inrdata_api-0.1.0.dist-info/METADATA

@@ -0,0 +1,358 @@
+Metadata-Version: 2.4
+Name: fa-inrdata-api
+Version: 0.1.0
+Summary: Python API for historical INR valuations of US-listed stocks, designed for Indian Income Tax Schedule FA reporting.
+Project-URL: Homepage, https://github.com/jdecodes/fa-inrdata
+Project-URL: Repository, https://github.com/jdecodes/fa-inrdata
+Project-URL: Issues, https://github.com/jdecodes/fa-inrdata/issues
+Author-email: jdecodes <jaideep_sharma@live.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: exchange-rate,finance,foreign-assets,forex,income-tax,india,itr,sbi,schedule-fa,stocks
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Office/Business :: Financial
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# fa-inrdata-api
+
+> A lightweight Python API for historical INR-adjusted stock prices, built specifically for Indian Income Tax **Schedule FA** reporting.
+
+`fa-inrdata-api` provides historical daily stock prices already converted to INR using the corresponding **State Bank of India (SBI) TT Buying Rate** for that date. Instead of downloading Yahoo Finance prices, searching SBI TT rates, and performing currency conversion yourself, this package gives you the final INR value in one API call.
+
+The data is powered by the **fa-inrdata** dataset.
+
+---
+
+## Why?
+
+While filing **Schedule FA (Foreign Assets)** in the Indian Income Tax Return, taxpayers are required to report values such as:
+
+- Initial value of investment
+- Peak value during the year
+- Closing balance
+- Value on a specific acquisition date
+
+Obtaining these values is surprisingly tedious.
+
+Typically you need to
+
+- download historical stock prices
+- obtain historical SBI TT buying rates
+- convert every day's closing price into INR
+- determine the maximum INR value for the required period
+
+This package performs those steps for you.
+
+---
+
+## Features
+
+- Historical daily close prices
+- Historical SBI TT Buying rates
+- Daily INR converted prices
+- Initial value for a year
+- Closing value for a year
+- Peak INR value for a year
+- Peak INR value within a custom date range
+- Value on any date (with automatic previous trading day fallback)
+- Ticker metadata
+- Local caching
+- Zero third-party dependencies
+
+---
+
+## Installation
+
+```bash
+pip install fa-inrdata-api
+```
+
+Requires Python **3.10+**
+
+---
+
+## Quick Example
+
+```python
+import fa_inrdata_api as fa
+
+summary = fa.schedule_fa_summary("AAPL", 2025)
+
+print(summary.initial)
+print(summary.peak)
+print(summary.closing)
+```
+
+---
+
+## Using the Object-Oriented API
+
+```python
+from fa_inrdata_api import Ticker
+
+aapl = Ticker("AAPL", 2025)
+
+print(aapl.schedule_fa_summary())
+print(aapl.max_value())
+print(aapl.value_at_start())
+print(aapl.value_at_end())
+```
+
+---
+
+## Supported Tickers
+
+```python
+import fa_inrdata_api as fa
+
+print(fa.supported_tickers())
+```
+
+---
+
+## Supported Years
+
+```python
+import fa_inrdata_api as fa
+
+print(fa.supported_years_for_ticker("AAPL"))
+```
+
+Example
+
+```python
+[2025]
+```
+
+---
+
+## Get Company Metadata
+
+```python
+import fa_inrdata_api as fa
+
+info = fa.ticker_metadata("AAPL")
+
+print(info)
+```
+
+Returns
+
+```python
+TickerInfo(
+    ticker="AAPL",
+    name="Apple Inc.",
+    address="One Apple Park Way",
+    zip="95014",
+    country="United States",
+)
+```
+
+---
+
+## Complete Daily Price History
+
+```python
+rows = fa.price_action("AAPL", 2025)
+
+print(rows[0])
+```
+
+Returns
+
+```python
+PriceRow(date="2025-01-02", close=243.85, sbi_tt=85.64, close_inr=20880.11)
+```
+
+---
+
+## Value on a Specific Date
+
+```python
+import fa_inrdata_api as fa
+
+row = fa.value_on_date("AAPL", "2025-05-17")
+
+print(row)
+```
+
+If the supplied date falls on a weekend or market holiday, the package automatically returns the nearest previous trading day.
+
+---
+
+## Initial Value
+
+```python
+fa.value_at_year_start("AAPL", 2025)
+```
+
+---
+
+## Closing Value
+
+```python
+fa.value_at_year_end("AAPL", 2025)
+```
+
+---
+
+## Maximum Value
+
+Entire year
+
+```python
+fa.max_value("AAPL", 2025)
+```
+
+Custom period
+
+```python
+fa.max_value(
+    "AAPL",
+    2025,
+    start_date="2025-03-15",
+    end_date="2025-08-31",
+)
+```
+
+---
+
+## Minimum Value
+
+```python
+fa.min_value("AAPL", 2025)
+```
+
+---
+
+## Schedule FA Summary
+
+This convenience function returns everything typically required for Schedule FA.
+
+```python
+summary = fa.schedule_fa_summary("AAPL", 2025)
+
+print(summary.initial)
+print(summary.peak)
+print(summary.closing)
+```
+
+Returns
+
+```python
+ScheduleFASummary(ticker="AAPL", year=2025, initial=..., peak=..., closing=...)
+```
+
+---
+
+## Warm the Cache
+
+The package downloads data lazily and stores it locally.
+
+If desired, you can warm the cache beforehand.
+
+```python
+import fa_inrdata_api as fa
+
+fa.warm_cache()
+```
+
+---
+
+## Caching
+
+Downloaded files are cached locally under
+
+```
+~/.cache/fa_inrdata_api/
+```
+
+Subsequent requests are served directly from the cache.
+
+---
+
+## Data Source
+
+This package reads data from
+
+https://github.com/jdecodes/fa-inrdata
+
+Each ticker has one CSV per calendar year.
+
+```
+data/
+    AAPL/
+        2023.csv
+        2024.csv
+        2025.csv
+
+    MSFT/
+        ...
+```
+
+Each CSV contains
+
+| Column | Description |
+|---------|-------------|
+| date | Trading date |
+| close | Yahoo Finance closing price |
+| sbi_tt | SBI TT Buying Rate |
+| close_inr | close × sbi_tt |
+
+---
+
+## Why SBI TT Buying Rate?
+
+Indian Income Tax guidance for Schedule FA generally requires foreign asset values to be converted into INR using the **State Bank of India Telegraphic Transfer (TT) Buying Rate**.
+
+This package performs that conversion in advance.
+
+---
+
+## Disclaimer
+
+This is an **unofficial**, community-maintained package.
+
+It is **not affiliated with**
+
+- State Bank of India (SBI)
+- Yahoo Finance
+- Indian Income Tax Department
+
+Although every effort is made to ensure accuracy, the data may contain errors or omissions.
+
+Always verify important values against official sources before filing taxes or making financial decisions.
+
+---
+
+## License
+
+MIT License
+
+---
+
+## Related Project
+
+This package is powered by the underlying dataset:
+
+**fa-inrdata**
+
+https://github.com/jdecodes/fa-inrdata
+
+---
+
+## Author
+
+Built by **jdecodes** : https://github.com/jdecodes
+
+
+Contributions, bug reports, feature requests, and pull requests are always welcome.

fa_inrdata_api-0.1.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+fa_inrdata_api/__init__.py,sha256=Q_UML0EBfSUcSF8eF4Q22XCkSi5t-eoGqXVZuAeVWPo,757
+fa_inrdata_api/core.py,sha256=TcluTVkYJaHBO2EoMvqdFc1CzI4FUZCRAOr1vVy6Jeo,15771
+fa_inrdata_api-0.1.0.dist-info/METADATA,sha256=hie1xtE8bGLBJzVL1937tENMfsE7EKc9sPX1SMXzE6Q,6636
+fa_inrdata_api-0.1.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+fa_inrdata_api-0.1.0.dist-info/licenses/LICENSE,sha256=-K0hxBCgXzTV9VIYz5avRkdRDzQ9G03FqaadbYI3UJU,1084
+fa_inrdata_api-0.1.0.dist-info/RECORD,,

fa_inrdata_api-0.1.0.dist-info/WHEEL

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

fa_inrdata_api-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 jdecodes
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.