siglab-py 0.1.0__py3-none-any.whl

siglab_py/util/aws_util.py

@@ -0,0 +1,47 @@
+from typing import Union, Dict
+
+'''
+https://gist.github.com/raphaelgabbarelli/bc5a41d93789046f9c71e4685f1463e7
+https://www.youtube.com/watch?v=CFEYKrP0vxs
+'''
+import boto3
+import base64
+
+class AwsKmsUtil(object):
+    def __init__(
+                    self, 
+                    key_id : str,
+                    profile_name : Union[str,None] = None
+                ):
+        self.key_id = key_id
+        aws_session = boto3.session.Session(profile_name=profile_name) # type: ignore "session" is not a known attribute of module "boto3"
+        self.aws_kms_client = aws_session.client('kms')
+    
+    def encrypt(self, plaintext : str) -> bytes:
+        encrypted = self.aws_kms_client.encrypt(KeyId=self.key_id, Plaintext=plaintext)
+        encrypted : bytes = base64.b64encode(encrypted['CiphertextBlob']) # type: ignore
+        return encrypted
+
+    def decrypt(self, encrypted : bytes) -> str:
+        decrypted : str = self.aws_kms_client.decrypt(CiphertextBlob=base64.b64decode(encrypted)) # type: ignore Cannot access attribute "ams_kms_client" for class "AwsKmsUtil*
+        return decrypted['Plaintext'].decode('utf-8') # type: ignore
+
+if __name__ == "__main__":
+    '''
+    From command line, run 'aws configure' with IAM user's Access key ID and Secret access key. (Assume you have awscli installed)
+        aws configure
+        AWS Access Key ID [****************ABCD]: <-- ***ABCD is your IAM user 
+        AWS Secret Access Key [****************xxx]: <-- xxx is password to your IAM user
+        Default region name [us-east-1]: <-- Region need be where your KMS key resides!
+        Default output format [None]: 
+    
+    Remember that when you create your KMS Key, you need to grant permission of the key newly created key to IAM user (This is done on KMS side, not IAM).
+    '''
+    key_id : str = "" # Enter your KMS key ID here. You'd find it from under AWS > KMS > Customer managed keys
+    original : str = "some secret"
+    
+    aws_kms = AwsKmsUtil(key_id=key_id, profile_name=None)
+    encrypted = aws_kms.encrypt(original)
+    decrpted = aws_kms.decrypt(encrypted)
+
+    print(f"original: {original}, encrypted: {encrypted.decode('utf-8')}, decrpted: {decrpted}") # type: ignore

siglab_py/util/market_data_util.py

@@ -0,0 +1,385 @@
+import tzlocal
+from datetime import datetime, timezone
+from typing import List, Dict, Union, NoReturn, Any, Tuple
+from pathlib import Path
+import math
+import pandas as pd
+import numpy as np
+
+from ccxt.base.exchange import Exchange as CcxtExchange
+from ccxt import deribit
+
+# https://www.analyticsvidhya.com/blog/2021/06/download-financial-dataset-using-yahoo-finance-in-python-a-complete-guide/
+from yahoofinancials import YahooFinancials
+
+# yfinance allows intervals '1m', '5m', '15m', '1h', '1d', '1wk', '1mo'. yahoofinancials not as flexible
+import yfinance as yf
+
+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))
+    )
+    pd_candles['datetime'] = pd.to_datetime(pd_candles['datetime'])
+    pd_candles['datetime'] = pd_candles['datetime'].dt.tz_localize(None)
+    pd_candles['datetime_utc'] = pd_candles['timestamp_ms'].apply(
+        lambda x: datetime.fromtimestamp(int(x.timestamp()) if isinstance(x, pd.Timestamp) else int(x / 1000), tz=timezone.utc)
+    )
+    
+    # This is to make it easy to do grouping with Excel pivot table
+    pd_candles['year'] = pd_candles['datetime'].dt.year
+    pd_candles['month'] = pd_candles['datetime'].dt.month
+    pd_candles['day'] = pd_candles['datetime'].dt.day
+    pd_candles['hour'] = pd_candles['datetime'].dt.hour
+    pd_candles['minute'] = pd_candles['datetime'].dt.minute
+    pd_candles['dayofweek'] = pd_candles['datetime'].dt.dayofweek  # dayofweek: Monday is 0 and Sunday is 6
+
+def fix_column_types(pd_candles : pd.DataFrame):
+    pd_candles['open'] = pd_candles['open'].astype(float)
+    pd_candles['high'] = pd_candles['high'].astype(float)
+    pd_candles['low'] = pd_candles['low'].astype(float)
+    pd_candles['close'] = pd_candles['close'].astype(float)
+    pd_candles['volume'] = pd_candles['volume'].astype(float)
+
+    timestamp_to_datetime_cols(pd_candles)
+
+    '''
+    The 'Unnamed: 0', 'Unnamed : 1'... etc columns often appears in a DataFrame when it is saved to a file (e.g., CSV or Excel) and later loaded. 
+    This usually happens if the DataFrame's index was saved along with the data, and then pandas automatically treats it as a column during the file loading process.
+    We want to drop them as it'd mess up idmin, idmax calls, which will take values from 'Unnamed' instead of actual pandas index.
+    '''
+    pd_candles.drop(pd_candles.columns[pd_candles.columns.str.contains('unnamed',case = False)],axis = 1, inplace = True)
+    pd_candles.reset_index(drop=True, inplace=True)
+    pd_candles.sort_values("datetime", inplace=True)
+
+'''
+https://polygon.io/docs/stocks
+'''
+class PolygonMarketDataProvider:
+    pass
+
+class NASDAQExchange:
+    def __init__(self, data_dir : Union[str, None]) -> None:
+        if data_dir:
+            self.data_dir = data_dir
+        else:
+            self.data_dir = Path(__file__).resolve().parents[2] / "data/nasdaq" 
+
+    def fetch_ohlcv(
+        self,
+        symbol : str,
+        since : int,
+        timeframe : str,
+        limit : int = 1
+    ) -> List:
+        pd_candles = self.fetch_candles(
+            symbols=[symbol],
+            start_ts=int(since/1000),
+            end_ts=None,
+            candle_size=timeframe
+        )[symbol]
+        if pd_candles is not None:
+            return pd_candles.values.tolist()
+        else:
+            return []
+    
+    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]] = {}
+
+        start_date = datetime.fromtimestamp(start_ts)
+        end_date = datetime.fromtimestamp(end_ts) if end_ts else None
+        start_date_str = start_date.strftime('%Y-%m-%d')
+        end_date_str = end_date.strftime('%Y-%m-%d') if end_date else None
+        local_tz = datetime.now().astimezone().tzinfo
+
+        for symbol in symbols:
+            # CSV from NASDAQ: https://www.nasdaq.com/market-activity/quotes/historical
+            pd_daily_candles = pd.read_csv(f"{self.data_dir}\\NASDAQ_hist_{symbol.replace('^','')}.csv")
+            pd_daily_candles.rename(columns={'Date' : 'datetime', 'Open': 'open', 'High': 'high', 'Low': 'low', 'Close/Last' : 'close', 'Adj Close' : 'adj_close', 'Volume' : 'volume' }, inplace=True)
+            pd_daily_candles['open'] = pd_daily_candles['open'].astype(str).str.replace('$','')
+            pd_daily_candles['high'] = pd_daily_candles['high'].astype(str).str.replace('$','')
+            pd_daily_candles['low'] = pd_daily_candles['low'].astype(str).str.replace('$','')
+            pd_daily_candles['close'] = pd_daily_candles['close'].astype(str).str.replace('$','')
+            pd_daily_candles['datetime']= pd.to_datetime(pd_daily_candles['datetime'])
+            pd_daily_candles['timestamp_ms'] = pd_daily_candles.datetime.values.astype(np.int64) // 10 ** 6
+            pd_daily_candles['symbol'] = symbol
+            pd_daily_candles['exchange'] = 'nasdaq'
+            fix_column_types(pd_daily_candles)
+
+            if candle_size=="1h":
+                # Fill forward (i.e. you dont actually have hourly candles)
+                start = pd_daily_candles["datetime"].min().normalize()
+                end = pd_daily_candles["datetime"].max().normalize() + pd.Timedelta(days=1)
+                hourly_index = pd.date_range(start=start, end=end, freq="h") # FutureWarning: 'H' is deprecated and will be removed in a future version, please use 'h' instead.
+                pd_hourly_candles = pd.DataFrame({"datetime": hourly_index})
+                pd_hourly_candles = pd.merge_asof(
+                    pd_hourly_candles.sort_values("datetime"),
+                    pd_daily_candles.sort_values("datetime"),
+                    on="datetime",
+                    direction="backward"
+                )
+
+                # When you fill foward, a few candles before start date can have null values (open, high, low, close, volume ...)
+                first_candle_dt = pd_hourly_candles[(~pd_hourly_candles.close.isna())  & (pd_hourly_candles['datetime'].dt.time == pd.Timestamp('00:00:00').time())].iloc[0]['datetime']
+                pd_hourly_candles = pd_hourly_candles[pd_hourly_candles.datetime>=first_candle_dt]
+                exchange_candles[symbol] = pd_hourly_candles
+
+            elif candle_size=="1d":
+                exchange_candles[symbol] = pd_daily_candles
+
+        return exchange_candles
+
+class YahooExchange:
+    def fetch_ohlcv(
+        self,
+        symbol : str,
+        since : int,
+        timeframe : str,
+        limit : int = 1
+    ) -> List:
+        pd_candles = self.fetch_candles(
+            symbols=[symbol],
+            start_ts=int(since/1000),
+            end_ts=None,
+            candle_size=timeframe
+        )[symbol]
+        if pd_candles is not None:
+            return pd_candles.values.tolist()
+        else:
+            return []
+
+    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]] = {}
+
+        start_date = datetime.fromtimestamp(start_ts)
+        end_date = datetime.fromtimestamp(end_ts)
+        start_date_str = start_date.strftime('%Y-%m-%d')
+        end_date_str = end_date.strftime('%Y-%m-%d')
+        local_tz = datetime.now().astimezone().tzinfo
+
+        for symbol in symbols:
+            # 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])
+            
+            fix_column_types(pd_candles)
+            pd_candles['symbol'] = symbol
+            pd_candles['exchange'] = 'yahoo'
+            exchange_candles[symbol] = pd_candles
+
+        return exchange_candles
+
+def fetch_historical_price(
+    exchange,
+    normalized_symbol : str,
+    timestamp_ms : int,
+    ref_timeframe : str = '1m'
+):
+    one_candle = fetch_ohlcv_one_candle(exchange=exchange, normalized_symbol=normalized_symbol, timestamp_ms=timestamp_ms, ref_timeframe=ref_timeframe)
+    reference_price = abs(one_candle['close'] + one_candle['open'])/2 if one_candle else None
+    return reference_price
+
+def fetch_ohlcv_one_candle(
+    exchange,
+    normalized_symbol : str,
+    timestamp_ms : int,
+    ref_timeframe : str = '1m'
+):
+    candles = exchange.fetch_ohlcv(symbol=normalized_symbol, since=int(timestamp_ms), timeframe=ref_timeframe, limit=1)
+    one_candle = {
+            'timestamp_ms' : candles[0][0],
+            'open' : candles[0][1],
+            'high' : candles[0][2],
+            'low' : candles[0][3],
+            'close' : candles[0][4],
+            'volume' : candles[0][5] 
+        } if candles and len(candles)>0 else None
+    
+    return one_candle
+    
+def fetch_candles(
+    start_ts, # in sec
+    end_ts, # in sec
+    exchange,
+    normalized_symbols,
+    candle_size,
+
+    logger = None,
+
+    num_candles_limit : int = 100,
+
+    cache_dir : Union[str, None] = None,
+
+    list_ts_field : Union[str, None] = None,
+
+    validation_max_gaps : int = 10,
+    validation_max_end_date_intervals : int = 1
+) -> Dict[str, Union[pd.DataFrame, None]]:
+    if type(exchange) is YahooExchange:
+        return exchange.fetch_candles(
+                            start_ts=start_ts,
+                            end_ts=end_ts,
+                            symbols=normalized_symbols,
+                            candle_size=candle_size
+                        )
+    elif type(exchange) is NASDAQExchange:
+        return exchange.fetch_candles(
+                            start_ts=start_ts,
+                            end_ts=end_ts,
+                            symbols=normalized_symbols,
+                            candle_size=candle_size
+                        )
+    elif issubclass(exchange.__class__, CcxtExchange):
+        return _fetch_candles_ccxt(
+            start_ts=start_ts,
+            end_ts=end_ts,
+            exchange=exchange,
+            normalized_symbols=normalized_symbols,
+            candle_size=candle_size,
+            logger=logger,
+            num_candles_limit=num_candles_limit,
+            cache_dir=cache_dir,
+            list_ts_field=list_ts_field
+        )
+    return { '' : None }
+
+def _fetch_candles_ccxt(
+    start_ts : int,
+    end_ts : int,
+    exchange,
+    normalized_symbols : List[str],
+    candle_size : str,
+    num_candles_limit : int = 100,
+    logger = None,
+    cache_dir : Union[str, None] = None,
+    list_ts_field : Union[str, None] = None
+) -> Dict[str, Union[pd.DataFrame, None]]:
+  ticker = normalized_symbols[0]
+  pd_candles = _fetch_candles(
+              symbol = ticker,
+              exchange = exchange,
+              start_ts = start_ts,
+              end_ts = end_ts,
+              candle_size = candle_size,
+          )
+  return {
+      ticker : pd_candles
+  }
+
+def _fetch_candles(
+    symbol : str,
+    exchange : CcxtExchange,
+    start_ts : int,
+    end_ts : int,
+    candle_size : str = '1d',
+    num_candles_limit : int = 100
+):
+    def _fetch_ohlcv(exchange, symbol, timeframe, since, limit, params) -> Union[List, NoReturn]:
+        one_timeframe = f"1{timeframe[-1]}"
+        candles = exchange.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(exchange=exchange, 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
+
+            this_cutoff = record_ts  + 1
+    columns = ['exchange', 'symbol', 'timestamp_ms', 'open', 'high', 'low', 'close', 'volume']
+    pd_all_candles = pd.DataFrame([ [ exchange.name, 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
+
+def fetch_deribit_btc_option_expiries(
+    market: str = 'BTC'
+) -> Dict[
+    str, Union[
+        Dict[str, float],
+        Dict[str, Dict[str, Union[str, float]]]
+    ]
+]:
+    exchange = deribit()
+    instruments = exchange.public_get_get_instruments({
+        'currency': market,
+        'kind': 'option',
+        # 'expired': 'true'
+    })['result']
+    
+    index_price = exchange.public_get_get_index_price({
+        'index_name': f"{market.lower()}_usd"
+    })['result']['index_price']
+    index_price = float(index_price)
+    
+    expiry_data : Dict[str, float] = {}
+    expiry_data_breakdown_by_strike : Dict[str, Dict] = {}
+    for instrument in instruments:
+        expiry_timestamp = int(instrument["expiration_timestamp"]) / 1000
+        expiry_date = datetime.utcfromtimestamp(expiry_timestamp)
+
+        strike = float(instrument['strike'])
+
+        option_type = instrument['instrument_name'].split('-')[-1]  # Last part is 'C' or 'P'
+        is_call = option_type == 'C'
+    
+        ticker = exchange.public_get_ticker({
+            'instrument_name': instrument['instrument_name']
+        })['result']
+        
+        open_interest = ticker.get("open_interest", 0)  # Open interest in BTC
+        open_interest = float(open_interest)
+        notional_value : float = open_interest * index_price  # Convert to USD
+        
+        expiry_str : str = expiry_date.strftime("%Y-%m-%d")
+        if expiry_str not in expiry_data:
+            expiry_data[expiry_str] = 0
+        expiry_data[expiry_str] += notional_value
+
+        if f"{expiry_str}-{strike}" not in expiry_data_breakdown_by_strike:
+            expiry_data_breakdown_by_strike[f"{expiry_str}-{strike}"] = {
+                'expiry' : expiry_str,
+                'strike' : strike,
+                'option_type': 'call' if is_call else 'put',
+                'notional_value' : notional_value
+            }
+        else:
+            expiry_data_breakdown_by_strike[f"{expiry_str}-{strike}"]['notional_value'] += notional_value
+    
+    sorted_expiry_data = sorted(expiry_data.items())
+
+    return {
+        'index_price' : index_price,
+        'by_expiry' : sorted_expiry_data, # type: ignore Otherwise, Error: Type "dict[str, list[tuple[str, float]] | dict[str, Dict[Unknown, Unknown]]]" is not assignable to return type "Dict[str, Dict[str, float] | Dict[str, Dict[str, str | float]]]"
+        'by_expiry_and_strike' : expiry_data_breakdown_by_strike
+    }

siglab_py/util/retry_util.py

@@ -0,0 +1,15 @@
+def retry(num_attempts : int = 1):
+    def decorator(method):
+        def wrapper(*args, **kw):
+            for i in range(num_attempts):
+                try:
+                    result = method(*args, **kw)
+                    if i>0:
+                        print(f"retry_gizmo.retry succeeded: {method.__name__} on #{i+1} invocation. {args} {kw}")
+                    return result
+                except Exception as retry_error:
+                    if i==(num_attempts-1):
+                        err_msg = f"retry_gizmo.retry failed: {method.__name__} after {num_attempts} invocations. {args} {kw}. {retry_error}"
+                        raise Exception(err_msg) from retry_error
+        return wrapper
+    return decorator

siglab_py-0.1.0.dist-info/METADATA

@@ -0,0 +1,36 @@
+Metadata-Version: 2.1
+Name: siglab-py
+Version: 0.1.0
+Summary: Market data fetches, TA calculations and generic order gateway.
+Author: r0bbarh00d
+Author-email: r0bbarh00d <r0bbarh00d@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/r0bbar/siglab/blob/master/siglab_py/README.md
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9.19
+Description-Content-Type: text/markdown
+Requires-Dist: python-dotenv
+Requires-Dist: dotmap
+Requires-Dist: typing-extensions
+Requires-Dist: arrow
+Requires-Dist: tzlocal
+Requires-Dist: nest-asyncio
+Requires-Dist: pandas
+Requires-Dist: numpy
+Requires-Dist: boto3
+Requires-Dist: web3
+Requires-Dist: ccxt
+Requires-Dist: ccxtpro
+Requires-Dist: yfinance
+Requires-Dist: yahoofinancials
+Requires-Dist: scipy
+Requires-Dist: statsmodels
+Requires-Dist: scikit-learn
+Requires-Dist: sklearn.preprocessing
+Requires-Dist: hurst
+Requires-Dist: redis
+Requires-Dist: redis-py-cluster
+Requires-Dist: kafka-python
+

siglab_py-0.1.0.dist-info/RECORD

@@ -0,0 +1,29 @@
+siglab_py/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+siglab_py/constants.py,sha256=YGNdEsWtQ99V2oltaynZTjM8VIboSfyIjDXJKSlhv4U,132
+siglab_py/exchanges/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+siglab_py/exchanges/any_exchange.py,sha256=blsB_itXEcr8-DxT4DI5n9v9htJGbU0OsW68fx6pIgo,727
+siglab_py/market_data_providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+siglab_py/market_data_providers/aggregated_orderbook_provider.py,sha256=uN6oD6PqbfnkPKVzKF_GfSEuXdtmv0lFTB-yg9gRYcI,23234
+siglab_py/market_data_providers/candles_provider.py,sha256=fqHJjlECsBiBlpgyywrc4gTgxiROPNzZM8KxQBB5cOg,14139
+siglab_py/market_data_providers/candles_ta_provider.py,sha256=uiAhbEZZdTF-YulBHpSLwabos5LHCKU91NTiTmpUc0w,12001
+siglab_py/market_data_providers/deribit_options_expiry_provider.py,sha256=mP-508KftjseOWvttjEOu6fXu7J7DPCYGoyeuY6I_mU,8585
+siglab_py/market_data_providers/orderbooks_provider.py,sha256=cBp-HYCups2Uiwzw0SaUwxrg4unJvnm2TDqIK8f4hUg,15674
+siglab_py/market_data_providers/test_provider.py,sha256=wBLCgcWjs7FGZJXWsNyn30lkOLa_cgpuvqRakMC0wbA,2221
+siglab_py/ordergateway/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+siglab_py/ordergateway/client.py,sha256=fweIM9aqtWqL2ajrIZ7ChRY4aUmMoqHDLMviv9q7kpU,4995
+siglab_py/ordergateway/encrypt_keys_util.py,sha256=-qi87db8To8Yf1WS1Q_Cp2Ya7ZqgWlRqSHfNXCM7wE4,1339
+siglab_py/ordergateway/gateway.py,sha256=xlTThsNRRHYWilpc3zpAcYC2nxG4crfpDY8Refbnl64,30038
+siglab_py/ordergateway/test_ordergateway.py,sha256=-uK3t82CPSAsO9Bt-GbN3PsbzKcr7lfkdusV3XrqV68,4708
+siglab_py/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+siglab_py/tests/integration/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+siglab_py/tests/integration/market_data_util_tests.py,sha256=_UyOMTTBW1VJ7rroyESoxmdhBCQzWSV2A14tAjV9J5U,5634
+siglab_py/tests/unit/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+siglab_py/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+siglab_py/util/analytic_util.py,sha256=QLabbEMqM4rKKH2PE_LqxIyo-BUdCRhkLybLATBImcc,43438
+siglab_py/util/aws_util.py,sha256=x_duGDXJ6sO0wVpoRVDTMxECag7feA7zOwZweVLGl_w,2251
+siglab_py/util/market_data_util.py,sha256=3qTq71xGvQXj0ORKJV50IN5FP_mCBF_gvdmlPyhdyco,16439
+siglab_py/util/retry_util.py,sha256=mxYuRFZRZoaQQjENcwPmxhxixtd1TFvbxIdPx4RwfRc,743
+siglab_py-0.1.0.dist-info/METADATA,sha256=_Gc1E24YhCE6nKmfmi0diNm8-ZNqr8QTeItlDgxe5DM,1096
+siglab_py-0.1.0.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
+siglab_py-0.1.0.dist-info/top_level.txt,sha256=AbD4VR9OqmMOGlMJLkAVPGQMtUPIQv0t1BF5xmcLJSk,10
+siglab_py-0.1.0.dist-info/RECORD,,

siglab_py-0.1.0.dist-info/WHEEL

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

siglab_py-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+siglab_py