btgsolutions-dataservices-python-client 2.11.4__py3-none-any.whl → 2.17.1__py3-none-any.whl

btgsolutions_dataservices/config.py

@@ -26,6 +26,7 @@ SECURITIES = 'securities'
 TRADES = 'trades'
 PROCESSEDTRADES = 'processed-trades'
 INSTRUMENTSTATUS = 'instrument_status'
+SETTLEMENTPRICES = 'settlement-price'
 BOOKS = 'books'
 INDICES = 'indices'
 CANDLES1S = 'candles-1S'
@@ -49,7 +50,8 @@ VALID_MARKET_DATA_TYPES = [
     CANDLES1S,
     CANDLES1M,
     STOPLOSS,
-    INSTRUMENTSTATUS
+    INSTRUMENTSTATUS,
+    SETTLEMENTPRICES
 ]
 VALID_MARKET_DATA_SUBTYPES = [ALL, STOCKS, OPTIONS, DERIVATIVES]
 
@@ -134,6 +136,11 @@ market_data_socket_urls = {
                 DERIVATIVES: f"{url_ws}v2/marketdata/{INSTRUMENTSTATUS}/{DERIVATIVES}",
                 OPTIONS: f"{url_ws}v2/marketdata/{INSTRUMENTSTATUS}/{OPTIONS}",
             }
+        },
+        SETTLEMENTPRICES: {
+            REALTIME: {
+                ALL: f"{url_ws}v2/marketdata/{SETTLEMENTPRICES}",
+            }
         }
     },
     BMV: {

btgsolutions_dataservices/rest/__init__.py

@@ -9,4 +9,6 @@ from .ticker_last_event import TickerLastEvent
 from .corporate_events import CorporateEvents
 from .company_data import CompanyData
 from .public_sources import PublicSources
-from .reference_data import ReferenceData
+from .reference_data import ReferenceData
+from .stock_loan import StockLoan
+from .ticker_last_event_polling import TickerLastEventPolling

btgsolutions_dataservices/rest/intraday_candles.py

@@ -58,7 +58,8 @@ class IntradayCandles:
         start:int=0,
         end:int=0,
         mode:str='absolute',
-        raw_data:bool=False
+        raw_data:bool=False,
+        cross_filter:str='',
     ):     
         """
         This method provides realtime intraday candles for a given ticker.
@@ -93,6 +94,10 @@ class IntradayCandles:
             Candle mode.
             Example: 'absolute', 'relative' or 'spark'.
             Default: absolute.
+        cross_filter: str
+            Filter trades by cross status. Available only when market_type is derivatives.
+            Options: 'all', 'only_cross' or 'without_cross'.
+            Default: 'all'.
         raw_data: bool
             If false, returns data in a dict of dataframes. If true, returns raw data.
             Default: False.
@@ -101,6 +106,8 @@ class IntradayCandles:
         if market_type not in ['stocks', 'derivatives', 'options', 'indices']: raise MarketTypeError(f"Must provide a valid 'market_type' parameter. Input: '{market_type}'. Accepted values: 'stocks', 'derivatives', 'options' or 'indices'.")
 
         if delay not in ['delayed', 'realtime']: raise DelayError(f"Must provide a valid 'delay' parameter. Input: '{delay}'. Accepted values: 'delayed' or 'realtime'.")
+        
+        if cross_filter and market_type != 'derivatives': raise DelayError(f"The 'cross_filter' flag is only valid for market_type 'derivatives'.")
 
         tickers = ','.join(tickers) if type(tickers) is list else tickers 
 
@@ -109,6 +116,8 @@ class IntradayCandles:
         if start: url += f'&start={start}'
 
         if end: url += f'&end={end}'
+        
+        if cross_filter: url += f'&cross_filter={cross_filter}'
 
         response = requests.request("GET", url,  headers=self.headers)
         if response.status_code == 200:

btgsolutions_dataservices/rest/stock_loan.py

@@ -0,0 +1,110 @@
+
+from typing import Optional
+from ..exceptions import BadResponse
+import requests
+from ..config import url_api_v1
+import json
+from .authenticator import Authenticator
+import pandas as pd
+
+class StockLoan:
+    """
+    This class provides trades related to stock loan operations.
+
+    * Main use case:
+
+    >>> from btgsolutions_dataservices import StockLoan
+    >>> stock_loan = StockLoan(
+    >>>     api_key='YOUR_API_KEY',
+    >>> )
+    >>> trades = stock_loan.get_trades(
+    >>>     ticker = 'PETR4'
+    >>> )
+    >>> trades = stock_loan.get_paginated_trades(
+    >>>     page = 1,
+    >>>     limit = 1000
+    >>> )
+    >>> stock_loan.get_available_tickers()
+
+    Parameters
+    ----------------
+    api_key: str
+        User identification key.
+        Field is required.
+    """
+    def __init__(
+        self,
+        api_key: Optional[str]
+    ):
+        self.api_key = api_key
+        self.token = Authenticator(self.api_key).token
+        self.headers = {"authorization": f"authorization {self.token}"}
+
+    def get_trades(
+        self,
+        ticker:Optional[str]='',
+    ):     
+        """
+        Returns trades related to stock loan operations.
+
+        Parameters
+        ----------------
+        ticker : str, optional
+            The ticker symbol to be returned.
+            Example: 'PETR4'
+
+        """
+        page = 1
+        df = pd.DataFrame()
+        while True:
+            url = f"{url_api_v1}/marketdata/stock-loan/daily-trades?page={page}&limit=20000"
+            if ticker: url += f'&ticker={ticker}'
+            response = requests.request("GET", url,  headers=self.headers)
+            if response.status_code != 200: raise BadResponse(response.json())
+            response = response.json()
+            df = pd.concat([df, pd.DataFrame(response['data'])])
+            if response['totalPages'] <= page: break
+            page += 1
+        
+        return df.reset_index(drop=True)
+    
+    def get_paginated_trades(
+        self,
+        page:int,
+        limit:int,
+        ticker:Optional[str]='',
+    ):     
+        """
+        Returns paginated trades related to stock loan operations.
+
+        Parameters
+        ----------------
+        ticker : str, optional
+            The ticker symbol to be returned.
+            Example: 'PETR4'
+
+        page : int
+            Page number for paginated results.
+            Example: 1
+
+        limit : int
+            Maximum number of items to return per page.
+            Example: 1000
+
+        """
+        url = f"{url_api_v1}/marketdata/stock-loan/daily-trades?page={page}&limit={limit}"
+        if ticker: url += f'&ticker={ticker}'
+        response = requests.request("GET", url,  headers=self.headers)
+        if response.status_code == 200: return json.loads(response.text)
+        raise BadResponse(response.json())
+
+    def get_available_tickers(
+        self,
+    ):
+        """
+        This method provides all tickers available for query.   
+        """
+        url = f"{url_api_v1}/marketdata/stock-loan/available-tickers"
+        response = requests.request("GET", url,  headers=self.headers)
+        if response.status_code == 200: return json.loads(response.text)
+        raise BadResponse(response.json())

btgsolutions_dataservices/rest/ticker_last_event.py

@@ -1,4 +1,4 @@
-from typing import Optional
+from typing import Optional, List
 from ..exceptions import BadResponse
 import requests
 from ..config import url_api_v1
@@ -18,10 +18,16 @@ class TickerLastEvent:
     >>> )
 
     >>> last_event.get_trades(
+    >>>     data_type = 'equities',
     >>>     ticker = 'PETR4',
     >>>     raw_data = False
     >>> )
 
+    >>> last_event.get_tob(
+    >>>     data_type = 'stocks',
+    >>>     raw_data = False
+    >>> )
+
     Parameters
     ----------------
     api_key: str
@@ -33,10 +39,12 @@ class TickerLastEvent:
         api_key:Optional[str]
     ):
         self.api_key = api_key
-        self.token = Authenticator(self.api_key).token
-        self.headers = {"authorization": f"authorization {self.token}"}
+        self.authenticator = Authenticator(self.api_key)
 
-        self.available_data_types = ['equities', 'derivatives']
+        self.available_data_types = {
+            "trades": ['equities', 'derivatives'],
+            "books": ['stocks', 'derivatives', 'options']
+        }
 
     def get_trades(self, data_type:str, ticker:str, raw_data:bool=False):
 
@@ -56,12 +64,12 @@ class TickerLastEvent:
             If false, returns data in a dataframe. If true, returns raw data.
             Field is not required. Default: False.
         """
-        if data_type not in self.available_data_types:
-            raise Exception("Must provide a valid data_type. Valid data types are: {self.available_data_types}")
+        if data_type not in self.available_data_types["trades"]:
+            raise Exception(f"Must provide a valid data_type. Valid data types are: {self.available_data_types['trades']}")
 
         url = f"{url_api_v1}/marketdata/last-event/trades/{data_type}?ticker={ticker}"
 
-        response = requests.request("GET", url,  headers=self.headers)
+        response = requests.request("GET", url,  headers={"authorization": f"Bearer {self.authenticator.token}"})
         if response.status_code == 200:
             if raw_data:
                 return response.json()
@@ -70,23 +78,100 @@ class TickerLastEvent:
         else:
             response = json.loads(response.text)
             raise BadResponse(f'Error: {response.get("error", "")}')
+        
+    def get_tobs(self, data_type:str, raw_data:bool=False):
+
+        """
+        This method provides the last available top of book for all tickers of the given market type.
+
+        Parameters
+        ----------------
+        data_type: str
+            Market Data Type.
+            Field is required. 
+            Example: 'stocks', 'derivatives', 'options'.
+        raw_data: bool
+            If false, returns data in a dataframe. If true, returns raw data.
+            Field is not required. Default: False.
+        """
+
+        if data_type not in self.available_data_types["books"]:
+            raise Exception(f"Must provide a valid data_type. Valid data types are: {self.available_data_types}")
+
+        url = f"{url_api_v1}/marketdata/last-event/books/top/{data_type}/batch"
+
+        response = requests.request("GET", url,  headers={"authorization": f"Bearer {self.authenticator.token}"})
+
+        if response.status_code == 200:
+            if raw_data:
+                return response.json()
+            else:
+                return pd.DataFrame(response.json())
+        else:
+
+            response = json.loads(response.text)
+            raise BadResponse(f'Error: {response.get("error", "")}')
 
-    def get_available_tickers(self, data_type:str):
+    def get_status(self, tickers:List[str]=None, raw_data:bool=False):
+
+        """
+        This method provides the current ticker trading status information.
+
+        Parameters
+        ----------------
+        tickers: List[str]
+            Ticker symbol.
+            Field is not required. Default: None
+            Example: ['PETR4', 'VALE3', 'DOLM25'].
+            If no ticker is provided, it returns trading status information for all available tickers.
+        raw_data: bool
+            If false, returns data in a dataframe. If true, returns raw data.
+            Field is not required. Default: False.
+        """
+
+        if tickers:
+            tickers = ','.join(tickers)
+            url = f"{url_api_v1}/marketdata/last-event/status/all/batch?tickers={tickers}"
+        else:
+            url = f"{url_api_v1}/marketdata/last-event/status/all/batch"
+
+        response = requests.request("GET", url,  headers={"authorization": f"Bearer {self.authenticator.token}"})
+        if response.status_code == 200:
+            if raw_data:
+                return response.json()
+            else:
+                return pd.DataFrame(response.json())
+        else:
+            response = json.loads(response.text)
+            raise BadResponse(f'Error: {response}')
+
+    def get_available_tickers(self,type:str, data_type:str):
 
         """
         This method provides all the available tickers for the specific data type.
 
         Parameters
         ----------------
+        type: str
+            Data Type.
+            Field is required. 
+            Example: 'trades', 'books'
         data_type: str
             Market Data Type.
             Field is required. 
-            Example: 'equities', 'derivatives'.
+            Example: 'equities', 'derivatives', 'options', 'stocks'.
         """
 
-        url = f"{url_api_v1}/marketdata/last-event/trades/{data_type}/available-tickers"
+        if type not in self.available_data_types:
+            raise Exception(f"Must provide a valid type. Valid data types are: {list(self.available_data_types.keys())}")
+        
+        if data_type not in self.available_data_types[type]:
+            raise Exception(f"Must provide a valid data_type. Valid data types are: {self.available_data_types['books']}")
+
+        url = f"{url_api_v1}/marketdata/last-event/trades/{data_type}/available-tickers" if type == "trades" else \
+            f"{url_api_v1}/marketdata/last-event/books/{data_type}/availables"
 
-        response = requests.request("GET", url,  headers=self.headers)
+        response = requests.request("GET", url,  headers={"authorization": f"Bearer {self.authenticator.token}"})
         if response.status_code == 200:
             return response.json()
         else:

btgsolutions_dataservices/rest/ticker_last_event_polling.py

@@ -0,0 +1,149 @@
+import time
+from typing import Optional, List
+from ..exceptions import BadResponse
+import requests
+from ..config import url_api_v1
+from .authenticator import Authenticator
+import pandas as pd
+import json
+from datetime import datetime, timezone, timedelta
+import threading
+
+class TickerLastEventPolling:
+    """
+    This class continuously polls and caches the latest ticker market data in the background for quick and up-to-date access.
+
+    * Main use case:
+
+    >>> from btgsolutions_dataservices import TickerLastEventPolling
+    >>> last_event = TickerLastEventPolling(
+    >>>     api_key='YOUR_API_KEY',
+    >>>     data_type='top-of-books',
+    >>>     data_subtype='stocks',
+    >>> )
+
+    >>> last_event.get(
+    >>>     raw_data=False
+    >>> )
+
+    Parameters
+    ----------------
+    api_key: str
+        User identification key.
+        Field is required.
+    data_type: str
+        Market Data type.
+        Options: 'top-of-books'
+        Field is required.
+    data_subtype: str
+        Market Data subtype.
+        Options: 'stocks', 'options', 'derivatives'.
+        Field is required.
+    """
+    def __init__(
+        self,
+        api_key:Optional[str],
+        data_type: str,
+        data_subtype: str,
+        interval_seconds: float = 1.0
+    ):
+        self.api_key = api_key
+        self.authenticator = Authenticator(self.api_key)
+        self.interval_seconds = interval_seconds
+        self.data_type = data_type
+
+        self._last_request_datetime = None
+        self._cache = {}
+
+        self._available_data_types = {
+            "top-of-books": ['stocks', 'derivatives', 'options']
+        }
+
+        self._available_url = {
+            "top-of-books": {
+                "data": f"{url_api_v1}/marketdata/last-event/books/top/{data_subtype}/batch", 
+                "available": f"{url_api_v1}/marketdata/last-event/books/{data_subtype}/availables"
+            }
+        }
+        
+        if data_type not in self._available_data_types:
+            raise Exception(f"Must provide a valid data_type. Valid data types are: {self._available_data_types}")
+
+        if data_subtype not in self._available_data_types[data_type]:
+            raise Exception(f"Must provide a valid data_subtype. Valid data subtypes are: {self._available_data_types[data_type]}")
+
+        self.url = self._available_url[self.data_type]["data"]
+
+        self._update_data()
+
+        threading.Thread(target=self._polling_loop, daemon=True).start()
+
+    def _polling_loop(self):
+
+        while True:
+            try:
+                self._update_data()
+            except Exception as e:
+                print("error on updating data:", e)
+                continue
+
+            time.sleep(self.interval_seconds)
+
+
+    def _update_data(self):
+        url = self.url + (f"?dt={(self._last_request_datetime - timedelta(seconds=60)).strftime('%Y-%m-%dT%H:%M:%S.000Z')}" if self._last_request_datetime else "")
+
+        request_datetime = datetime.now(timezone.utc)
+
+        response = requests.request("GET", url, headers={"authorization": f"Bearer {self.authenticator.token}"})
+        
+        if response.status_code != 200:
+            return
+
+
+        self._last_request_datetime = request_datetime
+        
+        new_data = { tob["sb"]: tob for tob in response.json() if tob.get("sb")}
+
+        self._cache.update(new_data)
+
+
+    def get(self, force_update: bool=False, raw_data:bool=False):
+
+        """
+        This method provides the last events for all tickers of the given data type and data subtype.
+
+        Parameters
+        ----------------
+        force_update: bool
+            If true, forces an update before returning the data. If false, returns the data.
+            Field is not required. Default: False.
+        raw_data: bool
+            If false, returns data in a dataframe. If true, returns raw data.
+            Field is not required. Default: False.
+        """
+        if force_update:
+            self._update_data()
+
+        if raw_data:
+            return list(self._cache.values())
+        else:
+            return pd.DataFrame(self._cache.values())
+
+            
+
+    def get_available_tickers(self):
+
+        """
+        This method provides all the available tickers for the specific data type and data subtype.
+
+        """
+
+        url = self._available_url[self.data_type]["available"]
+
+        response = requests.request("GET", url,  headers={"authorization": f"Bearer {self.authenticator.token}"})
+        if response.status_code == 200:
+            return response.json()
+        else:
+            response = json.loads(response.text)
+            raise BadResponse(f'Error: {response.get("error", "")}')

btgsolutions_dataservices/websocket/market_data_feed.py

@@ -1,19 +1,30 @@
 from typing import Optional, Callable, List
 import websocket
 import time
-from datetime import date
+from datetime import date, datetime
 import multiprocessing
 import logging
 from logging.handlers import QueueHandler, QueueListener
 import json
 import ssl
 import threading
+import uuid
 from ..rest import Authenticator
 from ..config import market_data_socket_urls, market_data_feedb_socket_urls, REALTIME, B3, TRADES, BOOKS, FEED_A, FEED_B, MAX_WS_RECONNECT_RETRIES
 from .websocket_default_functions import _on_open, _on_message_already_serialized, _on_error, _on_close
 
 multiprocessing.set_start_method("spawn", force=True)
 
+class LogConstFilter(logging.Filter):
+    def __init__(self, consts):
+        super().__init__()
+        self.consts = consts
+
+    def filter(self, record):
+        for key, value in self.consts.items():
+            setattr(record, key, value)
+        return True
+
 class MarketDataFeed:
     """
     WebSocket client that connects with BTG Solutions Data Services WebSocket servers. The servers streams realtime and delayed market data, such as trades and book events.
@@ -50,7 +61,7 @@ class MarketDataFeed:
         Field is not required. Default: 'b3'.
     data_type: str
         Market Data type.
-        Options: 'trades', 'processed-trades', 'books', 'indices', 'securities', 'stoploss', 'candles-1S', 'candles-1M', 'instrument_status'.
+        Options: 'trades', 'processed-trades', 'books', 'indices', 'securities', 'stoploss', 'candles-1S', 'candles-1M', 'instrument_status', 'settlement-price'.
         Field is not required. Default: 'trades'.
     data_subtype: str
         Market Data subtype (when applicable).
@@ -136,6 +147,9 @@ class MarketDataFeed:
         self.reconnect = reconnect
         self.__nro_reconnect_retries = 0
 
+        client_feed = f'feed_{exchange}_{data_type}_{stream_type}_{data_subtype}'
+        client_id = str(uuid.uuid4())
+
         self.server_message_queue = multiprocessing.Queue()
         self.client_message_queue = multiprocessing.Queue()
         self.log_queue = multiprocessing.Queue()
@@ -143,8 +157,10 @@ class MarketDataFeed:
         log_level = getattr(logging, log_level)
         self.log_level = log_level
 
+        log_constants = {'client_feed': client_feed, 'client_id': client_id}
         log_handler = logging.FileHandler(filename=f"MarketDataFeed_{date.today().isoformat()}.log")
-        log_handler.setFormatter(logging.Formatter('%(asctime)s - %(levelname)s - %(message)s'))
+        log_handler.setFormatter(logging.Formatter('%(asctime)s - %(client_feed)s - %(client_id)s - %(levelname)s - %(message)s'))
+        log_handler.addFilter(LogConstFilter(log_constants))
 
         log_queue_listener = QueueListener(self.log_queue, log_handler)
         log_queue_listener.start()
@@ -156,6 +172,14 @@ class MarketDataFeed:
         self.process = None
         self.running = False
 
+        self.head_message_count = 0
+        self.head_avg_latency = 0
+
+        self.instruments = []
+
+    def set_instruments(self, instruments: List[str]):
+        self.instruments = instruments
+
     def _ws_client_process(self, server_message_queue: multiprocessing.Queue, client_message_queue: multiprocessing.Queue, log_queue: multiprocessing.Queue, log_level: int):
 
         logger = logging.getLogger("client")
@@ -163,7 +187,27 @@ class MarketDataFeed:
         logger.addHandler(QueueHandler(log_queue))
 
         def on_message(ws, message):
-            server_message_queue.put(json.loads(message))
+            message = json.loads(message)
+            server_message_queue.put(message)
+
+            if self.log_level != logging.DEBUG:
+                return
+
+            msg_datetime = None
+            if self.data_type == BOOKS:
+                bid = message.get("bid")
+                offer = message.get("offer")
+                if bid:
+                    msg_datetime = bid[0]["datetime"]
+                elif offer:
+                    msg_datetime = offer[0]["datetime"]
+            else:
+                msg_datetime = message.get("tTime")
+            if msg_datetime:
+                msg_datetime = datetime.strptime(msg_datetime, "%Y-%m-%dT%H:%M:%S.%fZ")
+                latency = (time.time() - msg_datetime.timestamp()) * 1000
+                self.head_message_count += 1
+                self.head_avg_latency += (latency - self.head_avg_latency) / self.head_message_count
 
         def on_error(ws, error):
             logger.error(f"On Error | {error}")
@@ -182,6 +226,9 @@ class MarketDataFeed:
 
         def on_open(ws):
             logger.info(f"On Open | Connection open")
+            if self.instruments:
+                logger.info(f"On Open | Subscribing to {len(self.instruments)} instruments")
+                self.subscribe(self.instruments)
             self.on_open()
             self.__nro_reconnect_retries = 0
 
@@ -208,15 +255,28 @@ class MarketDataFeed:
                     break
                 pass
 
+            log_metrics_interval = 5
+            log_timer = time.time()
             while True:
                 try:
                     if not client_message_queue.empty():
                         msg = client_message_queue.get()
                         ws.send(json.dumps(msg))
-                    else:
-                        time.sleep(0.05)
+                    
+                    if self.log_level != logging.DEBUG:
+                        continue
+                    
+                    if time.time() - log_timer >= log_metrics_interval:
+                        if self.head_avg_latency == 0:
+                            logger.debug(f"HEAD - (ServerQ) Relative Latency: N/A; Throughput: N/A")
+                        else:
+                            logger.debug(f"HEAD - (ServerQ) Relative Latency: {round(self.head_avg_latency, 1)} ms; Throughput: {round(self.head_message_count/log_metrics_interval, 1)} msg/s")
+                        self.head_message_count = 0
+                        self.head_avg_latency = 0
+                        log_timer = time.time()
+
                 except Exception as e:
-                    time.sleep(0.1)
+                    time.sleep(0.01)
 
         run_forever_new_thread()
 
@@ -230,18 +290,47 @@ class MarketDataFeed:
 
         def run_on_new_thread(*args):
             log_timer = time.time()
+            log_metrics_interval = 5
+
+            message_count = 0
+            latency_message_count = 0
+            latency_average = 0
             while self.running:
                 if not self.server_message_queue.empty():
                     msg = self.server_message_queue.get()
                     self.on_message(msg)
-                else:
-                    time.sleep(0.01)
 
-                if time.time() - log_timer >= 5.0:
+                    if self.log_level != logging.DEBUG:
+                        continue
+                    
+                    message_count += 1
+                    msg_datetime = None
+                    if self.data_type == BOOKS:
+                        bid = msg.get("bid")
+                        offer = msg.get("offer")
+                        if bid:
+                            msg_datetime = bid[0]["datetime"]
+                        elif offer:
+                            msg_datetime = offer[0]["datetime"]
+                    else:
+                        msg_datetime = msg.get("tTime")
+                    if msg_datetime:
+                        msg_datetime = datetime.strptime(msg_datetime, "%Y-%m-%dT%H:%M:%S.%fZ")
+                        latency = (time.time() - msg_datetime.timestamp()) * 1000
+                        latency_message_count += 1
+                        latency_average += (latency - latency_average) / latency_message_count
+
+                if time.time() - log_timer >= log_metrics_interval:
                     server_queue_size = self.server_message_queue.qsize()
                     client_queue_size = self.client_message_queue.qsize()
-                    self.logger.debug(f"Server queue: {server_queue_size} | Client queue: {client_queue_size}")
+                    if message_count == 0:
+                        self.logger.debug(f"TAIL - (ServerQ) Relative Latency: N/A; Throughput: N/A; Size: {server_queue_size} | (ClientQ) Size: {client_queue_size}")
+                    else:
+                        self.logger.debug(f"TAIL - (ServerQ) Relative Latency: {round(latency_average, 1)} ms; Throughput: {round(message_count/log_metrics_interval, 1)} msg/s; Size: {server_queue_size} | (ClientQ) Size: {client_queue_size}")
                     log_timer = time.time()
+                    message_count = 0
+                    latency_message_count = 0
+                    latency_average = 0
         
         threading.Thread(target=run_on_new_thread).start()
 
@@ -262,7 +351,7 @@ class MarketDataFeed:
             message = json.dumps(message)
         self.client_message_queue.put(json.loads(message))
 
-    def subscribe(self, list_instruments: List[str], n=None):
+    def subscribe(self, list_instruments: List[str], n=None, initial_snapshot: bool=False):
         """
         Subscribes a list of instruments.
 
@@ -274,9 +363,17 @@ class MarketDataFeed:
             Field is not required.
             **For books data_type only.**
             Maximum book level. It must be between 1 and 10.    
+        initial_snapshot: float
+            If True, client receives ticker last event (snapshot) of the provided ticker. 
+            Field is not required.
+            Default: False
         """
-        if self.data_type == BOOKS and n is not None:
-            self._send({'action': 'subscribe', 'params': {"tickers": list_instruments, "n": n}})
+
+        if initial_snapshot or n is not None:
+            message = {'action': 'subscribe', 'params': {"tickers": list_instruments, "initial_snapshot": initial_snapshot}}
+            if n is not None:
+                message['params']['n'] = n
+            self._send(message)
         else:
             self._send({'action': 'subscribe', 'params': list_instruments})
 

btgsolutions_dataservices/websocket/market_data_websocket_client.py

@@ -2,7 +2,7 @@
 from typing import Optional, List
 from ..exceptions import WSTypeError, DelayedError, FeedError
 from ..rest import Authenticator
-from ..config import market_data_socket_urls, market_data_feedb_socket_urls, MAX_WS_RECONNECT_RETRIES, VALID_STREAM_TYPES, VALID_EXCHANGES, VALID_MARKET_DATA_TYPES, VALID_MARKET_DATA_SUBTYPES, REALTIME, B3, TRADES, INDICES, ALL, STOCKS, BOOKS, FEED_A, FEED_B
+from ..config import market_data_socket_urls, market_data_feedb_socket_urls, MAX_WS_RECONNECT_RETRIES, VALID_STREAM_TYPES, VALID_EXCHANGES, VALID_MARKET_DATA_TYPES, VALID_MARKET_DATA_SUBTYPES, REALTIME, B3, TRADES, INDICES, ALL, STOCKS, BOOKS, FEED_A, FEED_B, SETTLEMENTPRICES
 from .websocket_default_functions import _on_open, _on_message, _on_error, _on_close
 import websocket
 import json
@@ -49,7 +49,7 @@ class MarketDataWebSocketClient:
 
     data_type: str
         Market Data type.
-        Options: 'trades', 'processed-trades', 'books', 'indices', 'securities', 'stoploss', 'candles-1S', 'candles-1M', 'instrument_status'.
+        Options: 'trades', 'processed-trades', 'books', 'indices', 'securities', 'stoploss', 'candles-1S', 'candles-1M', 'instrument_status', 'settlement-price'.
         Field is not required. Default: 'trades'.
 
     data_subtype: str
@@ -93,7 +93,7 @@ class MarketDataWebSocketClient:
         self.__nro_reconnect_retries = 0
 
         if data_subtype is None:
-            if exchange is B3 and data_type is not INDICES:
+            if exchange is B3 and not data_type in [INDICES, SETTLEMENTPRICES]:
                 data_subtype = STOCKS
             else:
                 data_subtype = ALL
@@ -267,7 +267,7 @@ class MarketDataWebSocketClient:
         """
         self.ws.close()
 
-    def subscribe(self, list_instruments, n=None):
+    def subscribe(self, list_instruments, n=None, initial_snapshot: bool=False):
         """
         Subscribes a list of instruments.
 
@@ -278,12 +278,19 @@ class MarketDataWebSocketClient:
         n: int
             Field is not required.
             **For books data_type only.**
-            Maximum book level. It must be between 1 and 10.    
+            Maximum book level. It must be between 1 and 10. 
+        initial_snapshot: float
+            If True, client receives ticker last event (snapshot) of the provided ticker. 
+            Field is not required.
+            Default: False
         """
 
-        if self.data_type == BOOKS and n is not None:
-            self.__send({'action': 'subscribe', 'params': {"tickers": list_instruments, "n": n}})
-            self.__print(f'Socket subscribed the following instrument(s) with n = {n}: {list_instruments}')
+        if initial_snapshot or n is not None:
+            message = {'action': 'subscribe', 'params': {"tickers": list_instruments, "initial_snapshot": initial_snapshot}}
+            if n is not None:
+                message['params']['n'] = n
+            self.__send(message)
+            self.__print(f'Socket subscribed the following instrument(s) with n = {n}: {list_instruments} and initial_snapshot = {initial_snapshot}')
         else:
             self.__send({'action': 'subscribe', 'params': list_instruments})
             self.__print(f'Socket subscribed the following instrument(s): {list_instruments}')

{btgsolutions_dataservices_python_client-2.11.4.dist-info → btgsolutions_dataservices_python_client-2.17.1.dist-info}/METADATA

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: btgsolutions-dataservices-python-client
-Version: 2.11.4
+Version: 2.17.1
 Summary: Python package containing several classes and data for extracting and manipulating market and trading data.
 Home-page: https://github.com/BTG-Pactual-Solutions/btgsolutions-dataservices-python-client
 Author: BTG Solutions Data Services powered by BTG Pactual Solutions
-Requires-Python: >=3.9,<3.13
+Requires-Python: >=3.9,<3.14
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: pandas>=2.2.2
@@ -165,11 +165,26 @@ ws.run(on_message=lambda message: print(message))
 
 ```python
 import btgsolutions_dataservices as btg
-ws = btg.MarketDataWebSocketClient(api_key='YOUR_API_KEY', data_type='books')
+ws = btg.MarketDataWebSocketClient(api_key='YOUR_API_KEY', data_type='instrument_status', data_subtype='stocks')
 ws.run(on_message=lambda message: print(message))
 ws.instrument_status('PETR4')
 ws.instrument_status_history('PETR4')
 
+## The following is optional to keep the program running in a .py file:
+# from time import sleep
+# while True:
+#   sleep(1)
+```
+##### Settlement Price 
+
+```python
+import btgsolutions_dataservices as btg
+ws = btg.MarketDataWebSocketClient(api_key='YOUR_API_KEY', data_type='settlement-price', instruments=['ABEVOU25', 'WINV25'])
+ws.run(on_message=lambda message: print(message))
+
+## Getting the last event (settlement-price) of ABEVOU25:
+# ws.get_last_event(['ABEVOU25'])
+
 ## The following is optional to keep the program running in a .py file:
 # from time import sleep
 # while True:
@@ -214,7 +229,7 @@ quotes = btg.Quotes(api_key='YOUR_API_KEY')
 quotes.get_quote(market_type = 'stocks', tickers = ['PETR4', 'VALE3'])
 ```
 
-#### Ticker Last Event
+#### Ticker Last Trade
 
 ```python
 import btgsolutions_dataservices as btg
@@ -222,6 +237,31 @@ last_event = btg.TickerLastEvent(api_key='YOUR_API_KEY')
 last_event.get_trades(data_type='equities', ticker='VALE3')
 ```
 
+#### Ticker Last Top of Book
+
+```python
+import btgsolutions_dataservices as btg
+last_event = btg.TickerLastEvent(api_key='YOUR_API_KEY')
+last_event.get_tobs(data_type='stocks')
+```
+
+#### Ticker Last Trading Status
+
+```python
+import btgsolutions_dataservices as btg
+last_event = btg.TickerLastEvent(api_key='YOUR_API_KEY')
+last_event.get_status(tickers=['PETR4','VALE3'])
+```
+
+#### Ticker Last Polling - Top of Books
+
+```python
+import btgsolutions_dataservices as btg
+last_event = btg.TickerLastEventPolling(api_key='YOUR_API_KEY', data_type='top-of-books', data_subtype='stocks')
+last_event.get()
+```
+
+
 ### Historical Data
 
 #### Historical Candles
@@ -336,6 +376,16 @@ public_sources = btg.PublicSources(api_key='YOUR_API_KEY')
 public_sources.get_opas(start_date='2022-10-01', end_date='2024-10-01')
 ```
 
+#### STOCK LOAN
+
+```python
+import btgsolutions_dataservices as btg
+stock_loan = btg.StockLoan(api_key='YOUR_API_KEY')
+stock_loan.get_trades()
+stock_loan.get_paginated_trades(page=1, limit=1000, ticker ='PETR4')
+stock_loan.get_available_tickers()
+```
+
 #### Company Fundamentals
 
 ##### Company General Information

{btgsolutions_dataservices_python_client-2.11.4.dist-info → btgsolutions_dataservices_python_client-2.17.1.dist-info}/RECORD

@@ -1,26 +1,28 @@
 btgsolutions_dataservices/__init__.py,sha256=reSSb9MBIp5WQ5o872fX__moJYXx0sQgkhUf3QmfEjI,93
-btgsolutions_dataservices/config.py,sha256=syf7x6LL4WNAM0e6CI1BKfPHnprxWoww7llzvtV0QXs,5082
+btgsolutions_dataservices/config.py,sha256=9L9bIGL1j7XSAkpYMxLS8oqIu-F4CQ2EyAywIT496p8,5285
 btgsolutions_dataservices/exceptions.py,sha256=QlwQTDEohtVsTER0lHbQrDgAGvjiZBmoyDuqLkUcvh8,599
-btgsolutions_dataservices/rest/__init__.py,sha256=OI7KWRdAMG3oHABhaGn6nOsGCou4-FX7e0qH2rxChmE,494
+btgsolutions_dataservices/rest/__init__.py,sha256=NEar641a2Mosioj-D3HrcdrJqgjaFRCwos3rftnUhq0,591
 btgsolutions_dataservices/rest/authenticator.py,sha256=uBLARz5lCRhIDc_PZaC4a2rSQtrFJajmAC4Bdg9BnX0,1363
 btgsolutions_dataservices/rest/bulk_data.py,sha256=26CrFH-IVMUbpPLx0HaN-BePs5R9A1ZUINSir7qtfhE,9032
 btgsolutions_dataservices/rest/company_data.py,sha256=yhsgR-P7g5e6TDdpoMZoyiyqI85roBCXJGyob4g1P_8,7318
 btgsolutions_dataservices/rest/corporate_events.py,sha256=04DdoUnBaX1rSAWplCLzNm-YPrKks80txOR26xubEZ0,2399
 btgsolutions_dataservices/rest/hfn.py,sha256=0E-oNw797M8XgbDfwbhmMaPaf9z-WN4rhMpMR_2dkos,11205
 btgsolutions_dataservices/rest/historical_candles.py,sha256=0iu3clwbJUtwyHotxT5pb3xsqCJvpd6kRUsrYBVNU80,7359
-btgsolutions_dataservices/rest/intraday_candles.py,sha256=scH2eMh3ZhtWii_Kzv3PEGcUaLAUT-CAeswCY-3pYVc,5221
+btgsolutions_dataservices/rest/intraday_candles.py,sha256=WWujmvW_qoREPjYadhMoJyiVMX8Ts7zFo21KacqKhjU,5687
 btgsolutions_dataservices/rest/intraday_tick_data.py,sha256=VZZ-yPoQn9dZCJ9KnPYGwaEFq2FZi0oSnLDIIENYCNo,2469
 btgsolutions_dataservices/rest/public_sources.py,sha256=CMXsvHe8RKuEmJJ_baeVgsj28TrH2AYxE3TEfGSCdOQ,2459
 btgsolutions_dataservices/rest/quotes.py,sha256=sirlG1-_aCtE7auwYM7lTZkpMcW3UYisjtCaBWzPWuY,7508
 btgsolutions_dataservices/rest/reference_data.py,sha256=ntcHEMapKULGPHJvmzAnccUo8ZTGokt1M9bDBceV5Tk,2112
-btgsolutions_dataservices/rest/ticker_last_event.py,sha256=Lnm8sGS6wo6frL8yJddtBtEOEsPiodgjl4qq5Xdo0P0,2950
+btgsolutions_dataservices/rest/stock_loan.py,sha256=_EYxywO-qA-zC7CeAo8a1omUb327g13P1R1B-plPKtI,3207
+btgsolutions_dataservices/rest/ticker_last_event.py,sha256=1DR4fVsareRDr1iGya7E8308kDcciK5XtlS2SI56c1o,6328
+btgsolutions_dataservices/rest/ticker_last_event_polling.py,sha256=wCDplal8k5xHXI4JD69D5j-djYkL16SiNiso7Of3UCI,4656
 btgsolutions_dataservices/websocket/__init__.py,sha256=Bifok6zQFenYNIA-NE8hYSooZVIQ2MCeTCjIOYnfHzI,165
 btgsolutions_dataservices/websocket/hfn_websocket_client.py,sha256=wzyPXtXFsv31cVFcTWrTA5uhFBebgM2IpIxXQvPSP54,6253
-btgsolutions_dataservices/websocket/market_data_feed.py,sha256=Zh3aqFLoVZPnA3LVXCRxcsPYdlQId9qifrQsBkWUWrg,11770
-btgsolutions_dataservices/websocket/market_data_websocket_client.py,sha256=i_1kd6mdd9fLDYD54zx_t1HJPPBUdDzE4pojs3DIPLI,13375
+btgsolutions_dataservices/websocket/market_data_feed.py,sha256=HAVA4thvYyvmcVrHm4_exGaq4y9RCGjwl98yuXR8KVc,16209
+btgsolutions_dataservices/websocket/market_data_websocket_client.py,sha256=ix6EH6yHJcRc69RWuvUjHxr0H17zRSM_o9YjsO6OZIw,13812
 btgsolutions_dataservices/websocket/websocket_default_functions.py,sha256=JWbOR4uX14BI9JB3zXMbwqVsF8AtfDbEC83fgs8O5PY,335
-btgsolutions_dataservices_python_client-2.11.4.dist-info/licenses/LICENSE,sha256=vePSp4Jry-f15vZ48xge2vljuhNgkMZD6wU0XmuFBgA,1057
-btgsolutions_dataservices_python_client-2.11.4.dist-info/METADATA,sha256=___fOIFhAUcvenXmiN89UeDuljLwG8JBwtmNoBq5hMc,11808
-btgsolutions_dataservices_python_client-2.11.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-btgsolutions_dataservices_python_client-2.11.4.dist-info/top_level.txt,sha256=OaseSN41lI9j_Z-kHIE_XVo_m1hmGdAHE3EK1h5_Ce0,26
-btgsolutions_dataservices_python_client-2.11.4.dist-info/RECORD,,
+btgsolutions_dataservices_python_client-2.17.1.dist-info/licenses/LICENSE,sha256=vePSp4Jry-f15vZ48xge2vljuhNgkMZD6wU0XmuFBgA,1057
+btgsolutions_dataservices_python_client-2.17.1.dist-info/METADATA,sha256=cDuPuZOmolVyzvEqaHub2x0wvWAwv2kuAqeGSYPNYVg,13169
+btgsolutions_dataservices_python_client-2.17.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+btgsolutions_dataservices_python_client-2.17.1.dist-info/top_level.txt,sha256=OaseSN41lI9j_Z-kHIE_XVo_m1hmGdAHE3EK1h5_Ce0,26
+btgsolutions_dataservices_python_client-2.17.1.dist-info/RECORD,,