siglab-py 0.1.17__tar.gz → 0.1.19__tar.gz

{siglab_py-0.1.17 → siglab_py-0.1.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: siglab_py
-Version: 0.1.17
+Version: 0.1.19
 Summary: Market data fetches, TA calculations and generic order gateway.
 Author: r0bbarh00d
 Author-email: r0bbarh00d <r0bbarh00d@gmail.com>

{siglab_py-0.1.17 → siglab_py-0.1.19}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "siglab_py"
-version = "0.1.17"
+version = "0.1.19"
 description = "Market data fetches, TA calculations and generic order gateway."
 authors = [{name = "r0bbarh00d", email = "r0bbarh00d@gmail.com"}]
 license = {text = "MIT"}

{siglab_py-0.1.17 → siglab_py-0.1.19}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = siglab_py
-version = 0.1.17
+version = 0.1.19
 description = Market data fetches, TA calculations and generic order gateway.
 author = r0bbarh00d
 author_email = r0bbarh00d@gmail.com

{siglab_py-0.1.17 → siglab_py-0.1.19}/siglab_py/exchanges/any_exchange.py

@@ -15,7 +15,13 @@ b. Override ccxt basic functions
     - order amount rounding: amount_to_precision
     - order price rounding: price_to_precision
     ... etc
+
+    Besides above, it's very common below are required from algo's
+    - fetch_time
+    - fetch_order_book
+    - fetch_positions
+    
 '''
-class AnyExchange(Exception):
+class AnyExchange(Exchange):
     def __init__(self, *args: object) -> None:
         super().__init__(*args)

siglab_py-0.1.19/siglab_py/exchanges/futubull.py

@@ -0,0 +1,468 @@
+'''
+https://github.com/FutunnOpen/py-futu-api/blob/master/README.md
+https://www.futuhk.com/en/support/categories/909?global_content=%7B%22promote_id%22%3A13765%2C%22sub_promote_id%22%3A10%7D
+
+Fees: https://www.futuhk.com/en/commissionnew#crypto
+
+Subscribe L2 data: https://openapi.futunn.com/futu-api-doc/en/intro/authority.html#5331
+
+Investor Protection: https://www.futuhk.com/en
+
+Margin Trading: https://www.futunn.com/en/learn/detail-what-is-margin-trading-62010-220679271
+
+Download Futu OpenD
+    https://www.futuhk.com/en/support/topic1_464?global_content=%7B%22promote_id%22%3A13765%2C%22sub_promote_id%22%3A10%7D
+
+    If you run the installer version "Futu_OpenD-GUI_9.0.5008_Windows.exe", it'd be installed under:
+        C:\\Users\\xxx\\AppData\\Roaming\\Futu_OpenD\\Futu_OpenD.exe
+
+Architecture: https://openapi.futunn.com/futu-api-doc/en/intro/intro.html
+
+python -mpip install futu-api
+
+Whatsapp support: Moomoo OpenAPI 1群
+
+API
+    Fetches:
+        market status https://openapi.futunn.com/futu-api-doc/en/quote/get-global-state.html
+        stock basic info https://openapi.futunn.com/futu-api-doc/en/quote/get-static-info.html
+        historical candles https://openapi.futunn.com/futu-api-doc/en/quote/request-history-kline.html
+        realtime candles https://openapi.futunn.com/futu-api-doc/en/quote/get-kl.html
+        real time quote https://openapi.futunn.com/futu-api-doc/en/quote/get-stock-quote.html
+        open orders https://openapi.futunn.com/futu-api-doc/en/trade/get-order-list.html
+        historical orders https://openapi.futunn.com/futu-api-doc/en/trade/get-history-order-list.html
+        positions https://openapi.futunn.com/futu-api-doc/en/trade/get-position-list.html
+        balances https://openapi.futunn.com/futu-api-doc/en/trade/get-funds.html
+
+    Trading:
+        create order https://openapi.futunn.com/futu-api-doc/en/trade/place-order.html
+        amend order https://openapi.futunn.com/futu-api-doc/en/trade/modify-order.html
+
+'''
+from datetime import datetime, timedelta
+from typing import List, Dict, Union, Any, NoReturn
+import pandas as pd
+
+import futu as ft
+from futu import *
+
+from siglab_py.exchanges.any_exchange import AnyExchange
+
+class Futubull(AnyExchange):
+    def __init__(self, *args: Dict[str, Any]) -> None:
+        super().__init__(*args)
+        
+        self.name = 'futubull'
+
+        params : Dict[str, Any] = args[0] # Type "object" is not assignable to declared type "Dict[Unknown, Unknown]"
+        self.host_addr = params['daemon']['host']
+        self.port = params['daemon']['port']
+        self.market = params['market']
+        self.security_type = params['security_type']
+        self.quote_ctx = OpenQuoteContext(host=self.host_addr, port=self.port)
+        self.trd_ctx = OpenSecTradeContext(
+                filter_trdmarket=params['trdmarket'], 
+                host=self.host_addr, port=self.port, 
+                security_firm=params['security_firm']
+            )
+        self.markets : Dict = {}
+
+    def load_markets(self, reload=False, params={}):  # type: ignore
+        '''
+        Mimic CCXT load_markets https://github.com/ccxt/ccxt/blob/master/python/ccxt/base/exchange.py
+
+        Examplem,
+            {
+                ... more pairs ...
+                'ETH/USDC:USDC': {
+                    'id': 'ETH-USDC-SWAP',
+                    'lowercaseId': None,
+                    'symbol': 'ETH/USDC:USDC',
+                    'base': 'ETH',
+                    'quote': 'USDC',
+                    'settle': 'USDC',
+                    'baseId': 'ETH',
+                    'quoteId': 'USDC',
+                    'settleId': 'USDC',
+                    'type': 'swap',
+                    'spot': False,
+                    'margin': False,
+                    'swap': True,
+                    'future': False,
+                    'option': False,
+                    'index': None,
+                    'active': True,
+                    'contract': True,
+                    'linear': True,
+                    'inverse': False,
+                    'subType': 'linear',
+                    'taker': 0.0005,
+                    'maker': 0.0002,
+                    'contractSize': 0.001,
+                    'expiry': None,
+                    'expiryDatetime': None,
+                    'strike': None,
+                    'optionType': None,
+                    'precision': {'amount': 1.0, 'price': 0.01, 'cost': None, 'base': None, 'quote': None},
+                    'limits': {'leverage': {'min': 1.0, 'max': 50.0}, 'amount': {'min': 1.0, 'max': None}, 'price': {'min': None, 'max': None}, 'cost': {'min': None, 'max': None}},
+                    'marginModes': {'cross': None, 'isolated': None},
+                    'created': 1666076197702,
+                    'info' : {
+                        ... raw exchange response here ...
+                    }
+                },
+                ... more pairs ...
+            }
+
+        gateway.py will call:
+            1. multiplier = market['contractSize'] (Note this is contract size for futures, not same as 'Lot Size')
+            2. price_to_precision -> market['precision']['price']
+            3. amount_to_precision  -> market['precision']['amount']    <-- This is 'Lot Size'
+        '''
+        
+        ret, data = self.quote_ctx.get_stock_basicinfo(self.market, self.security_type)
+        if ret == RET_OK:
+            for index, row in data.iterrows(): # type: ignore
+                symbol = row['code']
+
+                name = row['name']
+                stock_type = row['stock_type']
+                stock_child_type = row['stock_child_type']
+                stock_owner = row['stock_owner']
+                option_type = row['option_type']
+                strike_time = row['strike_time']
+                strike_price = row['strike_price']
+                suspension = row['suspension']
+                stock_id = row['stock_id']
+                listing_date = row['listing_date']
+                delisting = bool(row['delisting'])
+                main_contract = bool(row['main_contract'])
+                last_trade_time = row['last_trade_time']
+                exchange_type = row['exchange_type']
+                lot_size = row['lot_size']
+                
+                # No additional information from 'get_stock_basicinfo'
+                # ret, detail = self.quote_ctx.get_stock_basicinfo(self.market, self.security_type, [ symbol ])
+
+                info : Dict = {
+                    'symbol' : symbol,
+                    'name' : name,
+                    'stock_type' : stock_type,
+                    'stock_child_type' : stock_child_type,
+                    'stock_owner' : stock_owner,
+                    'option_type' : option_type,
+                    'strike_time' : strike_time,
+                    'strike_price' : strike_price,
+                    'suspension' : suspension,
+                    'stock_id' : stock_id,
+                    'listing_date' : listing_date,
+                    'delisting' : delisting,
+                    'main_contract' : main_contract,
+                    'last_trade_time' : last_trade_time,
+                    'exchange_type' : exchange_type,
+                    'lot_size' : lot_size
+                }
+                self.markets[symbol] = {
+                    'symbol' : symbol,
+                    'id' : symbol,
+
+                    'base': None,
+                    'quote': None,
+                    'settle': None,
+                    'baseId': None,
+                    'quoteId': None,
+                    'settleId': None,
+
+                    'type': self.security_type,
+                    'spot': False,
+                    'margin': False,
+                    'swap': False,
+                    'future': False,
+                    'option': False,
+                    'index': None,
+                    'active': not delisting,
+                    'contract': False,
+                    'linear': False,
+                    'inverse': False,
+                    'subType': False,
+                    'taker': 0,
+                    'maker': 0,
+                    'contractSize': 0,
+                    'expiry': strike_time,
+                    'expiryDatetime': strike_time,
+                    'strike': strike_price,
+                    'optionType': option_type,
+
+                    'precision': {
+                        'amount': lot_size, 
+                        'price': 0.01, 
+                        'cost': None, 
+                        'base': None, 
+                        'quote': None
+                    },
+
+                    'limits': {
+                        'leverage': {'min': 1, 'max': 5}, 
+                        'amount': {'min': 1.0, 'max': None}, 
+                        'price': {'min': None, 'max': None}, 
+                        'cost': {'min': None, 'max': None}
+                    },
+                    'marginModes': {'cross': None, 'isolated': None},
+
+                    'info' : info
+                }
+        return self.markets
+
+    '''
+    With CCXT, 'params' is used to parse exchange specific parameters. Not actually used with Futu.
+
+    Get Historical Candlesticks max_count: In API doc it advises<1000, but when I tested, it's 246 (1 year).
+    To fetch more than this, use market_data_util.fetch_candles (Sliding window implemented).
+    Under the hood, it'd use implementation below.
+
+    CCXT fetch_ohlcv response format is:
+        [
+            [1704038400000, 42469.9, 42723.1, 42442.3, 42609.8, 3624.59]
+            [1704042000000, 42609.8, 42672.4, 42473.9, 42630.6, 2829.69]
+            [1704045600000, 42630.6, 42742.9, 42542.9, 42673.8, 2097.12]
+            [1704049200000, 42673.8, 42705.0, 42593.7, 42627.7, 2055.54]
+            [1704052800000, 42627.6, 42693.0, 42511.1, 42565.5, 2061.97]
+            ... more candles ...
+        ]
+    
+    Fields are: timestamp (in ms), open, high, low, close, volume.
+    '''
+    def fetch_ohlcv(self, symbol: str, timeframe : str ='1h', since: Union[int, None] = None, limit: int = 100, params={}) -> Union[List[List[Union[int, float]]], None]:  # type: ignore
+        if not symbol or not since:
+            return None
+        
+        ktype=KLType.K_DAY
+        if timeframe=="1m":
+            ktype=KLType.K_1M
+        elif timeframe=="1h":
+            ktype=KLType.K_60M
+        elif timeframe=="1h":
+            ktype=KLType.K_DAY
+
+        candles = []
+        dt_start = datetime.fromtimestamp(int(since/1000))
+        s_start : str = dt_start.strftime("%Y-%m-%d")
+        ret, data, page_req_key = self.quote_ctx.request_history_kline(code=symbol, start=s_start, ktype=ktype, max_count=limit)
+        if ret == RET_OK:
+            for index, row in data.iterrows(): # type: ignore
+
+                '''
+                From doc:
+                    Format: yyyy-MM-dd HH:mm:ss
+                    The default of HK stock market and A-share market is Beijing time, 
+                    while that of US stock market is US Eastern time.
+                '''
+                time_key = row['time_key']
+                dt = datetime.strptime(time_key, "%Y-%m-%d %H:%M:%S")
+                timestamp_ms = int(dt.timestamp() * 1000)
+                open = row['open']
+                high = row['high']
+                low = row['low']
+                close = row['close']
+                volume = row['volume']
+                candles.append(
+                    [ timestamp_ms, open, high, low, close, volume ]
+                )
+        return candles
+
+    def fetch_candles(
+        self,
+        start_ts,
+        end_ts,
+        symbols,
+        candle_size
+    ) -> Dict[str, Union[pd.DataFrame, None]]:
+        exchange_candles : Dict[str, Union[pd.DataFrame, None]] = {}
+
+        for symbol in symbols:
+            pd_candles = self._fetch_candles(symbol=symbol, start_ts=start_ts, end_ts=end_ts, candle_size=candle_size)
+            pd_candles['exchange'] = self.name
+            exchange_candles[symbol] = pd_candles
+
+        return exchange_candles
+
+    def _fetch_candles(
+        self,
+        symbol : str,
+        start_ts : int,
+        end_ts : int,
+        candle_size : str = '1d',
+        num_candles_limit : int = 100
+    ):
+        def _fetch_ohlcv(symbol, timeframe, since, limit, params) -> Union[List[List[Union[int, float]]], None]:
+            one_timeframe = f"1{timeframe[-1]}"
+            candles = self.fetch_ohlcv(symbol=symbol, timeframe=one_timeframe, since=since, limit=limit, params=params)
+            if candles and len(candles)>0:
+                candles.sort(key=lambda x : x[0], reverse=False)
+
+            return candles
+
+        all_candles = []
+        params = {}
+        this_cutoff = start_ts
+        while this_cutoff<=end_ts:
+            candles = _fetch_ohlcv(symbol=symbol, timeframe=candle_size, since=int(this_cutoff * 1000), limit=num_candles_limit, params=params)
+            if candles and len(candles)>0:
+                all_candles = all_candles + [[ int(x[0]), float(x[1]), float(x[2]), float(x[3]), float(x[4]), float(x[5]) ] for x in candles if x[1] and x[2] and x[3] and x[4] and x[5] ]
+
+                record_ts = max([int(record[0]) for record in candles])
+                record_ts_str : str = str(record_ts)
+                if len(record_ts_str)==13:
+                    record_ts = int(int(record_ts_str)/1000) # Convert from milli-seconds to seconds
+
+                if this_cutoff==record_ts+1:
+                    break
+                else:
+                    this_cutoff = record_ts  + 1
+        columns = ['exchange', 'symbol', 'timestamp_ms', 'open', 'high', 'low', 'close', 'volume']
+        pd_all_candles = pd.DataFrame([ [ "futubull", symbol, x[0], x[1], x[2], x[3], x[4], x[5] ] for x in all_candles], columns=columns)
+        # fix_column_types(pd_all_candles)
+        pd_all_candles['pct_chg_on_close'] = pd_all_candles['close'].pct_change()
+        return pd_all_candles
+
+if __name__ == '__main__':
+    params : Dict = {
+        'trdmarket' : TrdMarket.HK,
+        'security_firm' : SecurityFirm.FUTUSECURITIES,
+        'market' : Market.HK, 
+        'security_type' : SecurityType.STOCK,
+        'daemon' : {
+            'host' : '127.0.0.1',
+            'port' : 11111
+        }
+    }
+    exchange = Futubull(params)
+    markets = exchange.load_markets()
+
+    dt_end = datetime.today()
+    dt_start : datetime = dt_end - timedelta(days=365*3)
+    timestamp_ms : int = int(dt_start.timestamp() * 1000)
+    candles = exchange.fetch_ohlcv(symbol="HK.00700", timeframe="1h", since=timestamp_ms, limit=1000)
+
+    '''
+    Examples from Futu https://openapi.futunn.com/futu-api-doc/en
+
+    '''
+    quote_ctx = OpenQuoteContext(host='127.0.0.1', port=11111)
+
+    print(quote_ctx.get_global_state())
+
+    ret, data = quote_ctx.get_stock_basicinfo(Market.HK, SecurityType.STOCK)
+    if ret == RET_OK:
+        print(data)
+    else:
+        print('error:', data)
+    print('******************************************')
+    ret, data = quote_ctx.get_stock_basicinfo(Market.HK, SecurityType.STOCK, ['HK.06998', 'HK.00700'])
+    if ret == RET_OK:
+        assert isinstance(data, pd.DataFrame)
+        print(data)
+        print(data['name'][0])
+        print(data['name'].values.tolist())
+    else:
+        print('error:', data)
+
+    '''
+    KLType: https://openapi.futunn.com/futu-api-doc/en/quote/quote.html#66
+    '''
+    ret, data, page_req_key = quote_ctx.request_history_kline('HK.00700', start='2024-01-01', end='2025-03-07', ktype=KLType.K_60M, max_count=100)
+    if ret == RET_OK:
+        assert isinstance(data, pd.DataFrame)
+        print(data)
+        print(data['code'][0])
+        print(data['close'].values.tolist())
+    else:
+        print('error:', data)
+    while page_req_key != None:
+        print('*************************************')
+        ret, data, page_req_key = quote_ctx.request_history_kline('HK.00700', start='2019-09-11', end='2019-09-18', max_count=5,page_req_key=page_req_key) # Request the page after turning data
+        if ret == RET_OK:
+            print(data)
+        else:
+            print('error:', data)
+
+    # For any real time data, you need subscribe https://openapi.futunn.com/futu-api-doc/en/intro/authority.html#5331
+    ret_sub, err_message = quote_ctx.subscribe(['HK.00700'], [SubType.K_DAY], subscribe_push=False)
+    if ret_sub == RET_OK:
+        ret, data = quote_ctx.get_cur_kline('HK.00700', 2, SubType.K_DAY, AuType.QFQ)
+        if ret == RET_OK:
+            assert isinstance(data, pd.DataFrame)
+            print(data)
+            print(data['turnover_rate'][0])
+            print(data['turnover_rate'].values.tolist())
+        else:
+            print('error:', data)
+    else:
+        # (-1, '无权限订阅HK.00005的行情，请检查香港市场股票行情权限')
+        print('subscription failed', err_message)
+
+    ret_sub, err_message = quote_ctx.subscribe(['HK.00700'], [SubType.QUOTE], subscribe_push=False)
+    if ret_sub == RET_OK:
+        ret, data = quote_ctx.get_stock_quote(['HK.00700'])
+        if ret == RET_OK:
+            assert isinstance(data, pd.DataFrame)
+            print(data)
+            print(data['code'][0])
+            print(data['code'].values.tolist())
+        else:
+            print('error:', data)
+    else:
+        # '无权限订阅HK.00700的行情，请检查香港市场股票行情权限'
+        print('subscription failed', err_message)
+
+    ret_sub = quote_ctx.subscribe(['HK.00700'], [SubType.ORDER_BOOK], subscribe_push=False)[0]
+    if ret_sub == RET_OK:
+        ret, data = quote_ctx.get_order_book('HK.00700', num=3)
+        if ret == RET_OK:
+            print(data)
+        else:
+            print('error:', data)
+    else:
+        print('subscription failed')
+
+    trd_ctx = OpenSecTradeContext(filter_trdmarket=TrdMarket.HK, host='127.0.0.1', port=11111, security_firm=SecurityFirm.FUTUSECURITIES)
+    ret, data = trd_ctx.accinfo_query()
+    if ret == RET_OK:
+        assert isinstance(data, pd.DataFrame)
+        print(data)
+        print(data['power'][0])
+        print(data['power'].values.tolist())
+    else:
+        print('accinfo_query error: ', data)
+
+    ret, data = trd_ctx.order_list_query()
+    if ret == RET_OK:
+        assert isinstance(data, pd.DataFrame)
+        print(data)
+        if data.shape[0] > 0:
+            print(data['order_id'][0])
+            print(data['order_id'].values.tolist())
+    else:
+        print('order_list_query error: ', data)
+
+    ret, data = trd_ctx.history_order_list_query()
+    if ret == RET_OK:
+        assert isinstance(data, pd.DataFrame)
+        print(data)
+        if data.shape[0] > 0:
+            print(data['order_id'][0])
+            print(data['order_id'].values.tolist())
+    else:
+        print('history_order_list_query error: ', data)
+
+    ret, data = trd_ctx.position_list_query()
+    if ret == RET_OK:
+        assert isinstance(data, pd.DataFrame)
+        print(data)
+        if data.shape[0] > 0:
+            print(data['stock_name'][0])
+            print(data['stock_name'].values.tolist())
+    else:
+        print('position_list_query error: ', data)
+
+    trd_ctx.close()

{siglab_py-0.1.17 → siglab_py-0.1.19}/siglab_py/ordergateway/gateway.py

@@ -210,10 +210,6 @@ sh = logging.StreamHandler()
 sh.setLevel(log_level)
 sh.setFormatter(formatter)
 logger.addHandler(sh)
-fh = logging.FileHandler(f"ordergateway.log")
-fh.setLevel(log_level)
-fh.setFormatter(formatter)     
-logger.addHandler(fh)
 
 DUMMY_EXECUTION : Dict[str, Any] = {
     "clientOrderId": None,
@@ -776,6 +772,11 @@ async def work(
 async def main():
     parse_args()
 
+    fh = logging.FileHandler(f"ordergateway_{param['gateway_id']}.log")
+    fh.setLevel(log_level)
+    fh.setFormatter(formatter)     
+    logger.addHandler(fh)
+
     if not param['apikey']:
         log("Loading credentials from .env")
 

{siglab_py-0.1.17 → siglab_py-0.1.19}/siglab_py/tests/integration/market_data_util_tests.py

@@ -1,9 +1,10 @@
 import unittest
-from datetime import datetime
+from datetime import datetime, timedelta
 from typing import Union
 from pathlib import Path
 
 from util.market_data_util import *
+from exchanges.futubull import Futubull
 
 from ccxt.binance import binance
 from ccxt.bybit import bybit
@@ -11,6 +12,9 @@ from ccxt.okx import okx
 from ccxt.deribit import deribit
 from ccxt.base.exchange import Exchange
 
+from futu import *
+
+
 # @unittest.skip("Skip all integration tests.")
 class MarketDataUtilTests(unittest.TestCase):
 
@@ -115,4 +119,37 @@ class MarketDataUtilTests(unittest.TestCase):
             assert pd_candles['timestamp_ms'].notna().all(), "timestamp_ms column contains NaN values."
             assert pd_candles['timestamp_ms'].is_monotonic_increasing, "Timestamps are not in ascending order."
         
+    def test_fetch_candles_futubull(self):
+        end_date : datetime = datetime.today()
+        start_date : datetime = end_date - timedelta(days=365*3)
+
+        params : Dict = {
+            'trdmarket' : TrdMarket.HK,
+            'security_firm' : SecurityFirm.FUTUSECURITIES,
+            'market' : Market.HK, 
+            'security_type' : SecurityType.STOCK,
+            'daemon' : {
+                'host' : '127.0.0.1',
+                'port' : 11111
+            }
+        }
+        exchange = Futubull(params)
+        
+        symbol = "HK.00700"
+        pd_candles: Union[pd.DataFrame, None] = fetch_candles(
+                start_ts=int(start_date.timestamp()),
+                end_ts=int(end_date.timestamp()),
+                exchange=exchange,
+                normalized_symbols=[ symbol ],
+                candle_size='1d'
+            )[symbol]
+
+        assert pd_candles is not None
 
+        if pd_candles is not None:
+            assert len(pd_candles) > 0, "No candles returned."
+            expected_columns = {'exchange', 'symbol', 'timestamp_ms', 'open', 'high', 'low', 'close', 'volume', 'datetime_utc', 'datetime', 'year', 'month', 'day', 'hour', 'minute'}
+            assert set(pd_candles.columns) >= expected_columns, "Missing expected columns."
+            assert pd_candles['timestamp_ms'].notna().all(), "timestamp_ms column contains NaN values."
+            assert pd_candles['timestamp_ms'].is_monotonic_increasing, "Timestamps are not in ascending order."
+        

{siglab_py-0.1.17 → siglab_py-0.1.19}/siglab_py/util/market_data_util.py

@@ -15,6 +15,8 @@ from yahoofinancials import YahooFinancials
 # yfinance allows intervals '1m', '5m', '15m', '1h', '1d', '1wk', '1mo'. yahoofinancials not as flexible
 import yfinance as yf
 
+from exchanges.futubull import Futubull
+
 def timestamp_to_datetime_cols(pd_candles : pd.DataFrame):
     pd_candles['datetime'] = pd_candles['timestamp_ms'].apply(
         lambda x: datetime.fromtimestamp(int(x.timestamp()) if isinstance(x, pd.Timestamp) else int(x / 1000))
@@ -172,15 +174,15 @@ class YahooExchange:
             # From yf, "DateTime" in UTC
             # The requested range must be within the last 730 days. Otherwise API will return empty DataFrame.
             pd_candles = yf.download(tickers=symbol, start=start_date_str, end=end_date_str, interval=candle_size)
-            pd_candles.reset_index(inplace=True)
-            pd_candles.rename(columns={ 'Date' : 'datetime', 'Datetime' : 'datetime', 'Open': 'open', 'High': 'high', 'Low': 'low', 'Close' : 'close', 'Adj Close' : 'adj_close', 'Volume' : 'volume' }, inplace=True)
-            pd_candles['datetime'] = pd.to_datetime(pd_candles['datetime'])
-            if pd_candles['datetime'].dt.tz is None:
-                pd_candles['datetime'] = pd.to_datetime(pd_candles['datetime']).dt.tz_localize('UTC')
-            pd_candles['datetime'] = pd_candles['datetime'].dt.tz_convert(local_tz)
-            pd_candles['datetime'] = pd_candles['datetime'].dt.tz_localize(None)
-            pd_candles['timestamp_ms'] = pd_candles.datetime.values.astype(np.int64) // 10**6
-            pd_candles = pd_candles.sort_values(by=['timestamp_ms'], ascending=[True])
+            pd_candles.reset_index(inplace=True) # type: ignore
+            pd_candles.rename(columns={ 'Date' : 'datetime', 'Datetime' : 'datetime', 'Open': 'open', 'High': 'high', 'Low': 'low', 'Close' : 'close', 'Adj Close' : 'adj_close', 'Volume' : 'volume' }, inplace=True) # type: ignore
+            pd_candles['datetime'] = pd.to_datetime(pd_candles['datetime']) # type: ignore
+            if pd_candles['datetime'].dt.tz is None: # type: ignore
+                pd_candles['datetime'] = pd.to_datetime(pd_candles['datetime']).dt.tz_localize('UTC') # type: ignore
+            pd_candles['datetime'] = pd_candles['datetime'].dt.tz_convert(local_tz) # type: ignore
+            pd_candles['datetime'] = pd_candles['datetime'].dt.tz_localize(None)  # type: ignore
+            pd_candles['timestamp_ms'] = pd_candles.datetime.values.astype(np.int64) // 10**6 # type: ignore
+            pd_candles = pd_candles.sort_values(by=['timestamp_ms'], ascending=[True]) # type: ignore
             
             fix_column_types(pd_candles)
             pd_candles['symbol'] = symbol
@@ -249,6 +251,18 @@ def fetch_candles(
                             symbols=normalized_symbols,
                             candle_size=candle_size
                         )
+    elif type(exchange) is Futubull:
+        exchange_candles = exchange.fetch_candles(
+                            start_ts=start_ts,
+                            end_ts=end_ts,
+                            symbols=normalized_symbols,
+                            candle_size=candle_size
+                        )
+        for symbol in exchange_candles:
+            pd_candles = exchange_candles[symbol]
+            if not pd_candles is None:
+                fix_column_types(pd_candles) # You don't want to do this from Futubull as you'd need import Futubull from there: Circular references
+        return exchange_candles
     elif issubclass(exchange.__class__, CcxtExchange):
         return _fetch_candles_ccxt(
             start_ts=start_ts,

{siglab_py-0.1.17 → siglab_py-0.1.19}/siglab_py.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: siglab-py
-Version: 0.1.17
+Version: 0.1.19
 Summary: Market data fetches, TA calculations and generic order gateway.
 Author: r0bbarh00d
 Author-email: r0bbarh00d <r0bbarh00d@gmail.com>

{siglab_py-0.1.17 → siglab_py-0.1.19}/siglab_py.egg-info/SOURCES.txt

@@ -9,6 +9,7 @@ siglab_py.egg-info/requires.txt
 siglab_py.egg-info/top_level.txt
 siglab_py/exchanges/__init__.py
 siglab_py/exchanges/any_exchange.py
+siglab_py/exchanges/futubull.py
 siglab_py/market_data_providers/__init__.py
 siglab_py/market_data_providers/aggregated_orderbook_provider.py
 siglab_py/market_data_providers/candles_provider.py