pyalgotrading 2023.7.1__py3-none-any.whl → 2023.10.1__py3-none-any.whl

pyalgotrading/algobulls/api.py

@@ -26,6 +26,7 @@ class AlgoBullsAPI:
         """
         self.connection = connection
         self.headers = None
+        self.page_size = 1000
         self.__key_backtesting = {}  # strategy-cstc_id mapping
         self.__key_papertrading = {}  # strategy-cstc_id mapping
         self.__key_realtrading = {}  # strategy-cstc_id mapping
@@ -335,7 +336,7 @@ class AlgoBullsAPI:
                 TradingType.BACKTESTING: 'backDataDate'
             }
             execute_config = {
-                map_trading_type_to_date_key[trading_type]: [start_timestamp.astimezone(timezone.utc).isoformat(), end_timestamp.astimezone(timezone.utc).isoformat()],
+                map_trading_type_to_date_key[trading_type]: [start_timestamp.astimezone(timezone.utc).replace(tzinfo=None).isoformat(), end_timestamp.astimezone(timezone.utc).replace(tzinfo=None).isoformat()],
                 'isLiveDataTestMode': trading_type in [TradingType.PAPERTRADING, TradingType.REALTRADING],
                 'customizationsQuantity': lots,
                 'brokingDetails': broker_details,
@@ -408,14 +409,13 @@ class AlgoBullsAPI:
 
         return response
 
-    def get_logs(self, strategy_code: str, trading_type: TradingType, log_type: str, initial_next_token: str = None) -> dict:
+    def get_logs(self, strategy_code: str, trading_type: TradingType, initial_next_token: str = None) -> dict:
         """
         Fetch logs for a strategy
 
         Args:
             strategy_code: Strategy code
             trading_type: Trading type
-            log_type: type of logs, 'partial' or 'full' requests
             initial_next_token: Token of next logs for v4 logs
 
         Returns:
@@ -424,23 +424,17 @@ class AlgoBullsAPI:
         Info: ENDPOINT
             `POST`: v2/user/strategy/logs
         """
-        key = self.__get_key(strategy_code=strategy_code, trading_type=trading_type)
-        params = None
-
-        if log_type == 'partial':
-            endpoint = 'v4/user/strategy/logs'
-            json_data = {'key': key, 'nextToken': initial_next_token, 'limit': 1000, 'direction': 'forward', 'reverse': False, 'type': 'userLogs'}
-            params = {'isPythonBuild': True, 'isLive': trading_type == TradingType.REALTRADING}
 
-        else:
-            endpoint = 'v2/user/strategy/logs'
-            json_data = {'key': key}
+        key = self.__get_key(strategy_code=strategy_code, trading_type=trading_type)
+        endpoint = 'v4/user/strategy/logs'
+        json_data = {'key': key, 'nextForwardToken': initial_next_token, 'limit': self.page_size, 'direction': 'forward', 'type': 'userLogs'}
+        params = {'isPythonBuild': True, 'isLive': trading_type == TradingType.REALTRADING}
 
         response = self._send_request(method='post', endpoint=endpoint, json_data=json_data, params=params)
 
         return response
 
-    def get_reports(self, strategy_code: str, trading_type: TradingType, report_type: TradingReportType, location: str) -> dict:
+    def get_reports(self, strategy_code: str, trading_type: TradingType, report_type: TradingReportType, country: str, current_page: int) -> dict:
         """
         Fetch report for a strategy
 
@@ -448,25 +442,24 @@ class AlgoBullsAPI:
             strategy_code: Strategy code
             trading_type: Value of TradingType Enum
             report_type: Value of TradingReportType Enum
-            location: Location of the exchange
-
+            country: Country of the exchange
+            current_page: current page of data being retrieved (for order history)
         Returns:
             Report data
 
         Info: ENDPOINT
-            `GET` v2/user/strategy/pltable          for P&L Table
-            `GET` v2/user/strategy/statstable       for Stats Table
-            `GET` v2/user/strategy/orderhistory     Order History
+            `GET` v4/book/pl/data                       for P&L Table
+            `GET` v5/build/python/user/order/charts     Order History
         """
 
         key = self.__get_key(strategy_code=strategy_code, trading_type=trading_type)
         if report_type is TradingReportType.PNL_TABLE:
             _filter = json.dumps({"tradingType": trading_type.value})
-            endpoint = f'v3/book/pl/data'
-            params = {'pageSize': 0, 'isPythonBuild': "true", 'strategyId': strategy_code, 'isLive': trading_type is TradingType.REALTRADING, 'location': location, 'filters': _filter}
+            endpoint = f'v4/book/pl/data'
+            params = {'pageSize': 0, 'isPythonBuild': "true", 'strategyId': strategy_code, 'isLive': trading_type is TradingType.REALTRADING, 'country': country, 'filters': _filter}
         elif report_type is TradingReportType.ORDER_HISTORY:
-            endpoint = 'v2/user/strategy/orderhistory'
-            params = {'key': key}
+            endpoint = 'v5/build/python/user/order/charts'
+            params = {'strategyId': strategy_code, 'country': country, 'currentPage': current_page, 'pageSize': self.page_size, 'isLive': trading_type is TradingType.REALTRADING}
         else:
             raise NotImplementedError
 

pyalgotrading/algobulls/connection.py

@@ -2,6 +2,7 @@
 Module for AlgoBulls connection
 """
 import inspect
+import os
 import pprint
 import re
 import time
@@ -14,10 +15,10 @@ from tabulate import tabulate
 from tqdm.auto import tqdm
 
 from .api import AlgoBullsAPI
-from .exceptions import AlgoBullsAPIBadRequestException, AlgoBullsAPIGatewayTimeoutErrorException
-from ..constants import StrategyMode, TradingType, TradingReportType, CandleInterval, AlgoBullsEngineVersion, EXCHANGE_LOCALE_MAP, Locale, ExecutionStatus
+from .exceptions import AlgoBullsAPIBadRequestException, AlgoBullsAPIGatewayTimeoutErrorException, AlgoBullsAPIUnauthorizedErrorException
+from ..constants import StrategyMode, TradingType, TradingReportType, CandleInterval, AlgoBullsEngineVersion, Country, ExecutionStatus, EXCHANGE_LOCALE_MAP, Locale, CandleIntervalSecondsMap
 from ..strategy.strategy_base import StrategyBase
-from ..utils.func import get_valid_enum_names, get_datetime_with_tz
+from ..utils.func import get_valid_enum_names, get_datetime_with_tz, calculate_brokerage, calculate_slippage
 
 
 class AlgoBullsConnection:
@@ -36,7 +37,7 @@ class AlgoBullsConnection:
             'end_timestamp_map': {}
         }
 
-        self.strategy_locale_map = {
+        self.strategy_country_map = {
             TradingType.BACKTESTING: {},
             TradingType.PAPERTRADING: {},
             TradingType.REALTRADING: {},
@@ -68,19 +69,27 @@ class AlgoBullsConnection:
         url = 'https://app.algobulls.com/settings?section=developerOptions'
         print(f'Please login to this URL to get your unique token: {url}')
 
-    def set_access_token(self, access_token):
+    def set_access_token(self, access_token, validate_token=True):
         """
         Set the access token
 
         Args:
             access_token: access token
-
+            validate_token: whether you want to validate the access-token
         Returns:
             None
         """
         assert isinstance(access_token, str), f'Argument "access_token" should be a string'
         self.api.set_access_token(access_token)
 
+        if validate_token:
+            try:
+                _ = self.api.get_all_strategies()
+                print("Access token is valid.")
+            except AlgoBullsAPIUnauthorizedErrorException:
+                print(f"Access token is invalid. ", end='')
+                self.get_token_url()
+
     def create_strategy(self, strategy, overwrite=False, strategy_code=None, abc_version=None):
         """
         Method to upload new strategy.
@@ -270,89 +279,121 @@ class AlgoBullsConnection:
         assert isinstance(strategy_code, str), f'Argument "strategy_code" should be a string'
         assert isinstance(trading_type, TradingType), f'Argument "trading_type" should be an enum of type {TradingType.__name__}'
 
-        response = self.api.stop_strategy_algotrading(strategy_code=strategy_code, trading_type=trading_type)
+        self.api.stop_strategy_algotrading(strategy_code=strategy_code, trading_type=trading_type)
 
-    def get_logs(self, strategy_code, trading_type, auto_update=True, display_logs_in_auto_update_mode=False):
+    def get_logs(self, strategy_code, trading_type, display_progress_bar=True, print_live_logs=False):
         """
         Fetch logs for a strategy
 
         Args:
             strategy_code: strategy code
             trading_type: trading type
-            auto_update: If True, logs will be continuously fetched until strategy execution is complete. A progress bar will show the live status of strategy execution
-            display_logs_in_auto_update_mode: Applicable only if auto_update is True; display the logs as they are fetched
-
+            display_progress_bar: to track the execution progress bar as your strategy is executed
+            print_live_logs: to print the logs as they are fetched
         Returns:
             Execution logs
         """
 
         assert isinstance(strategy_code, str), f'Argument "strategy_code" should be a string'
         assert isinstance(trading_type, TradingType), f'Argument "trading_type" should be an enum of type {TradingType.__name__}'
-        assert isinstance(auto_update, bool), f'Argument "show_progress_bar" should be a boolean'
 
         # TODO: to extract timestamp from a different source which will be independent of whether save parameters are present in the object
         start_timestamp_map = self.saved_parameters.get('start_timestamp_map')
         end_timestamp_map = self.saved_parameters.get('end_timestamp_map')
-        all_logs = ''
-
-        # logging with progress bar
-        if auto_update and start_timestamp_map.get(trading_type) and end_timestamp_map.get(trading_type):
-            tqdm_progress_bar = None
-            initial_next_token = None
-            error_counter = 0
-            status = None
+        sleep_time = 1
+        total_seconds = 1
 
-            start_timestamp = start_timestamp_map.get(trading_type).replace(tzinfo=None)
-            end_timestamp = end_timestamp_map.get(trading_type).replace(tzinfo=None)
-            total_seconds = (end_timestamp - start_timestamp).total_seconds()
+        # calculate the sleep time for RT and PT
+        if trading_type is not TradingType.BACKTESTING:
+            try:
+                sleep_time = CandleIntervalSecondsMap[self.saved_parameters.get('candle_interval').value]
+                print(f"Your candle interval is {self.saved_parameters.get('candle_interval').value}, therefore logs will be fetched every {sleep_time} seconds.")
+            except AttributeError:
+                print("WARNING: Could not fetch the candle interval from saved parameters. Logs will be fetched every 60 seconds.")
+                sleep_time = 60
+
+        # initialize the parameters required for displaying progress bar
+        if display_progress_bar:
+            if start_timestamp_map.get(trading_type) and end_timestamp_map.get(trading_type):
+                start_timestamp = start_timestamp_map.get(trading_type).replace(tzinfo=None)
+                end_timestamp = end_timestamp_map.get(trading_type).replace(tzinfo=None)
+                total_seconds = (end_timestamp - start_timestamp).total_seconds()
+            else:
+                display_progress_bar = False
 
-            count_starting_status = 0
-            while True:
+        # initialize all the variables
+        all_logs = ''
+        tqdm_progress_bar = None
+        initial_next_token = None
+        error_counter = 0
+        status = None
+        count_starting_status = 0
+        response = {}
+        logs = []
+
+        while True:
+            # if logs are in starting phase, we wait until it changes
+            if status is None or status == ExecutionStatus.STARTING.value:
+                status = self.get_job_status(strategy_code, trading_type)["message"]
+                time.sleep(5)
+
+                # log the counting for "STARTING" phase of execution
+                if status == ExecutionStatus.STARTING.value:
+                    count_starting_status += 1
+                    print('\r', end=f'Looking for a dedicated virtual server to execute your strategy... ({count_starting_status})')
+                continue
+
+            # if logs get in started phase, we initialize the tqdm object for progress tracking
+            if display_progress_bar:
+                if tqdm_progress_bar is None and status == ExecutionStatus.STARTED.value:
+                    tqdm_progress_bar = tqdm(desc='Execution Progress', total=total_seconds, position=0, leave=True, bar_format='{l_bar}{bar}| {n_fmt}/{total_fmt} [{elapsed}<{remaining}]')
 
-                # if logs are in starting phase, we wait until it changes
-                if status is None or status == ExecutionStatus.STARTING.value:
-                    status = self.get_job_status(strategy_code, trading_type)["message"]
+            # try the logs API 5 times or until it succeeds
+            for i in range(5):
+                try:
+                    response = self.api.get_logs(strategy_code=strategy_code, trading_type=trading_type, initial_next_token=initial_next_token)
+                    logs = response.get('data')
+                    if logs:
+                        break
+                except AlgoBullsAPIGatewayTimeoutErrorException:
+                    tqdm.write(f"\n{'----' * 10}\nFaced an error while fetching logs.\n{'----' * 10}\n")
                     time.sleep(5)
-                    if status == ExecutionStatus.STARTING.value:
-                        count_starting_status += 1
-                        print('\r', end=f'Looking for a dedicated virtual server to execute your strategy... ({count_starting_status})')
-                    continue
 
-                # if logs get in started phase, we initialize the tqdm object for progress tracking
-                if tqdm_progress_bar is None and status == ExecutionStatus.STARTED.value:
-                    tqdm_progress_bar = tqdm(desc='Execution Progress', total=total_seconds, position=0, leave=True, bar_format='{l_bar}{bar}| {n_fmt}/{total_fmt} [{elapsed}<{remaining}]')
+            initial_next_token = response.get('nextForwardToken')
 
-                response = self.api.get_logs(strategy_code=strategy_code, trading_type=trading_type, log_type='partial', initial_next_token=initial_next_token)
-                logs = response.get('data')
-                if type(logs) is list:
-                    all_logs += '\n'.join(logs) + '\n'
+            # if logs are empty we validate the status of execution
+            if not logs:
+                status = self.get_job_status(strategy_code, trading_type)["message"]
 
-                # if logs are empty we wait
-                if not logs:
-                    status = self.get_job_status(strategy_code, trading_type)["message"]
+                # if status is stopped we break the while loop
+                if status in [ExecutionStatus.STOPPED.value, ExecutionStatus.STOPPING.value]:
 
-                    # if status is stopped we break the while loop
-                    if status in [ExecutionStatus.STOPPED.value, ExecutionStatus.STOPPING.value]:
-                        # tqdm.write(f'INFO: Got status as {status}, strategy execution completed.')    # for debug
+                    # tqdm.write(f"INFO: Got status as {status}, strategy execution completed.")    # for debug
+                    if display_progress_bar:
                         if tqdm_progress_bar is not None:
                             tqdm_progress_bar.close()
-                        break
-
-                    # continue if logs are not fetched
-                    else:
-                        # tqdm.write(f'WARNING: got no data, current status is {status}...')      # for debug
-                        time.sleep(5)
-                        continue
+                    break
 
+                # continue if logs are not fetched
                 else:
-                    # print the logs below progressbar
-                    if display_logs_in_auto_update_mode:
-                        tqdm.write('\n'.join(logs))
+                    time.sleep(5)
+
+                    # tqdm.write(f"WARNING: got no data, current status is {status}...")      # for debug
+                    continue
 
-                    # iterate in reverse order
+            else:
+                # incoming logs are in list, merge them to string
+                if type(logs) is list and initial_next_token:
+                    all_logs += ''.join(logs)
+
+                # print the logs below progressbar
+                if print_live_logs:
+                    tqdm.write(''.join(logs))
+
+                # iterate in reverse order
+                if display_progress_bar:
                     for log in logs[::-1]:
                         try:
-
                             # extract log terms inside square brackets
                             _ = re.findall(r'\[(.*?)\]', log)
 
@@ -367,26 +408,28 @@ class AlgoBullsConnection:
                             tqdm.write(f'WARNING: faced an error while updating logs process. Error: {ex}')
                             error_counter += 1
 
-                        # avoid infinite loop in case of error
-                        if error_counter > 5:
-                            break
+                    # avoid infinite loop in case of error
+                    if error_counter > 5:
+                        break
+
+                if len(logs) >= self.api.page_size:
+                    # tqdm.write(f"\n{'-----' * 5}\nWaiting {sleep_time} seconds for fetching next logs ...\n{'-----' * 5}\n")  # for debug
+                    time.sleep(sleep_time)
+                else:
+                    time.sleep(1)
 
-                    initial_next_token = response.get('initialNextToken')
-        else:
-            all_logs = self.api.get_logs(strategy_code=strategy_code, trading_type=trading_type, log_type='full').get('data')
         return all_logs
 
-    def get_report(self, strategy_code, trading_type, report_type, render_as_dataframe=False, show_all_rows=False, location=None):
+    def get_report_order_history(self, strategy_code, trading_type, render_as_dataframe=False, show_all_rows=True, country=None):
         """
         Fetch report for a strategy
 
         Args:
             strategy_code: Strategy code
             trading_type: Value of TradingType Enum
-            report_type: Value of TradingReportType Enum
             render_as_dataframe: True or False
             show_all_rows: True or False
-            location: Location of the Exchange
+            country: country of the Exchange
 
         Returns:
             report details
@@ -394,30 +437,86 @@ class AlgoBullsConnection:
 
         assert isinstance(strategy_code, str), f'Argument "strategy_code" should be a string'
         assert isinstance(trading_type, TradingType), f'Argument "trading_type" should be an enum of type {TradingType.__name__}'
-        assert isinstance(report_type, TradingReportType), f'Argument "report_type" should be an enum of type {TradingReportType.__name__}'
         assert isinstance(render_as_dataframe, bool), f'Argument "render_as_dataframe" should be a bool'
         assert isinstance(show_all_rows, bool), f'Argument "show_all_rows" should be a bool'
         # assert (broker is None or isinstance(broker, AlgoBullsSupportedBrokers) is True), f'Argument broker should be None or an enum of type {AlgoBullsSupportedBrokers.__name__}'
-        response = self.api.get_reports(strategy_code=strategy_code, trading_type=trading_type, report_type=report_type, location=location)
-        if response.get('data'):
+
+        main_data = []
+        total_data = 0
+        _total = 0
+        i = 1
+
+        if country is None:
+            country = self.strategy_country_map[trading_type].get(strategy_code, Country.DEFAULT.value)
+
+        while True:
+            for _ in range(5):
+                try:
+                    response = self.api.get_reports(strategy_code=strategy_code, trading_type=trading_type, report_type=TradingReportType.ORDER_HISTORY, country=country, current_page=i)
+                    _total = response.get("totalTrades")
+                    _data = response.get("data")
+
+                    # if data is retrieved as a list then update the main data
+                    if _data and isinstance(_data, list):
+                        main_data.extend(_data)
+                        total_data += self.api.page_size
+                        i += 1
+                        break
+
+                except AlgoBullsAPIGatewayTimeoutErrorException:
+                    time.sleep(5)
+
+            # break if total requested data is more than total data
+            if total_data > _total:
+                break
+
+        if main_data:
+
+            # for rendering as dataframe
             if render_as_dataframe:
-                if show_all_rows:
-                    pandas_dataframe_all_rows()
-                _response = pd.DataFrame(response['data'])
+                pandas_dataframe_all_rows()
+
+                # explode the "customer_tradebook_states" column to get separate rows for every state
+                _response = pd.DataFrame(main_data)
+                df = _response.explode('customer_tradebook_states').reset_index(drop=True)
+                df = df.join(pd.json_normalize(df.pop('customer_tradebook_states')))
+                _response = df.set_index("orderId").sort_values("timestamp_created")[["timestamp_created", "transaction_type", "state", "instrument", "quantity", "currency", "price"]]
+
+            # for rendering as string or json
             else:
-                _response = response['data']
+                _response = main_data
+                main_order_string = ""
+
+                for i in range(len(main_data)):
+                    # tables for displaying order details and order stats
+                    order_detail = [
+                        ["Order ID", main_data[i]["orderId"]],
+                        ["Transaction Type", main_data[i]["transaction_type"]],
+                        ["Instrument", main_data[i]["instrument"]],
+                        ["Quantity", main_data[i]["quantity"]],
+                        ["Price", str(main_data[i]["currency"]) + str(main_data[i]["price"])]
+                    ]
+                    main_order_string += tabulate(order_detail, tablefmt="psql") + "\n"
+                    main_order_string += tabulate(main_data[i]["customer_tradebook_states"], headers="keys", tablefmt="psql") + "\n"
+                    main_order_string += '\n' + '======' * 15 + '\n'
+
+                _response = main_order_string
             return _response
         else:
-            print('Report not available yet. Please retry in sometime')
+            print("Report not available yet. Please retry in sometime")
 
-    def get_pnl_report_table(self, strategy_code, trading_type, location):
+    def get_report_pnl_table(self, strategy_code, trading_type, country, brokerage_percentage=None, brokerage_flat_price=None, slippage_percent=None, show_all_rows=True):
         """
             Fetch BT/PT/RT Profit & Loss details
 
             Args:
                 strategy_code: strategy code
                 trading_type: type of trades : Backtesting, Papertrading, Realtrading
-                location: Location of the exchange
+                country: country of the exchange
+                brokerage_percentage: Percentage of broker commission per trade
+                brokerage_flat_price: Broker fee per trade
+                slippage_percent: percentage of slippage per order
+                show_all_rows: show all rows of the dataframe returned
 
             Returns:
                 Report details
@@ -425,11 +524,16 @@ class AlgoBullsConnection:
 
         assert isinstance(strategy_code, str), f'Argument "strategy_code" should be a string'
 
+        # Set the country code
+        if country is None:
+            country = self.strategy_country_map[trading_type].get(strategy_code, Country.DEFAULT.value)
+
         # Fetch the data
-        if location is None:
-            location = self.strategy_locale_map[trading_type].get(strategy_code, Locale.DEFAULT.value)
+        response = self.api.get_reports(strategy_code=strategy_code, trading_type=trading_type, report_type=TradingReportType.PNL_TABLE, country=country, current_page=1)
+        data = response.get("data")
 
-        data = self.get_report(strategy_code=strategy_code, trading_type=trading_type, report_type=TradingReportType.PNL_TABLE, location=location)
+        if show_all_rows:
+            pandas_dataframe_all_rows()
 
         # Post-processing: Cleanup & converting data to dataframe
         column_rename_map = OrderedDict([
@@ -447,6 +551,7 @@ class AlgoBullsConnection:
             ('exit.price', 'exit_price'),
             ('pnlAbsolute.value', 'pnl_absolute')
         ])
+
         if data:
             # Generate df from json data & perform cleanups
             _df = pd.json_normalize(data[::-1])[list(column_rename_map.keys())].rename(columns=column_rename_map)
@@ -455,13 +560,19 @@ class AlgoBullsConnection:
             _df['exit_transaction_type'] = _df['exit_transaction_type'].apply(lambda _: 'BUY' if _ else 'SELL')
             _df["pnl_cumulative_absolute"] = _df["pnl_absolute"].cumsum(axis=0, skipna=True)
 
+            # generate slippage data
+            if slippage_percent:
+                _df = calculate_slippage(pnl_df=_df, slippage_percent=slippage_percent)
+
+            _df = calculate_brokerage(pnl_df=_df, brokerage_percentage=brokerage_percentage, brokerage_flat_price=brokerage_flat_price)
         else:
             # No data available, send back an empty dataframe
             _df = pd.DataFrame(columns=list(column_rename_map.values()))
+            _df['net_pnl'] = None
 
         return _df
 
-    def get_report_statistics(self, strategy_code, initial_funds, report, html_dump, pnl_df):
+    def get_report_statistics(self, strategy_code=None, initial_funds=None, report="full", html_dump=True, pnl_df=None, file_path="None", date_time_format="%Y-%m-%d %H:%M:%S%z"):
         """
             Fetch BT/PT/RT report statistics
 
@@ -469,19 +580,45 @@ class AlgoBullsConnection:
                 strategy_code: strategy code
                 report: format and content of the report
                 html_dump: save it as a html file
-                pnl_df: dataframe containing pnl reports
+                pnl_df: dataframe containing pnl reports; this parameter will be ignored if file_path is provided
                 initial_funds: initial funds to before starting the job
+                file_path: file path of the csv or xlsx containing pnl data for statistics; if provided, pnl_df would be ignored
+                date_time_format: datetime format of the column inside the "entry_timestamp" column in the csv or xlxs file
             Returns:
                 Report details
         """
 
+        # read and validate the csv given in path file
+        if os.path.isfile(file_path):
+            # only accept csv or xlxs files
+            _, _ext = os.path.splitext(file_path)
+            if _ext == '.csv':
+                pnl_df = pd.read_csv(file_path)
+            elif _ext == '.xlxs':
+                pnl_df = pd.read_excel(file_path)
+            else:
+                raise Exception(f'ERROR: File with extension {_ext} is not supported.\n Please provide path to files with extension as ".csv" or ".xlxs"')
+
+            # handle the exceptions gracefully, check the validity of the input file
+            if "entry_timestamp" not in pnl_df.columns or "net_pnl" not in pnl_df.columns:
+                raise Exception(f"ERROR: Given  {_ext} file does not have the required columns 'entry_timestamp' and 'net_pnl'.")
+            try:
+                dt.strptime(pnl_df.iloc[0]["entry_timestamp"], date_time_format)
+            except ValueError:
+                raise ValueError(f"ERROR: Datetime strings inside 'entry_timestamp' column should be of the format {date_time_format}.")
+
+            # cleanup dataframe generated from read files
+            pnl_df[['entry_timestamp']] = pnl_df[['entry_timestamp']].apply(pd.to_datetime, format=date_time_format, errors="coerce")
+
         order_report = None
+        if initial_funds is None:
+            initial_funds = self.saved_parameters.get("initial_funds_virtual") or 1e9
 
         # get pnl data and cleanup as per quantstats format
-        _returns_df = pnl_df[['entry_timestamp', 'pnl_absolute']]
+        _returns_df = pnl_df[['entry_timestamp', 'net_pnl']]
         _returns_df['entry_timestamp'] = _returns_df['entry_timestamp'].dt.tz_localize(None)  # Note: Quantstats has a bug. It doesn't accept the df index, which is set below, with timezone. Hence, we have to drop the timezone info
         _returns_df = _returns_df.set_index('entry_timestamp')
-        _returns_df["total_funds"] = _returns_df.pnl_absolute.cumsum() + initial_funds
+        _returns_df["total_funds"] = _returns_df.net_pnl.cumsum() + initial_funds
         _returns_df = _returns_df.dropna()
 
         # Note: Quantstats has a potential bug. It cannot work with multiple entries having the same timestamp. For now, we are dropping multiple entries with the same entry_timestamp (else the quantstats code below would throw an error)
@@ -492,15 +629,22 @@ class AlgoBullsConnection:
         total_funds_series = _returns_df.total_funds
 
         # select report type
-        if report == "metrics":
-            order_report = qs.reports.metrics(total_funds_series)
-        elif report == "full":
-            order_report = qs.reports.full(total_funds_series)
+        try:
+            if report == "metrics":
+                order_report = qs.reports.metrics(total_funds_series)
+            elif report == "full":
+                order_report = qs.reports.full(total_funds_series)
+        except ZeroDivisionError:
+            raise Exception("ERROR: PnL data generated is too less to perform statistical analysis")
 
         # save as html file
         if html_dump:
-            all_strategies = self.get_all_strategies()
-            strategy_name = all_strategies.loc[all_strategies['strategyCode'] == strategy_code]['strategyName'].iloc[0]
+            # if there is an error in calling the API, give a default name to html file.
+            try:
+                all_strategies = self.get_all_strategies()
+                strategy_name = all_strategies.loc[all_strategies['strategyCode'] == strategy_code]['strategyName'].iloc[0]
+            except Exception:
+                strategy_name = 'strategy_results'
             qs.reports.html(total_funds_series, title=strategy_name, output='', download_filename=f'report_{strategy_name}_{time.time():.0f}.html')
 
         return order_report
@@ -563,7 +707,6 @@ class AlgoBullsConnection:
 
         Returns:
             job submission status
-            location of the instruments
         """
 
         # check if values received by new parameter names, else extract from old parameter names, else extract from saved parameters
@@ -603,6 +746,8 @@ class AlgoBullsConnection:
             candle_interval = CandleInterval[_]
         if isinstance(instruments, str):
             instruments = [instruments]
+        if strategy_parameters == {} or strategy_parameters is None:
+            strategy_parameters = dict()
 
         # Sanity checks - Validate config parameters
         assert isinstance(strategy_code, str), f'Argument "strategy" should be a valid string'
@@ -697,7 +842,7 @@ class AlgoBullsConnection:
         response = self.api.start_strategy_algotrading(strategy_code=strategy_code, start_timestamp=start_timestamp, end_timestamp=end_timestamp, trading_type=trading_type,
                                                        lots=lots, initial_funds_virtual=initial_funds_virtual, broker_details=broking_details, location=location)
 
-        self.strategy_locale_map[trading_type][strategy_code] = location
+        self.strategy_country_map[trading_type][strategy_code] = Country[Locale(location).name].value
         return response
 
     def backtest(self, strategy=None, start=None, end=None, instruments=None, lots=None, parameters=None, candle=None, mode=None, delete_previous_trades=True, initial_funds_virtual=None, vendor_details=None, **kwargs):
@@ -731,7 +876,7 @@ class AlgoBullsConnection:
         """
 
         # start backtesting job
-        response = self.start_job(
+        _ = self.start_job(
             strategy_code=strategy, start_timestamp=start, end_timestamp=end, instruments=instruments, lots=lots, strategy_parameters=parameters, candle_interval=candle, strategy_mode=mode,
             initial_funds_virtual=initial_funds_virtual, delete_previous_trades=delete_previous_trades, trading_type=TradingType.BACKTESTING, broking_details=vendor_details, **kwargs
         )
@@ -769,50 +914,53 @@ class AlgoBullsConnection:
 
         return self.stop_job(strategy_code=strategy_code, trading_type=TradingType.BACKTESTING)
 
-    def get_backtesting_logs(self, strategy_code, auto_update=True, display_logs_in_auto_update_mode=False):
+    def get_backtesting_logs(self, strategy_code, display_progress_bar=True, print_live_logs=False):
         """
         Fetch Back Testing logs
 
         Args:
             strategy_code: Strategy code
-            auto_update: If True, logs will be continuously fetched until strategy execution is complete. A progress bar will show the live status of strategy execution
-            display_logs_in_auto_update_mode: Applicable only if auto_update is True; display the logs as they are fetched
+            display_progress_bar: to track the execution on progress bar as your strategy is executed
+            print_live_logs: to print the live logs as your strategy is executed
 
         Returns:
             Report details
         """
 
         assert isinstance(strategy_code, str), f'Argument "strategy_code" should be a string'
+        assert isinstance(display_progress_bar, bool), f'Argument "display_progress_bar" should be a boolean'
+        assert isinstance(print_live_logs, bool), f'Argument "print_live_logs" should be a boolean'
 
-        return self.get_logs(strategy_code, trading_type=TradingType.BACKTESTING, auto_update=auto_update, display_logs_in_auto_update_mode=display_logs_in_auto_update_mode)
+        return self.get_logs(strategy_code, trading_type=TradingType.BACKTESTING, display_progress_bar=display_progress_bar, print_live_logs=print_live_logs)
 
-    def get_backtesting_report_pnl_table(self, strategy_code, location=None, show_all_rows=False, force_fetch=False):
+    def get_backtesting_report_pnl_table(self, strategy_code, country=None, force_fetch=False, broker_commission_percentage=None, broker_commission_price=None, slippage_percent=None):
         """
         Fetch Back Testing Profit & Loss details
 
         Args:
             strategy_code: strategy code
-            location: Location of Exchange
-            show_all_rows: True or False
+            country: country of Exchange
             force_fetch: Forcefully fetch PnL data
+            broker_commission_percentage: Percentage of broker commission per trade
+            broker_commission_price: Broker fee per trade
+            slippage_percent: Slippage percentage value
 
         Returns:
             Report details
         """
 
-        if self.backtesting_pnl_data is None or location is not None or force_fetch:
-            self.backtesting_pnl_data = self.get_pnl_report_table(strategy_code, TradingType.BACKTESTING, location)
+        if self.backtesting_pnl_data is None or country is not None or force_fetch:
+            self.backtesting_pnl_data = self.get_report_pnl_table(strategy_code, TradingType.BACKTESTING, country, broker_commission_percentage, broker_commission_price, slippage_percent)
 
         return self.backtesting_pnl_data
 
-    def get_backtesting_report_statistics(self, strategy_code, initial_funds=1e9, mode='quantstats', report='metrics', html_dump=False):
+    def get_backtesting_report_statistics(self, strategy_code, initial_funds=None, report='metrics', html_dump=False):
         """
         Fetch Back Testing report statistics
 
         Args:
             strategy_code: strategy code
             initial_funds: initial funds that were set before backtesting
-            mode: extension used to generate statistics
             report: format and content of the report
             html_dump: save it as a html file
 
@@ -831,20 +979,21 @@ class AlgoBullsConnection:
 
         return order_report
 
-    def get_backtesting_report_order_history(self, strategy_code):
+    def get_backtesting_report_order_history(self, strategy_code, country=None, render_as_dataframe=False):
         """
         Fetch Back Testing order history
 
         Args:
             strategy_code: strategy code
-
+            country: country of the segment
+            render_as_dataframe: return order history as dataframe or pretty string
         Returns:
             Report details
         """
 
         assert isinstance(strategy_code, str), f'Argument "strategy_code" should be a string'
 
-        return self.get_report(strategy_code=strategy_code, trading_type=TradingType.BACKTESTING, report_type=TradingReportType.ORDER_HISTORY)
+        return self.get_report_order_history(strategy_code=strategy_code, trading_type=TradingType.BACKTESTING, render_as_dataframe=render_as_dataframe, country=country)
 
     def papertrade(self, strategy=None, start=None, end=None, instruments=None, lots=None, parameters=None, candle=None, mode=None, delete_previous_trades=True, initial_funds_virtual=None, vendor_details=None, **kwargs):
         """
@@ -877,7 +1026,7 @@ class AlgoBullsConnection:
         """
 
         # start papertrading job
-        response = self.start_job(
+        _ = self.start_job(
             strategy_code=strategy, start_timestamp=start, end_timestamp=end, instruments=instruments, lots=lots, strategy_parameters=parameters, candle_interval=candle, strategy_mode=mode,
             initial_funds_virtual=initial_funds_virtual, delete_previous_trades=delete_previous_trades, trading_type=TradingType.PAPERTRADING, broking_details=vendor_details, **kwargs
         )
@@ -915,50 +1064,53 @@ class AlgoBullsConnection:
 
         return self.stop_job(strategy_code=strategy_code, trading_type=TradingType.PAPERTRADING)
 
-    def get_papertrading_logs(self, strategy_code, auto_update=False, display_logs_in_auto_update_mode=False):
+    def get_papertrading_logs(self, strategy_code, display_progress_bar=True, print_live_logs=True):
         """
         Fetch Paper Trading logs
 
         Args:
             strategy_code: Strategy code
-            auto_update: If True, logs will be continuously fetched until strategy execution is complete. A progress bar will show the live status of strategy execution
-            display_logs_in_auto_update_mode: Applicable only if auto_update is True; display the logs as they are fetched
+            display_progress_bar: to track the execution on progress bar as your strategy is executed
+            print_live_logs: to print the live logs as your strategy is executed
 
         Returns:
             Report details
         """
 
         assert isinstance(strategy_code, str), f'Argument "strategy_code" should be a string'
+        assert isinstance(display_progress_bar, bool), f'Argument "display_progress_bar" should be a boolean'
+        assert isinstance(print_live_logs, bool), f'Argument "print_live_logs" should be a boolean'
 
-        return self.get_logs(strategy_code=strategy_code, trading_type=TradingType.PAPERTRADING, auto_update=auto_update, display_logs_in_auto_update_mode=display_logs_in_auto_update_mode)
+        return self.get_logs(strategy_code, trading_type=TradingType.PAPERTRADING, display_progress_bar=display_progress_bar, print_live_logs=print_live_logs)
 
-    def get_papertrading_report_pnl_table(self, strategy_code, location=None, show_all_rows=False, force_fetch=False):
+    def get_papertrading_report_pnl_table(self, strategy_code, country=None, force_fetch=False, broker_commission_percentage=None, broker_commission_price=None, slippage_percent=None):
         """
         Fetch Paper Trading Profit & Loss details
 
         Args:
             strategy_code: strategy code
-            location: Location of the exchange
-            show_all_rows: True or False
+            country: country of the exchange
             force_fetch: Forcefully fetch PnL data
+            broker_commission_percentage: Percentage of broker commission per trade
+            broker_commission_price: Broker fee per trade
+            slippage_percent: Slippage percentage value
 
         Returns:
             Report details
         """
 
-        if self.papertrade_pnl_data is None or location is not None or force_fetch:
-            self.papertrade_pnl_data = self.get_pnl_report_table(strategy_code, TradingType.PAPERTRADING, location)
+        if self.papertrade_pnl_data is None or country is not None or force_fetch:
+            self.papertrade_pnl_data = self.get_report_pnl_table(strategy_code, TradingType.PAPERTRADING, country, broker_commission_percentage, broker_commission_price, slippage_percent)
 
         return self.papertrade_pnl_data
 
-    def get_papertrading_report_statistics(self, strategy_code, initial_funds=1e9, mode='quantstats', report='metrics', html_dump=False):
+    def get_papertrading_report_statistics(self, strategy_code, initial_funds=None, report='metrics', html_dump=False):
         """
         Fetch Paper Trading report statistics
 
         Args:
             strategy_code: strategy code
             initial_funds: initial funds allotted before papertrading
-            mode: extension used to generate statistics
             report: format and content of the report
             html_dump: save it as a html file
 
@@ -977,12 +1129,14 @@ class AlgoBullsConnection:
 
         return order_report
 
-    def get_papertrading_report_order_history(self, strategy_code):
+    def get_papertrading_report_order_history(self, strategy_code, country=None, render_as_dataframe=False):
         """
         Fetch Paper Trading order history
 
         Args:
-            strategy_code: Strategy code
+            strategy_code: strategy code
+            country: country of the segment
+            render_as_dataframe: return order history as dataframe or pretty string
 
         Returns:
             Report details
@@ -990,7 +1144,7 @@ class AlgoBullsConnection:
 
         assert isinstance(strategy_code, str), f'Argument "strategy_code" should be a string'
 
-        return self.get_report(strategy_code=strategy_code, trading_type=TradingType.PAPERTRADING, report_type=TradingReportType.ORDER_HISTORY)
+        return self.get_report_order_history(strategy_code=strategy_code, trading_type=TradingType.PAPERTRADING, render_as_dataframe=render_as_dataframe, country=country)
 
     def realtrade(self, strategy=None, start=None, end=None, instruments=None, lots=None, parameters=None, candle=None, mode=None, broking_details=None, **kwargs):
         """
@@ -1024,9 +1178,8 @@ class AlgoBullsConnection:
         """
 
         # start realtrading job
-        response = self.start_job(strategy_code=strategy, start_timestamp=start, end_timestamp=end, instruments=instruments, lots=lots, strategy_parameters=parameters, candle_interval=candle, strategy_mode=mode, trading_type=TradingType.REALTRADING,
-                                  broking_details=broking_details,
-                                  **kwargs)
+        _ = self.start_job(strategy_code=strategy, start_timestamp=start, end_timestamp=end, instruments=instruments, lots=lots, strategy_parameters=parameters, candle_interval=candle, strategy_mode=mode, trading_type=TradingType.REALTRADING,
+                           broking_details=broking_details, **kwargs)
 
         # Update previously saved pnl data and exchange location
         self.realtrade_pnl_data = None
@@ -1064,50 +1217,52 @@ class AlgoBullsConnection:
 
         return self.stop_job(strategy_code=strategy_code, trading_type=TradingType.REALTRADING)
 
-    def get_realtrading_logs(self, strategy_code, auto_update=False, display_logs_in_auto_update_mode=False):
+    def get_realtrading_logs(self, strategy_code, display_progress_bar=True, print_live_logs=True):
         """
         Fetch Real Trading logs
 
         Args:
             strategy_code: Strategy code
-            auto_update: If True, logs will be continuously fetched until strategy execution is complete. A progress bar will show the live status of strategy execution
-            display_logs_in_auto_update_mode: Applicable only if auto_update is True; display the logs as they are fetched
+            display_progress_bar: to track the execution on progress bar as your strategy is executed
+            print_live_logs: to print the live logs as your strategy is executed
 
         Returns:
             Report details
         """
 
         assert isinstance(strategy_code, str), f'Argument "strategy_code" should be a string'
+        assert isinstance(display_progress_bar, bool), f'Argument "display_progress_bar" should be a boolean'
+        assert isinstance(print_live_logs, bool), f'Argument "print_live_logs" should be a boolean'
 
-        return self.get_logs(strategy_code=strategy_code, trading_type=TradingType.REALTRADING, auto_update=auto_update, display_logs_in_auto_update_mode=display_logs_in_auto_update_mode)
+        return self.get_logs(strategy_code, trading_type=TradingType.REALTRADING, display_progress_bar=display_progress_bar, print_live_logs=print_live_logs)
 
-    def get_realtrading_report_pnl_table(self, strategy_code, location=None, show_all_rows=False, force_fetch=False):
+    def get_realtrading_report_pnl_table(self, strategy_code, country=None, force_fetch=False, broker_commission_percentage=None, broker_commission_price=None):
         """
         Fetch Real Trading Profit & Loss details
 
         Args:
             strategy_code: strategy code
-            location: Location of the Exchange
-            show_all_rows: True or False
+            country: country of the Exchange
             force_fetch: Forcefully fetch PnL data
+            broker_commission_percentage: Percentage of broker commission per trade
+            broker_commission_price: Broker fee per trade
 
         Returns:
             Report details
         """
 
-        if self.realtrade_pnl_data is None or location is not None or force_fetch:
-            self.realtrade_pnl_data = self.get_pnl_report_table(strategy_code, TradingType.REALTRADING, location)
+        if self.realtrade_pnl_data is None or country is not None or force_fetch:
+            self.realtrade_pnl_data = self.get_report_pnl_table(strategy_code, TradingType.REALTRADING, country, broker_commission_percentage, broker_commission_price)
 
         return self.realtrade_pnl_data
 
-    def get_realtrading_report_statistics(self, strategy_code, initial_funds=1e9, mode='quantstats', report='metrics', html_dump=False):
+    def get_realtrading_report_statistics(self, strategy_code, initial_funds=None, report='metrics', html_dump=False):
         """
         Fetch Real Trading report statistics
 
         Args:
             strategy_code: strategy code
             initial_funds: initial funds allotted before realtrading
-            mode: extension used to generate statistics
             report: format and content of the report
             html_dump: save it as a html file
 
@@ -1126,11 +1281,13 @@ class AlgoBullsConnection:
 
         return order_report
 
-    def get_realtrading_report_order_history(self, strategy_code):
+    def get_realtrading_report_order_history(self, strategy_code, country=None, render_as_dataframe=False):
         """
         Fetch Real Trading order history
         Args:
-            strategy_code: Strategy code
+            strategy_code: strategy code
+            country: country of the segment
+            render_as_dataframe: return order history as dataframe or pretty string
 
         Returns:
             Report details
@@ -1138,7 +1295,7 @@ class AlgoBullsConnection:
         # assert (isinstance(broker, AlgoBullsSupportedBrokers) is True), f'Argument broker should be an enum of type {AlgoBullsSupportedBrokers.__name__}'
         assert isinstance(strategy_code, str), f'Argument "strategy_code" should be a string'
 
-        return self.get_report(strategy_code=strategy_code, trading_type=TradingType.REALTRADING, report_type=TradingReportType.ORDER_HISTORY)
+        return self.get_report_order_history(strategy_code=strategy_code, trading_type=TradingType.REALTRADING, render_as_dataframe=render_as_dataframe, country=country)
 
 
 def pandas_dataframe_all_rows():

pyalgotrading/constants.py

@@ -255,6 +255,15 @@ class Locale(Enum):
     USA = 'en-US'
 
 
+class Country(Enum):
+    """
+    A class of countries
+    """
+    DEFAULT = 'USA'
+    INDIA = 'India'
+    USA = 'USA'
+
+
 class ExecutionStatus(Enum):
     """
     A class of status values of execution
@@ -265,6 +274,41 @@ class ExecutionStatus(Enum):
     STOPPED = 'STOPPED'
 
 
+class OptionsStrikeDirection(Enum):
+    ITM = 'ITM'
+    ATM = 'ATM'
+    OTM = 'OTM'
+
+
+class OptionsTradingsymbolSuffix(Enum):
+    CE = 'CE'
+    PE = 'PE'
+
+
+class OptionsExpiryKey(Enum):
+    WEEKLY_CURRENT = 'WEEKLY_CURRENT'
+    WEEKLY_NEXT = 'WEEKLY_NEXT'
+    MONTHLY_CURRENT = 'MONTHLY_CURRENT'
+    MONTHLY_NEXT = 'MONTHLY_NEXT'
+
+
+class OptionsInstrumentDirection(Enum):
+    EXACT = 'EXACT'
+    ROUNDUP = 'ROUNDUP'
+    ROUNDDOWN = 'ROUNDDOWN'
+
+
+CandleIntervalSecondsMap = {
+    'minute': 60,
+    '3minutes': 180,
+    '5minutes': 300,
+    '10minutes': 600,
+    '15minutes': 900,
+    '30minutes': 1800,
+    '60minutes': 3600,
+    'day': 86400
+}
+
 KEY_DT_FORMAT_WITH_TIMEZONE = 0
 KEY_DT_FORMAT_WITHOUT_TIMEZONE = 1
 

pyalgotrading/strategy/__init__.py

@@ -1 +1,3 @@
+from ..constants import *
 from .strategy_base import StrategyBase
+from .strategy_options_base_v2 import StrategyOptionsBaseV2

pyalgotrading/strategy/strategy_options_base_v2.py

@@ -0,0 +1,90 @@
+from pyalgotrading.strategy.strategy_base import StrategyBase
+from pyalgotrading.constants import *
+
+
+class StrategyOptionsBaseV2(StrategyBase):
+    """
+    Dummy placeholder class. Here to ensure all required methods are implemented and as per requirements.
+
+    Once uploaded, this strategy will be replaced with the real base class strategy
+    """
+
+    @staticmethod
+    def get_options_ref_key(instrument, expiry_date):
+        pass
+
+    def initialize_instrument(self, instrument):
+        pass
+
+    def get_allowed_expiry_dates(self):
+        """
+        Gives the allowed expiry date, depending on the selection of monthly expiry or weekly expiry.
+        Checkout the documentation to understand in more detail
+        """
+        return []
+
+    def options_instruments_set_up(self, base_instrument, instrument_direction, expiry_date, tradingsymbol_suffix, ltp=None, apply_modulo=False, modulo_value=100):
+        pass
+
+    def get_options_instruments(self, base_instrument, expiry_date, tradingsymbol_suffix, instrument_direction, ltp, apply_modulo=False, modulo_value=100):
+        pass
+
+    def get_options_instrument_with_strike_direction(self, base_instrument, expiry_date, tradingsymbol_suffix, strike_direction, no_of_strikes):
+        instrument = None
+        return instrument
+
+
+class IntrumentsMappingManager:
+    def __init__(self):
+        self.base_instrument_to_instrument_map_list = {}
+        self.instrument_to_base_instrument_map = {}
+
+    def add_mappings(self, base_instrument, child_instruments):
+        pass
+
+    def is_base_instrument(self, instrument):
+        return
+
+    def is_child_instrument(self, instrument):
+        return
+
+    def get_base_instrument(self, instrument):
+        return
+
+    def get_child_instruments_list(self, instrument):
+        return
+
+
+class OrderTagManager:
+
+    def add_order(self, order, tags=None):
+        """
+        Adds an order to tags extracted from the order object as well as given tags (if any)
+        """
+        return
+
+    # take 1 or more tags; return 1 or more items if many=True; return only 1 item if many=False;
+    def get_orders(self, tags, many=False, ignore_errors=False):
+        """
+        Takes 1 or more tags; returns 1 or more orders if many=True; returns only 1 order if many=False
+        """
+        return
+
+    def remove_tags(self, tags):
+        """
+        Removes 1 or more tags from the data structure
+        """
+        return
+
+    def remove_order(self, order):
+        """
+        Removes an order from the data structure
+        """
+        return
+
+    def get_internals(self):
+        """
+        Returns the complete data structure
+        The developer should use this for debugging, but remove its usages before finalizing
+        """
+        return

pyalgotrading/utils/func.py

@@ -2,7 +2,7 @@
 A module for plotting candlesticks
 """
 from datetime import datetime as dt, timezone
-
+import random
 import pandas as pd
 
 from pyalgotrading.constants import PlotType, TRADING_TYPE_DT_FORMAT_MAP, KEY_DT_FORMAT_WITHOUT_TIMEZONE, KEY_DT_FORMAT_WITH_TIMEZONE
@@ -156,8 +156,69 @@ def get_datetime_with_tz(timestamp_str, trading_type, label=''):
             timestamp_str = dt.strptime(timestamp_str, TRADING_TYPE_DT_FORMAT_MAP[trading_type][KEY_DT_FORMAT_WITHOUT_TIMEZONE])
             timestamp_str = timestamp_str.replace(tzinfo=timezone.utc)
             print(f'Warning: Timezone info not provided. Expected timestamp format is "{TRADING_TYPE_DT_FORMAT_MAP[trading_type][KEY_DT_FORMAT_WITH_TIMEZONE]}", received time "{timestamp_str}". Assuming timezone as UTC(+0000)...')
-        except ValueError as ex:
-            raise ValueError(f'Error: Invalid string timestamp format for argument "{label}".\nExpected timestamp format for {trading_type.name} is "{TRADING_TYPE_DT_FORMAT_MAP[trading_type][KEY_DT_FORMAT_WITH_TIMEZONE]}". Received "{timestamp_str}" instead.')
+        except ValueError:
+            raise ValueError(f'Error: Invalid string timestamp format for argument "{label}".\nExpected timestamp format for {trading_type.name} is "{TRADING_TYPE_DT_FORMAT_MAP[trading_type][KEY_DT_FORMAT_WITH_TIMEZONE]}". '
+                             f'Received "{timestamp_str}" instead.')
 
     return timestamp_str
 
+
+def calculate_slippage(pnl_df, slippage_percent):
+    if 'exit_variety' not in pnl_df.columns or 'entry_variety' not in pnl_df.columns:
+        pnl_df['exit_variety'] = 'MARKET'
+        pnl_df['entry_variety'] = 'MARKET'
+        print('WARNING: Column for Order Variety not found. Assuming all trades are Market Orders.')
+
+    pnl_df[['entry_price', 'exit_price']] = pnl_df.apply(
+        lambda row: (slippage(row.entry_price, row.entry_variety, row.entry_transaction_type, slippage_percent), slippage(row.exit_price, row.exit_variety, row.exit_transaction_type, slippage_percent)), axis=1, result_type='expand')
+
+    pnl_df['pnl_absolute'] = pnl_df['exit_price'] - pnl_df['entry_price']
+    return pnl_df
+
+
+def calculate_brokerage(pnl_df, brokerage_percentage, brokerage_flat_price):
+    # generate brokerage data
+    brokerage_generated = False
+
+    # brokerage commission based on only percentage
+    if brokerage_percentage is not None:
+        pnl_df['brokerage'] = ((pnl_df['entry_price'] * pnl_df['entry_quantity']) + (pnl_df['exit_price'] * pnl_df['exit_quantity'])) * (brokerage_percentage / 100)
+        brokerage_generated = True
+
+    # brokerage commission based on only flat price
+    elif brokerage_flat_price is not None:
+        pnl_df['brokerage'] = brokerage_flat_price
+        brokerage_generated = True
+
+    # brokerage 0
+    else:
+        pnl_df['brokerage'] = 0
+
+    # brokerage commission based on minimum of percentage and flat price
+    if brokerage_percentage is not None and brokerage_flat_price is not None:
+        pnl_df["brokerage"].loc[pnl_df["brokerage"] > brokerage_flat_price] = brokerage_flat_price
+        brokerage_generated = True
+
+    if brokerage_generated:
+        pnl_df['net_pnl'] = pnl_df['pnl_absolute'] - pnl_df['brokerage']
+    else:
+        pnl_df['net_pnl'] = pnl_df['pnl_absolute']
+
+    return pnl_df
+
+
+def slippage(price, variety, transaction_type, slip_percent=1):
+
+    # convert slippage percentage to decimal
+    slip_percent = abs(slip_percent) / 100
+
+    # if market orders, we consider negative as well as positive slippage
+    if variety in ['MARKET', 'STOPLOSS_MARKET']:
+        return price*(1 + random.choice([1, 0, -1]) * slip_percent)
+
+    # if limit orders, we consider only positive slippage
+    else:
+        if transaction_type == 'BUY':
+            return price*(1 + random.choice([0, -1]) * slip_percent)
+        else:
+            return price*(1 + random.choice([1, 0]) * slip_percent)

{pyalgotrading-2023.7.1.dist-info → pyalgotrading-2023.10.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyalgotrading
-Version: 2023.7.1
+Version: 2023.10.1
 Summary: Official Python Package for Algorithmic Trading APIs powered by AlgoBulls
 Home-page: https://github.com/algobulls/pyalgotrading
 Author: Pushpak Dagade
@@ -25,8 +25,9 @@ Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
 Requires-Python: >=3.6
 Description-Content-Type: text/markdown
-Requires-Dist: requests (>=2.24.0)
-Requires-Dist: pandas (>=0.25.3)
+License-File: LICENSE
+Requires-Dist: pandas >=0.25.3
+Requires-Dist: requests >=2.24.0
 
 # pyalgotrading
 

{pyalgotrading-2023.7.1.dist-info → pyalgotrading-2023.10.1.dist-info}/RECORD

@@ -1,8 +1,8 @@
 pyalgotrading/__init__.py,sha256=e0lmS8IOW1JBf_jfyDAO-9cCEyNsNoSCjwetSCWPeIg,181
-pyalgotrading/constants.py,sha256=tXclfw_CW5A9arWh2ZmHBRBqWRmOHGAji_AAVIhUl-E,6544
+pyalgotrading/constants.py,sha256=gAzDcdmOqYGFC2GYC9w1i_aSCUF03eFhCLNZNOYCwLM,7309
 pyalgotrading/algobulls/__init__.py,sha256=IRkbWtJfgQnPH7gikjqpa6QsYnmk_NQ1lwtx7LPIC6c,133
-pyalgotrading/algobulls/api.py,sha256=EIh0PUFyWzVXin_jWvd9MpF45gs9EWvdUPkQ05aOfYE,19585
-pyalgotrading/algobulls/connection.py,sha256=oNlGOWjrPF0exKjJBSaQ9HUFZ5iQ7sR-_z5oDf4y3EI,51042
+pyalgotrading/algobulls/api.py,sha256=fhW0Ms73FqLGRSzz5HDB95ViNsnstXFig8aqGECODCY,19594
+pyalgotrading/algobulls/connection.py,sha256=DKCzloCaZ8sQCr5YXqapQKxpdE_B1svKYkgvETHrzYY,59399
 pyalgotrading/algobulls/exceptions.py,sha256=B96On8cN8tgtX7i4shKOlYfvjSjvspIRPbOpyF-jn0I,2187
 pyalgotrading/broker/__init__.py,sha256=jXVWBVRlqzevKxNDqrPANJz9WubROBes8gaKcxcYz58,66
 pyalgotrading/broker/broker_connection_base.py,sha256=vAJN5EAQuVfL8Ngf03wsaI5TTGdziCHKCb0bczGgSJ0,7594
@@ -14,17 +14,18 @@ pyalgotrading/order/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSu
 pyalgotrading/order/order_base.py,sha256=trC_bvazLNvvuGqZEdacxzlacc3g73ZvqpedYYwuKJA,1742
 pyalgotrading/order/order_bracket_base.py,sha256=7Sj0nlCWE20wZiZ12NciptPYKKGE9KsnKLCjdO7sKV4,3576
 pyalgotrading/order/order_regular_base.py,sha256=wOFmv7QnxJvNKtqdoZn0a-cbTotik4cap5Z5mz0Qcs0,2313
-pyalgotrading/strategy/__init__.py,sha256=NSR4t9X44sjL8jVEg11SBt-_J8i8sArHE_LZX6m3lcU,40
+pyalgotrading/strategy/__init__.py,sha256=V58WuYIWpsmbs5pat5Z1FLxOR3nHwjaIhnJTQ8tzAUA,126
 pyalgotrading/strategy/strategy_base.py,sha256=9I6ZdZT1IimO9g03QURrFo2Pxvs4Dsk8Ybdtij8ZIUQ,4717
+pyalgotrading/strategy/strategy_options_base_v2.py,sha256=3SfCvWjz8eGXtlB2hIXREAODV0PbrtXIYgXRFB08UjQ,2765
 pyalgotrading/strategy/validate_strategy.py,sha256=Ot2kvROtG-tpcbK_Fv-OdapG8oNdgvSNV2hTWtfTCQI,482
 pyalgotrading/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pyalgotrading/utils/func.py,sha256=V1ktGhQqr1Hdyw30B6TMQ5wntnrW7NVwQZd1enyjyFc,8656
+pyalgotrading/utils/func.py,sha256=Vadc2kbJox0vmBBUWD6DvuWB08rvYGDfvDi-pyOefUA,11155
 pyalgotrading/utils/candlesticks/__init__.py,sha256=maIn__tvTvJDjldPhU9agBcNNuROt_lpNTV4CZ1Yl6I,83
 pyalgotrading/utils/candlesticks/heikinashi.py,sha256=SpcuK7AYV0sgzcw-DMfLNtTDn2RfWqGvWBt4no7yKD4,2003
 pyalgotrading/utils/candlesticks/linebreak.py,sha256=cYwoETMrenWOa06d03xASZoiou-qRz7n2mZYCi5ilEs,1434
 pyalgotrading/utils/candlesticks/renko.py,sha256=zovQ6D658pBLas86FuTu9fU3-Kkv2hM-4h7OQJjdxng,2089
-pyalgotrading-2023.7.1.dist-info/LICENSE,sha256=-LLEprvixKS-LwHef99YQSOFon_tWeTwJRAWuUwwr1g,1066
-pyalgotrading-2023.7.1.dist-info/METADATA,sha256=8JVGrO4p_ZvHy1WAvX4P4iA6UapgYhLGRVjCxJc0dW8,5123
-pyalgotrading-2023.7.1.dist-info/WHEEL,sha256=g4nMs7d-Xl9-xC9XovUrsDHGXt-FT0E17Yqo92DEfvY,92
-pyalgotrading-2023.7.1.dist-info/top_level.txt,sha256=A12PTnbXqO3gsZ0D0Gkyzf_OYRQxjJvtg3MqN-Ur2zY,14
-pyalgotrading-2023.7.1.dist-info/RECORD,,
+pyalgotrading-2023.10.1.dist-info/LICENSE,sha256=-LLEprvixKS-LwHef99YQSOFon_tWeTwJRAWuUwwr1g,1066
+pyalgotrading-2023.10.1.dist-info/METADATA,sha256=bEA0ZdUGea69WTYNxyEdqPKTmO9SbRtt3pJom3I-aI0,5142
+pyalgotrading-2023.10.1.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
+pyalgotrading-2023.10.1.dist-info/top_level.txt,sha256=A12PTnbXqO3gsZ0D0Gkyzf_OYRQxjJvtg3MqN-Ur2zY,14
+pyalgotrading-2023.10.1.dist-info/RECORD,,

{pyalgotrading-2023.7.1.dist-info → pyalgotrading-2023.10.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.34.2)
+Generator: bdist_wheel (0.41.2)
 Root-Is-Purelib: true
 Tag: py3-none-any