finmiti 0.0.1__py3-none-any.whl

finmiti/__init__.py

@@ -0,0 +1,12 @@
+from importlib.metadata import version
+__version__ = version("finmetry")
+
+
+from . import clients
+from .stocks_handler import Stock, StockDict
+from . import constants
+from .strategy_handler import StrategyBase, StgDataLoader
+from .portfolio_handler import Portfolio, Account
+from .backtest_handler import Backtester
+
+from .utils import *

finmiti/backtest_handler/__init__.py

@@ -0,0 +1,2 @@
+
+from .base import Backtester

finmiti/backtest_handler/base.py

@@ -0,0 +1,19 @@
+from ..portfolio_handler import Portfolio
+from ..executioners import ExecutionModel
+from ..strategy_handler import StgDataLoader, StrategyBase
+
+class Backtester:
+    def __init__(self, data_loader: StgDataLoader, strategy: StrategyBase, portfolio: Portfolio):
+        self.data_loader = data_loader
+        self.strategy = strategy
+        self.portfolio = portfolio
+
+    def run(self):
+        for market_data in self.data_loader:
+            entry_orders = self.strategy(market_data)
+            exit_orders = self.portfolio.get_exit_orders(market_data)
+            ### keeping exit_orders first to avoid cash going negative
+            all_orders = exit_orders + entry_orders
+            for order in all_orders:
+                self.portfolio.on_order(order)
+            self.portfolio.mark_to_market(market_data)

finmiti/clients/__init__.py

@@ -0,0 +1,2 @@
+
+from . import client_5paisa

finmiti/clients/client_5paisa.py

@@ -0,0 +1,242 @@
+"""
+This module contains the objects related to 5paisa client
+
+@author: Rathod Darshan
+"""
+
+import py5paisa as p5
+import pandas as pd
+import datetime as dtm
+from typing import Union, TypedDict
+
+from ..stocks_handler import Stock, StockDict
+
+from ..constants import INTERVAL
+
+
+class ScripMaster:
+    """ScripMaster contains all the scipts of 5paisa client.
+
+    To get the name and symbol of any script, this class needs to be accessed. This class just filters the data from single .csv.
+    """
+
+    def __init__(self, filepath: str = None) -> None:
+        """Initializes the ScripMaster class.
+
+        Loads the .csv file into data attribute.
+
+        Parameters
+        ----------
+        filepath : str, optional
+            filepath to .csv file. If filepath is given then it reads the file, else it will download the file. by default None
+        """
+        if filepath is not None:
+            self.data = pd.read_pickle(filepath)
+        else:
+            self.data = pd.read_csv("https://images.5paisa.com/website/scripmaster-csv-format.csv")
+
+        self.data["Expiry"] = pd.to_datetime(self.data["Expiry"], format="%Y-%m-%d %H:%M:%S")
+        self.data["Name"] = self.data["Name"].apply(str.upper)
+        self.data["Symbol"] = self.data["Name"]
+
+    def __repr__(self):
+        return f"scrip master data"
+
+    def __call__(self):
+        return self.data
+
+    def save(self, filepath: str) -> None:
+        """saves the scrip master data
+
+        Parameters
+        ----------
+        filepath : str
+            filepath with filename with .pkl extention
+
+        Returns
+        -------
+        _type_
+            None
+        """
+        return self.data.to_pickle(filepath)
+
+    def get_scrip(self, stock: Stock) -> pd.DataFrame:
+        """returns the scrips of the stock
+
+        Parameters
+        ----------
+        stock : Stock
+            a stock object
+
+        Returns
+        -------
+        pd.DataFrame
+            Scrip data of a given stock
+        """
+        try:
+            return stock.scrip
+        except:
+            pass
+        d1 = self.data
+        f1 = (d1["Exch"] == stock.exchange) & (d1["ExchType"] == stock.exchange_type) & (d1["Symbol"] == stock.symbol)
+        f2 = (d1["Series"] == "EQ") | (d1["Series"] == "XX")
+        d2 = d1[f1 & f2]
+        if d2.empty:
+            raise ValueError(f"No Scrip found for {stock.symbol} in scrip_master")
+        d2 = d2.set_index("Name")
+        ### setting the scrip to stock object
+        stock.scrip = d2
+        return d2
+
+
+class Client5paisaCred(TypedDict):
+    APP_NAME: str
+    APP_SOURCE: str
+    USER_ID: str
+    PASSWORD: str
+    USER_KEY: str
+    ENCRYPTION_KEY: str
+
+
+class Client5paisa(p5.FivePaisaClient):
+    def __init__(self, totp: str, mpin: str, client_code: str, cred: Client5paisaCred, scrip_master: ScripMaster = None, **kwargs):
+        super().__init__(cred=cred)
+        self.get_totp_session(client_code, f"{totp}", mpin)
+
+        print("downloading the scrip-master")
+
+        self.scrip_master = ScripMaster() if scrip_master is None else scrip_master
+        return
+
+    def download_historical_data(
+        self,
+        stock: Stock,
+        interval: INTERVAL = INTERVAL.one_day,
+        start: Union[str, dtm.datetime] = "2023-01-01",
+        end: Union[str, dtm.datetime] = "2023-03-30",
+    ) -> pd.DataFrame:
+        """Downloads the historical data and saves it to local drive or in Stock.data variable.
+
+        Parameters
+        ----------
+        stock : Stock
+            Stock object
+        interval : str, optional
+            time interval of data. it should be within [1m,5m,10m,15m,30m,60m,1d], by default "1d"
+        start : Union[str, dtm.datetime], optional
+            start date of the data. The data for this date will be downloaded, by default "2023-01-01"
+        end : Union[str, dtm.datetime], optional
+            end date of the data. The data for this date will be downloaded, by default "2023-03-30"
+
+        Returns
+        ----------
+        pd.DataFrame
+            A dataframe containing a historical data.
+
+        """
+        # scrip = self.scrip_master.get_scrip(stock)
+
+        # if isinstance(start, dtm.datetime):
+        #     start = start.strftime("%Y-%m-%d")
+        # if isinstance(end, dtm.datetime):
+        #     end = end.strftime("%Y-%m-%d")
+
+        # df = self.historical_data(stock.exchange, stock.exchange_type, scrip.loc[stock.symbol, "Scripcode"], interval.value, start, end)
+        # df.columns = ["Datetime", "Open", "High", "Low", "Close", "Volume"]
+        # df["Datetime"] = pd.to_datetime(df["Datetime"])
+        # df = df.set_index("Datetime")
+
+        # return df
+
+        scrip = self.scrip_master.get_scrip(stock)
+        if isinstance(start, str):
+            start_dt = dtm.datetime.strptime(start, "%Y-%m-%d")
+        else:
+            start_dt = start
+
+        if isinstance(end, str):
+            end_dt = dtm.datetime.strptime(end, "%Y-%m-%d")
+        else:
+            end_dt = end
+
+        def _fetch_chunk(s: dtm.datetime, e: dtm.datetime) -> pd.DataFrame:
+            df = self.historical_data(stock.exchange, stock.exchange_type, scrip.loc[stock.symbol, "Scripcode"], interval.value, s.strftime("%Y-%m-%d"), e.strftime("%Y-%m-%d"))
+            if df is None or df.empty:
+                return pd.DataFrame()
+            df.columns = ["Datetime", "Open", "High", "Low", "Close", "Volume"]
+            df["Datetime"] = pd.to_datetime(df["Datetime"])
+            return df.set_index("Datetime")
+
+        dfs = []
+        curr_start = start_dt
+
+        while curr_start < end_dt:
+            curr_end = min(curr_start + dtm.timedelta(days=90), end_dt)
+            chunk = _fetch_chunk(curr_start, curr_end)
+            if not chunk.empty:
+                dfs.append(chunk)
+
+            curr_start = curr_end
+
+        if not dfs:
+            return pd.DataFrame()
+
+        df = pd.concat(dfs).sort_index()
+        df = df.loc[~df.index.duplicated(keep="first")]
+
+        return df
+
+    def get_market_depth(self, stockdict: Union[list[Stock], StockDict]) -> pd.DataFrame:
+        """Gets the market depth for given list of Stocks
+
+        Parameters
+        ----------
+        StockDict : list[Stock]|StockDict
+            list of Stock class instances or StockDict type object.
+
+        Returns
+        -------
+        _pd.DataFrame
+            Live Market Depth for all the Stocks in list.
+        """
+        scrips = pd.concat(self.scrip_master.get_scrip(stock) for stock in stockdict)
+        a = scrips.rename(columns={"Exch": "Exchange", "ExchType": "ExchangeType"})[["Exchange", "ExchangeType", "Symbol"]].to_dict(orient="records")
+        d1 = pd.DataFrame(self.fetch_market_depth_by_symbol(a)["Data"])
+
+        d1.set_index("ScripCode", inplace=True)
+        d1["Datetime"] = dtm.datetime.now()
+        scrips.set_index("Scripcode", inplace=True)
+        d1["Symbol"] = scrips["Symbol"]
+        d1.set_index("Symbol", inplace=True)
+        d1.rename(columns={"Close": "PrevClose"}, inplace=True)
+        d1.rename(columns={"LastTradedPrice": "Close"}, inplace=True)
+        return d1
+
+    def update_stock_histdata0_to_ltp(self, stockdict: Union[list[Stock], StockDict]) -> None:
+        """Updates the market depth to stock.hist_data0 attribute
+
+        Parameters
+        ----------
+        StockDict : list[Stock]|StockDict
+            list of Stock class instances or StockDict type object.
+
+        Returns
+        -------
+        None
+        """
+        d1 = self.get_market_depth(stockdict)
+        d1 = d1[["Datetime", "Open", "High", "Low", "Close", "Volume"]]
+        d1["Datetime"] = d1["Datetime"].dt.normalize()
+        ### Convert datatypes of specific columns
+        float_cols = ["Open", "High", "Low", "Close"]
+        d1[float_cols] = d1[float_cols].astype(float)
+        d1["Volume"] = d1["Volume"].astype(int)
+
+        for s1 in stockdict:
+            try:
+                d = d1.loc[s1.symbol]
+                s1.hist_data0.loc[d.Datetime] = d
+            except:
+                print(f"Error in {s1.symbol}")
+                continue
+        return

finmiti/constants.py

@@ -0,0 +1,133 @@
+from enum import Enum
+from dataclasses import dataclass, field, asdict
+from typing import TypedDict, Optional, get_type_hints, Dict, Tuple
+import pandas as pd
+import uuid
+from datetime import datetime
+
+import numpy as np
+
+
+class EXCHANGE(Enum):
+    nse = "N"
+    bse = "B"
+    mcx = "MCX"
+
+
+class EXCHANGE_TYPE(Enum):
+    cash = "C"
+    derivative = "D"
+    currency = "U"
+
+
+class INTERVAL(Enum):
+    one_day = "1d"
+    one_min = "1m"
+    five_min = "5m"
+    fifteen_min = "15m"
+
+
+class ORDERTYPE(Enum):
+    buy = "buy"
+    sell = "sell"
+
+
+@dataclass
+class Order:
+    timestamp: datetime | np.datetime64
+    symbol: str
+    price: float
+    order_type: ORDERTYPE
+    ### most of the below attributes are for backtesting and evaluation purpose.
+    ### value_frac decides how much fraction of the total cash goes into this order
+    value_frac: float = None
+    id: Optional[str] = None
+    target: Optional[float] = None
+    stop_loss: Optional[float] = None
+    hold_uptill: Optional[datetime] = None
+    remarks: Optional[str] = None
+    ### items for handling order fill related noise. These will be handlerd by executioner object. They will fill these values hence they are None initialized.
+    fill_price: float = None
+    fill_qty: float = None
+    fill_timestamp: datetime | np.datetime64 = None
+    fill_remarks: Optional[str] = None
+    brokerage_cost: float = 0
+    total_cost: float = None
+    ### the account id is for isolating the cash.
+    account_idx: int = 0
+
+    def __post_init__(self):
+        if self.id is None:
+            self.id = str(uuid.uuid4())
+
+
+@dataclass(frozen=True, slots=True)
+class StockData:
+    """
+    Strategy input data (TorchGeometric-style Data object).
+    All arrays must be aligned on the last dimension. Here, the data could be only the last value or it could be the array of historical data. The timestamps must match those values as well.
+    """
+
+    symbol: str
+    ### market data entry
+    timestamp: datetime | np.datetime64
+    open: float
+    high: float
+    low: float
+    close: float
+    volume: float
+    ### anything else you want
+    features: Optional[Dict[str, np.ndarray]] = None
+
+
+@dataclass(frozen=True, slots=True)
+class DiEdgeData:
+    """Directed edge from one stock to another."""
+
+    start_node_symbol: str
+    end_node_symbol: str
+    features: Optional[Dict[str, np.ndarray]] = None
+
+
+@dataclass(frozen=True, slots=True)
+class MarketGraphData:
+    """
+    Multi-asset market snapshot.
+    """
+
+    ### the time of the data. The StockData could have historical data upto this timestamp.
+    timestamp: datetime | np.datetime64
+    ### nodes, named after its symbol
+    stocks: Dict[str, StockData]
+    ### edges: (src, dst) --> edge feature vector. from one node to other.
+    edges: Optional[DiEdgeData] = None
+    ### optional global features (VIX, index returns, liquidity, etc.)
+    global_features: Optional[Dict[str, np.ndarray]] = None
+
+
+### Error class
+class StockDataNotAvailableError(Exception):
+    """Raised when stock data is missing for a given timestamp."""
+    def __init__(self, timestamp:datetime=None, symbol: str=None):
+        message = f"Stock data not available. No data for {symbol} on {timestamp}."
+        super().__init__(message)
+    
+
+class NegativeCashError(Exception):
+    """Raised when the cash of an account goes negative."""
+    def __init__(self, account_idx:int=None):
+        message=f"The cash in an account cannot go negative. Negative cash registered in account - {account_idx}"
+        super().__init__(message)
+
+class OrderTypeError(Exception):
+    """Raised when the ordertype is out of pre-defined orders"""
+    def __init__(self, order: Order=None):
+        message=f"The ordertype must be from finmetry.constants.ORDERTYPE. For {order.symbol} on {order.timestamp} got {order.order_type}."
+        super().__init__(message)
+
+class NotEnoughData(Exception):
+    """Raised when there are not enough historical data for feature computation"""
+    def __init__(self, timestamp:datetime=None, symbol: str=None):
+        message = f"Not enough data available. for {symbol} on {timestamp}."
+        super().__init__(message)
+    

finmiti/executioners.py

@@ -0,0 +1,49 @@
+from typing import List
+from .constants import Order, ORDERTYPE
+
+
+class ExecutionModel:
+    """ExecutionModel is a simulator of a real market. Slippage, volume limits, liquidity etc. kind of real-market scenarios should be implemented here. This could have also been done in portfolio handler but we apply it here for separating the responsibilities.
+
+    Thus ExecutionModel introduces real-market noise. And portfolio simply stores the order.
+    """
+
+    def __init__(self, brokerage_perc: float = 0.0):
+        self.brokerage = 0.0
+
+    def fill_buy_order(self, order: Order, available_cash: float) -> Order:
+        total_cost = available_cash * order.value_frac
+        ### the total cost includes brokerage cost. Thus the amount available to buy is obtained after deducting brokerage from the total cost.
+        ### the formula is total_cost = net_cost * (1 + self.brokerage), thus
+        net_cost = total_cost / (1 + self.brokerage)
+
+        order.fill_price = order.price
+        order.fill_qty = net_cost / order.fill_price
+        order.fill_timestamp = order.timestamp
+        order.brokerage_cost = total_cost - net_cost
+        order.total_cost = total_cost
+        order.fill_remarks = "No added noise"
+
+        return order
+
+    def fill_sell_order(self, order: Order) -> Order:
+        gross_receivable = order.fill_qty * order.price
+        net_receivable = gross_receivable / (1 + self.brokerage)
+
+        order.fill_price = order.price
+        order.fill_timestamp = order.timestamp
+        order.brokerage_cost = gross_receivable - net_receivable
+        order.total_cost = net_receivable
+        order.fill_remarks = "No added noise"
+
+        return order
+
+    def fill_order(self, order: Order, available_cash: float) -> Order:
+        """
+        Naive execution: fill immediately at order.price
+        """
+        if order.order_type == ORDERTYPE.buy:
+            order = self.fill_buy_order(order=order, available_cash=available_cash)
+        elif order.order_type == ORDERTYPE.sell:
+            order = self.fill_sell_order(order=order)
+        return order

finmiti/portfolio_handler/__init__.py

@@ -0,0 +1,2 @@
+
+from .base import Portfolio, Account

finmiti/portfolio_handler/base.py

@@ -0,0 +1,231 @@
+from typing import Dict, List, Optional, TypedDict
+import pandas as pd
+from datetime import datetime
+import numpy as np
+
+from ..executioners import ExecutionModel
+from ..constants import Order, MarketGraphData, ORDERTYPE, NegativeCashError, OrderTypeError
+
+
+class PorfolioSnapshot(TypedDict):
+    """A snapshot of the portfolio at a given Datetime."""
+
+    timestamp: str | datetime | np.datetime64
+    value: float
+
+
+class Portfolio:
+    def __init__(self, executioner: ExecutionModel, starting_cash: float = 100.0, total_accounts: int = 1):
+        self.executioner = executioner
+        self.total_accounts = total_accounts
+
+        self.accounts: List[Account] = [Account(account_idx=i, starting_cash=starting_cash / self.total_accounts, executioner=self.executioner) for i in range(total_accounts)]
+        self.history: List[PorfolioSnapshot] = []
+
+    def mark_to_market(self, market_data: MarketGraphData):
+        value = 0.0
+        for account in self.accounts:
+            account.mark_to_market(market_data=market_data)
+            account_snapshot = account.account_history[-1]
+            value += account_snapshot["cash"] + account_snapshot["holdings_value"]
+        self.history.append(PorfolioSnapshot(timestamp=market_data.timestamp, value=value))
+        return
+
+    def on_order(self, order: Order):
+        account = self.accounts[order.account_idx]
+        account.on_order(order=order)
+        return
+
+    def get_exit_orders(self, market: MarketGraphData) -> List[Order]:
+        exit_orders: List[Order] = []
+        for account in self.accounts:
+            exit_orders += account.get_exit_orders(market=market)
+        return exit_orders
+
+    @property
+    def order_book(self) -> pd.DataFrame:
+        d1 = pd.DataFrame()
+        for account in self.accounts:
+            account_ob = pd.DataFrame(account.order_book)
+            d1 = pd.concat([d1, account_ob], ignore_index=True)
+        d1["order_type"] = d1["order_type"].apply(lambda x: x.value)
+        return d1
+
+    @property
+    def arranged_order_book(self) -> pd.DataFrame:
+        keys = ["symbol", "fill_price", "fill_qty", "fill_timestamp", "total_cost", "account_idx", "hold_uptill", "remarks"]
+        d1 = self.order_book
+        d2 = d1.groupby("order_type").get_group("buy").set_index("id")[keys].add_prefix("buy_")
+        d3 = d1.groupby("order_type").get_group("sell").set_index("id")[keys].add_prefix("sell_")
+        d4 = pd.concat([d2, d3], axis=1).sort_values(by="buy_fill_timestamp")
+        return d4
+
+    @property
+    def account_history(self) -> pd.DataFrame:
+        return pd.DataFrame(self.history).set_index("timestamp")
+
+    @property
+    def holdings(self) -> pd.DataFrame:
+        d1 = pd.DataFrame()
+        for account in self.accounts:
+            account_hd = pd.DataFrame(account.holdings.values())
+            d1 = pd.concat([d1, account_hd], axis=0, ignore_index=True)
+        return d1
+
+
+class Holding(TypedDict):
+    """A holding entry."""
+
+    order_id: str
+    account_idx: int
+    symbol: str
+    qty: float
+    entry_price: float
+    ltp: float
+    target: Optional[float] = None
+    stop_loss: Optional[float] = None
+    holding_start_date: Optional[datetime]
+    holding_end_date: Optional[datetime]
+
+
+class AccountSnapshot(TypedDict):
+    """A snapshot of the portfolio at a given Datetime."""
+
+    timestamp: str | datetime | np.datetime64
+    holdings_value: float
+    cash: float
+
+
+class Account:
+    def __init__(self, account_idx: int, executioner: ExecutionModel, starting_cash: float = 100.0) -> None:
+        self.executioner = executioner
+        self.idx = account_idx
+        self.cash = starting_cash
+
+        ### holdings are indexed by its holding_id, which is order_id.
+        self.holdings: Dict[str, Holding] = {}
+        self.order_book: List[Order] = []
+        self.account_history: List[AccountSnapshot] = []
+
+    def mark_to_market(self, market_data: MarketGraphData):
+        """
+        Update the ltp of holdings from the latest market_data
+        Also records portfolio value and cash at this point in time.
+        """
+        holdings_value = 0.0
+        for _, holding in self.holdings.items():
+            symbol = holding["symbol"]
+            try:
+                holding["ltp"] = market_data.stocks[symbol].close
+            except KeyError:
+                print(f"Cannot update the data for {symbol}, due to missing data on {market_data.timestamp}")
+            holdings_value += holding["qty"] * holding["ltp"]
+
+        self.account_history.append(AccountSnapshot(timestamp=market_data.timestamp, holdings_value=holdings_value, cash=self.cash))
+        return
+
+    def on_order(self, order: Order) -> None:
+        order = self.executioner.fill_order(available_cash=self.cash, order=order)
+
+        qty = order.fill_qty
+        price = order.fill_price
+        total_cost = order.total_cost
+
+        if order.order_type == ORDERTYPE.buy:
+            qty *= 1
+            total_cost *= 1
+        elif order.order_type == ORDERTYPE.sell:
+            qty *= -1
+            total_cost *= -1
+        else:
+            raise OrderTypeError(order=order)
+
+        ### change the cash available in the portfolio. If it is sell order then total_cost will be negative and thus that amount will be added to self.cash.
+        self.cash = self.cash - total_cost
+        if self.cash < 0:
+            raise NegativeCashError(account_idx=self.idx)
+
+        ### add new holding or edit the holding
+        holding = self.holdings.get(order.id, None)
+        if holding is None:
+            holding = Holding(
+                order_id=order.id,
+                account_idx=self.idx,
+                symbol=order.symbol,
+                qty=qty,
+                entry_price=price,
+                ltp=price,
+                target=order.target,
+                stop_loss=order.stop_loss,
+                holding_start_date=order.timestamp,
+                holding_end_date=order.hold_uptill,
+            )
+            self.holdings[order.id] = holding
+        else:
+            assert (holding["qty"] + qty) == 0, "If you are trying to exit a position then quantity must match with the order_id. Partial fills shall be applied as separate orders."
+            self.holdings.pop(order.id, None)
+
+        ### add order to orderbook
+        self.order_book.append(order)
+
+        return
+
+    def get_exit_orders(self, market: MarketGraphData) -> List[Order]:
+        """
+        Check stops, targets, expiry.
+        Emits exit Orders if needed.
+        """
+        exit_orders: List[Order] = []
+
+        for order_id, holding in self.holdings.items():
+            try:
+                close = market.stocks[holding["symbol"]].close
+                low = market.stocks[holding["symbol"]].low
+                high = market.stocks[holding["symbol"]].high
+                ### sometimes the data for any particular stock may be missing on a given timestamp. It will thus hault the backtest. To avoid haulting, bypass it.
+            except KeyError:
+                print(f"Cannot check for exit orders for {holding['symbol']}, due to missing data on {market.timestamp}")
+                continue
+
+            # reason = None
+            # if holding["stop_loss"] and close <= holding["stop_loss"]:
+            #     reason = "stop_loss"
+            #     # exit_price = holding["stop_loss"]
+            # elif holding["target"] and close >= holding["target"]:
+            #     reason = "target"
+            #     # exit_price = holding["target"]
+            # elif holding["holding_end_date"] and market.timestamp >= holding["holding_end_date"]:
+            #     reason = "expiry"
+            # else:
+            #     continue
+            # exit_price = close
+
+            reason = None
+            if holding["stop_loss"] and  low<= holding["stop_loss"]:
+                reason = "stop_loss"
+                exit_price = holding["stop_loss"]
+            elif holding["target"] and high >= holding["target"]:
+                reason = "target"
+                exit_price = holding["target"]
+            elif holding["holding_end_date"] and market.timestamp >= holding["holding_end_date"]:
+                reason = "expiry"
+                exit_price = close
+            else:
+                continue
+
+
+            exit_order_type = ORDERTYPE.sell if holding["qty"] > 0 else ORDERTYPE.buy
+            exit_orders.append(
+                Order(
+                    timestamp=market.timestamp,
+                    symbol=holding["symbol"],
+                    price=exit_price,
+                    order_type=exit_order_type,
+                    fill_qty=abs(holding["qty"]),
+                    remarks=reason,
+                    account_idx=self.idx,
+                    id=order_id,
+                )
+            )
+
+        return exit_orders

finmiti/stocks_handler/__init__.py

@@ -0,0 +1,3 @@
+
+from .stock import Stock
+from .stockdict import StockDict

finmiti/stocks_handler/stock.py

@@ -0,0 +1,209 @@
+"""Module consisting of base class of stock"""
+
+import os as _os
+from pathlib import Path
+import datetime as _dtm
+import numpy as _np
+import pandas as _pd
+
+from typing import TypeVar, Union, Optional
+
+from enum import Enum
+
+import duckdb
+
+from ..constants import EXCHANGE, EXCHANGE_TYPE, INTERVAL
+
+
+def append_it(data: _pd.DataFrame, filepath: str) -> None:
+    """Appends the data on the given filepath after comparing Indexes of both the data.
+
+    This compares the data already at the given filepath, and then appends only the data not already present.
+
+    Parameters
+    ----------
+    data : _pd.DataFrame
+        data frame with Datetime like index
+    filepath : str
+        filepath, where the dataframe will be appended.
+    """
+    try:
+        df1 = data.combine_first(_pd.read_parquet(filepath)).sort_index()
+        df1.to_parquet(filepath)
+    except FileNotFoundError as e:
+        print(f"Creating the file - {filepath}")
+        data.to_parquet(filepath)
+    return
+
+
+class Stock:
+    def __init__(
+        self,
+        symbol: str,
+        exchange: EXCHANGE = EXCHANGE.nse,
+        exchange_type: EXCHANGE_TYPE = EXCHANGE_TYPE.cash,
+    ) -> None:
+        """Manages the data for list of stocks.
+
+        Parameters
+        ----------
+        Parameters
+        ----------
+        symbol : str
+            Stock symbol as available online.
+        exchange : EXCHANGE
+            Stock Exchange. can be N, B, M for Nifty, BSE and MCX respectively. By default N
+        exchange_type : EXCHANGE_TYPE
+            Type of Stock Exchange. can be C, D or U for Cash, Derivative or Currency respectively. By default C.
+        """
+        self.symbol = symbol
+        if isinstance(exchange, EXCHANGE):
+            self.exchange = exchange.value
+        else:
+            raise ValueError("exchange can only be of type EXCHANGE enum")
+
+        if isinstance(exchange_type, EXCHANGE_TYPE):
+            self.exchange_type = exchange_type.value
+        else:
+            raise ValueError("exchange_type can only be of type EXCHANGE_TYPE enum")
+        
+        
+        self.hist_data0: Optional[_pd.DataFrame] = None
+
+    @property
+    def foldname(self):
+        return self.exchange + "_" + self.exchange_type + "_" + self.symbol
+    
+    def __repr__(self):
+        return f"{self.symbol} stock class"
+
+    def get_filename(self, date: _dtm.datetime, interval: INTERVAL):
+        return f"{date.year}{str(date.month).zfill(2)}_{interval.value}.parquet"
+
+    def save_historical_data(
+        self,
+        data: _pd.DataFrame,
+        interval: INTERVAL,
+        local_data_foldpath: str,
+        overwrite: bool = False,
+    ) -> None:
+        """saves the historical stock data.
+
+        Multiple files, each for saparate month data is created.
+
+        Parameters
+        ----------
+        data : _pd.DataFrame
+            Data to be saved. It should be indexed with Datetime values.
+        interval : str
+            time interval of the data
+        local_data_foldpath : str
+            path to folder where the data will be stored. Inside this folder, multiple folders of individual stocks are created and inside that stock folder, historical data and other data is stored.
+        overwrite : bool, False
+            wheather to overwrite the existing file or just append the new data. default False. If True then it will overwrite the present data.
+        """
+        ### creating the folder
+        data_foldpath = Path(local_data_foldpath) / self.foldname
+        Path(data_foldpath).mkdir(exist_ok=True)
+        
+        ### writing the data
+        data["filename"] = data.index.to_series().apply(lambda x: self.get_filename(x, interval))
+        for fnm, df in data.groupby("filename"):
+            df = df.drop(columns="filename")
+            filepath = data_foldpath / fnm
+
+            if overwrite:
+                print("Overwriting:-", filepath)
+                df.to_parquet(filepath)
+            else:
+                append_it(df, filepath)
+            pass
+        return
+
+    def load_historical_data(
+        self, 
+        start: Union[str, _dtm.datetime], 
+        end: Union[str, _dtm.datetime], 
+        local_data_foldpath: str,
+        interval: INTERVAL = INTERVAL.one_day,
+        fill_holidays: bool = False,
+        remove_weekends: bool = True,
+    ) -> _pd.DataFrame:
+        """Loads the data from local_directory
+
+        Parameters
+        ----------
+        start : Union[str, _dtm.datetime]
+            start date of the data. The data for this date will be downloaded
+        end : Union[str, _dtm.datetime]
+            end date of the data. The data for this date will be downloaded
+        local_data_foldpath : str
+            path to folder where the data is stored. inside this folder there are multiple sub-folders of individual stock. You only have to give the parent folder path.
+        interval : INTERVAL, Optional
+            time interval of data. it should be of type INTERVAL enum. Defaults to one day interval
+        fill_holidays : bool, Default is False
+            The data is not available for the holidays. If this is made True then the previous day data will be filled in as that day's data and that missing holiday row will be inserted.
+        remove_weekends : bool, Default is True
+            Sometimes the markets are open on saturdays and sundays. These are vary rare and thus are removed from historical data while loading.
+
+        Returns
+        -------
+        _pd.DataFrame
+            data
+
+        Raises
+        ------
+        ValueError
+            if no data is found
+        """
+        data_foldpath = Path(local_data_foldpath) / self.foldname
+        Path(data_foldpath).mkdir(exist_ok=True)
+
+        if isinstance(start, _dtm.datetime):
+            start = start.strftime("%Y-%m-%d")
+        if isinstance(end, _dtm.datetime):
+            end = end.strftime("%Y-%m-%d")
+
+        # DuckDB SQL
+        query = f"""
+        SELECT *
+        FROM read_parquet('{data_foldpath}/*_{interval.value}.parquet')
+        WHERE Datetime BETWEEN TIMESTAMP '{start}' AND TIMESTAMP '{end}'
+        ORDER BY Datetime
+        """
+        with duckdb.connect() as con:
+            df = con.execute(query).df()
+        d1 = df.set_index("Datetime")
+        if fill_holidays:
+            # Create full business day range
+            full_range = _pd.date_range(start=d1.index.min(), end=d1.index.max(), freq="B")
+            d1 = d1.reindex(full_range).ffill()
+            d1.index.name = "Datetime"
+        if remove_weekends:
+            d1 = d1[d1.index.weekday < 5]
+        return d1
+    
+    @property
+    def scrip(self) -> _pd.DataFrame:
+        """scrip for client 5paisa.
+
+        Returns
+        -------
+        _pd.DataFrame
+            scrip data.
+        """
+        return self._scrip
+
+    @scrip.setter
+    def scrip(self, data: _pd.DataFrame) -> None:
+        """saves the scrip
+
+        Parameters
+        ----------
+        data : _pd.DataFrame
+            scrip data. This can be optained by ScripMaster.get_scrip() method.
+        """
+        self._scrip = data
+        return
+
+

finmiti/stocks_handler/stockdict.py

@@ -0,0 +1,109 @@
+import numpy as np
+import pandas as pd
+
+from concurrent.futures import ThreadPoolExecutor
+
+from .stock import Stock
+import duckdb
+
+
+class StockDict:
+    """Class to handle functionalities related to multiple stocks, using symbol as keys."""
+
+    def __init__(self, stocks: list[Stock]=None) -> None:
+        self.stockdict: dict[str, Stock] = {}
+        if stocks is not None:
+            for stock in stocks:
+                self.add(stock)
+            
+
+
+    def __repr__(self) -> str:
+        return f"StockList object with {len(self.stockdict)} Stocks"
+
+    def __type__(self) -> str:
+        return "StockDict"
+
+    def __getitem__(self, i: str|int):
+        if isinstance(i, str):
+            return self.stockdict[i]
+        elif isinstance(i, int):
+            return list(self.stockdict.values())[i]
+        else:
+            raise ValueError("can only give string or integer values")
+
+    def __len__(self):
+        return len(self.stockdict)
+
+    def __iter__(self):
+        return iter(self.stockdict.values())
+
+    def __contains__(self, symbol: str) -> bool:
+        return symbol in self.stockdict
+
+    def add(self, stock: Stock) -> None:
+        """Adds or replaces a Stock object using its ticker symbol."""
+        self.stockdict[stock.symbol] = stock
+        return
+
+    def remove(self, symbol: str) -> None:
+        """Removes a stock by its symbol, if it exists."""
+        self.stockdict.pop(symbol, None)
+        return
+
+    def get(self, symbol: str) -> Stock | None:
+        return self.stockdict.get(symbol)
+
+    @property
+    def symbols(self) -> list[str]:
+        return list(self.stockdict.keys())
+
+    @property
+    def stocklist(self) -> list[Stock]:
+        return list(self.stockdict.values())
+
+    def load_multiple_stocks(self, symbols: list[str], *args, **kwargs) -> None:
+        """Loads multiple stocks using their symbols and adds them to the stockdict."""
+        for symbol in symbols:
+            try:
+                stock = Stock(symbol, *args, **kwargs)
+                self.add(stock)
+            except Exception as e:
+                print(f"[{symbol}] Error loading stock:\n{e}")
+        return
+
+    def apply(self, method_name: str, *args, **kwargs) -> dict[str, any]:
+        """Applies a method to all Stock objects and returns a dict of results."""
+        results = {}
+        for symbol, stock in self.stockdict.items():
+            method = getattr(stock, method_name, None)
+            if callable(method):
+                results[symbol] = method(*args, **kwargs)
+            else:
+                results[symbol] = None
+        return results
+
+    def load_historical_data(self, *args, max_workers: int = 5, remove_error_stocks: bool = True, print_info: bool = True, **kwargs) -> None:
+        """Calls stock.load_historical_data() for all stocks using multithreading."""
+
+        def _load(stock: Stock):
+            try:
+                if print_info:
+                    print(f"[{stock.symbol}] Loading historical data...")
+                stock.hist_data0 = stock.load_historical_data(*args, **kwargs)
+                stock.hist_data0 = stock.hist_data0[~stock.hist_data0.index.duplicated(keep="first")]  # removing duplicate timestamps
+                if print_info:
+                    print(f"[{stock.symbol}] Data loaded successfully.")
+            except Exception as e:
+                print(f"[{stock.symbol}] Error loading data:\n{e}")
+                errors.append(stock.symbol)
+
+        errors = []
+        with ThreadPoolExecutor(max_workers=max_workers) as executor:
+            executor.map(_load, self.stockdict.values())
+        if remove_error_stocks:
+            for symbol in errors:
+                print(f"[{symbol}] Removing stock due to loading error.")
+                self.remove(symbol)
+
+        return

finmiti/strategy_handler/__init__.py

@@ -0,0 +1,2 @@
+
+from .base import StrategyBase, StgDataLoader

finmiti/strategy_handler/base.py

@@ -0,0 +1,36 @@
+from abc import ABC, abstractmethod
+from typing import List, Iterator
+import datetime as dtm
+
+from ..stocks_handler import StockDict
+from ..constants import Order
+from ..constants import MarketGraphData, StockData
+from ..utils import str_to_dtm
+
+
+class StgDataLoader(ABC):
+    @abstractmethod
+    def __getitem__(self, idx: str | dtm.datetime) -> MarketGraphData:
+        raise NotImplementedError
+    
+    @abstractmethod
+    def __len__(self) -> int:
+        raise NotImplementedError
+    
+    @abstractmethod
+    def __iter__(self) -> Iterator[MarketGraphData]:
+        raise NotImplementedError
+    
+
+class StrategyBase(ABC):
+    def __call__(self, data: MarketGraphData) -> List[Order]:
+        orders = self.forward(data)
+
+        if not isinstance(orders, list):
+            raise TypeError("Strategy.forward must return List[Order]")
+
+        return orders
+
+    @abstractmethod
+    def forward(self, data: MarketGraphData) -> List[Order]:
+        raise NotImplementedError

finmiti/utils.py

@@ -0,0 +1,7 @@
+import datetime as dtm
+
+def str_to_dtm(timestring:str)->dtm.datetime:
+    return dtm.datetime.strptime(timestring, "%Y-%m-%d")
+
+def dtm_to_str(timestamp:dtm.datetime)->str:
+    return timestamp.strftime("%Y-%m-%d")

finmiti-0.0.1.dist-info/METADATA

@@ -0,0 +1,136 @@
+Metadata-Version: 2.4
+Name: finmiti
+Version: 0.0.1
+Summary: Persnal project for stock market data analysis
+Author-email: Darshan Rathod <darshan.rathod1994@gmail.com>
+Maintainer-email: Darshan Rathod <darshan.rathod1994@gmail.com>
+License: MIT
+Project-URL: Homepage, https://dev-ddr.github.io/finmiti/
+Project-URL: Repository, https://github.com/dev-ddr/finmiti
+Project-URL: Issues, https://github.com/dev-ddr/finmiti/issues
+Keywords: finance,stock-market,quant,research,personal
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: numpy==2.3.5
+Requires-Dist: pandas==2.3.3
+Requires-Dist: pyyaml==6.0.3
+Requires-Dist: duckdb==1.4.2
+Requires-Dist: pyarrow==22.0.0
+Requires-Dist: py5paisa==0.7.21.2
+Requires-Dist: pydantic
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: jupyter; extra == "dev"
+Requires-Dist: notebook; extra == "dev"
+Requires-Dist: sphinx; extra == "dev"
+Requires-Dist: mkdocs; extra == "dev"
+Requires-Dist: mkdocs-material; extra == "dev"
+Requires-Dist: mkdocstrings[python]; extra == "dev"
+Requires-Dist: nbconvert; extra == "dev"
+Requires-Dist: matplotlib; extra == "dev"
+Requires-Dist: plotly; extra == "dev"
+
+# Finmiti
+
+**This project is developed for my personal use.** I am developing this to keep the documentation, architecture and pipeline consistent so that I can focus more on developing strategies instead of developing pipelines.
+
+Visit [Finmiti](https://dev-ddr.github.io/finmetry/) guide for further steps.
+
+> This project is solely developed for my personal use. I am publishing this only to keep myself updated and to remove the headache of setting up the framework again and again.
+
+---
+
+**Finmiti is a research-first quantitative trading framework** designed to keep
+strategy logic, execution logic, and accounting logic strictly separated.
+
+It exists to eliminate repeated reinvention of trading pipelines, so you can
+focus on **researching strategies**, not rebuilding infrastructure.
+
+
+## What Finmiti Is (and Is Not)
+
+Finmiti is:
+
+- a framework for systematic trading research
+- equally suited for backtesting and live trading
+- opinionated by design
+- built around explicit, auditable abstractions
+
+Finmiti is **not**:
+
+- a strategy library
+- a signal generator
+- a black-box trading system
+
+If you want flexibility at the cost of correctness, this framework will feel restrictive.
+That restriction is intentional.
+
+
+## The Core Trading Loop
+
+Every strategy in finmiti follows the same explicit loop:
+
+```text
+Market Data → Strategy → Orders → Portfolio → Execution → Accounting
+````
+
+Each stage is implemented as a **separate module** with strict responsibilities.
+
+This guarantees that:
+
+* strategies remain stateless
+* execution assumptions are explicit
+* accounting is consistent
+* backtests can be trusted
+* live trading reuses the same abstractions
+
+## Major Modules
+
+Finmiti is organized into the following conceptual modules:
+
+### [Client Handling](https://dev-ddr.github.io/finmetry/concepts/client_handling_module/)
+
+Handles interaction with external systems such as broker APIs and live data feeds.
+Keeps the rest of the framework broker-agnostic.
+
+### [Stocks](https://dev-ddr.github.io/finmetry/concepts/stocks_handling_module/)
+
+Manages symbols, historical data, and OHLCV storage.
+Acts as the foundation for all market data access.
+
+### [Strategy](https://dev-ddr.github.io/finmetry/concepts/strategy_handling_module/)
+
+Consumes immutable market snapshots and emits **order intent only**.
+Strategies never manage cash, positions, or execution details.
+
+### [Orders](https://dev-ddr.github.io/finmetry/concepts/order/)
+
+Orders are the contract between strategy, portfolio, and execution.
+They represent intent, not outcome.
+
+### [Executioners](https://dev-ddr.github.io/finmetry/concepts/executioners/)
+
+Simulate (or connect to) market reality:
+slippage, brokerage, partial fills, or live execution.
+
+### [Portfolio](https://dev-ddr.github.io/finmetry/concepts/portfolio_handling_module/)
+
+The single source of truth for positions, cash, and PnL.
+All state mutation happens here.
+
+### [Backtesting](https://dev-ddr.github.io/finmetry/concepts/backtesting_handling_module/)
+
+Pure orchestration.
+Iterates over time and wires everything together without adding logic.
+
+## Final Note
+
+> I have built this for my personal use in mind.
+
+
+
+

finmiti-0.0.1.dist-info/RECORD

@@ -0,0 +1,19 @@
+finmiti/__init__.py,sha256=yyUQrRvmxjIo9Zc2zAFjv-VddqMDjg5md9zYB12uq4c,349
+finmiti/constants.py,sha256=d7MwCQ1w2FhH_nYfwWu11FrL_urECIkH0MaeRGOMPt8,4143
+finmiti/executioners.py,sha256=NCDlL-YgRIYWkR5OusFD7GWAqWgcn7MFl8ptOP3637c,2088
+finmiti/utils.py,sha256=LhBtCJuPTqXEmz1eARrNhNFUjD8K5TD78-lyAB7mLOA,214
+finmiti/backtest_handler/__init__.py,sha256=9ewjO3EbFqBpOx42fHZgH_w1FFvkXSjsmuFalsQSiKQ,29
+finmiti/backtest_handler/base.py,sha256=bCxMNm-UVuUbUjPtqksiBNuiuFZLQzCyYRsCIZN1ADM,818
+finmiti/clients/__init__.py,sha256=lw_3EbWD7lgWB3_-A88reMb3MNrOQJtCI0CI_W8PwJw,28
+finmiti/clients/client_5paisa.py,sha256=Nzkld-T24qKX0ja5lx3hkh88XEGmCWTJfeC7U5HP8bA,8084
+finmiti/portfolio_handler/__init__.py,sha256=lo09jpUvIurBeKii8KOL3rhRyJBmo3dZC4J-XHzD1D0,38
+finmiti/portfolio_handler/base.py,sha256=MZhesSyPTcH_UVaSqzpL_Nlfoik9xpz6rGn3SJGQtO4,8794
+finmiti/stocks_handler/__init__.py,sha256=XtfClx4hgqQsxNJsgCS4vUC1MhdMfmBfezRZC1IEHeI,58
+finmiti/stocks_handler/stock.py,sha256=5ijFo0NNnp8XlLrnv-2413ek0p30eL-NKqKf6PzBjVI,7087
+finmiti/stocks_handler/stockdict.py,sha256=BhjaT_DRYRLh3OHA9Nga8Ga2-w1gkRDPiit560Tx4mA,3796
+finmiti/strategy_handler/__init__.py,sha256=-xdmRKzfBh0DFk7EshRjSAvv0rCwcfBGXa1KxH52Qys,46
+finmiti/strategy_handler/base.py,sha256=WuPaHSPebtr_JqFNm5MBnv2eB7jy0zQhWvKJs4GDoUI,981
+finmiti-0.0.1.dist-info/METADATA,sha256=_e-ZgOUBh1UVBI2O0589i8fU8-RMcjUuaULB6rl15P8,4528
+finmiti-0.0.1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+finmiti-0.0.1.dist-info/top_level.txt,sha256=ufoAcQ5Q6CpgwLLsoR_wah292RWfdiIBshfpZBTY_Nc,8
+finmiti-0.0.1.dist-info/RECORD,,

finmiti-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

finmiti-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+finmiti