plotguy 2.1.7__tar.gz → 2.1.9__tar.gz

{plotguy-2.1.7 → plotguy-2.1.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plotguy
-Version: 2.1.7
+Version: 2.1.9
 Summary: Plotguy
 Home-page: https://pypi.org/project/plotguy/
 Author: Plotguy Team

{plotguy-2.1.7 → plotguy-2.1.9}/plotguy/__init__.py

@@ -11,14 +11,16 @@ import zlib
 import requests
 import pandas as pd
 import numpy as np
+import io
 
 from .equity_curves import *
 from .signals import *
 from .aggregate import *
 from .components import *
 import itertools
+from bs4 import BeautifulSoup
 
-def get_all_para_combination(para_dict, backtest_attribute, df_dict, sec_profile, manager_list):
+def get_all_para_combination(para_dict, backtest_attribute, df_dict, sec_profile, manager_list, count_down=False):
 
     risk_free_rate = get_risk_free_rate(backtest_attribute['start_date'], backtest_attribute['end_date'])
 
@@ -60,11 +62,12 @@ def get_all_para_combination(para_dict, backtest_attribute, df_dict, sec_profile
 
         all_para_combination[ref_code]      = para_combination
 
-    print('5 second countdown before running backtest()')
-    for i in range(5):
-        print(5 - i)
-        time.sleep(1)
-    print(0)
+    if count_down:
+        print('5 second countdown before running backtest()')
+        for i in range(5):
+            print(5 - i)
+            time.sleep(1)
+        print(0)
 
     print(datetime.datetime.now().strftime('%H:%M:%S'), 'start running backtest()')
 
@@ -75,8 +78,6 @@ def generate_or_read_backtest_result(read_only, mp_mode, number_of_core, manager
 
     if read_only and os.path.isfile('backtest_result.parquet'):
         backtest_result_df = pd.read_parquet('backtest_result.parquet')
-        #backtest_result_df = backtest_result_df[backtest_result_df.index.isin(all_para_combination.keys())]
-
     else:
         t1 = datetime.datetime.now()
         if mp_mode:
@@ -117,6 +118,7 @@ def save_backtest_result(df, para_combination_item):
     risk_free_rate         = para_combination['risk_free_rate']
     default_market_price   = para_combination['default_market_price']
     intraday               = para_combination['intraday']
+    long_short             = para_combination['long_short']
 
     total_commission = df['commission'].sum()
 
@@ -149,10 +151,10 @@ def save_backtest_result(df, para_combination_item):
 
     price_return_on_capital = price_net_profit / df_daily.at[df_daily.index[0], 'price']
     price_annualized_return = (np.sign(1 + price_return_on_capital) * np.abs(1 + price_return_on_capital)) ** (
-                365 / holding_period_day) - 1
+            365 / holding_period_day) - 1
     price_annualized_std = price_pct_series.std() * math.sqrt(365)
     price_annualized_sr = (
-                                      price_annualized_return - risk_free_rate / 100) / price_annualized_std if price_annualized_std != 0 else 0
+                                  price_annualized_return - risk_free_rate / 100) / price_annualized_std if price_annualized_std != 0 else 0
     price_net_profit_to_mdd = price_net_profit / price_mdd_dollar if price_mdd_dollar != 0 else 0
 
     price_return_on_capital = round(100 * price_return_on_capital, 2)
@@ -215,7 +217,7 @@ def save_backtest_result(df, para_combination_item):
         yearly_stats['year_return'] = 100 * (yearly_stats['year_pnl'] / yearly_stats['year_start_equity_value'])
         yearly_stats['year_win_rate'] = 100 * (yearly_stats['year_win_count'] / yearly_stats['year_trade_count'])
 
-        cov_return = yearly_stats['year_win_rate'].std() / yearly_stats['year_win_rate'].mean() if yearly_stats['year_win_rate'].mean() != 0 else 0
+        cov_return = yearly_stats['year_return'].std() / yearly_stats['year_return'].mean() if yearly_stats['year_return'].mean() != 0 else 0
         cov_count = yearly_stats['year_trade_count'].std() / yearly_stats['year_trade_count'].mean() if yearly_stats['year_trade_count'].mean() != 0 else 0
 
         yearly_stats = yearly_stats.applymap(lambda x: f'{x:.2f}')
@@ -257,10 +259,10 @@ def save_backtest_result(df, para_combination_item):
 
         equity_return_on_capital = equity_net_profit / df.at[df.index[0], 'equity_value']
         equity_annualized_return = (np.sign(1 + equity_return_on_capital) * np.abs(1 + equity_return_on_capital)) ** (
-                    365 / holding_period_day) - 1
+                365 / holding_period_day) - 1
         equity_annualized_std = equity_pct_series.std() * math.sqrt(365)
         equity_annualized_sr = (
-                                           equity_annualized_return - risk_free_rate / 100) / equity_annualized_std if equity_annualized_std != 0 else 0
+                                       equity_annualized_return - risk_free_rate / 100) / equity_annualized_std if equity_annualized_std != 0 else 0
         equity_net_profit_to_mdd = equity_net_profit / equity_mdd_dollar if equity_mdd_dollar != 0 else 0
 
         equity_return_on_capital = round(100 * equity_return_on_capital, 2)
@@ -269,7 +271,11 @@ def save_backtest_result(df, para_combination_item):
         equity_annualized_sr = round(equity_annualized_sr, 2)
         equity_net_profit_to_mdd = round(100 * equity_net_profit_to_mdd, 2)
 
-    return_on_capital_diff = equity_annualized_return - price_annualized_return
+    if long_short == 'short':
+        return_on_capital_diff = equity_annualized_return - (-1) * price_annualized_return
+    else:
+        ### consider both long and long_short ###
+        return_on_capital_diff = equity_annualized_return - price_annualized_return
 
     if intraday:
         df = df[['price', 'equity_value']]
@@ -343,8 +349,11 @@ def get_risk_free_rate(start_date, end_date):
         else:
             risk_free_rate = get_geometric_mean_of_yearly_rate(start_date_year, end_date_year)
     except:
-        risk_free_rate = 2  # if network error, set rate to 2 %
-        print('Network error. Risk free rate: {:.2f} %'.format(risk_free_rate))
+        try:
+            risk_free_rate = get_geometric_mean_of_yearly_rate_backup(start_date_year, end_date_year)
+        except:
+            risk_free_rate = 2  # if network error, set rate to 2 %
+            print('Network error. Risk free rate: {:.2f} %'.format(risk_free_rate))
 
     return risk_free_rate
 
@@ -379,9 +388,9 @@ def get_latest_fed_fund_rate():
     return fed_funds_rate
 
 
-def get_geometric_mean_of_yearly_rate(start_year, end_year):  # backtest period
+def get_geometric_mean_of_yearly_rate(start_year, end_year):
     url = "https://fred.stlouisfed.org/graph/fredgraph.csv?id=DTB3"
-    response = requests.get(url)
+    response = requests.get(url, timeout=10)
     data = response.text.split("\n")[:-1]
     data = [row.split(",") for row in data]
     df = pd.DataFrame(data[1:], columns=data[0])
@@ -389,6 +398,35 @@ def get_geometric_mean_of_yearly_rate(start_year, end_year):  # backtest period
     df["date"] = pd.to_datetime(df["date"])
     df["risk_free_rate"] = pd.to_numeric(df["risk_free_rate"], errors='coerce')
     df.dropna(subset=['risk_free_rate'], inplace=True)
+    print('Got Federal Funds Rate from stlouisfed.org')
+
+    risk_free_rate_history_yearly = df.resample("A", on="date").mean()
+    risk_free_rate_history_yearly = risk_free_rate_history_yearly.round(3)
+
+    # show only start between start_year and end_year
+    risk_free_rate_history_yearly = risk_free_rate_history_yearly[
+        risk_free_rate_history_yearly.index.year >= start_year]
+    risk_free_rate_history_yearly = risk_free_rate_history_yearly[risk_free_rate_history_yearly.index.year <= end_year]
+
+    fed_fund_rate_geometric_mean = np.exp(np.log(risk_free_rate_history_yearly["risk_free_rate"]).mean())
+    fed_fund_rate_geometric_mean = round(fed_fund_rate_geometric_mean, 2)
+    print("Federal Funds Rate Geometric mean from {} to {}: {} %".format(start_year, end_year,
+                                                                         fed_fund_rate_geometric_mean))
+
+    return fed_fund_rate_geometric_mean
+
+def get_geometric_mean_of_yearly_rate_backup(start_year, end_year):
+    url = '/get_fred'
+    my_headers = {'token': '3f52e8c4-8c49-4c9a-8c57-1e4e9f6b0a40'}
+    my_main_url = "http://120.26.40.125:8080"
+    response = requests.get(f'{my_main_url}{url}', headers=my_headers)
+    data_str = response.content.decode('utf-8')
+    data_io = io.StringIO(data_str)
+    df = pd.read_csv(data_io)
+    df = df.rename(columns={'value' : 'risk_free_rate'})
+    df["date"] = pd.to_datetime(df["date"])
+    df.dropna(subset=['risk_free_rate'], inplace=True)
+    print('Got Federal Funds Rate from backup source')
 
     risk_free_rate_history_yearly = df.resample("A", on="date").mean()
     risk_free_rate_history_yearly = risk_free_rate_history_yearly.round(3)

{plotguy-2.1.7 → plotguy-2.1.9}/plotguy/components.py

@@ -316,7 +316,7 @@ class Components:
             result_df['equity_annualized_std']    = result_df['equity_annualized_std'].apply(lambda x: f"{x:,.2f} %")
             result_df['equity_annualized_sr']     = result_df['equity_annualized_sr'].apply(lambda x: f"{x:,.2f}")
 
-            result_df['return_on_capital_diff']     = result_df['return_on_capital_diff'].apply(lambda x: f"{x:,.0f}")
+            result_df['return_on_capital_diff']     = result_df['return_on_capital_diff'].apply(lambda x: f"{x:,.0f} %")
 
             result_df['price_mdd_dollar'] = result_df['price_mdd_dollar'].apply(lambda x: f"{int(x):,}")
             result_df['price_mdd_pct']    = result_df['price_mdd_pct'].apply(lambda x: f"{x:,.2f} %")
@@ -798,73 +798,73 @@ class Components:
             saved_strategies_path = os.path.join(str_dir, 'saved_strategies.parquet')
             saved_strategies_df   = pd.read_parquet(saved_strategies_path)
 
-            if len(saved_strategies_df) > 1:
-                for i, row in saved_strategies_df.iterrows():
-                    equity_path = os.path.join(str_dir, row["equity_curve_folder"], str(row['ref_code']) + '.parquet')
-
-                    yearly_stats_string  = row['yearly_stats_string']
-                    para_keys_str  = row['para_keys_str']
-                    para_keys_list = para_keys_str.split('|')
-
-                    parameters = {}
-                    for para_keys in para_keys_list:
-                        parameters[para_keys] = str(row[para_keys])
-
-                    equity_curve_dict = {}
-
-                    equity_curve_dict['folder']        = str_dir
-                    equity_curve_dict['backtest_name'] = row['backtest_name']
-                    equity_curve_dict['equity_path']   =  equity_path
-                    equity_curve_dict['parameters']    = parameters
-
-                    equity_curve_dict['performance'] = {
-                        'initial_capital':   row['initial_capital'],
-                        'sharpe_ratio':      row['equity_annualized_sr'],
-                        'annualized_return': row['equity_annualized_return'],
-                        'net_profit_to_mdd': row['equity_net_profit_to_mdd'],
-                        'net_profit':        row['equity_net_profit'],
-                        'mdd_dollar':        row['equity_mdd_dollar'],
-                        'mdd_pct':           row['equity_mdd_pct'],
-                        'num_of_trade':      row['num_of_trade'],
-                        'num_of_win':        row['num_of_win'],
-                        'return_on_capital': row['equity_return_on_capital'],
-                        'total_commission':  row['total_commission'],
-                    }
-
-                    ref_code = str(row['ref_code'])
-                    equity_curve_dict['ref_code'] = ref_code
-
-                    yearly_stats_dict = {}
-                    years_data = yearly_stats_string.split("|")
-
-                    for year_data in years_data:
-                        parts = year_data.split(",")
-                        year = parts[0]
-                        yearly_stats_dict[year] = {}
-
-                        for item in parts[1:]:
-                            key, value = item.split(":")
-                            yearly_stats_dict[year][key] = float(value)
-
-                    for idx, (year, value) in enumerate(yearly_stats_dict.items()):
-                        year_trade_count = value['year_trade_count']
-                        year_win_rate = value['year_win_rate']
-                        year_return = value['year_return']
-
-                        year_win_count =  year_trade_count * year_win_rate * 0.01
-
-                        ### dont remove ###
-                        # year_trade_count = "{:d}".format(int(year_trade_count))
-                        # year_win_count = "{:d}".format(int(year_win_count))
-                        # year_win_rate = "{:d}%".format(int(year_win_rate))
-                        # year_return = "{:.2f} %".format(int(year_return))
-
-                        equity_curve_dict['performance'][f'{year} Count']    = year_trade_count
-                        equity_curve_dict['performance'][f'{year} Win Rate'] = year_win_rate
-                        equity_curve_dict['performance'][f'{year} Win Count'] = year_win_count
-                        equity_curve_dict['performance'][f'{year} Return']   = year_return
-
-                    equity_curves_dict_list.append(equity_curve_dict)
+            for i, row in saved_strategies_df.iterrows():
+                equity_path = os.path.join(str_dir, row["equity_curve_folder"], str(row['ref_code']) + '.parquet')
+                #df_equity = pd.read_parquet(equity_path)
+
+                yearly_stats_string  = row['yearly_stats_string']
+                para_keys_str  = row['para_keys_str']
+                para_keys_list = para_keys_str.split('|')
+
+                parameters = {}
+                for para_keys in para_keys_list:
+                    parameters[para_keys] = str(row[para_keys])
+
+                equity_curve_dict = {}
+
+                equity_curve_dict['folder']        = str_dir
+                equity_curve_dict['backtest_name'] = row['backtest_name']
+                equity_curve_dict['equity_path']   =  equity_path
+                equity_curve_dict['parameters']    = parameters
+
+                equity_curve_dict['performance'] = {
+                    'initial_capital':   row['initial_capital'],
+                    'sharpe_ratio':      row['equity_annualized_sr'],
+                    'annualized_return': row['equity_annualized_return'],
+                    'net_profit_to_mdd': row['equity_net_profit_to_mdd'],
+                    'net_profit':        row['equity_net_profit'],
+                    'mdd_dollar':        row['equity_mdd_dollar'],
+                    'mdd_pct':           row['equity_mdd_pct'],
+                    'num_of_trade':      row['num_of_trade'],
+                    'num_of_win':        row['num_of_win'],
+                    'return_on_capital': row['equity_return_on_capital'],
+                    'total_commission':  row['total_commission'],
+                }
+
+                ref_code = str(row['ref_code'])
+                equity_curve_dict['ref_code'] = ref_code
+
+                yearly_stats_dict = {}
+                years_data = yearly_stats_string.split("|")
+
+                for year_data in years_data:
+                    parts = year_data.split(",")
+                    year = parts[0]
+                    yearly_stats_dict[year] = {}
+
+                    for item in parts[1:]:
+                        key, value = item.split(":")
+                        yearly_stats_dict[year][key] = float(value)
+
+                for idx, (year, value) in enumerate(yearly_stats_dict.items()):
+                    year_trade_count = value['year_trade_count']
+                    year_win_rate = value['year_win_rate']
+                    year_return = value['year_return']
+
+                    year_win_count =  year_trade_count * year_win_rate * 0.01
+
+                    ### dont remove ###
+                    # year_trade_count = "{:d}".format(int(year_trade_count))
+                    # year_win_count = "{:d}".format(int(year_win_count))
+                    # year_win_rate = "{:d}%".format(int(year_win_rate))
+                    # year_return = "{:.2f} %".format(int(year_return))
+
+                    equity_curve_dict['performance'][f'{year} Count']    = year_trade_count
+                    equity_curve_dict['performance'][f'{year} Win Rate'] = year_win_rate
+                    equity_curve_dict['performance'][f'{year} Win Count'] = year_win_count
+                    equity_curve_dict['performance'][f'{year} Return']   = year_return
+
+                equity_curves_dict_list.append(equity_curve_dict)
 
         line_colour = []
         for c in range(len(equity_curves_dict_list)):

{plotguy-2.1.7 → plotguy-2.1.9}/plotguy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plotguy
-Version: 2.1.7
+Version: 2.1.9
 Summary: Plotguy
 Home-page: https://pypi.org/project/plotguy/
 Author: Plotguy Team

{plotguy-2.1.7 → plotguy-2.1.9}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r") as fh:
 
 setuptools.setup(
     name="plotguy",
-    version="2.1.7",
+    version="2.1.9",
     author="Plotguy Team",
     author_email="plotguy.info@gmail.com",
     description="Plotguy",