quantplay 2.0.34__tar.gz → 2.0.36__tar.gz

{quantplay-2.0.34 → quantplay-2.0.36}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: quantplay
-Version: 2.0.34
+Version: 2.0.36
 Summary: This python package will be stored in AWS CodeArtifact
 Home-page: 
 Author: 

{quantplay-2.0.34 → quantplay-2.0.36}/quantplay/broker/aliceblue.py

@@ -134,7 +134,7 @@ class Aliceblue(Broker):
             return TransactionType.Sell
 
         raise InvalidArgumentException(
-            "transaction type {} not supported for trading".format(transaction_type)
+            f"transaction type {transaction_type} not supported for trading"
         )
 
     def get_order_type(self, order_type):
@@ -170,9 +170,7 @@ class Aliceblue(Broker):
         ]:
             return product
 
-        raise InvalidArgumentException(
-            "Product {} not supported for trading".format(product)
-        )
+        raise InvalidArgumentException(f"Product {product} not supported for trading")
 
     def place_order(
         self,

{quantplay-2.0.34 → quantplay-2.0.36}/quantplay/broker/angelone.py

@@ -5,7 +5,7 @@ import json
 import pickle
 from queue import Queue
 import traceback
-from typing import Callable, Dict
+from typing import Any, Callable, Dict
 
 from SmartApi.smartExceptions import DataException
 import polars as pl
@@ -157,9 +157,7 @@ class AngelOne(Broker):
         elif product in ["BO", "MARGIN", "INTRADAY", "CARRYFORWARD", "DELIVERY"]:
             return product
 
-        raise InvalidArgumentException(
-            "Product {} not supported for trading".format(product)
-        )
+        raise InvalidArgumentException(f"Product {product} not supported for trading")
 
     def ltp(self, exchange, tradingsymbol: str) -> float:
         if tradingsymbol in MarketConstants.INDEX_SYMBOL_TO_DERIVATIVE_SYMBOL_MAP:
@@ -224,7 +222,7 @@ class AngelOne(Broker):
                 "ordertag": tag,
             }
 
-            Constants.logger.info("[PLACING_ORDER] {}".format(json.dumps(order)))
+            Constants.logger.info(f"[PLACING_ORDER] {json.dumps(order)}")
             return self.invoke_angelone_api(self.wrapper.placeOrder, orderparams=order)
 
         except (TimeoutError, ConnectTimeout):
@@ -563,7 +561,7 @@ class AngelOne(Broker):
         stop_max_attempt_number=3,
         retry_on_exception=retry_exception,
     )
-    def invoke_angelone_api(self, fn: Callable, *args, **kwargs) -> Dict:
+    def invoke_angelone_api(self, fn: Callable, *args, **kwargs) -> Any:
         try:
             response = fn(*args, **kwargs)
             if "errorCode" in response and response["errorCode"] == "AG8001":

{quantplay-2.0.34 → quantplay-2.0.36}/quantplay/broker/five_paisa.py

@@ -1,3 +1,4 @@
+from ast import alias
 import codecs
 import pickle
 import traceback
@@ -5,7 +6,7 @@ from typing import Dict
 
 import polars as pl
 import pyotp
-from py5paisa import FivePaisaClient
+from py5paisa import FivePaisaClient  # type: ignore
 from retrying import retry  # type: ignore
 
 from quantplay.broker.generics.broker import Broker
@@ -147,9 +148,8 @@ class FivePaisa(Broker):
         return self.client.fetch_market_feed_scrip(req_list_)["Data"][0]["LastRate"]  # type: ignore
 
     def add_exchange(self, data: pl.DataFrame):
-        data["exchange"] = None
-
         return data.with_columns(
+            pl.lit(None).alias("exchange"),
             pl.when((pl.col("Exch").eq("N")) & (pl.col("ExchType").eq("D")))
             .then(pl.lit("NFO"))
             .alias("exchange"),

{quantplay-2.0.34 → quantplay-2.0.36}/quantplay/broker/generics/broker.py

@@ -147,7 +147,7 @@ class Broker:
         if not input:
             raise InvalidArgumentException(message)
 
-    def symbol_attribute(self, exchange: ExchangeType, symbol, value):
+    def symbol_attribute(self, exchange: ExchangeType, symbol: str, value):
         try:
             return_value = self.symbol_data[f"{exchange}:{symbol}"][value]
             return return_value
@@ -307,6 +307,7 @@ class Broker:
         file_name = url.split(".txt")[0].split("/")[-1]
         os.system("cp /tmp/{}.txt /tmp/{}.csv".format(file_name, file_name))
         time.sleep(2)
+
         return pd.read_csv("/tmp/{}.csv".format(file_name))
 
     def initialize_expiry_fields(self):
@@ -1166,13 +1167,13 @@ class Broker:
                 if modification_count[order_id] > max_modification_count:
                     order["order_type"] = "MARKET"
                     order["price"] = 0
-                    Constants.logger.info("Placing MARKET order [{}]".format(order))
+                    Constants.logger.info(f"Placing MARKET order [{order}]")
                     self.modify_order(order)  # type: ignore
 
                 elif modification_count[order_id] > 20:
                     self.cancel_order(order_id)
                     Constants.logger.error(
-                        "Max Modification Limit Exceeded : [{}]".format(order_id)
+                        f"Max Modification Limit Exceeded : [{order_id}]"
                     )
 
     def log_event(

{quantplay-2.0.34 → quantplay-2.0.36}/quantplay/broker/uplink/uplink_utils.py

@@ -71,7 +71,6 @@ class UplinkUtils:
 
             time.sleep(2)
             url = f"{UplinkUtils.auth_url}dialog?response_type=code&client_id={api_key}&redirect_uri={redirect_url}"
-            print("Upstox Url {}".format(url))
 
             driver.get(url)
             time.sleep(1)

{quantplay-2.0.34 → quantplay-2.0.36}/quantplay/broker/upstox.py

@@ -142,8 +142,8 @@ class Upstox(Broker):
                 f"{self.get_exchange(symbol_info['exchange'])}:{tradingsymbol}"
             ].last_price
         except ApiException as e:
-            Constants.logger.error("Exception when calling MarketQuoteApi->ltp: %s\n" % e)
             self.handle_exception(e)
+            Constants.logger.error("Exception when calling MarketQuoteApi->ltp: %s\n" % e)
         return ltp
 
     @retry(
@@ -172,6 +172,7 @@ class Upstox(Broker):
             api_response = api_instance.modify_order(body, self.api_version)
             return api_response.status  # type:ignore
         except ApiException as e:
+            self.handle_exception(e)
             Constants.logger.error(
                 "Exception when calling OrderApi->modify_order: %s\n" % e
             )
@@ -181,10 +182,9 @@ class Upstox(Broker):
                     order_to_modify["order_id"], order_to_modify["price"]
                 )
             )
-            self.handle_exception(e)
         return order_to_modify["order_id"]
 
-    def cancel_order(self, order_id: str, variety=None) -> None:
+    def cancel_order(self, order_id: str, variety: str | None = None) -> None:
         api_instance = upstox_client.OrderApi(self.api_client)
 
         try:
@@ -289,8 +289,8 @@ class Upstox(Broker):
             self.email = response["email"]
             self.enabled_exchanges = response["exchanges"]
         except ApiException as e:
-            Constants.logger.info("error when calling UserApi->get_profile: %s\n" % e)
             self.handle_exception(e)
+            Constants.logger.info("error when calling UserApi->get_profile: %s\n" % e)
 
         self.user_id = response["user_id"]
         return response
@@ -305,10 +305,10 @@ class Upstox(Broker):
             holdings = [holding.to_dict() for holding in api_response.data]  # type:ignore
             holdings_df = pl.DataFrame(holdings)
         except ApiException as e:
+            self.handle_exception(e)
             Constants.logger.error(
                 "Exception when calling PortfolioApi->get_holdings: %s\n" % e
             )
-            self.handle_exception(e)
 
         if len(holdings_df) == 0:
             return pl.DataFrame(schema=self.holidings_schema)
@@ -359,10 +359,10 @@ class Upstox(Broker):
             ]
             positions_df = pl.DataFrame(positions)
         except ApiException as e:
+            self.handle_exception(e)
             Constants.logger.error(
                 "Exception when calling PortfolioApi->get_positions: %s\n" % e
             )
-            self.handle_exception(e)
 
         if len(positions_df) == 0:
             return pl.DataFrame(schema=self.positions_schema)
@@ -451,10 +451,10 @@ class Upstox(Broker):
             orders = [order.to_dict() for order in api_response.data]  # type:ignore
             orders_df = pl.DataFrame(orders)
         except ApiException as e:
+            self.handle_exception(e)
             Constants.logger.error(
                 "Exception when calling OrderApi->get_order_book: %s\n" % e
             )
-            self.handle_exception(e)
 
         if len(orders_df) == 0:
             return pl.DataFrame(schema=self.orders_schema)
@@ -570,10 +570,10 @@ class Upstox(Broker):
                 api_response.data["equity"].available_margin  # type:ignore
             )
         except ApiException as e:
+            self.handle_exception(e)
             Constants.logger.error(
                 "Exception when calling UserApi->get_user_fund_margin: %s\n" % e
             )
-            self.handle_exception(e)
 
         margins = {
             "margin_used": margin_used,

{quantplay-2.0.34 → quantplay-2.0.36}/quantplay/broker/xts.py

@@ -52,7 +52,7 @@ class XTS(Broker):
         self.root_url = root_url
 
         try:
-            if wrapper:
+            if wrapper and ClientID:
                 self.set_wrapper(wrapper, md_wrapper)
                 self.ClientID = ClientID
                 self.wrapper.root = root_url
@@ -164,7 +164,7 @@ class XTS(Broker):
         ):
             raise TokenException(response["description"])
         if "type" in response and response["type"] == "error":
-            raise Exception("[XTS_Error]: " + response["description"])
+            raise Exception(f"[XTS_Error]: {response["description"]}")
 
     @retry(
         wait_exponential_multiplier=3000,
@@ -668,7 +668,7 @@ class XTS(Broker):
         disclosed_quantity = 0
 
         api_response = self.wrapper.modify_order(
-            appOrderID=order_id,
+            appOrderID=int(order_id),
             modifiedTimeInForce=time_in_force,
             modifiedDisclosedQuantity=disclosed_quantity,
             modifiedLimitPrice=price,
@@ -698,6 +698,9 @@ class XTS(Broker):
         )
 
     def stream_order_updates(self):
+        if self.wrapper.token is None:
+            raise InvalidArgumentException("XTS Token Missing")
+
         socket = OrderSocket_io(
             userID=self.ClientID,
             token=self.wrapper.token,

{quantplay-2.0.34 → quantplay-2.0.36}/quantplay/broker/xts_utils/Connect.py

@@ -9,7 +9,7 @@ import json
 import logging
 import os
 import traceback
-from typing import Any, Dict, Literal
+from typing import Any, Dict, List, Literal
 
 import requests
 import urllib3
@@ -20,6 +20,7 @@ from six.moves.urllib.parse import urljoin  # type:ignore
 from quantplay.broker.xts_utils import Exception as ex
 from quantplay.broker.xts_utils.Exception import XTSDataException
 from quantplay.exception.exceptions import BrokerException
+from quantplay.model.xts import ExchangeSegmentType
 
 log = logging.getLogger(__name__)
 
@@ -346,15 +347,15 @@ class XTSConnect(XTSCommon):
 
     def modify_order(
         self,
-        appOrderID,
+        appOrderID: int,
         modifiedProductType,
         modifiedOrderType,
-        modifiedOrderQuantity,
-        modifiedDisclosedQuantity,
-        modifiedLimitPrice,
-        modifiedStopPrice,
+        modifiedOrderQuantity: int,
+        modifiedDisclosedQuantity: int,
+        modifiedLimitPrice: float,
+        modifiedStopPrice: float,
         modifiedTimeInForce,
-        orderUniqueIdentifier,
+        orderUniqueIdentifier: str,
         clientID: str | None = None,
     ):
         """The facility to modify your open orders by allowing you to change limit order to market or vice versa,
@@ -468,7 +469,7 @@ class XTSConnect(XTSCommon):
             raise BrokerException("convert_position Failed for XTS")
 
     def cancel_order(
-        self, appOrderID, orderUniqueIdentifier, clientID: str | None = None
+        self, appOrderID: int, orderUniqueIdentifier: str, clientID: str | None = None
     ):
         """This API can be called to cancel any open order of the user by providing correct appOrderID matching with
         the chosen open order to cancel."""
@@ -485,7 +486,7 @@ class XTSConnect(XTSCommon):
             traceback.print_exc()
             raise BrokerException("cancel_order Failed for XTS")
 
-    def cancelall_order(self, exchangeSegment, exchangeInstrumentID):
+    def cancelall_order(self, exchangeSegment: ExchangeSegmentType, exchangeInstrumentID):
         """This API can be called to cancel all open order of the user by providing exchange segment and exchange instrument ID"""
         try:
             params: Dict[str, Any] = {
@@ -506,10 +507,10 @@ class XTSConnect(XTSCommon):
         exchangeInstrumentID,
         orderSide,
         orderType,
-        orderQuantity,
-        disclosedQuantity,
-        limitPrice,
-        stopPrice,
+        orderQuantity: int,
+        disclosedQuantity: int,
+        limitPrice: float,
+        stopPrice: float,
         orderUniqueIdentifier,
         clientID: str | None = None,
     ):
@@ -537,7 +538,7 @@ class XTSConnect(XTSCommon):
             traceback.print_exc()
             raise BrokerException("place_cover_order Failed for XTS")
 
-    def exit_cover_order(self, appOrderID, clientID: str | None = None):
+    def exit_cover_order(self, appOrderID: int, clientID: str | None = None):
         """Exit Cover API is a functionality to enable user to easily exit an open stoploss order by converting it
         into Exit order."""
         try:
@@ -583,7 +584,7 @@ class XTSConnect(XTSCommon):
             traceback.print_exc()
             raise BrokerException("squareoff_position Failed for XTS")
 
-    def get_order_history(self, appOrderID, clientID: str | None = None):
+    def get_order_history(self, appOrderID: int, clientID: str | None = None):
         """Order history will provide particular order trail chain. This indicate the particular order & its state
         changes. i.e.Pending New to New, New to PartiallyFilled, PartiallyFilled, PartiallyFilled & PartiallyFilled
         to Filled etc"""
@@ -677,7 +678,7 @@ class XTSConnect(XTSCommon):
             traceback.print_exc()
             raise BrokerException("send_unsubscription Failed for XTS")
 
-    def get_master(self, exchangeSegmentList):
+    def get_master(self, exchangeSegmentList: List[ExchangeSegmentType]):
         try:
             params: Dict[str, Any] = {"exchangeSegmentList": exchangeSegmentList}
             response = self._post("market.instruments.master", json.dumps(params))
@@ -688,7 +689,7 @@ class XTSConnect(XTSCommon):
 
     def get_ohlc(
         self,
-        exchangeSegment,
+        exchangeSegment: ExchangeSegmentType,
         exchangeInstrumentID,
         startTime,
         endTime,
@@ -708,7 +709,7 @@ class XTSConnect(XTSCommon):
             traceback.print_exc()
             raise BrokerException("get_ohlc Failed for XTS")
 
-    def get_series(self, exchangeSegment):
+    def get_series(self, exchangeSegment: ExchangeSegmentType):
         try:
             params: Dict[str, Any] = {"exchangeSegment": exchangeSegment}
             response = self._get("market.instruments.instrument.series", params)
@@ -717,7 +718,7 @@ class XTSConnect(XTSCommon):
             traceback.print_exc()
             raise BrokerException("get_series Failed for XTS")
 
-    def get_equity_symbol(self, exchangeSegment, series, symbol):
+    def get_equity_symbol(self, exchangeSegment: ExchangeSegmentType, series, symbol):
         try:
             params: Dict[str, Any] = {
                 "exchangeSegment": exchangeSegment,
@@ -730,7 +731,7 @@ class XTSConnect(XTSCommon):
             traceback.print_exc()
             raise BrokerException("get_equity_symbol Failed for XTS")
 
-    def get_expiry_date(self, exchangeSegment, series, symbol):
+    def get_expiry_date(self, exchangeSegment: ExchangeSegmentType, series, symbol):
         try:
             params: Dict[str, Any] = {
                 "exchangeSegment": exchangeSegment,
@@ -743,7 +744,9 @@ class XTSConnect(XTSCommon):
             traceback.print_exc()
             raise BrokerException("get_expiry_date Failed for XTS")
 
-    def get_future_symbol(self, exchangeSegment, series, symbol, expiryDate):
+    def get_future_symbol(
+        self, exchangeSegment: ExchangeSegmentType, series, symbol, expiryDate
+    ):
         try:
             params: Dict[str, Any] = {
                 "exchangeSegment": exchangeSegment,
@@ -758,7 +761,13 @@ class XTSConnect(XTSCommon):
             raise BrokerException("get_future_symbol Failed for XTS")
 
     def get_option_symbol(
-        self, exchangeSegment, series, symbol, expiryDate, optionType, strikePrice
+        self,
+        exchangeSegment: ExchangeSegmentType,
+        series,
+        symbol,
+        expiryDate,
+        optionType,
+        strikePrice,
     ):
         try:
             params: Dict[str, Any] = {
@@ -775,7 +784,9 @@ class XTSConnect(XTSCommon):
             traceback.print_exc()
             raise BrokerException("get_option_symbol Failed for XTS")
 
-    def get_option_type(self, exchangeSegment, series, symbol, expiryDate):
+    def get_option_type(
+        self, exchangeSegment: ExchangeSegmentType, series, symbol, expiryDate
+    ):
         try:
             params: Dict[str, Any] = {
                 "exchangeSegment": exchangeSegment,
@@ -789,7 +800,7 @@ class XTSConnect(XTSCommon):
             traceback.print_exc()
             raise BrokerException("get_option_type Failed for XTS")
 
-    def get_index_list(self, exchangeSegment):
+    def get_index_list(self, exchangeSegment: ExchangeSegmentType):
         try:
             params: Dict[str, Any] = {"exchangeSegment": exchangeSegment}
             response = self._get("market.instruments.indexlist", params)

{quantplay-2.0.34 → quantplay-2.0.36}/quantplay/broker/xts_utils/InteractiveSocketClient.py

@@ -1,5 +1,5 @@
-from typing import Literal
-import socketio
+from typing import Any, Dict, List, Literal
+import socketio  # type: ignore
 
 
 class OrderSocket_io(socketio.Client):
@@ -38,18 +38,18 @@ class OrderSocket_io(socketio.Client):
 
     def __init__(
         self,
-        token,
-        userID,
-        root_url,
-        reconnection=True,
-        reconnection_attempts=0,
-        reconnection_delay=1,
-        reconnection_delay_max=50000,
-        randomization_factor=0.5,
-        logger=False,
-        binary=False,
-        json=None,
-        **kwargs,
+        token: str,
+        userID: str,
+        root_url: str,
+        reconnection: bool = True,
+        reconnection_attempts: int = 0,
+        reconnection_delay: float = 1,
+        reconnection_delay_max: float = 50000,
+        randomization_factor: float = 0.5,
+        logger: bool = False,
+        binary: bool = False,
+        json: Any | None = None,
+        **kwargs: Any,
     ):
         self.sid = socketio.Client(logger=False, engineio_logger=False)
         self.eventlistener = self.sid
@@ -65,24 +65,24 @@ class OrderSocket_io(socketio.Client):
             port + self.token + "&userID=" + self.userID + "&apiType=INTERACTIVE"
         )
 
-    def setup_event_listners(self, on_order):
-        self.sid.on("order", on_order)
+    def setup_event_listners(self, on_order: Any):
+        self.sid.on("order", on_order)  # type: ignore
 
         # self.sid.on("connect", self.on_connect)
-        self.sid.on("message", self.on_message)
+        self.sid.on("message", self.on_message)  # type: ignore
         # self.sid.on("joined", self.on_joined)
-        self.sid.on("error", self.on_error)
-        self.sid.on("trade", self.on_trade)
-        self.sid.on("position", self.on_position)
-        self.sid.on("tradeConversion", self.on_tradeconversion)
-        self.sid.on("logout", self.on_messagelogout)
+        self.sid.on("error", self.on_error)  # type: ignore
+        self.sid.on("trade", self.on_trade)  # type: ignore
+        self.sid.on("position", self.on_position)  # type: ignore
+        self.sid.on("tradeConversion", self.on_tradeconversion)  # type: ignore
+        self.sid.on("logout", self.on_messagelogout)  # type: ignore
         # self.sid.on("disconnect", self.on_disconnect)
 
     def connect(  # type: ignore
         self,
-        headers={},
+        headers: Dict[str, str] = {},
         transports: Literal["polling", "websocket"] = "websocket",
-        namespaces=None,
+        namespaces: List[str] | None = None,
         socketio_path: str = "/interactive/socket.io",
         verify: bool = False,
     ):
@@ -108,7 +108,7 @@ class OrderSocket_io(socketio.Client):
         url = self.connection_url
 
         """Connected to the socket."""
-        self.sid.connect(url, headers, transports, namespaces, socketio_path)
+        self.sid.connect(url, headers, transports, namespaces, socketio_path)  # type: ignore
         self.sid.wait()
         """Disconnect from the socket."""
         # self.sid.disconnect()
@@ -121,33 +121,33 @@ class OrderSocket_io(socketio.Client):
         """On message from socket"""
         print("I received a message!")
 
-    def on_joined(self, data):
+    def on_joined(self, data: Any):
         """On socket joined"""
-        print("Interactive socket joined successfully!" + data)
+        print(f"Interactive socket joined successfully!{data}")
 
-    def on_error(self, data):
+    def on_error(self, data: Any):
         """On receiving error from socket"""
-        print("Interactive socket error!" + data)
+        print(f"Interactive socket error!{data}")
 
-    def on_order(self, data):
+    def on_order(self, data: Any):
         """On receiving order placed data from socket"""
-        print("Order placed!" + data)
+        print(f"Order placed!{data}")
 
-    def on_trade(self, data):
+    def on_trade(self, data: Any):
         """On receiving trade data from socket"""
-        print("Trade Received!" + data)
+        print(f"Trade Received!{data}")
 
-    def on_position(self, data):
+    def on_position(self, data: Any):
         """On receiving position data from socket"""
-        print("Position Retrieved!" + data)
+        print(f"Position Retrieved!{data}")
 
-    def on_tradeconversion(self, data):
+    def on_tradeconversion(self, data: Any):
         """On receiving trade conversion data from socket"""
-        print("Trade Conversion Received!" + data)
+        print(f"Trade Conversion Received!{data}")
 
-    def on_messagelogout(self, data):
+    def on_messagelogout(self, data: Any):
         """On receiving user logout message"""
-        print("User logged out!" + data)
+        print(f"User logged out!{data}")
 
     def on_disconnect(self):
         """On receiving disconnection from socket"""

quantplay-2.0.36/quantplay/model/xts.py

@@ -0,0 +1,7 @@
+from typing import Literal
+
+
+ExchangeSegmentType = Literal[1, 2, 3, 11, 12]
+XTSMessageCodeType = Literal[1501, 1502, 1505, 1507, 1510, 1512, 1105]
+PublishFormatType = Literal["JSON", "Binary"]
+ExchangeType = Literal["NSECM", "NSEFO", "NSECD", "BSECM", "BSEFO"]

{quantplay-2.0.34 → quantplay-2.0.36}/quantplay/utils/pickle_utils.py

@@ -8,12 +8,12 @@ from quantplay.model.instrument_data import InstrumentDataType
 class PickleUtils:
     @staticmethod
     def save_data(data: Any, file_name: str):
-        with open("/tmp/{}.pickle".format(file_name), "wb") as handle:
+        with open(f"/tmp/{file_name}.pickle", "wb") as handle:
             pickle.dump(data, handle, protocol=pickle.HIGHEST_PROTOCOL)
 
     @staticmethod
     def load_data(file_name: str):
-        with open("/tmp/{}.pickle".format(file_name), "rb") as disk_data:
+        with open(f"/tmp/{file_name}.pickle", "rb") as disk_data:
             unserialized_data = pickle.load(disk_data)
 
         return unserialized_data
@@ -44,7 +44,7 @@ class InstrumentData:
 
         try:
             self.lock.acquire()
-            with open("/tmp/{}.pickle".format(file_name), "rb") as disk_data:
+            with open(f"/tmp/{file_name}.pickle", "rb") as disk_data:
                 unserialized_data = pickle.load(disk_data)
             self.instrument_data[file_name] = unserialized_data
             self.lock.release()

{quantplay-2.0.34 → quantplay-2.0.36}/quantplay/wrapper/aws/s3.py

@@ -37,15 +37,15 @@ class S3Utils:
                 lock.release()
 
         except Exception:
-            print("Data not found for {}".format(key))
+            print(f"Data not found for {key}")
 
-        print("fetching bucket from s3 {} key {}".format(bucket, key))
+        print(f"fetching bucket from s3 {bucket} key {key}")
 
         client = boto3.client("s3")  # type: ignore
         raw_stream = client.get_object(Bucket=bucket, Key=key)
         content = raw_stream["Body"].read().decode("utf-8")
 
-        print("Saving data at {}".format("/tmp/" + key))
+        print(f"Saving data at /tmp/{key}")
         full_folder_path = full_path[0 : full_path.rfind("/")]
         if not os.path.exists(full_folder_path):
             os.makedirs(full_folder_path)

{quantplay-2.0.34 → quantplay-2.0.36}/quantplay.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: quantplay
-Version: 2.0.34
+Version: 2.0.36
 Summary: This python package will be stored in AWS CodeArtifact
 Home-page: 
 Author: 

{quantplay-2.0.34 → quantplay-2.0.36}/quantplay.egg-info/SOURCES.txt

@@ -43,6 +43,7 @@ quantplay/model/broker.py
 quantplay/model/generics.py
 quantplay/model/instrument_data.py
 quantplay/model/order_event.py
+quantplay/model/xts.py
 quantplay/utils/__init__.py
 quantplay/utils/constant.py
 quantplay/utils/exchange.py

{quantplay-2.0.34 → quantplay-2.0.36}/setup.py

@@ -21,7 +21,7 @@ requirements = [
 setup(
     name="quantplay",
     long_description=Path("README.md").read_text(),
-    version="2.0.34",
+    version="2.0.36",
     setup_requires=["pytest-runner"],
     install_requires=requirements,
     tests_require=[],