fima 0.1.0__py3-none-any.whl

fima/Bonds.py

@@ -0,0 +1,102 @@
+import requests
+import pandas as pd
+import numpy as np
+from bs4 import BeautifulSoup
+from io import StringIO
+import jdatetime as jd
+
+
+def get_risk_free_rate() -> float:
+    all_bonds_without_coupons = get_all_bonds_without_coupons(deprecated=False)
+    all_t_notes = all_bonds_without_coupons[all_bonds_without_coupons['Ticker'].str.contains('سخاب|اخزا')].copy()
+    today_date = jd.date.today()
+    all_t_notes['DaysTillMaturity'] = (all_t_notes['MaturityDate'] - today_date).apply(lambda delta: delta.days)
+    last_traded_t_notes = all_t_notes[all_t_notes['LastTradedDate'] == all_t_notes['LastTradedDate'].max()]
+    rf = last_traded_t_notes['YTM'].mean()
+    return rf
+
+
+def get_all_bonds_without_coupons(deprecated: bool = True) -> pd.DataFrame:
+    url = "https://ifb.ir/YTM.aspx"
+
+    session = requests.Session()
+    response = session.get(url)
+
+    if response.status_code != 200:
+        print(f"Failed to access page. Status code: {response.status_code}")
+        return None
+
+    soup = BeautifulSoup(response.content, "html.parser")
+    table = soup.find("table", {"id": "ContentPlaceHolder1_grdytmforkhazaneh", "class": "KhazanehGrid"})
+
+    if table is None:
+        print("Table not found.")
+        return None
+
+    df_list = pd.read_html(StringIO(str(table)))
+    bonds_without_coupons = df_list[0]
+
+    if ~deprecated:
+        bonds_without_coupons = bonds_without_coupons[bonds_without_coupons['YTM'] != 'سررسید شده'].copy()
+
+    bonds_without_coupons.columns = ['Index', 'Ticker', 'LastTradedPrice', 'LastTradedDate', 'MaturityDate', 'YTM', 'SimpleReturn']
+
+    bonds_without_coupons['LastTradedDate'] = \
+        bonds_without_coupons['LastTradedDate'].apply(lambda str_date: jd.date(year=int(str_date[:4]),
+                                                                               month=int(str_date[5:7]),
+                                                                               day=int(str_date[8:])))
+
+    bonds_without_coupons['MaturityDate'] = \
+        bonds_without_coupons['MaturityDate'].apply(lambda str_date: jd.date(year=int(str_date[:4]),
+                                                                               month=int(str_date[5:7]),
+                                                                               day=int(str_date[8:])))
+
+    bonds_without_coupons['YTM'] = \
+        bonds_without_coupons['YTM'].apply(lambda str_ytm: float(str_ytm.replace('/', '.').replace('%', '')) / 100)
+    bonds_without_coupons['SimpleReturn'] = \
+        bonds_without_coupons['SimpleReturn'].apply(lambda str_ytm: float(str_ytm.replace('/', '.').replace('%', '')) / 100)
+
+    bonds_without_coupons.drop('Index', inplace=True, axis=1)
+    bonds_without_coupons.reset_index(inplace=True, drop=True)
+
+    return bonds_without_coupons
+
+
+def get_all_bonds_with_coupons(deprecated: bool = True) -> pd.DataFrame:
+    url = "https://ifb.ir/YTM.aspx"
+
+    session = requests.Session()
+    response = session.get(url)
+
+    if response.status_code != 200:
+        print(f"Failed to access page. Status code: {response.status_code}")
+        return None
+
+    soup = BeautifulSoup(response.content, "html.parser")
+    table = soup.find("table", {"id": "ContentPlaceHolder1_grdytm", "class": "mGrid"})
+
+    if table is None:
+        print("Table not found.")
+        return None
+
+    df_list = pd.read_html(StringIO(str(table)))
+    bonds_with_coupons = df_list[0]
+
+    if ~deprecated:
+        bonds_with_coupons = bonds_with_coupons[bonds_with_coupons['YTM'] != 'سررسید شده'].copy()
+
+    bonds_with_coupons.columns = ['Index', 'Ticker', 'LastTradedPrice', 'LastTradedDate', 'MaturityDate', 'YTM']
+
+    bonds_with_coupons['LastTradedDate'] = bonds_with_coupons['LastTradedDate'].apply(
+        lambda str_date: jd.date(year=int(str_date[:4]), month=int(str_date[5:7]), day=int(str_date[8:])) if pd.notna(str_date) else np.nan)
+
+    bonds_with_coupons['MaturityDate'] = bonds_with_coupons['MaturityDate'].apply(
+        lambda str_date: jd.date(year=int(str_date[:4]), month=int(str_date[5:7]), day=int(str_date[8:])) if str_date != '0' else np.nan)
+
+    bonds_with_coupons['YTM'] = bonds_with_coupons['YTM'].apply(
+        lambda str_ytm: float(str_ytm.replace('/', '.').replace('%', '')) / 100 if (pd.notna(str_ytm) and str_ytm != 'سررسید شده') else np.nan)
+
+    bonds_with_coupons.drop('Index', inplace=True, axis=1)
+    bonds_with_coupons.reset_index(inplace=True, drop=True)
+
+    return bonds_with_coupons

fima/Options.py

@@ -0,0 +1,675 @@
+import pandas as pd
+import requests
+import jdatetime as jd
+from fima.Bonds import get_risk_free_rate
+from mibian import BS
+from scipy.stats import norm
+import numpy as np
+
+
+def calculate_d1(s, k, t, r_f, sigma) -> float:
+    return (np.log(s / k) + (r_f + 0.5 * sigma ** 2) * t) / (sigma * np.sqrt(t))
+
+
+def calculate_d2(s, k, t, r_f, sigma) -> float:
+    return calculate_d1(s, k, t, r_f, sigma) - sigma * np.sqrt(t)
+
+
+def calculate_delta(s, k, t, r_f, sigma, option_type) -> float:
+    if option_type == 'Call':
+        return norm.cdf(calculate_d1(s, k, t, r_f, sigma))
+    elif option_type == 'Put':
+        return -norm.cdf(-(np.log(s / k) + (r_f + sigma ** 2 / 2) * t) / (sigma * np.sqrt(t)))
+    return None
+
+
+def calculate_theta(s, k, t, r_f, sigma, option_type) -> float:
+    if option_type == 'Call':
+        p1 = - s * norm.pdf(calculate_d1(s, k, t, r_f, sigma)) * sigma / (2 * np.sqrt(t))
+        p2 = r_f * k * np.exp(-r_f * t) * norm.cdf(calculate_d2(s, k, t, r_f, sigma))
+        return p1 - p2
+    elif option_type == 'Put':
+        p1 = - s * norm.pdf(calculate_d1(s, k, t, r_f, sigma)) * sigma / (2 * np.sqrt(t))
+        p2 = r_f * k * np.exp(-r_f * t) * norm.cdf(-calculate_d2(s, k, t, r_f, sigma))
+        return p1 + p2
+    return None
+
+
+def calculate_gamma(s, k, t, r_f, sigma) -> float:
+    return norm.pdf(calculate_d1(s, k, t, r_f, sigma)) / (s * sigma * np.sqrt(t))
+
+
+def calculate_vega(s, k, t, r_f, sigma) -> float:
+    return s * np.sqrt(t) * norm.pdf(calculate_d1(s, k, t, r_f, sigma))
+
+
+def calculate_rho(s, k, t, r_f, sigma, option_type) -> float:
+    if option_type == 'Call':
+        return k * t * np.exp(-r_f * t) * norm.cdf(calculate_d2(s, k, t, r_f, sigma))
+    elif option_type == 'Put':
+        return -k * t * np.exp(-r_f * t) * norm.cdf(-calculate_d2(s, k, t, r_f, sigma))
+    return None
+
+
+def calculate_row_wise_implied_volatility(row) -> float:
+    # print(f"Calculating {row['Ticker']} implied volatility...")
+    return get_implied_volatility(ticker=row['Ticker'], ticker_info_df=row.to_frame().T, r_f=row['RiskFreeRate'],
+                                  ua_historical_data=row['HistoricalData-UA'])
+
+
+def get_implied_volatility(ticker: str, ticker_info_df: pd.DataFrame = None, volatility_window_size: int = None,
+                       r_f: float = None, minimum_required_history: int = 30, ua_historical_data: pd.DataFrame = None) -> float:
+
+    if ticker_info_df is None:
+        ticker_info_df = ticker_info(ticker=ticker, j_date=True)
+
+    if ua_historical_data is None:
+        try:
+            _, ua_historical_data = download_historical_data(ticker)
+        except requests.exceptions.HTTPError:
+            print(f'Couldn\'t download historical data for: {ticker}')
+            return None
+
+        if ua_historical_data is None:
+            return None
+
+    if r_f is None:
+        r_f = get_risk_free_rate()
+
+    stock_days_available = len(ua_historical_data)
+    if stock_days_available < minimum_required_history:
+        print(
+            f"Not enough stock history for {ticker_info_df['Ticker-UA']} ({stock_days_available} days available, "
+            f"{minimum_required_history} days required).")
+        return None
+
+    days_to_maturity = ticker_info_df['DaysToMaturity'].values[0]
+    if days_to_maturity < 10:
+        print(f"Option {ticker} expires too soon ({days_to_maturity} days left). Calculated implied volatility may not be reliable.")
+        return None
+
+    max_safe_window = min(stock_days_available, days_to_maturity)
+    if volatility_window_size is None:
+        volatility_window_size = min(30, max(5, max_safe_window // 2))  # dynamic choice
+    else:
+        volatility_window_size = min(volatility_window_size, max_safe_window)  # force safe
+
+    if volatility_window_size < 5:
+        print(f"Volatility window too small ({volatility_window_size} days). Cannot calculate meaningful volatility for {ticker}.")
+        return None
+
+    sigma = calculate_volatility(ua_historical_data, volatility_window_size)
+    s = ticker_info_df['LastPrice-UA'].values[0]
+    k = ticker_info_df['StrikePrice'].values[0]
+    t = days_to_maturity / 365
+    option_type = ticker_info_df['Type'].values[0]
+    premium = ticker_info_df['LastPrice'].values[0]
+
+    if sigma == 0 or t == 0:
+        print("Zero volatility or expired option.")
+        return None
+
+    try:
+        if option_type == 'Call':
+            ticker_implied_volatility = BS([s, k, r_f, t * 365], callPrice=premium)
+        elif option_type == 'Put':
+            ticker_implied_volatility = BS([s, k, r_f, t * 365], putPrice=premium)
+        else:
+            print('Option type is not a valid one.')
+            return None
+    except (UnboundLocalError, IndexError):
+        print('mibian library error.')
+        return None
+    return ticker_implied_volatility.impliedVolatility / 100
+
+
+def get_greeks(ticker: str, ticker_info_df: pd.DataFrame = None, volatility_window_size: int = None, r_f: float = None,
+           minimum_required_history: int = 30, ua_historical_data: pd.DataFrame = None) -> pd.Series:
+
+    delta, gamma, theta, vega, rho = (None, None, None, None, None)
+
+    if ticker_info_df is None:
+        ticker_info_df = ticker_info(ticker=ticker, j_date=True)
+
+    if ua_historical_data is None:
+        try:
+            _, ua_historical_data = download_historical_data(ticker)
+        except requests.exceptions.HTTPError:
+            print(f'Couldn\'t download historical data for: {ticker}')
+            return pd.Series({'Delta': delta, 'Gamma': gamma, 'Theta': theta, 'Vega': vega, 'Rho': rho})
+
+        if ua_historical_data is None:
+            return pd.Series({'Delta': delta, 'Gamma': gamma, 'Theta': theta, 'Vega': vega, 'Rho': rho})
+
+    if r_f is None:
+        r_f = get_risk_free_rate()
+
+    stock_days_available = len(ua_historical_data)
+    if stock_days_available < minimum_required_history:
+        print(
+            f"Not enough stock history for {ticker_info_df['Ticker-UA']} ({stock_days_available} days available, "
+            f"{minimum_required_history} days required).")
+        return pd.Series({'Delta': delta, 'Gamma': gamma, 'Theta': theta, 'Vega': vega, 'Rho': rho})
+
+    days_to_maturity = ticker_info_df['DaysToMaturity'].values[0]
+    if days_to_maturity < 10:
+        print(f"Option {ticker} expires too soon ({days_to_maturity} days left). Calculated greeks may not be reliable.")
+        return pd.Series({'Delta': delta, 'Gamma': gamma, 'Theta': theta, 'Vega': vega, 'Rho': rho})
+
+    max_safe_window = min(stock_days_available, days_to_maturity)
+    if volatility_window_size is None:
+        volatility_window_size = min(30, max(5, max_safe_window // 2))  # dynamic choice
+    else:
+        volatility_window_size = min(volatility_window_size, max_safe_window)  # force safe
+
+    if volatility_window_size < 5:
+        print(
+            f"Volatility window too small ({volatility_window_size} days). Cannot calculate meaningful volatility for {ticker}.")
+        return pd.Series({'Delta': delta, 'Gamma': gamma, 'Theta': theta, 'Vega': vega, 'Rho': rho})
+
+    sigma = calculate_volatility(ua_historical_data, volatility_window_size)
+    s = ticker_info_df['LastPrice-UA'].values[0]
+    k = ticker_info_df['StrikePrice'].values[0]
+    t = days_to_maturity / 365
+    option_type = ticker_info_df['Type'].values[0]
+
+    if sigma == 0 or t == 0:
+        print("Zero volatility or expired option.")
+        return pd.Series({'Delta': delta, 'Gamma': gamma, 'Theta': theta, 'Vega': vega, 'Rho': rho})
+
+    delta = calculate_delta(s, k, t, sigma, r_f, option_type)
+    gamma = calculate_gamma(s, k, t, sigma, r_f)
+    theta = calculate_theta(s, k, t, sigma, r_f, option_type)
+    vega = calculate_vega(s, k, t, sigma, r_f)
+    rho = calculate_rho(s, k, t, sigma, r_f, option_type)
+
+    return pd.Series({'Delta': delta, 'Gamma': gamma, 'Theta': theta, 'Vega': vega, 'Rho': rho})
+
+
+def calculate_row_wise_greeks(row) -> pd.Series:
+    # print(f"Calculating {row['Ticker']} greeks...")
+    return get_greeks(ticker=row['Ticker'], ticker_info_df=row.to_frame().T, r_f=row['RiskFreeRate'], ua_historical_data=row['HistoricalData-UA'])
+
+
+def calculate_row_wise_bsm(row) -> pd.Series:
+    # print(f"Calculating {row['Ticker']} price with Black, Scholes and Merton model...")
+    volatility, bsm_price = black_scholes_merton(ticker=row['Ticker'], ticker_info_df=row.to_frame().T,
+                                                 r_f=row['RiskFreeRate'], ua_historical_data=row['HistoricalData-UA'])
+    return pd.Series({'Volatility': volatility, 'BSMPrice': bsm_price})
+
+
+def ticker_info(ticker: str, j_date: bool = True) -> pd.DataFrame:
+    all_options_market_watch = download_market_watch(market='All', stack='Vertical', j_date=j_date)
+    if ticker in list(all_options_market_watch.loc[:, 'Ticker']):
+        ticker_info_df = all_options_market_watch[all_options_market_watch['Ticker'] == ticker].copy()
+        ticker_info_df.reset_index(inplace=True, drop=True)
+    else:
+        ticker_info_df = None
+        print(f'{ticker} not found.')
+    return ticker_info_df
+
+
+def calculate_volatility(ua_historical_data, window_size) -> float:
+    log_returns = np.log(ua_historical_data['ClosePrice'] / ua_historical_data['ClosePrice'].shift(1))
+    volatility = np.sqrt(window_size) * log_returns.std()
+    return volatility
+
+
+def calculate_black_scholes_merton(s, k, t, sigma, r_f, option_type) -> (float, float):
+    d1 = calculate_d1(s, k, t, r_f, sigma)
+    d2 = calculate_d2(s, k, t, r_f, sigma)
+
+    if option_type == 'Call':
+        price = s * norm.cdf(d1) - k * np.exp(-r_f * t) * norm.cdf(d2)
+    elif option_type == 'Put':
+        price = k * np.exp(-r_f * t) * norm.cdf(-d2) - s * norm.cdf(-d1)
+    else:
+        raise ValueError(f"Unknown option type '{option_type}'. Expected 'Call' or 'Put'.")
+    return price
+
+
+def black_scholes_merton(ticker: str, ticker_info_df: pd.DataFrame = None, volatility_window_size: int = None,
+                         r_f: float = None, minimum_required_history: int = 30, ua_historical_data: pd.DataFrame = None) -> (float, float):
+
+    if ticker_info_df is None:
+        ticker_info_df = ticker_info(ticker=ticker, j_date=True)
+
+    if ua_historical_data is None:
+        try:
+            _, ua_historical_data = download_historical_data(ticker)
+        except requests.exceptions.HTTPError:
+            print(f'Couldn\'t download historical data for: {ticker}')
+            return None, None
+
+        if ua_historical_data is None:
+            return None, None
+
+    if r_f is None:
+        r_f = get_risk_free_rate()
+
+    stock_days_available = len(ua_historical_data)
+    if stock_days_available < minimum_required_history:
+        print(
+            f"Not enough stock history for {ticker_info_df['Ticker-UA']} ({stock_days_available} days available, "
+            f"{minimum_required_history} days required).")
+        return None, None
+
+    days_to_maturity = ticker_info_df['DaysToMaturity'].values[0]
+    if days_to_maturity < 10:
+        print(f"Option {ticker} expires too soon ({days_to_maturity} days left). BSM model may not be reliable.")
+        return None, None
+
+    max_safe_window = min(stock_days_available, days_to_maturity)
+    if volatility_window_size is None:
+        volatility_window_size = min(30, max(5, max_safe_window // 2))  # dynamic choice
+    else:
+        volatility_window_size = min(volatility_window_size, max_safe_window)  # force safe
+
+    if volatility_window_size < 5:
+        print(
+            f"Volatility window too small ({volatility_window_size} days). Cannot calculate meaningful volatility for {ticker}.")
+        return None, None
+
+    sigma = calculate_volatility(ua_historical_data, volatility_window_size)
+    s = ticker_info_df['LastPrice-UA'].values[0]
+    k = ticker_info_df['StrikePrice'].values[0]
+    t = days_to_maturity / 365
+    option_type = ticker_info_df['Type'].values[0]
+
+    if sigma == 0 or t == 0:
+        print("Zero volatility or expired option. Returning price = 0.")
+        return 0, 0
+
+    price = calculate_black_scholes_merton(s, k, t, sigma, r_f, option_type)
+
+    return sigma, price
+
+
+def download_all_underlying_assets(all_options_market_watch: pd.DataFrame = None, market: str = 'All') -> pd.DataFrame:
+    if all_options_market_watch is None:
+        all_options_market_watch = download_market_watch(market=market, stack='Horizontal', j_date=True)
+    all_underlying_assets = all_options_market_watch.loc[:, [column for column in all_options_market_watch.columns if column.endswith('-UA')]]
+    all_underlying_assets.drop_duplicates(inplace=True)
+    all_underlying_assets.reset_index(inplace=True, drop=True)
+    all_underlying_assets.columns = [column.replace('-UA', '') for column in all_underlying_assets.columns]
+    return all_underlying_assets
+
+
+def download_ua_historical_data(ticker: str, start_date: str = None, end_date: str = None) -> pd.DataFrame:
+    all_options_market_watch = download_market_watch(market='All', stack='Vertical', j_date=False)
+
+    # underlying asset
+    ticker_data = all_options_market_watch[all_options_market_watch['Ticker-UA'] == ticker]
+    ticker_instrument_code = ticker_data['InstrumentCode-UA'].values[0]
+    ticker_historical_data_url = f'https://cdn.tsetmc.com/api/ClosingPrice/GetClosingPriceDailyList/{ticker_instrument_code}/0'
+
+    response = requests.get(ticker_historical_data_url)
+    response.raise_for_status()
+
+    data = response.json()
+    ticker_historical_data = pd.json_normalize(data["closingPriceDaily"])
+
+    if ticker_historical_data.empty:
+        print(f'Couldn\'t download historical data for ticker: {ticker}')
+        return None
+
+    ticker_historical_data.columns = ['PriceChange', 'MinPrice', 'MaxPrice', 'YesterdayPrice', 'FirstPrice', 'Last', 'ID',
+                                      'InstrumentCode', 'Date', 'H', 'ClosePrice', 'I', 'Y', 'LastPrice', 'Quantity', 'Volume', 'Value']
+    ticker_historical_data = ticker_historical_data.loc[:, ['Date', 'Quantity', 'Volume', 'Value', 'MinPrice', 'MaxPrice',
+                                                            'FirstPrice', 'LastPrice', 'ClosePrice']]
+    ticker_historical_data['Date'] =  pd.to_datetime(ticker_historical_data['Date'].astype(str), format='%Y%m%d')
+    ticker_historical_data['Date'] = ticker_historical_data['Date'].dt.date
+    ticker_historical_data['Date'] = \
+        ticker_historical_data['Date'].apply(lambda g_date: jd.date.fromgregorian(year=g_date.year, month=g_date.month, day=g_date.day))
+
+    if start_date is not None and end_date is not None:
+        start_date_year, start_date_month, start_date_day = [int(date) for date in start_date.split('-')]
+        start_date = jd.date(start_date_year, start_date_month, start_date_day)
+
+        end_date_year, end_date_month, end_date_day = [int(date) for date in end_date.split('-')]
+        end_date = jd.date(end_date_year, end_date_month, end_date_day)
+
+        ticker_historical_data = ticker_historical_data[(ticker_historical_data['Date'] >= start_date) & (ticker_historical_data['Date'] <= end_date)]
+    ticker_historical_data.reset_index(inplace=True, drop=True)
+
+    return ticker_historical_data
+
+
+def download_historical_data(ticker: str, start_date: str = None, end_date: str = None) -> (pd.DataFrame, pd.DataFrame):
+
+    all_options_market_watch = download_market_watch(market='All', stack='Vertical', j_date=False)
+
+    # option
+    ticker_data = all_options_market_watch[all_options_market_watch['Ticker'] == ticker]
+    ticker_instrument_code = ticker_data['InstrumentCode'].values[0]
+    ticker_historical_data_url = f'https://cdn.tsetmc.com/api/ClosingPrice/GetClosingPriceDailyList/{ticker_instrument_code}/0'
+
+    response = requests.get(ticker_historical_data_url)
+    response.raise_for_status()
+
+    data = response.json()
+    ticker_historical_data = pd.json_normalize(data["closingPriceDaily"])
+
+    if ticker_historical_data.empty:
+        print(f'Couldn\'t download historical data for ticker: {ticker}')
+        return None, None
+
+    ticker_historical_data.columns = ['PriceChange', 'MinPrice', 'MaxPrice', 'YesterdayPrice', 'FirstPrice', 'Last', 'ID',
+                                      'InstrumentCode', 'Date', 'H', 'ClosePrice', 'I', 'Y', 'LastPrice', 'Quantity', 'Volume', 'Value']
+    ticker_historical_data = ticker_historical_data.loc[:, ['Date', 'Quantity', 'Volume', 'Value', 'MinPrice', 'MaxPrice',
+                                                            'FirstPrice', 'LastPrice', 'ClosePrice']]
+    ticker_historical_data['Date'] =  pd.to_datetime(ticker_historical_data['Date'].astype(str), format='%Y%m%d')
+    ticker_historical_data['Date'] = ticker_historical_data['Date'].dt.date
+    ticker_historical_data['Date'] = \
+        ticker_historical_data['Date'].apply(lambda g_date: jd.date.fromgregorian(year=g_date.year, month=g_date.month, day=g_date.day))
+
+    # underlying asset
+    ua_instrument_code = ticker_data['InstrumentCode-UA'].values[0]
+    ua_ticker_historical_data_url = f'https://cdn.tsetmc.com/api/ClosingPrice/GetClosingPriceDailyList/{ua_instrument_code}/0'
+
+    response = requests.get(ua_ticker_historical_data_url)
+    response.raise_for_status()
+
+    data = response.json()
+    ua_ticker_historical_data = pd.json_normalize(data["closingPriceDaily"])
+
+    if ua_ticker_historical_data.empty:
+        print(f'Couldn\'t download historical data for ticker: {ticker}')
+        return None, None
+
+    ua_ticker_historical_data.columns = ['PriceChange', 'MinPrice', 'MaxPrice', 'YesterdayPrice', 'FirstPrice', 'Last', 'ID',
+                                      'InstrumentCode', 'Date', 'H', 'ClosePrice', 'I', 'Y', 'LastPrice', 'Quantity', 'Volume', 'Value']
+    ua_ticker_historical_data = ua_ticker_historical_data.loc[:, ['Date', 'Quantity', 'Volume', 'Value', 'MinPrice', 'MaxPrice',
+                                                            'FirstPrice', 'LastPrice', 'ClosePrice']]
+    ua_ticker_historical_data['Date'] =  pd.to_datetime(ua_ticker_historical_data['Date'].astype(str), format='%Y%m%d')
+    ua_ticker_historical_data['Date'] = ua_ticker_historical_data['Date'].dt.date
+    ua_ticker_historical_data['Date'] = \
+        ua_ticker_historical_data['Date'].apply(lambda g_date: jd.date.fromgregorian(year=g_date.year, month=g_date.month, day=g_date.day))
+
+    if start_date is not None and end_date is not None:
+        start_date_year, start_date_month, start_date_day = [int(date) for date in start_date.split('-')]
+        start_date = jd.date(start_date_year, start_date_month, start_date_day)
+
+        end_date_year, end_date_month, end_date_day = [int(date) for date in end_date.split('-')]
+        end_date = jd.date(end_date_year, end_date_month, end_date_day)
+
+        ticker_historical_data = ticker_historical_data[(ticker_historical_data['Date'] >= start_date) & (ticker_historical_data['Date'] <= end_date)]
+        ua_ticker_historical_data = ua_ticker_historical_data[(ua_ticker_historical_data['Date'] >= start_date) & (ua_ticker_historical_data['Date'] <= end_date)]
+
+    ticker_historical_data.reset_index(inplace=True, drop=True)
+    ua_ticker_historical_data.reset_index(inplace=True, drop=True)
+
+    return ticker_historical_data, ua_ticker_historical_data
+
+
+def download_chain_contracts(underlying_ticker: str, j_date: str = True, bsm: bool = True, greeks: bool = False,
+                             implied_volatility: bool = False) -> pd.DataFrame:
+    try:
+        url = "https://cdn.tsetmc.com/api/Instrument/GetInstrumentOptionMarketWatch/0"
+        response = requests.get(url)
+        response.raise_for_status()
+
+        data = response.json()
+        all_options_market_watch = pd.json_normalize(data["instrumentOptMarketWatch"])
+
+        all_options_market_watch.columns = ['InstrumentCode-P', 'InstrumentCode-C', 'ContractSize', 'InstrumentCode-UA',
+                                            'Ticker-P', 'Name-P', 'Volume-P', 'Quantity-P', 'Value-P', 'NotionalValue-P',
+                                            'ClosePrice-P', 'YesterdayPrice-P', 'OpenPositions-P', 'LastPrice-P',
+                                            'Ticker-UA', 'ClosePrice-UA', 'LastPrice-UA', 'YesterdayPrice-UA',
+                                            'BeginDate', 'EndDate', 'StrikePrice', 'DaysToMaturity', 'LastPrice-C', 'OpenPositions-C',
+                                            'ClosePrice-C', 'YesterdayPrice-C', 'NotionalValue-C', 'Value-C', 'Quantity-C',
+                                            'Volume-C', 'Name-C', 'Ticker-C', 'BidPrice-P', 'BidVolume-P', 'AskPrice-P',
+                                            'AskVolume-P', 'BidPrice-C', 'BidVolume-C', 'AskPrice-C', 'AskVolume-C',
+                                            'YesterdayOpenPositions-C', 'YesterdayOpenPositions-P']
+        chain_contracts = all_options_market_watch[all_options_market_watch['Ticker-UA'] == underlying_ticker].copy()
+
+        chain_contracts['URL-P'] = chain_contracts['InstrumentCode-P'].apply(lambda ins_code: f'https://tsetmc.ir/instInfo/{ins_code}')
+        chain_contracts['URL-C'] = chain_contracts['InstrumentCode-C'].apply(lambda ins_code: f'https://tsetmc.ir/instInfo/{ins_code}')
+        chain_contracts['URL-UA'] = chain_contracts['InstrumentCode-UA'].apply(lambda ins_code: f'https://tsetmc.ir/instInfo/{ins_code}')
+
+        chain_contracts['BeginDate'] =  pd.to_datetime(chain_contracts['BeginDate'].astype(str), format='%Y%m%d')
+        chain_contracts['BeginDate'] = chain_contracts['BeginDate'].dt.date
+        chain_contracts['EndDate'] =  pd.to_datetime(chain_contracts['EndDate'].astype(str), format='%Y%m%d')
+        chain_contracts['EndDate'] = chain_contracts['EndDate'].dt.date
+
+        if j_date:
+            chain_contracts['BeginDate'] = \
+                chain_contracts['BeginDate'].apply(lambda g_date: jd.date.fromgregorian(year=g_date.year, month=g_date.month, day=g_date.day))
+            chain_contracts['EndDate'] = \
+                chain_contracts['EndDate'].apply(lambda g_date: jd.date.fromgregorian(year=g_date.year, month=g_date.month, day=g_date.day))
+
+        conditions = [chain_contracts['LastPrice-UA'] > chain_contracts['StrikePrice'],
+                      chain_contracts['LastPrice-UA'] < chain_contracts['StrikePrice']]
+        choices = ['ITM', 'OTM']
+        default = 'ATM'
+        chain_contracts['Status-C'] = np.select(conditions, choices, default=default)
+
+        conditions = [chain_contracts['LastPrice-UA'] > chain_contracts['StrikePrice'],
+                      chain_contracts['LastPrice-UA'] < chain_contracts['StrikePrice']]
+        choices = ['OTM', 'ITM']
+        default = 'ATM'
+        chain_contracts['Status-P'] = np.select(conditions, choices, default=default)
+
+        call_chain_contracts_columns = ['Ticker-C', 'Name-C', 'InstrumentCode-C', 'Status-C', 'Volume-C', 'Quantity-C', 'Value-C',
+                                             'NotionalValue-C', 'OpenPositions-C', 'ClosePrice-C', 'LastPrice-C', 'YesterdayPrice-C',
+                                             'BidPrice-C', 'BidVolume-C', 'AskPrice-C', 'AskVolume-C', 'URL-C']
+        ua_chain_contracts_columns = ['ContractSize', 'StrikePrice', 'DaysToMaturity', 'BeginDate', 'EndDate',
+                                            'Ticker-UA', 'InstrumentCode-UA', 'ClosePrice-UA', 'LastPrice-UA',
+                                            'YesterdayPrice-UA', 'URL-UA']
+        put_chain_contracts_columns = ['Ticker-P', 'Name-P', 'InstrumentCode-P', 'Status-P', 'Volume-P', 'Quantity-P', 'Value-P',
+                                             'NotionalValue-P', 'OpenPositions-P', 'ClosePrice-P', 'LastPrice-P', 'YesterdayPrice-P',
+                                             'BidPrice-P', 'BidVolume-P', 'AskPrice-P', 'AskVolume-P', 'URL-P']
+
+
+        if bsm or greeks or implied_volatility:
+            uas_historical_data = {}
+            print(f'Downloading {underlying_ticker} historical data...')
+            ua_historical_data = download_ua_historical_data(ticker=underlying_ticker).loc[:, ['Date', 'ClosePrice']].copy()
+            print(f'Historical data downloaded for {underlying_ticker}.')
+
+            chain_contracts['HistoricalData-UA'] = None
+            for index, row in chain_contracts.iterrows():
+                chain_contracts.at[index, 'HistoricalData-UA'] = ua_historical_data.copy()
+            ua_chain_contracts_columns.append('HistoricalData-UA')
+
+            call_chain_contracts = chain_contracts.loc[:, call_chain_contracts_columns + ua_chain_contracts_columns].copy()
+            put_chain_contracts = chain_contracts.loc[:, put_chain_contracts_columns + ua_chain_contracts_columns].copy()
+            call_chain_contracts['Type'] = 'Call'
+            call_chain_contracts.columns = call_chain_contracts.columns.map(lambda column: column.replace('-C', ''))
+            call_chain_contracts_columns.append('Type')
+            put_chain_contracts['Type'] = 'Put'
+            put_chain_contracts.columns = put_chain_contracts.columns.map(lambda column: column.replace('-P', ''))
+            put_chain_contracts_columns.append('Type')
+
+            risk_free_rate = get_risk_free_rate()
+            call_chain_contracts['RiskFreeRate'] = risk_free_rate
+            put_chain_contracts['RiskFreeRate'] = risk_free_rate
+            ua_chain_contracts_columns.append('RiskFreeRate')
+
+            if bsm:
+                call_chain_contracts[['Volatility', 'BSMPrice']] = call_chain_contracts.apply(calculate_row_wise_bsm, axis=1)
+                call_chain_contracts_columns.append(['Volatility', 'BSMPrice'])
+                put_chain_contracts[['Volatility', 'BSMPrice']] = put_chain_contracts.apply(calculate_row_wise_bsm, axis=1)
+                put_chain_contracts_columns.append(['Volatility', 'BSMPrice'])
+
+            if greeks:
+                call_chain_contracts[['Delta', 'Gamma', 'Theta', 'Vega', 'Rho']] = call_chain_contracts.apply(calculate_row_wise_greeks, axis=1)
+                call_chain_contracts_columns.append(['Delta', 'Gamma', 'Theta', 'Vega', 'Rho'])
+                put_chain_contracts[['Delta', 'Gamma', 'Theta', 'Vega', 'Rho']] = put_chain_contracts.apply(calculate_row_wise_greeks, axis=1)
+                put_chain_contracts_columns.append(['Delta', 'Gamma', 'Theta', 'Vega', 'Rho'])
+
+            if implied_volatility:
+                call_chain_contracts['ImpliedVolatility'] = call_chain_contracts.apply(calculate_row_wise_implied_volatility, axis=1)
+                call_chain_contracts_columns.append(['ImpliedVolatility'])
+                put_chain_contracts['ImpliedVolatility'] = put_chain_contracts.apply(calculate_row_wise_implied_volatility, axis=1)
+                put_chain_contracts_columns.append(['ImpliedVolatility'])
+
+            call_chain_contracts.drop('HistoricalData-UA', inplace=True, axis=1)
+            put_chain_contracts.drop('HistoricalData-UA', inplace=True, axis=1)
+            ua_chain_contracts_columns.remove('HistoricalData-UA')
+
+            call_chain_contracts.columns = [f"{column}-C" for column in call_chain_contracts.columns]
+            put_chain_contracts.columns = [f"{column}-P" for column in put_chain_contracts.columns]
+            chain_contracts = pd.merge(call_chain_contracts, put_chain_contracts,
+                                                left_index=True, right_index=True, how='inner')
+            chain_contracts.drop([f"{column}-P" for column in ua_chain_contracts_columns], axis=1, inplace=True)
+            chain_contracts.columns = [column.replace('-C', '')
+                                                if column[:-2] in ua_chain_contracts_columns else column for column in chain_contracts.columns]
+            chain_contracts.drop(['Type-C', 'Type-P'], axis=1, inplace=True)
+        else:
+            chain_contracts = chain_contracts.loc[:, call_chain_contracts_columns + ua_chain_contracts_columns + put_chain_contracts_columns]
+
+        chain_contracts.reset_index(inplace=True, drop=True)
+        chain_contracts.sort_values(by=['EndDate', 'StrikePrice'], inplace=True, ignore_index=True)
+        return chain_contracts
+    except Exception as e:
+        print(f"Failed to get the market watch with the error:\n {e}")
+        return None
+
+
+def download_market_watch(market: str = 'All', stack: str = 'Horizontal', j_date: bool = True,
+                          bsm: str = False, greeks: bool = False, implied_volatility: bool = False) -> pd.DataFrame:
+
+    if market == 'TSE':
+        url = "https://cdn.tsetmc.com/api/Instrument/GetInstrumentOptionMarketWatch/1"
+    elif market == 'IFB':
+        url = "https://cdn.tsetmc.com/api/Instrument/GetInstrumentOptionMarketWatch/2"
+    else:       # 'All'
+        url = "https://cdn.tsetmc.com/api/Instrument/GetInstrumentOptionMarketWatch/0"
+
+    try:
+        response = requests.get(url)
+        response.raise_for_status()
+
+        data = response.json()
+        all_options_market_watch = pd.json_normalize(data["instrumentOptMarketWatch"])
+
+        all_options_market_watch.columns = ['InstrumentCode-P', 'InstrumentCode-C', 'ContractSize', 'InstrumentCode-UA',
+                                            'Ticker-P', 'Name-P', 'Volume-P', 'Quantity-P', 'Value-P', 'NotionalValue-P',
+                                            'ClosePrice-P', 'YesterdayPrice-P', 'OpenPositions-P', 'LastPrice-P',
+                                            'Ticker-UA', 'ClosePrice-UA', 'LastPrice-UA', 'YesterdayPrice-UA',
+                                            'BeginDate', 'EndDate', 'StrikePrice', 'DaysToMaturity', 'LastPrice-C', 'OpenPositions-C',
+                                            'ClosePrice-C', 'YesterdayPrice-C', 'NotionalValue-C', 'Value-C', 'Quantity-C',
+                                            'Volume-C', 'Name-C', 'Ticker-C', 'BidPrice-P', 'BidVolume-P', 'AskPrice-P',
+                                            'AskVolume-P', 'BidPrice-C', 'BidVolume-C', 'AskPrice-C', 'AskVolume-C',
+                                            'YesterdayOpenPositions-C', 'YesterdayOpenPositions-P']
+        all_options_market_watch['URL-P'] = all_options_market_watch['InstrumentCode-P'].apply(lambda ins_code: f'https://tsetmc.ir/instInfo/{ins_code}')
+        all_options_market_watch['URL-C'] = all_options_market_watch['InstrumentCode-C'].apply(lambda ins_code: f'https://tsetmc.ir/instInfo/{ins_code}')
+        all_options_market_watch['URL-UA'] = all_options_market_watch['InstrumentCode-UA'].apply(lambda ins_code: f'https://tsetmc.ir/instInfo/{ins_code}')
+
+        all_options_market_watch['BeginDate'] =  pd.to_datetime(all_options_market_watch['BeginDate'].astype(str), format='%Y%m%d')
+        all_options_market_watch['BeginDate'] = all_options_market_watch['BeginDate'].dt.date
+        all_options_market_watch['EndDate'] =  pd.to_datetime(all_options_market_watch['EndDate'].astype(str), format='%Y%m%d')
+        all_options_market_watch['EndDate'] = all_options_market_watch['EndDate'].dt.date
+
+        if j_date:
+            all_options_market_watch['BeginDate'] = \
+                all_options_market_watch['BeginDate'].apply(lambda g_date: jd.date.fromgregorian(year=g_date.year, month=g_date.month, day=g_date.day))
+            all_options_market_watch['EndDate'] = \
+                all_options_market_watch['EndDate'].apply(lambda g_date: jd.date.fromgregorian(year=g_date.year, month=g_date.month, day=g_date.day))
+
+        conditions = [all_options_market_watch['LastPrice-UA'] > all_options_market_watch['StrikePrice'],
+                      all_options_market_watch['LastPrice-UA'] < all_options_market_watch['StrikePrice']]
+        choices = ['ITM', 'OTM']
+        default = 'ATM'
+        all_options_market_watch['Status-C'] = np.select(conditions, choices, default=default)
+
+        conditions = [all_options_market_watch['LastPrice-UA'] > all_options_market_watch['StrikePrice'],
+                      all_options_market_watch['LastPrice-UA'] < all_options_market_watch['StrikePrice']]
+        choices = ['OTM', 'ITM']
+        default = 'ATM'
+        all_options_market_watch['Status-P'] = np.select(conditions, choices, default=default)
+
+        call_options_market_watch_columns = ['Ticker-C', 'Name-C', 'InstrumentCode-C', 'Status-C', 'Volume-C', 'Quantity-C', 'Value-C',
+                                             'NotionalValue-C', 'OpenPositions-C', 'ClosePrice-C', 'LastPrice-C', 'YesterdayPrice-C',
+                                             'BidPrice-C', 'BidVolume-C', 'AskPrice-C', 'AskVolume-C', 'URL-C']
+        ua_market_watch_columns = ['ContractSize', 'StrikePrice', 'DaysToMaturity', 'BeginDate', 'EndDate',
+                                            'Ticker-UA', 'InstrumentCode-UA', 'ClosePrice-UA', 'LastPrice-UA',
+                                            'YesterdayPrice-UA', 'URL-UA']
+        put_options_market_watch_columns = ['Ticker-P', 'Name-P', 'InstrumentCode-P', 'Status-P', 'Volume-P', 'Quantity-P', 'Value-P',
+                                             'NotionalValue-P', 'OpenPositions-P', 'ClosePrice-P', 'LastPrice-P', 'YesterdayPrice-P',
+                                             'BidPrice-P', 'BidVolume-P', 'AskPrice-P', 'AskVolume-P', 'URL-P']
+
+
+        if bsm or greeks or implied_volatility:
+            uas_historical_data = {}
+            all_uas = download_all_underlying_assets(all_options_market_watch.copy(), market=market)
+            print('Starting to download historical data for all tickers...')
+            for ua in all_uas['Ticker']:
+                print(f'Downloading {ua} historical data...')
+                uas_historical_data[ua] = download_ua_historical_data(ticker=ua).loc[:, ['Date', 'ClosePrice']].copy()
+            print('Historical data downloaded for all underlying assets.')
+
+            all_options_market_watch['HistoricalData-UA'] = None
+            for index, row in all_options_market_watch.iterrows():
+                all_options_market_watch.at[index, 'HistoricalData-UA'] = uas_historical_data[row['Ticker-UA']].copy()
+            ua_market_watch_columns.append('HistoricalData-UA')
+
+            call_options_market_watch = all_options_market_watch.loc[:, call_options_market_watch_columns + ua_market_watch_columns].copy()
+            put_options_market_watch = all_options_market_watch.loc[:, put_options_market_watch_columns + ua_market_watch_columns].copy()
+            call_options_market_watch['Type'] = 'Call'
+            call_options_market_watch.columns = call_options_market_watch.columns.map(lambda column: column.replace('-C', ''))
+            call_options_market_watch_columns.append('Type')
+            put_options_market_watch['Type'] = 'Put'
+            put_options_market_watch.columns = put_options_market_watch.columns.map(lambda column: column.replace('-P', ''))
+            put_options_market_watch_columns.append('Type')
+
+            risk_free_rate = get_risk_free_rate()
+            call_options_market_watch['RiskFreeRate'] = risk_free_rate
+            put_options_market_watch['RiskFreeRate'] = risk_free_rate
+            ua_market_watch_columns.append('RiskFreeRate')
+
+            if bsm:
+                call_options_market_watch[['Volatility', 'BSMPrice']] = call_options_market_watch.apply(calculate_row_wise_bsm, axis=1)
+                call_options_market_watch_columns.append(['Volatility', 'BSMPrice'])
+                put_options_market_watch[['Volatility', 'BSMPrice']] = put_options_market_watch.apply(calculate_row_wise_bsm, axis=1)
+                put_options_market_watch_columns.append(['Volatility', 'BSMPrice'])
+
+            if greeks:
+                call_options_market_watch[['Delta', 'Gamma', 'Theta', 'Vega', 'Rho']] = call_options_market_watch.apply(calculate_row_wise_greeks, axis=1)
+                call_options_market_watch_columns.append(['Delta', 'Gamma', 'Theta', 'Vega', 'Rho'])
+                put_options_market_watch[['Delta', 'Gamma', 'Theta', 'Vega', 'Rho']] = put_options_market_watch.apply(calculate_row_wise_greeks, axis=1)
+                put_options_market_watch_columns.append(['Delta', 'Gamma', 'Theta', 'Vega', 'Rho'])
+
+            if implied_volatility:
+                call_options_market_watch['ImpliedVolatility'] = call_options_market_watch.apply(calculate_row_wise_implied_volatility, axis=1)
+                call_options_market_watch_columns.append(['ImpliedVolatility'])
+                put_options_market_watch['ImpliedVolatility'] = put_options_market_watch.apply(calculate_row_wise_implied_volatility, axis=1)
+                put_options_market_watch_columns.append(['ImpliedVolatility'])
+
+            call_options_market_watch.drop('HistoricalData-UA', inplace=True, axis=1)
+            put_options_market_watch.drop('HistoricalData-UA', inplace=True, axis=1)
+            ua_market_watch_columns.remove('HistoricalData-UA')
+
+            if stack == 'Vertical':
+                all_options_market_watch = pd.concat([call_options_market_watch, put_options_market_watch], axis=0, ignore_index=True)
+            else:   # 'Horizontal'
+                call_options_market_watch.columns = [f"{column}-C" for column in call_options_market_watch.columns]
+                put_options_market_watch.columns = [f"{column}-P" for column in put_options_market_watch.columns]
+                all_options_market_watch = pd.merge(call_options_market_watch, put_options_market_watch,
+                                                    left_index=True, right_index=True, how='inner')
+                all_options_market_watch.drop([f"{column}-P" for column in ua_market_watch_columns], axis=1, inplace=True)
+                all_options_market_watch.columns = [column.replace('-C', '')
+                                                    if column[:-2] in ua_market_watch_columns else column for column in all_options_market_watch.columns]
+                all_options_market_watch.drop(['Type-C', 'Type-P'], axis=1, inplace=True)
+        else:
+            if stack == 'Vertical':
+                call_options_market_watch = all_options_market_watch.loc[:, call_options_market_watch_columns + ua_market_watch_columns].copy()
+                put_options_market_watch = all_options_market_watch.loc[:, put_options_market_watch_columns + ua_market_watch_columns].copy()
+                call_options_market_watch['Type'] = 'Call'
+                call_options_market_watch.columns = call_options_market_watch.columns.map(lambda column: column.replace('-C', ''))
+                call_options_market_watch_columns.append('Type')
+                put_options_market_watch['Type'] = 'Put'
+                put_options_market_watch.columns = put_options_market_watch.columns.map(lambda column: column.replace('-P', ''))
+                put_options_market_watch_columns.append('Type')
+                all_options_market_watch = pd.concat([call_options_market_watch, put_options_market_watch], axis=0, ignore_index=True)
+            else:   # Horizontal
+                all_options_market_watch = all_options_market_watch.loc[:, call_options_market_watch_columns + ua_market_watch_columns + put_options_market_watch_columns]
+
+        all_options_market_watch.reset_index(inplace=True, drop=True)
+        all_options_market_watch.sort_values(by=['Ticker-UA', 'EndDate', 'StrikePrice'], inplace=True, ignore_index=True)
+        return all_options_market_watch
+
+    except Exception as e:
+        print(f"Failed to get the market watch with the error:\n {e}")
+        return None

fima/__init__.py

@@ -0,0 +1,9 @@
+from .Options import (download_chain_contracts, get_greeks, get_implied_volatility, black_scholes_merton,
+                      download_market_watch, download_all_underlying_assets, download_historical_data, ticker_info,
+                      calculate_delta, calculate_vega, calculate_theta, calculate_gamma, calculate_rho, calculate_d1,
+                      calculate_d2, calculate_black_scholes_merton, download_ua_historical_data, calculate_volatility)
+from .Bonds import get_risk_free_rate, get_all_bonds_without_coupons, get_all_bonds_with_coupons
+
+
+# __all__ = ["download_chain_contracts", "download_market_watch", "download_historical_data", "get_greeks",
+#            "get_implied_volatility", "black_scholes_merton", "get_risk_free_rate", "get_all_bonds_without_coupons", "get_all_bonds_with_coupons"]

fima-0.1.0.dist-info/METADATA

@@ -0,0 +1,270 @@
+Metadata-Version: 2.4
+Name: fima
+Version: 0.1.0
+Summary: fima – A Python package for scraping and analyzing Iran’s financial market data. It currently supports bonds and options, with tools for calculating BSM prices, greeks, and implied volatility. Future versions will expand to include other instruments such as commodities and more.
+Home-page: https://github.com/hemoboghosian/fima
+Author: Hemo Boghosian
+Author-email: Hemo Boghosian <HemoBoghosian@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/hemoboghosian/fima
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pandas
+Requires-Dist: requests
+Requires-Dist: jdatetime
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: bs4
+Requires-Dist: selenium
+Requires-Dist: mibian
+Requires-Dist: lxml
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# fima
+## معرفی و هدف
+
+
+این کتابخانه جهت دسترسی آسان و سریع به داده‌های بازارهای مالی ایران با زبان برنامه‌نویسی پایتون پیاده‌سازی شده است. هدف نهایی این پروژه، ساخت کتابخانه‌ای جامع جهت استخراج، ساختاردهی و تحلیل داده‌های مالی از منابع مختلف موجود است.
+**این کتابخانه هنوز در حال توسعه و تکامل است و ممکن است در برخی قسمت‌ها اشتباهاتی داشته باشد. لطفاً اگر خطا یا نقصی دیدید اطلاع دهید.**
+
+## اطلاعات تماس
+* ایمیل: HemoBoghosian@gmail.com
+* تلگرام: @HemoBoghosian
+
+## نصب کتابخانه
+```
+pip install fima
+```
+
+## توابع مربوط به اختیارهای معامله
+### فراخوانی تمام توابع
+
+```python
+from fima.Options import *
+```
+
+### دریافت سابقه قیمت اختیار معامله و دارایی پایه آن
+
+```python
+from fima.Options import download_historical_data
+
+option_historical_data, ua_historical_data = download_historical_data(ticker='ضهرم4018', start_date='1404-01-01',
+                                                                      end_date='1404-01-31')
+```
+#### ورودی
+* ticker: نماد اختیار معامله
+* start_date: تاریخ شروع داده‌ها
+* end_date: تاریخ پایان داده‌ها
+
+#### خروجی
+* option_historical_data: سابقه قیمت اختیار معامله
+* ua_historical_data: سابقه قیمت دارایی پایه نماد وارد شده
+
+##### توجه: در صورت وارد نکردن تاریخ شروع و پایان، خروجی تابع تمام سابقه قیمت اختیار معامله و دارایی پایه آن خواهد بود.
+
+### دریافت اطلاعات لحظه‌ای یک نماد اختیار معامله
+
+```python
+from fima.Options import ticker_info
+
+ticker_info_data = ticker_info(ticker='ضهرم4018', j_date=True)
+```
+
+#### ورود
+* ticker: نماد اختیار معامله مد نظرم
+* j_date: تاریخ شمسی
+
+#### خروجی
+* ticker_info_data: اطلاعات لحظه‌ای مربوط به نماد مد نظر
+
+### دریافت زنجیره قراردادهای یک دارایی پایه
+
+```python
+from fima.Options import download_chain_contracts
+
+chain_contracts = download_chain_contracts(underlying_ticker='اهرم', j_date=True, bsm=False, greeks=False,
+                                           implied_volatility=False)
+```
+#### ورودی
+* underlying_ticker: نماد دارایی پایه
+* j_date: تاریخ شمسی
+* bsm: محاسبه ارزش اختیار معامله با مدل بلک، شولز و مرتون 
+* greeks: محاسبه دلتا، تتا، گاما، رو و وگا
+* implied_volatility: محاسبه نوسانات ضمنی
+
+#### خروجی
+* chain_contracts: اطلاعات تمامی زنجیره قراردادهای مربوط به دارایی پایه مد نظر
+
+##### توجه: برای محاسبات مربوط به مدل بلک، شولز و مرتون از میانگین نرخ بازده تا سررسید اسناد خزانه در آخرین تاریخ (دریافت‌شده از سایت فرابورس ایران) به عنوان نرخ بازده بدون ریسک استفاده می‌شود.
+
+### دریافت دیده‌بان بازار
+
+```python
+from fima.Options import download_market_watch
+
+market_watch = download_market_watch(market='All', stack='Vertical', j_date=True, bsm=False, greeks=False,
+                                     implied_volatility=False)
+```
+#### ورودی
+* market: بازار معامله اختیار معامله
+  * 'TSE': بورس اوراق بهادار تهران
+  * 'IFB': فرابورس ایران
+  * 'All': تمامی اختیارهای معامله
+* stack: نحوه چینش داده‌ها
+  * 'Vertical': چینش عمودی داده‌ها
+  * 'Horizontal': چینش افقی داده‌ها
+* j_date: تاریخ شمسی
+* bsm: محاسبه ارزش اختیار معامله با مدل بلک، شولز و مرتون 
+* greeks: محاسبه دلتا، تتا، گاما، رو و وگا
+* implied_volatility: محاسبه نوسانات ضمنی
+
+#### خروجی
+* market_watch: اطلاعات تمامی اختیارهای معامله بازار مد نظر
+
+##### توجه: برای محاسبات مربوط به مدل بلک، شولز و مرتون از میانگین نرخ بازده تا سررسید اسناد خزانه در آخرین تاریخ (دریافت‌شده از سایت فرابورس ایران) به عنوان نرخ بازده بدون ریسک استفاده می‌شود.
+
+### دریافت ارزش محاسبه‌شده توسط مدل بلک، شولز و مرتون برای یک نماد
+
+```python
+from fima.Options import black_scholes_merton
+
+volatility, bsm_price = black_scholes_merton(ticker='ضهرم4018')
+```
+#### ورودی
+* ticker: نماد اختیار معامله مد نظر
+
+#### خروجی
+* volatility: نوسانات دارایی پایه محاسبه‌شده در مدل
+* bsm_price: ارزش محاسبه‌شده اختیار معامله مد نظر با مدل بلک، شولز و مرتون
+
+##### توجه
+* توجه: در صورت عدم وارد کردن متغیر مربوط به نرخ بازده بدون ریسک، برای محاسبات مربوط به مدل بلک، شولز و مرتون از میانگین نرخ بازده تا سررسید اسناد خزانه در آخرین تاریخ (دریافت‌شده از سایت فرابورس ایران) به عنوان نرخ بازده بدون ریسک استفاده می‌شود.
+* در صورتی که روزهای باقی‌مانده تا سررسید اختیار معامله کمتر از ۱۰ روز باشند، به دلیل احتمال خطا، مدل بلک، شولز و مرتون اعمال نخواهد شد.
+
+### دریافت گریکز برای یک نماد
+
+```python
+from fima.Options import get_greeks
+
+ticker_greeks = get_greeks(ticker='ضهرم4018')
+```
+#### ورودی
+* ticker: نماد اختیار معامله مد نظر
+* r_f: نرخ بازده بدون ریسک
+* minimum_required_history: کمینه دیتای مورد نیاز برای دارایی پایهجهت محاسبه نوسانات که به صورت پیش‌فرض ۳۰ روز در نظر گرفته شده است.
+
+#### خروجی
+* ticker_greeks: دلتا، تتا، گاما، وگا و رو برای نماد مد نظر 
+
+##### توجه 
+* در صورت عدم وارد کردن متغیر مربوط به نرخ بازده بدون ریسک، برای محاسبات مربوط به مدل بلک، شولز و مرتون از میانگین نرخ بازده تا سررسید اسناد خزانه در آخرین تاریخ (دریافت‌شده از سایت فرابورس ایران) به عنوان نرخ بازده بدون ریسک استفاده می‌شود.
+* در صورتی که روزهای باقی‌مانده تا سررسید اختیار معامله کمتر از ۱۰ روز باشند، به دلیل احتمال خطا، مدل بلک، شولز و مرتون اعمال نخواهد شد.
+
+### دریافت نوسانات ضمنی برای یک نماد
+
+```python
+from fima.Options import get_implied_volatility
+
+ticker_implied_volatility = get_implied_volatility(ticker='ضهرم4018')
+```
+#### ورودی
+* ticker: نماد اختیار معامله مد نظر
+* r_f: نرخ بازده بدون ریسک
+* minimum_required_history: کمینه دیتای مورد نیاز برای دارایی پایهجهت محاسبه نوسانات که به صورت پیش‌فرض ۳۰ روز در نظر گرفته شده است.
+
+#### خروجی
+* ticker_implied_volatility: نوسانات ضمنی برای نماد مد نظر 
+
+##### توجه 
+* در صورت عدم وارد کردن متغیر مربوط به نرخ بازده بدون ریسک، برای محاسبات مربوط به مدل بلک، شولز و مرتون از میانگین نرخ بازده تا سررسید اسناد خزانه در آخرین تاریخ (دریافت‌شده از سایت فرابورس ایران) به عنوان نرخ بازده بدون ریسک استفاده می‌شود.
+* در صورتی که روزهای باقی‌مانده تا سررسید اختیار معامله کمتر از ۱۰ روز باشند، به دلیل احتمال خطا، مدل بلک، شولز و مرتون اعمال نخواهد شد.
+
+### دریافت تمامی نمادهای دارای اختیار معامله
+
+```python
+from fima.Options import download_all_underlying_assets
+
+all_underlying_assets = download_all_underlying_assets(market='All')
+```
+#### ورودی
+* market: بازار معامله اختیار معامله
+  * 'TSE': بورس اوراق بهادار تهران
+  * 'IFB': فرابورس ایران
+  * 'All': تمامی اختیارهای معامله (حالت پیش‌فرض)
+
+#### خروجی
+* all_underlying_assets: اطلاعات مربوط به نمادهای دارای اختیار معامله
+
+#### توجه: در صورت عدم وارد کردن market، تمامی اختیارهای معامله دریافت خواهد شد. 
+
+### توابع مربوط به محاسبات
+
+```python
+from fima.Options import (calculate_black_scholes_merton, calculate_delta, calculate_vega,
+                          calculate_theta, calculate_gamma, calculate_rho)
+
+bsm_price = calculate_black_scholes_merton(s=550, k=28000, option_type='Call', t=71, sigma=0.9588, r_f=0.3372)
+delta = calculate_delta(s=550, k=28000, option_type='Call', t=71, sigma=0.9588, r_f=0.3372)
+theta = calculate_theta(s=550, k=28000, option_type='Call', t=71, sigma=0.9588, r_f=0.3372)
+gamma = calculate_gamma(s=550, k=28000, t=71, sigma=0.9588, r_f=0.3372)
+rho = calculate_rho(s=550, k=28000, option_type='Call', t=71, sigma=0.9588, r_f=0.3372)
+vega = calculate_vega(s=550, k=28000, t=71, sigma=0.9588, r_f=0.3372)
+```
+
+## توابع مربوط به اوراق درآمد ثابت
+### فراخوانی تمام توابع
+
+```python
+from fima.Bonds import *
+```
+
+### دریافت سابقه قیمت اختیار معامله و دارایی پایه آن
+
+```python
+from fima.Bonds import get_risk_free_rate
+
+risk_free_rate = get_risk_free_rate()
+```
+
+#### خروجی
+* risk_free_rate: میانگین نرخ بازده تا سررسید اسناد خزانه در آخرین تاریخ (دریافت‌شده از سایت فرابورس ایران)
+
+### دریافت اوراق درآمد ثابت بدون کوپن
+
+```python
+from fima.Bonds import get_all_bonds_without_coupons
+
+all_bonds_without_coupons = get_all_bonds_without_coupons(deprecated=True)
+```
+
+#### ورودی
+* deprecated:
+  * True: اوراق سررسید شده نیز در خروجی بیاید
+  * False: اوراق سررسید شده در خروجی نیاید
+#### خروجی
+* all_bonds_without_coupons: اطلاعات مربوط به اوراق درآمد ثابت بدون کوپن (دریاقت‌شده از سایت فرابورس ایران)
+
+### دریافت اوراق درآمد ثابت با کوپن
+
+```python
+from fima.Bonds import get_all_bonds_with_coupons
+
+all_bonds_with_coupons = get_all_bonds_with_coupons(deprecated=True)
+```
+
+#### ورودی
+* deprecated:
+  * True: اوراق سررسید شده نیز در خروجی بیاید
+  * False: اوراق سررسید شده در خروجی نیاید
+#### خروجی
+* all_bonds_without_coupons: اطلاعات مربوط به اوراق درآمد ثابت با کوپن (دریاقت‌شده از سایت فرابورس ایران)
+
+## نقشه راه
+1. [ ] عیب‌یابی و بهبود توابع پیاده‌سازی‌شده
+2. [ ] دریافت اطلاعات از سایت tgju
+3. [ ] دریافت اطلاعات از سایت tsetmc
+4. [ ] دریافت و پاکسازی اطلاعات سایت codal

fima-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+fima/Bonds.py,sha256=u12dNTrPPUPc3cnZ1aERbWhltVry7YrxFeUq8iEC0RE,4580
+fima/Options.py,sha256=CUOulN8OcErTwE4Gyfid6Xct-AsyIQvmeCo_sMlY4og,39999
+fima/__init__.py,sha256=pjSRFxliqrZRva4pjqzMybxZb_3xN4oPcKJWgtt94uc,823
+fima-0.1.0.dist-info/licenses/LICENSE,sha256=l6425dmjnidzk4JQwhT01C8SpICmjSBMNREAdPnPA9E,1087
+test/TestBonds.py,sha256=gO3tUgiOJsEzX5uD1UsKLQze4Zl8_isT6BlbcQuGeAY,1217
+test/TestOptions.py,sha256=nRVR65dsOO7DZfKXWk30jtAn0_aVHzLYVx7e95F5Mbw,8523
+test/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fima-0.1.0.dist-info/METADATA,sha256=-ZmCg0dsRUXzNSql_CO1KPnDmNexg_4Tsy-SmbSeUYo,13351
+fima-0.1.0.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
+fima-0.1.0.dist-info/top_level.txt,sha256=3iVjx26xETazVXH-Vc_8TGy95qyk4BX05vce6KpYP_E,10
+fima-0.1.0.dist-info/RECORD,,

fima-0.1.0.dist-info/WHEEL

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

fima-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Your Name
+
+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.

fima-0.1.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+fima
+test

test/TestBonds.py

@@ -0,0 +1,26 @@
+import pytest
+from fima.Bonds import get_risk_free_rate, get_all_bonds_without_coupons, get_all_bonds_with_coupons
+
+
+def test_get_risk_free_rate_range():
+    risk_free_rate = get_risk_free_rate()
+    assert isinstance(risk_free_rate, float)
+    assert 0.25 <= risk_free_rate <= 0.5  # Typical YTM for Iranian T-bills
+
+
+@pytest.mark.parametrize("deprecated", [True, False])
+def test_get_all_bonds_without_coupons(deprecated):
+    all_bonds_without_coupons = get_all_bonds_without_coupons(deprecated=deprecated)
+    assert all_bonds_without_coupons is not None
+    assert not all_bonds_without_coupons.empty
+    for column in ['Ticker', 'LastTradedPrice', 'LastTradedDate', 'MaturityDate', 'YTM', 'SimpleReturn']:
+        assert column in all_bonds_without_coupons.columns
+
+
+@pytest.mark.parametrize("deprecated", [True, False])
+def test_get_all_bonds_with_coupons(deprecated):
+    all_bonds_with_coupons = get_all_bonds_with_coupons(deprecated=deprecated)
+    assert all_bonds_with_coupons is not None
+    assert not all_bonds_with_coupons.empty
+    for column in ['Ticker', 'LastTradedPrice', 'LastTradedDate', 'MaturityDate', 'YTM']:
+        assert column in all_bonds_with_coupons.columns

test/TestOptions.py

@@ -0,0 +1,123 @@
+import pandas as pd
+import pytest
+from fima.Options import (get_greeks, get_implied_volatility, black_scholes_merton, download_chain_contracts,
+                          download_market_watch, download_all_underlying_assets, download_historical_data)
+
+
+@pytest.mark.parametrize("market", ["All", "IFB", "TSE"])
+def test_download_all_underlying_assets(market):
+    all_underlying_assets = download_all_underlying_assets(market=market)
+    assert all_underlying_assets is not None
+    assert not all_underlying_assets.empty
+    assert isinstance(all_underlying_assets, pd.DataFrame)
+    for column in ['Ticker', 'InstrumentCode', 'ClosePrice', 'LastPrice', 'YesterdayPrice', 'URL']:
+        assert column in all_underlying_assets
+
+
+@pytest.mark.parametrize(["ticker", "start_date", "end_date"], [("ضهرم4018", '1404-02-01', '1404-02-31'),
+                                                                ("طهرم4018", '1404-02-01', '1404-02-31'),
+                                                                ("ضهرم4018", None, None),
+                                                                ("طهرم4018", None, None)])
+def test_download_historical_data(ticker, start_date, end_date):
+    option_historical_data, ua_historical_data = download_historical_data(ticker=ticker, start_date=start_date, end_date=end_date)
+    assert option_historical_data is not None
+    assert ua_historical_data is not None
+    assert not option_historical_data.empty
+    assert not ua_historical_data.empty
+    assert isinstance(option_historical_data, pd.DataFrame)
+    assert isinstance(ua_historical_data, pd.DataFrame)
+    for column in ['Date', 'Quantity', 'Volume', 'Value', 'MinPrice', 'MaxPrice', 'FirstPrice', 'LastPrice', 'ClosePrice']:
+        assert column in option_historical_data
+    for column in ['Date', 'Quantity', 'Volume', 'Value', 'MinPrice', 'MaxPrice', 'FirstPrice', 'LastPrice', 'ClosePrice']:
+        assert column in option_historical_data
+
+
+@pytest.mark.parametrize("ticker", ["ضهرم4018", "ظهرم4018"])
+def test_get_greeks(ticker):
+    greeks = get_greeks(ticker)
+    assert greeks is not None
+    assert isinstance(greeks, pd.Series)  # pandas Series
+    for greek in ['Delta', 'Gamma', 'Theta', 'Vega', 'Rho']:
+        assert greek in greeks
+
+
+@pytest.mark.parametrize("ticker", ["ضهرم4018", "طهرم4018"])
+def test_black_scholes_merton(ticker):
+    volatility, bsm_price = black_scholes_merton(ticker)
+    assert all(isinstance(v, float) for v in [volatility, bsm_price])
+    assert 0 <= volatility <= 2
+    assert isinstance(bsm_price, float)
+    assert 0 <= bsm_price
+    assert all(v is not None for v in [volatility, bsm_price])
+
+
+@pytest.mark.parametrize("ticker", ["ضهرم4018", "طهرم4018"])
+def test_get_implied_volatility(ticker):
+    implied_volatility = get_implied_volatility(ticker)
+    assert isinstance(implied_volatility, float)
+    assert 0 <= implied_volatility <= 2
+
+
+@pytest.mark.parametrize(["underlying_ticker", "j_date", "bsm", "greeks", "implied_volatility"],
+                         [('اهرم', True, True, True, True), ('اهرم', True, True, True, False),
+                          ('اهرم', True, True, False, True), ('اهرم', True, True, False, False),
+                          ('اهرم', True, False, True, True), ('اهرم', True, False, True, False),
+                          ('اهرم', True, False, False, True), ('اهرم', True, False, False, False),
+                          ('اهرم', False, True, True, True), ('اهرم', False, True, True, False),
+                          ('اهرم', False, True, False, True), ('اهرم', False, True, False, False),
+                          ('اهرم', False, False, True, True), ('اهرم', False, False, True, False),
+                          ('اهرم', False, False, False, True), ('اهرم', False, False, False, False)])
+def test_download_chain_contracts(underlying_ticker, j_date, bsm, greeks, implied_volatility):
+    chain_contracts = download_chain_contracts(underlying_ticker=underlying_ticker, j_date=j_date, bsm=bsm,
+                                               greeks=greeks, implied_volatility=implied_volatility)
+    assert chain_contracts is not None
+    assert not chain_contracts.empty
+    assert isinstance(chain_contracts, pd.DataFrame)
+
+    if bsm:
+        assert all(column in chain_contracts.columns for column in ['BSMPrice-C', 'BSMPrice-P', 'Volatility-C', 'Volatility-P']), "Horizontal, BSM"
+    if greeks:
+        assert all(column in chain_contracts.columns for column in ['Delta-C', 'Gamma-C', 'Theta-C', 'Vega-C', 'Rho-C',
+                                                                    'Delta-P', 'Gamma-P', 'Theta-P', 'Vega-P', 'Rho-P']), "Horizontal, Greeks"
+    if implied_volatility:
+        assert all(column in chain_contracts.columns for column in ['ImpliedVolatility-C', 'ImpliedVolatility-P']), "Horizontal, IV"
+
+
+@pytest.mark.parametrize(["market", "stack", "j_date", "bsm", "greeks", "implied_volatility"],
+                         [('TSE', 'Horizontal', False, False, False, False), ('TSE', 'Vertical', False, False, False, False),
+                          ('TSE', 'Horizontal', False, False, False, True), ('TSE', 'Vertical', False, False, False, True),
+                          ('TSE', 'Horizontal', True, True, True, True), ('TSE', 'Horizontal', True, True, True, False),
+                          ('TSE', 'Horizontal', True, True, False, True), ('TSE', 'Horizontal', True, True, False, False),
+                          ('TSE', 'Horizontal', True, False, True, True), ('TSE', 'Horizontal', True, False, True, False),
+                          ('TSE', 'Horizontal', True, False, False, True), ('TSE', 'Horizontal', True, False, False, False),
+                          ('TSE', 'Horizontal', False, True, True, True), ('TSE', 'Horizontal', False, True, True, False),
+                          ('TSE', 'Horizontal', False, True, False, True), ('TSE', 'Horizontal', False, True, False, False),
+                          ('TSE', 'Horizontal', False, False, True, True), ('TSE', 'Horizontal', False, False, True, False),
+                          ('TSE', 'Vertical', True, True, True, True), ('TSE', 'Vertical', True, True, True, False),
+                          ('TSE', 'Vertical', True, True, False, True), ('TSE', 'Vertical', True, True, False, False),
+                          ('TSE', 'Vertical', True, False, True, True), ('TSE', 'Vertical', True, False, True, False),
+                          ('TSE', 'Vertical', True, False, False, True), ('TSE', 'Vertical', True, False, False, False),
+                          ('TSE', 'Vertical', False, True, True, True), ('TSE', 'Vertical', False, True, True, False),
+                          ('TSE', 'Vertical', False, True, False, True), ('TSE', 'Vertical', False, True, False, False),
+                          ('TSE', 'Vertical', False, False, True, True), ('TSE', 'Vertical', False, False, True, False)])
+def test_download_market_watch(market, stack, j_date, bsm, greeks, implied_volatility):
+    market_watch = download_market_watch(market=market, j_date=j_date, bsm=bsm, greeks=greeks, implied_volatility=implied_volatility)
+    assert market_watch is not None
+    assert not market_watch.empty
+    assert isinstance(market_watch, pd.DataFrame)
+
+    if stack == 'Horizontal':
+        if bsm:
+            assert all(column in market_watch.columns for column in ['BSMPrice-C', 'BSMPrice-P', 'Volatility-C', 'Volatility-P']), "Horizontal, BSM"
+        if greeks:
+            assert all(column in market_watch.columns for column in ['Delta-C', 'Gamma-C', 'Theta-C', 'Vega-C', 'Rho-C',
+                                                                        'Delta-P', 'Gamma-P', 'Theta-P', 'Vega-P', 'Rho-P']), "Horizontal, Greeks"
+        if implied_volatility:
+            assert all(column in market_watch.columns for column in ['ImpliedVolatility-C', 'ImpliedVolatility-P']), "Horizontal, IV"
+    if stack == 'Vertical':
+        if bsm:
+            assert all(column in market_watch.columns for column in ['BSMPrice', 'Volatility']), "Vertical, BSM"
+        if greeks:
+            assert all(column in market_watch.columns for column in ['Delta', 'Gamma', 'Theta', 'Vega', 'Rho']), "Vertical, Greeks"
+        if implied_volatility:
+            assert all(column in market_watch.columns for column in ['ImpliedVolatility']), "Vertical, IV"