marketmyna 0.2.0__py3-none-any.whl

marketmyna/data/india.py

@@ -0,0 +1,241 @@
+"""Indian market data fetcher using jugaad-data and Yahoo Finance."""
+
+from datetime import datetime, timedelta
+from typing import Optional
+
+import pandas as pd
+
+from ..analysis.fundamental import yfinance_fundamentals
+from ..core.constants import TimeFrame
+from .base import DataFetcher
+from .extra_sources import twelvedata_history, twelvedata_key, twelvedata_quote
+from .resilience import FallbackChain
+
+STALE_QUOTE_GAP = 0.10
+
+
+def quote_from_bars(symbol: str, bars: pd.DataFrame) -> dict:
+    """A quote from the latest daily bars (Yahoo history: Open/High/Low/Close/Volume)."""
+    bar = bars.iloc[-1]
+    price = float(bar["Close"])
+    prev = float(bars["Close"].iloc[-2]) if len(bars) > 1 else None
+    return {
+        "symbol": symbol,
+        "price": price,
+        "previous_close": prev,
+        "open": float(bar["Open"]),
+        "day_high": float(bar["High"]),
+        "day_low": float(bar["Low"]),
+        "volume": int(bar["Volume"]),
+        "change": price - prev if prev else 0,
+        "change_percent": (price - prev) / prev * 100 if prev else 0,
+    }
+
+
+# A BSE history shorter than this is treated as missing (see get_history).
+BSE_MIN_BARS = 30
+
+
+def is_bse(symbol: str) -> bool:
+    """RELIANCE.BO = the BSE listing; RELIANCE or RELIANCE.NS = NSE."""
+    return symbol.upper().endswith(".BO")
+
+
+class IndiaDataFetcher(DataFetcher):
+    """Fetches Indian stock market data (NSE/BSE)."""
+
+    def __init__(self):
+        self._cache = {}
+        # Try to import jugaad_data, fall back to yfinance if not available
+        try:
+            from jugaad_data.nse import NSELive, stock_df
+            self._nse_live = NSELive()
+            self._stock_df = stock_df
+            self._use_jugaad = True
+        except ImportError:
+            self._use_jugaad = False
+
+    def _get_yf_symbol(self, symbol: str) -> str:
+        """Convert to Yahoo Finance format for Indian stocks."""
+        # Don't modify index symbols (they start with ^)
+        if symbol.startswith("^"):
+            return symbol
+        if not symbol.endswith(".NS") and not symbol.endswith(".BO"):
+            return f"{symbol}.NS"  # Default to NSE
+        return symbol
+
+    def _fetch_quote_jugaad(self, symbol: str) -> dict:
+        quote = self._nse_live.stock_quote(symbol.replace(".NS", "").replace(".BO", ""))
+        price_info = quote.get("priceInfo", {})
+        return {
+            "symbol": symbol,
+            "price": price_info.get("lastPrice", 0),
+            "previous_close": price_info.get("previousClose", 0),
+            "open": price_info.get("open", 0),
+            "day_high": price_info.get("intraDayHighLow", {}).get("max", 0),
+            "day_low": price_info.get("intraDayHighLow", {}).get("min", 0),
+            "volume": quote.get("securityWiseDP", {}).get("quantityTraded", 0),
+            "change": price_info.get("change", 0),
+            "change_percent": price_info.get("pChange", 0),
+        }
+
+    def _fetch_quote_yfinance(self, symbol: str) -> dict:
+        import yfinance as yf
+        ticker = yf.Ticker(self._get_yf_symbol(symbol))
+        info = ticker.fast_info
+        try:
+            last, prev = info.last_price, info.previous_close
+        except KeyError:
+            # Yahoo has no such symbol (a typo, a fund name): an empty answer,
+            # not a source failure, so it can't trip the breaker for every stock.
+            return {}
+
+        # Yahoo's live quote for some listings (REITs, InvITs) is frozen at
+        # an old date while its daily bars stay current. A move of more than
+        # 10% is checked against the bars; if they disagree, the bars win.
+        if last and prev and abs(last / prev - 1) > STALE_QUOTE_GAP:
+            bars = ticker.history(period="5d", interval="1d")
+            if not bars.empty and abs(last / float(bars["Close"].iloc[-1]) - 1) > STALE_QUOTE_GAP:
+                return quote_from_bars(symbol, bars)
+
+        return {
+            "symbol": symbol,
+            "price": last,
+            "previous_close": prev,
+            "open": info.open,
+            "day_high": info.day_high,
+            "day_low": info.day_low,
+            "volume": info.last_volume,
+            "change": last - prev if prev else 0,
+            "change_percent": ((last - prev) / prev) * 100 if prev else 0,
+        }
+
+    def get_quote(self, symbol: str) -> dict:
+        """Get current quote for an Indian stock."""
+        chain = FallbackChain("india.get_quote")
+        # jugaad-data reads NSE only: a BSE symbol (.BO) goes straight to Yahoo.
+        if self._use_jugaad and not is_bse(symbol):
+            chain.add("jugaad", self._fetch_quote_jugaad)
+        chain.add("yfinance", self._fetch_quote_yfinance)
+        if not symbol.startswith("^") and twelvedata_key():
+            chain.add("twelvedata", lambda s: twelvedata_quote(s, "india"))
+        return chain.call(symbol, is_empty=lambda d: not d or not d.get("price"))
+
+    _PERIOD_DAYS = {"1d": 1, "5d": 5, "1mo": 30, "3mo": 90, "6mo": 180, "1y": 365, "2y": 730, "5y": 1825}
+
+    def _fetch_history_jugaad(
+        self,
+        symbol: str,
+        period: str = "1y",
+        start: Optional[datetime] = None,
+        end: Optional[datetime] = None,
+        **_ignored,
+    ) -> pd.DataFrame:
+        clean_symbol = symbol.replace(".NS", "").replace(".BO", "")
+        range_start = start or (datetime.now() - timedelta(days=self._PERIOD_DAYS.get(period, 365)))
+        range_end = end or datetime.now()
+
+        df = self._stock_df(symbol=clean_symbol, from_date=range_start.date(), to_date=range_end.date())
+        if df.empty:
+            return df
+
+        df = df.rename(
+            columns={
+                "DATE": "date",
+                "OPEN": "open",
+                "HIGH": "high",
+                "LOW": "low",
+                "CLOSE": "close",
+                "LTP": "ltp",
+                "VOLUME": "volume",
+            }
+        )
+        df.set_index("date", inplace=True)
+        return df
+
+    def get_history(
+        self,
+        symbol: str,
+        period: str = "1y",
+        interval: TimeFrame = TimeFrame.DAY_1,
+        start: Optional[datetime] = None,
+        end: Optional[datetime] = None,
+    ) -> pd.DataFrame:
+        """Get historical price data for an Indian stock."""
+        chain = FallbackChain("india.get_history")
+        if self._use_jugaad and interval == TimeFrame.DAY_1 and not is_bse(symbol):
+            chain.add("jugaad", self._fetch_history_jugaad)
+        chain.add("yfinance", self._fetch_history_yfinance)
+        if not symbol.startswith("^") and twelvedata_key():
+            chain.add("twelvedata", lambda s, **kw: twelvedata_history(s, "india", **kw))
+        df = chain.call(
+            symbol, period=period, interval=interval, start=start, end=end, is_empty=lambda df: df.empty
+        )
+        if is_bse(symbol) and len(df) < BSE_MIN_BARS:
+            # Yahoo often has only the last day or two for a BSE listing
+            # (RELIANCE.BO). The same company's NSE history trades within
+            # paise of it, so charts, indicators and levels use that instead.
+            try:
+                nse = self.get_history(symbol[:-3], period=period, interval=interval, start=start, end=end)
+            except Exception:
+                nse = None
+            if nse is not None and len(nse) > len(df):
+                nse.attrs["history_from"] = "NSE"
+                return nse
+        return df
+
+    def _fetch_history_yfinance(self, symbol: str, **kwargs) -> pd.DataFrame:
+        from .stocks import StockDataFetcher
+
+        return StockDataFetcher()._fetch_history_yfinance(self._get_yf_symbol(symbol), **kwargs)
+
+    def search(self, query: str) -> list[dict]:
+        """Search for Indian stocks matching query."""
+        # Use yfinance for search
+        import yfinance as yf
+
+        results = []
+        for suffix in [".NS", ".BO"]:
+            try:
+                ticker = yf.Ticker(f"{query}{suffix}")
+                info = ticker.info
+                if info and info.get("symbol"):
+                    results.append(
+                        {
+                            "symbol": info.get("symbol"),
+                            "name": info.get("longName", info.get("shortName", "")),
+                            "exchange": "NSE" if suffix == ".NS" else "BSE",
+                            "type": info.get("quoteType", "EQUITY"),
+                        }
+                    )
+            except Exception:
+                pass
+
+        return results
+
+    def get_info(self, symbol: str) -> dict:
+        """Get detailed information about an Indian stock."""
+        import yfinance as yf
+
+        ticker = yf.Ticker(self._get_yf_symbol(symbol))
+        info = ticker.info
+
+        return {
+            "symbol": info.get("symbol", symbol),
+            "name": info.get("longName", ""),
+            "sector": info.get("sector", ""),
+            "industry": info.get("industry", ""),
+            "description": info.get("longBusinessSummary", ""),
+            "currency": "INR",
+            "market_cap": info.get("marketCap", 0),
+            "pe_ratio": info.get("trailingPE", 0),
+            "pb_ratio": info.get("priceToBook", 0),
+            "dividend_yield": info.get("dividendYield", 0),
+            "52_week_high": info.get("fiftyTwoWeekHigh", 0),
+            "52_week_low": info.get("fiftyTwoWeekLow", 0),
+            "book_value": info.get("bookValue", 0),
+            "face_value": info.get("faceValue", 0),
+            # Normalized ratios for FundamentalAnalyzer (overrides the raw
+            # yfinance-unit fields above, e.g. dividend_yield)
+            **yfinance_fundamentals(info),
+        }

marketmyna/data/india_filings.py

@@ -0,0 +1,343 @@
+"""Indian financial statements from the companies' own XBRL filings on NSE.
+
+Every listed company files its results with the exchange in XBRL (SEBI's
+Ind-AS taxonomy), so these are the official numbers, the same ones data
+sites compile from. Two NSE feeds cover the history:
+
+- corporates-financial-results (Quarterly / Annual): 2005 to Dec 2024;
+- integrated-filing-results (Financials): SEBI's integrated filing, 2025 on.
+
+Quarterly filings carry the profit and loss for the quarter; the March
+filing also carries the full year, the year-end balance sheet and the
+year's cash flows (the September one the half-year balance sheet).
+
+statements() returns three DataFrames shaped like yfinance's statements
+(rows named as yfinance names them, one column per period end, newest
+first), so services/financials.py analyses them unchanged. Filings never
+change once published, so each parsed file is cached on disk for good;
+the filing lists are cached for a few hours. Anything unreadable raises,
+and the caller falls back to Yahoo.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import logging
+import re
+import threading
+import time
+from datetime import date, datetime
+from pathlib import Path
+from typing import Optional
+from xml.etree import ElementTree as ET
+
+import pandas as pd
+import requests
+
+from marketmyna.core.home import app_home
+
+logger = logging.getLogger(__name__)
+
+API = "https://www.nseindia.com/api"
+_HEADERS = {
+    "User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0 Safari/537.36",
+    "Referer": "https://www.nseindia.com/",
+    "Accept": "application/json, text/plain, */*",
+}
+_TIMEOUT = 25
+LIST_TTL = 6 * 3600
+QUARTERS = 8
+PARSE_VERSION = 2
+YEARS = 5
+
+_lock = threading.Lock()
+_lists: dict[str, tuple[float, list[dict]]] = {}
+
+
+def _cache_dir() -> Path:
+    path = app_home() / "india_filings"
+    path.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def _get(url: str) -> requests.Response:
+    resp = requests.get(url, headers=_HEADERS, timeout=_TIMEOUT)
+    resp.raise_for_status()
+    return resp
+
+
+# ------------------------------------------------------------------ filing lists
+
+
+def _day(text: str) -> Optional[date]:
+    for fmt in ("%d-%b-%Y", "%d-%B-%Y"):
+        try:
+            return datetime.strptime(text.strip().title(), fmt).date()
+        except (AttributeError, ValueError):
+            continue
+    return None
+
+
+def filings(symbol: str) -> list[dict]:
+    """[{end, consolidated, url}] for every results filing, newest first."""
+    symbol = symbol.upper()
+    with _lock:
+        hit = _lists.get(symbol)
+        if hit and time.time() - hit[0] < LIST_TTL:
+            return hit[1]
+    out: dict[tuple, dict] = {}
+
+    def add(end: Optional[date], consolidated: str, url: Optional[str]):
+        if end and url and url.endswith(".xml"):
+            key = (end, consolidated.lower().startswith("consolidated"))
+            out.setdefault(key, {"end": end, "consolidated": key[1], "url": url})
+
+    errors = []
+    try:
+        data = _get(f"{API}/integrated-filing-results?symbol={symbol}&type=Integrated%20Filing-%20Financials").json()
+        for r in data.get("data") or []:
+            add(_day(r.get("qe_Date") or ""), r.get("consolidated") or "", r.get("xbrl"))
+    except Exception as exc:
+        errors.append(exc)
+    for period in ("Annual", "Quarterly"):
+        try:
+            for r in _get(f"{API}/corporates-financial-results?index=equities&symbol={symbol}&period={period}").json():
+                add(_day(r.get("toDate") or ""), r.get("consolidated") or "", r.get("xbrl"))
+        except Exception as exc:
+            errors.append(exc)
+    if not out:
+        raise RuntimeError(f"No NSE results filings for {symbol}: {errors[:1]}")
+    rows = sorted(out.values(), key=lambda r: r["end"], reverse=True)
+    with _lock:
+        _lists[symbol] = (time.time(), rows)
+    return rows
+
+
+# ------------------------------------------------------------------ XBRL
+
+
+def parse(xml: bytes) -> list[tuple[str, Optional[str], str, float]]:
+    """[(tag, start or None for an instant, end, value)] for the facts with
+    no dimension (the company totals, not segments or breakdowns)."""
+    root = ET.fromstring(xml)
+    periods: dict[str, tuple[Optional[str], str]] = {}
+    for ctx in root:
+        if not ctx.tag.endswith("context"):
+            continue
+        if any(el.tag.endswith(("explicitMember", "typedMember")) for el in ctx.iter()):
+            continue
+        start = ctx.find(".//{*}startDate")
+        end = ctx.find(".//{*}endDate")
+        instant = ctx.find(".//{*}instant")
+        if instant is not None and instant.text:
+            periods[ctx.get("id")] = (None, instant.text.strip())
+        elif start is not None and end is not None and start.text and end.text:
+            begin, stop = start.text.strip(), end.text.strip()
+            if ctx.get("id") == "FourD":
+                # "FourD" is the year to date. Filings before 2025 give it the
+                # quarter's dates by mistake; it always starts on 1 April.
+                last = date.fromisoformat(stop)
+                begin = date(last.year if last.month >= 4 else last.year - 1, 4, 1).isoformat()
+            periods[ctx.get("id")] = (begin, stop)
+    facts = []
+    for el in root:
+        ref = el.get("contextRef")
+        text = (el.text or "").strip()
+        if ref not in periods or not re.fullmatch(r"-?\d+(\.\d+)?", text):
+            continue
+        start, end = periods[ref]
+        facts.append((el.tag.split("}")[-1], start, end, float(text)))
+    return facts
+
+
+def _facts(url: str) -> list[tuple]:
+    # The version prefix retires cached parses when parse() changes.
+    path = _cache_dir() / (hashlib.sha256(f"{PARSE_VERSION}:{url}".encode()).hexdigest()[:24] + ".json")
+    try:
+        return [tuple(f) for f in json.loads(path.read_text(encoding="utf-8"))]
+    except (OSError, ValueError):
+        pass
+    facts = parse(_get(url).content)
+    tmp = path.with_suffix(".tmp")
+    tmp.write_text(json.dumps(facts), encoding="utf-8")
+    tmp.replace(path)
+    return facts
+
+
+# ------------------------------------------------------------------ statements
+
+# yfinance row name -> how to read it from one period's facts {tag: value}.
+def _sum(v: dict, *tags: str) -> Optional[float]:
+    vals = [v[t] for t in tags if t in v]
+    return sum(vals) if vals else None
+
+
+def _first(v: dict, *tags: str) -> Optional[float]:
+    return next((v[t] for t in tags if t in v), None)
+
+
+def _minus(a: Optional[float], b: Optional[float]) -> Optional[float]:
+    return a - b if a is not None and b is not None else None
+
+
+def _income(v: dict) -> dict:
+    revenue = v.get("RevenueFromOperations")
+    cost = _sum(v, "CostOfMaterialsConsumed", "PurchasesOfStockInTrade",
+                "ChangesInInventoriesOfFinishedGoodsWorkInProgressAndStockInTrade")
+    pbt_before_exceptional = _first(v, "ProfitBeforeExceptionalItemsAndTax", "ProfitBeforeTax")
+    finance = v.get("FinanceCosts")
+    operating = None
+    if pbt_before_exceptional is not None:
+        operating = pbt_before_exceptional + (finance or 0) - (v.get("OtherIncome") or 0)
+    depreciation = v.get("DepreciationDepletionAndAmortisationExpense")
+    return {
+        "Total Revenue": revenue,
+        "Cost Of Revenue": cost,
+        "Gross Profit": _minus(revenue, cost),
+        "Operating Income": operating,
+        "EBITDA": operating + depreciation if operating is not None and depreciation is not None else None,
+        "Interest Expense": finance,
+        # Overheads: Ind-AS has no SG&A line; staff plus other expenses stand in
+        "Selling General And Administration": _sum(v, "EmployeeBenefitExpense", "OtherExpenses"),
+        "Pretax Income": v.get("ProfitBeforeTax"),
+        "Tax Provision": v.get("TaxExpense"),
+        "Net Income": _first(v, "ProfitOrLossAttributableToOwnersOfParent", "ProfitLossForPeriod"),
+        "Diluted EPS": _first(v, "DilutedEarningsLossPerShareFromContinuingAndDiscontinuedOperations",
+                              "DilutedEarningsLossPerShareFromContinuingOperations"),
+        "Basic EPS": _first(v, "BasicEarningsLossPerShareFromContinuingAndDiscontinuedOperations",
+                            "BasicEarningsLossPerShareFromContinuingOperations"),
+    }
+
+
+def _balance(v: dict) -> dict:
+    debt = _sum(v, "BorrowingsNoncurrent", "BorrowingsCurrent")
+    cash = v.get("CashAndCashEquivalents")
+    paid_up, face = v.get("PaidUpValueOfEquityShareCapital") or v.get("EquityShareCapital"), v.get("FaceValueOfEquityShareCapital")
+    return {
+        "Total Assets": v.get("Assets"),
+        "Current Assets": v.get("CurrentAssets"),
+        "Cash And Cash Equivalents": cash,
+        "Accounts Receivable": v.get("TradeReceivablesCurrent"),
+        "Inventory": v.get("Inventories"),
+        "Total Liabilities Net Minority Interest": v.get("Liabilities"),
+        "Current Liabilities": v.get("CurrentLiabilities"),
+        "Total Debt": debt,
+        "Net Debt": _minus(debt, cash),
+        "Stockholders Equity": _first(v, "EquityAttributableToOwnersOfParent", "Equity"),
+        "Goodwill And Other Intangible Assets": _sum(v, "Goodwill", "OtherIntangibleAssets"),
+        "Net PPE": v.get("PropertyPlantAndEquipment"),
+        # Ind-AS "other equity" is reserves and surplus, mostly retained earnings
+        "Retained Earnings": _first(v, "RetainedEarnings", "OtherEquity"),
+        "Ordinary Shares Number": paid_up / face if paid_up and face else None,
+    }
+
+
+def _cashflow(v: dict) -> dict:
+    operating = v.get("CashFlowsFromUsedInOperatingActivities")
+    purchase = v.get("PurchaseOfPropertyPlantAndEquipmentClassifiedAsInvestingActivities")
+    capex = -abs(purchase) if purchase is not None else None
+    dividends = v.get("DividendsPaidClassifiedAsFinancingActivities")
+    return {
+        "Operating Cash Flow": operating,
+        "Capital Expenditure": capex,
+        "Free Cash Flow": operating + capex if operating is not None and capex is not None else None,
+        "Investing Cash Flow": v.get("CashFlowsFromUsedInInvestingActivities"),
+        "Depreciation And Amortization": _first(v, "AdjustmentsForDepreciationAndAmortisationExpense",
+                                                "DepreciationDepletionAndAmortisationExpense"),
+        "Financing Cash Flow": v.get("CashFlowsFromUsedInFinancingActivities"),
+        "Cash Dividends Paid": -abs(dividends) if dividends is not None else None,
+    }
+
+
+def _span_days(start: str, end: str) -> int:
+    return (date.fromisoformat(end) - date.fromisoformat(start)).days
+
+
+def _period_values(facts: list[tuple], end: date, span: tuple[int, int]) -> tuple[dict, dict]:
+    """(duration facts covering `span` days and ending at `end`, instant facts at `end`)."""
+    iso = end.isoformat()
+    durations, instants = {}, {}
+    for tag, start, stop, value in facts:
+        if stop != iso:
+            continue
+        if start is None:
+            instants.setdefault(tag, value)
+        elif span[0] <= _span_days(start, stop) <= span[1]:
+            durations.setdefault(tag, value)
+    return durations, instants
+
+
+QUARTER_DAYS = (80, 100)
+YEAR_DAYS = (350, 380)
+
+
+def _frame(columns: dict[date, dict]) -> pd.DataFrame:
+    """yfinance-shaped: rows = line items, columns = period ends (newest first)."""
+    if not columns:
+        return pd.DataFrame()
+    df = pd.DataFrame({pd.Timestamp(d): col for d, col in columns.items()})
+    df = df[sorted(df.columns, reverse=True)]
+    return df.dropna(how="all")
+
+
+def statements(symbol: str, quarterly: bool = False) -> tuple[pd.DataFrame, pd.DataFrame, pd.DataFrame]:
+    """(income, balance, cashflow) from NSE filings, consolidated when the
+    company files consolidated results, else standalone."""
+    rows = filings(symbol)
+    consolidated = any(r["consolidated"] for r in rows[:4])
+    rows = [r for r in rows if r["consolidated"] == consolidated]
+    if quarterly:
+        rows = rows[:QUARTERS]
+        span = QUARTER_DAYS
+    else:
+        rows = [r for r in rows if r["end"].month == 3 and r["end"].day == 31][:YEARS]
+        span = YEAR_DAYS
+    if not rows:
+        raise RuntimeError(f"No {'quarterly' if quarterly else 'annual'} filings for {symbol}")
+
+    income, balance, cashflow = {}, {}, {}
+    shares: dict[date, float] = {}
+    for r in rows:
+        try:
+            facts = _facts(r["url"])
+        except Exception as exc:
+            logger.info("NSE filing %s unreadable: %s", r["url"], exc)
+            continue
+        durations, instants = _period_values(facts, r["end"], span)
+        if durations.get("RevenueFromOperations") is not None:
+            income[r["end"]] = _income(durations)
+            count = _share_count({**instants, **durations})
+            if count:
+                shares[r["end"]] = count
+        if instants.get("Assets") is not None:
+            balance[r["end"]] = _balance(instants)
+        if durations.get("CashFlowsFromUsedInOperatingActivities") is not None:
+            cashflow[r["end"]] = _cashflow(durations)
+    if len(income) < 2:
+        # Banks and insurers file a different layout (interest earned, ...): leave them to Yahoo.
+        raise RuntimeError(f"NSE filings for {symbol} have no readable income statement")
+    _restate_eps(income, shares)
+    return _frame(income), _frame(balance), _frame(cashflow)
+
+
+def _share_count(v: dict) -> Optional[float]:
+    paid_up = v.get("PaidUpValueOfEquityShareCapital") or v.get("EquityShareCapital")
+    face = v.get("FaceValueOfEquityShareCapital")
+    return paid_up / face if paid_up and face else None
+
+
+def _restate_eps(income: dict[date, dict], shares: dict[date, float]) -> None:
+    """Filings report EPS on the share count of their day; a later bonus or
+    split would read as an earnings collapse. Restate each period's EPS onto
+    the latest share count (as Yahoo does)."""
+    if not shares:
+        return
+    latest = shares[max(shares)]
+    for end, row in income.items():
+        count = shares.get(end)
+        if not count or abs(count / latest - 1) < 0.01:
+            continue
+        for key in ("Diluted EPS", "Basic EPS"):
+            if row.get(key) is not None:
+                row[key] = round(row[key] * count / latest, 2)