cryptodatapy 0.2.12__py3-none-any.whl → 0.2.14__py3-none-any.whl

cryptodatapy/extract/data_vendors/coinmetrics_api.py

@@ -71,21 +71,12 @@ class CoinMetrics(DataVendor):
         rate_limit: Any, optional, Default None
             Number of API calls made and left, by time frequency.
         """
-        DataVendor.__init__(
-            self,
-            categories,
-            exchanges,
-            indexes,
-            assets,
-            markets,
-            market_types,
-            fields,
-            frequencies,
-            base_url,
-            api_key,
-            max_obs_per_call,
-            rate_limit,
+        super().__init__(
+            categories, exchanges, indexes, assets, markets, market_types,
+            fields, frequencies, base_url, api_key, max_obs_per_call, rate_limit
         )
+        self.data_req = None
+        self.data = pd.DataFrame()
 
     @staticmethod
     def req_meta(data_type: str) -> Dict[str, Any]:
@@ -176,27 +167,6 @@ class CoinMetrics(DataVendor):
 
         return self.assets
 
-    def get_inst_info(self, as_dict: bool = False) -> Union[Dict[str, List[str]], pd.DataFrame]:
-        """
-        Get institutions info.
-
-        Parameters
-        ----------
-        as_dict: bool, default False
-            Returns available institutions as dictionary.
-
-        Returns
-        -------
-        inst: dictionary or pd.DataFrame
-            Dictionary or dataframe with info on available institutions.
-        """
-        # req data
-        inst = self.req_meta(data_type='catalog_institutions')
-        # wrangle data resp
-        inst = WrangleInfo(inst).cm_inst_info(as_dict=as_dict)
-
-        return inst
-
     def get_markets_info(self, as_list: bool = False) -> Union[List[str], pd.DataFrame]:
         """
         Get markets info.
@@ -258,14 +228,11 @@ class CoinMetrics(DataVendor):
         # req data
         ohlcv_fields = ['price_open', 'price_close', 'price_high', 'price_low', 'vwap', 'volume', 'candle_usd_volume',
                         'candle_trades_count']  # get market fields
-        inst_fields = [v for k, v in self.get_inst_info(as_dict=True).items()][0]  # inst fields
         onchain_fields = self.get_onchain_fields_info()  # get onchain fields
 
         # fields df
         if data_type == "market":
             self.fields = onchain_fields[onchain_fields.category == "Market"]
-        elif data_type == "off-chain":
-            self.fields = inst_fields
         else:
             self.fields = onchain_fields
 
@@ -275,10 +242,8 @@ class CoinMetrics(DataVendor):
                 self.fields = ohlcv_fields + list(self.fields.index)
             elif data_type == "on-chain":
                 self.fields = list(self.fields.index)
-            elif data_type == "off-chain":
-                self.fields = inst_fields
             else:
-                self.fields = ohlcv_fields + list(self.fields.index) + inst_fields
+                self.fields = ohlcv_fields + list(self.fields.index)
 
         return self.fields
 
@@ -297,15 +262,14 @@ class CoinMetrics(DataVendor):
             List of available assets for selected fields.
         """
         # convert data request parameters to Coin Metrics format
-        cm_data_req = ConvertParams(data_req).to_coinmetrics()
-        # fields param
-        fields = cm_data_req["fields"]
+        self.data_req = ConvertParams(data_req).to_coinmetrics()
 
         # fields info
         self.get_fields_info()
+
         # fields dict
         fields_dict = {}
-        for field in fields:
+        for field in self.data_req.source_fields:
             if field in self.fields.index:
                 df = self.fields.loc[field]  # get fields metadata
                 # add to dict
@@ -341,12 +305,14 @@ class CoinMetrics(DataVendor):
         if self.fields is None:
             self.get_fields_info(as_list=True)
 
-    def req_data(self, data_type: str, params: Dict[str, Union[str, int]]) -> pd.DataFrame:
+    def req_data(self, data_req: DataRequest, data_type: str, params: Dict[str, Union[str, int]]) -> pd.DataFrame:
         """
         Sends data request to Python client.
 
         Parameters
         ----------
+        data_req: DataRequest
+            Parameters of data request in CryptoDataPy format.
         data_type: str
             Data type to retrieve.
         params: dict
@@ -361,7 +327,7 @@ class CoinMetrics(DataVendor):
         url = self.base_url + data_type
 
         # data request
-        data_resp = DataRequest().get_req(url=url, params=params)
+        data_resp = data_req.get_req(url=url, params=params)
 
         # raise error if data is None
         if data_resp is None:
@@ -374,10 +340,10 @@ class CoinMetrics(DataVendor):
             # while loop
             while next_page_url:
                 # wait to avoid exceeding rate limit
-                sleep(0.6)
+                sleep(data_req.pause)
 
                 # request next page
-                next_page_data_resp = DataRequest(pause=0.6).get_req(url=next_page_url, params=None)
+                next_page_data_resp = data_req.get_req(url=next_page_url, params=None)
                 next_page_data, next_page_url = next_page_data_resp.get('data', []), next_page_data_resp.get(
                     'next_page_url')
 
@@ -390,7 +356,7 @@ class CoinMetrics(DataVendor):
             return df
 
     @staticmethod
-    def wrangle_data_resp(data_req: DataRequest, data_resp: pd.DataFrame()):
+    def wrangle_data_resp(data_req: DataRequest, data_resp: pd.DataFrame()) -> pd.DataFrame():
         """
         Wrangle data response.
 
@@ -433,13 +399,13 @@ class CoinMetrics(DataVendor):
             Dataframe with DatetimeIndex (level 0), ticker (level 1) and values for fields/col, in tidy data format.
         """
         # get entire data history
-        df = self.req_data(data_type, params)
+        df = self.req_data(data_req, data_type, params)
         # wrangle df
         df = self.wrangle_data_resp(data_req, df)
 
         return df
 
-    def check_tickers(self, data_req: DataRequest, data_type: str) -> List[str]:
+    def check_tickers(self, data_req: DataRequest, data_type: str) -> DataRequest:
         """
         Checks tickers for data availability.
 
@@ -457,40 +423,41 @@ class CoinMetrics(DataVendor):
             List of available tickers.
         """
         # convert params
-        cm_data_req = ConvertParams(data_req).to_coinmetrics()
-        # tickers
-        tickers = []
+        self.data_req = ConvertParams(data_req).to_coinmetrics()
 
         # check indexes
         if data_type == 'indexes':
             self.get_indexes_info(as_list=True)
             # avail tickers
-            tickers = [ticker for ticker in cm_data_req["tickers"] if ticker.upper() in self.indexes]
+            self.data_req.source_tickers = [ticker for ticker in self.data_req.source_tickers
+                                            if ticker.upper() in self.indexes]
 
         # check markets
         elif data_type == 'market_candles' or data_type == 'open_interest' or \
                 data_type == 'funding_rates' or data_type == 'trades' or data_type == 'quotes':
             self.get_assets_info(as_list=True)
             # avail tickers
-            tickers = [ticker for asset, ticker in zip(cm_data_req["tickers"], cm_data_req["mkts"]) if
-                       asset in self.assets]
+            self.data_req.source_markets = [market for ticker, market in
+                                            zip(self.data_req.source_tickers, self.data_req.source_markets)
+                                            if ticker in self.assets]
 
         # check assets
         elif data_type == 'asset_metrics':
             self.get_assets_info(as_list=True)
             # avail tickers
-            tickers = [ticker for ticker in cm_data_req["tickers"] if ticker in self.assets]
+            self.data_req.source_tickers = [ticker for ticker in self.data_req.source_tickers
+                                            if ticker in self.assets]
 
         # raise error if no tickers available
-        if len(tickers) == 0:
+        if len(self.data_req.source_tickers) == 0:
             raise ValueError(
                 f"{data_req.tickers} are not valid tickers for the requested data type."
                 f" Use get_metadata to get a list of available indexes and assets."
             )
 
-        return tickers
+        return self.data_req
 
-    def check_fields(self, data_req: DataRequest, data_type: str) -> List[str]:
+    def check_fields(self, data_req: DataRequest, data_type: str) -> DataRequest:
         """
         Checks fields for data availability.
 
@@ -508,33 +475,25 @@ class CoinMetrics(DataVendor):
             List of avaialble fields.
         """
         # convert params
-        cm_data_req = ConvertParams(data_req).to_coinmetrics()
-        # fields
-        fields = []
-
-        # check instution
-        if data_type == 'institutions':
-            # avail inst
-            inst_list = [val for key, val in self.get_inst_info(as_dict=True).items()][0]
-            fields = [field for field in cm_data_req["fields"] if field in inst_list]
+        self.data_req = ConvertParams(data_req).to_coinmetrics()
 
         # check on-chain metrics
-        elif data_type == 'asset_metrics':
+        if data_type == 'asset_metrics':
             self.get_fields_info(data_type='on-chain', as_list=True)
             # avail fields
-            fields = [field for field in cm_data_req["fields"] if field in self.fields]
+            self.data_req.source_fields = [field for field in self.data_req.source_fields
+                                           if field in self.fields]
 
         # raise error if fields is empty
-        if len(fields) == 0:
+        if len(self.data_req.source_fields) == 0:
             raise ValueError(
                 f"{data_req.fields} are not valid fields."
                 f" Use the get_fields_info or get_inst_info methods to get available source fields."
             )
 
-        return fields
+        return self.data_req
 
-    @staticmethod
-    def check_params(data_req: DataRequest, data_type: str) -> None:
+    def check_params(self, data_req: DataRequest, data_type: str) -> None:
         """
         Checks data request parameters.
 
@@ -548,27 +507,19 @@ class CoinMetrics(DataVendor):
 
         """
         # convert params
-        cm_data_req = ConvertParams(data_req).to_coinmetrics()
+        self.data_req = ConvertParams(data_req).to_coinmetrics()
 
         # indexes
         if data_type == 'indexes':
-            if cm_data_req["freq"] not in ["1h", "1d"]:
+            if self.data_req.source_freq not in ["1h", "1d"]:
                 raise ValueError(
                     f"Indexes data is only available for hourly, daily, weekly, monthly and quarterly"
                     f" frequencies. Change data request frequency and try again."
                 )
 
-        # institutions
-        elif data_type == 'institutions':
-            if cm_data_req["freq"] != "1d":
-                raise ValueError(
-                    f"Institutions data is only available for daily frequency."
-                    f" Change data request frequency and try again."
-                )
-
         # ohlcv
         elif data_type == 'market_candles':
-            if cm_data_req["freq"] not in ["1m", "1h", "1d"]:
+            if self.data_req.source_freq not in ["1m", "1h", "1d"]:
                 raise ValueError(
                     f"OHLCV data is only available for minute, hourly, daily, weekly, monthly and quarterly"
                     f" frequencies. Change data request frequency and try again."
@@ -576,7 +527,7 @@ class CoinMetrics(DataVendor):
 
         # on-chain
         elif data_type == 'asset_metrics':
-            if cm_data_req["freq"] not in ["1b", "1d"]:
+            if self.data_req.source_freq not in ["1b", "1d"]:
                 raise ValueError(
                     f"On-chain data is only available for 'block' and 'd' frequencies."
                     f" Change data request frequency and try again."
@@ -584,14 +535,15 @@ class CoinMetrics(DataVendor):
 
         # funding rate
         elif data_type == 'funding_rates':
-            if data_req.mkt_type not in ["perpetual_future", "future", "option"]:
+            if self.data_req.mkt_type not in ["perpetual_future", "future", "option"]:
                 raise ValueError(
                     f"Funding rates are only available for 'perpetual_future', 'future' and"
                     f" 'option' market types. Change 'mkt_type' in data request and try again."
                 )
 
+        # oi
         elif data_type == 'open_interest':
-            if data_req.mkt_type not in ["perpetual_future", "future", "option"]:
+            if self.data_req.mkt_type not in ["perpetual_future", "future", "option"]:
                 raise ValueError(
                     f"Open interest is only available for 'perpetual_future', 'future' and"
                     f" 'option' market types. Change 'mkt_type' in data request and try again."
@@ -599,7 +551,7 @@ class CoinMetrics(DataVendor):
 
         # trades
         elif data_type == 'trades':
-            if cm_data_req["freq"] != "raw":
+            if self.data_req.source_freq != "raw":
                 raise ValueError(
                     f"{data_type} data is only available at the 'tick' frequency."
                     f" Change data request frequency and try again."
@@ -607,7 +559,7 @@ class CoinMetrics(DataVendor):
 
         # quotes
         elif data_type == 'quotes':
-            if cm_data_req["freq"] not in ["raw", "1s", "1m", "1h", "1d"]:
+            if self.data_req.source_freq not in ["raw", "1s", "1m", "1h", "1d"]:
                 raise ValueError(
                     f"{data_type} data is only available at the 'tick', '1s', '1m', '1h' and '1d' frequencies."
                     f" Change data request frequency and try again."
@@ -630,21 +582,21 @@ class CoinMetrics(DataVendor):
             DataFrame with DatetimeIndex (level 0), tickers (level 1) and index values (cols).
         """
         # convert data request parameters to Coin Metrics format
-        cm_data_req = ConvertParams(data_req).to_coinmetrics()
+        self.data_req = ConvertParams(data_req).to_coinmetrics()
 
         # check params
         self.check_params(data_req, data_type='indexes')
 
         # check tickers
-        tickers = self.check_tickers(data_req, data_type='indexes')
-        sleep(0.6)
+        self.check_tickers(data_req, data_type='indexes')
+        sleep(self.data_req.pause)
 
         # params
         params = {
-            'indexes': ','.join(tickers),
-            'frequency': cm_data_req['freq'],
-            'start_time': cm_data_req["start_date"],
-            'end_time': cm_data_req["end_date"],
+            'indexes': ','.join(self.data_req.source_tickers),
+            'frequency': self.data_req.source_freq,
+            'start_time': self.data_req.source_start_date,
+            'end_time': self.data_req.source_end_date,
             'pretty': True,
             'page_size': 10000,
         }
@@ -656,48 +608,6 @@ class CoinMetrics(DataVendor):
 
         return df
 
-    def get_institutions(self, data_req: DataRequest) -> pd.DataFrame:
-        """
-        Get institutions data.
-
-        Parameters
-        ----------
-        data_req: DataRequest
-            Parameters of data request in CryptoDataPy format.
-
-        Returns
-        -------
-        df: pd.DataFrame
-            DataFrame with DatetimeIndex (level 0), tickers (level 1) and institution fields values (cols).
-        """
-        # convert data request parameters to Coin Metrics format
-        cm_data_req = ConvertParams(data_req).to_coinmetrics()
-
-        # check params
-        self.check_params(data_req, data_type='institutions')
-
-        # check fields
-        fields = self.check_fields(data_req, data_type='institutions')
-        sleep(0.6)
-
-        # params
-        params = {
-            'institutions': cm_data_req["inst"],
-            'metrics': ','.join(fields),
-            'frequency': cm_data_req['freq'],
-            'start_time': cm_data_req["start_date"],
-            'end_time': cm_data_req["end_date"],
-            'pretty': True,
-            'page_size': 10000,
-        }
-
-        # get tidy data
-        df = self.get_tidy_data(data_req,
-                                data_type='/timeseries/institution-metrics',
-                                params=params)
-
-        return df
-
     def get_ohlcv(self, data_req: DataRequest) -> pd.DataFrame:
         """
         Get OHLCV (candles) data.
@@ -713,21 +623,21 @@ class CoinMetrics(DataVendor):
             DataFrame with DatetimeIndex (level 0), ticker (level 1), and OHLCV values (cols).
         """
         # convert data request parameters to Coin Metrics format
-        cm_data_req = ConvertParams(data_req).to_coinmetrics()
+        self.data_req = ConvertParams(data_req).to_coinmetrics()
 
         # check freq
         self.check_params(data_req, data_type='market_candles')
 
         # check tickers
-        tickers = self.check_tickers(data_req, data_type='market_candles')
-        sleep(0.6)
+        self.check_tickers(data_req, data_type='market_candles')
+        sleep(self.data_req.pause)
 
         # params
         params = {
-            'markets': ','.join(tickers),
-            'frequency': cm_data_req['freq'],
-            'start_time': cm_data_req["start_date"],
-            'end_time': cm_data_req["end_date"],
+            'markets': ','.join(self.data_req.source_markets),
+            'frequency': self.data_req.source_freq,
+            'start_time': self.data_req.source_start_date,
+            'end_time': self.data_req.source_end_date,
             'pretty': True,
             'page_size': 10000,
         }
@@ -754,26 +664,26 @@ class CoinMetrics(DataVendor):
             DataFrame with DatetimeIndex (level 0), ticker (level 1), and on-chain values (cols).
         """
         # convert data request parameters to Coin Metrics format
-        cm_data_req = ConvertParams(data_req).to_coinmetrics()
+        self.data_req = ConvertParams(data_req).to_coinmetrics()
 
         # check params
         self.check_params(data_req, data_type='asset_metrics')
 
         # check tickers
-        tickers = self.check_tickers(data_req, data_type='asset_metrics')
-        sleep(0.6)
+        self.check_tickers(data_req, data_type='asset_metrics')
+        sleep(self.data_req.pause)
 
         # check fields
-        fields = self.check_fields(data_req, data_type='asset_metrics')
-        sleep(0.6)
+        self.check_fields(data_req, data_type='asset_metrics')
+        sleep(self.data_req.pause)
 
         # params
         params = {
-            'assets': ','.join(tickers),
-            'metrics': ','.join(fields),
-            'frequency': cm_data_req['freq'],
-            'start_time': cm_data_req["start_date"],
-            'end_time': cm_data_req["end_date"],
+            'assets': ','.join(self.data_req.source_tickers),
+            'metrics': ','.join(self.data_req.source_fields),
+            'frequency': self.data_req.source_freq,
+            'start_time': self.data_req.source_start_date,
+            'end_time': self.data_req.source_end_date,
             'pretty': True,
             'page_size': 10000,
             'ignore_forbidden_errors': True,
@@ -804,20 +714,20 @@ class CoinMetrics(DataVendor):
             DataFrame with DatetimeIndex (level 0), ticker (level 1), and open interest values (cols).
         """
         # convert data request parameters to Coin Metrics format
-        cm_data_req = ConvertParams(data_req).to_coinmetrics()
+        self.data_req = ConvertParams(data_req).to_coinmetrics()
 
         # check params
         self.check_params(data_req, data_type='open_interest')
 
         # check tickers
-        tickers = self.check_tickers(data_req, data_type='open_interest')
-        sleep(0.6)
+        self.check_tickers(data_req, data_type='open_interest')
+        sleep(self.data_req.pause)
 
         # params
         params = {
-            'markets': ','.join(tickers),
-            'start_time': cm_data_req["start_date"],
-            'end_time': cm_data_req["end_date"],
+            'markets': ','.join(self.data_req.source_markets),
+            'start_time': self.data_req.source_start_date,
+            'end_time': self.data_req.source_end_date,
             'pretty': True,
             'page_size': 10000,
         }
@@ -845,20 +755,20 @@ class CoinMetrics(DataVendor):
             DataFrame with DatetimeIndex (level 0), ticker (level 1), and funding rates values (cols).
         """
         # convert data request parameters to Coin Metrics format
-        cm_data_req = ConvertParams(data_req).to_coinmetrics()
+        self.data_req = ConvertParams(data_req).to_coinmetrics()
 
         # check params
         self.check_params(data_req, data_type='funding_rates')
 
         # check tickers
-        tickers = self.check_tickers(data_req, data_type='funding_rates')
-        sleep(0.6)
+        self.check_tickers(data_req, data_type='funding_rates')
+        sleep(self.data_req.pause)
 
         # params
         params = {
-            'markets': ','.join(tickers),
-            'start_time': cm_data_req["start_date"],
-            'end_time': cm_data_req["end_date"],
+            'markets': ','.join(self.data_req.source_markets),
+            'start_time': self.data_req.source_start_date,
+            'end_time': self.data_req.source_end_date,
             'pretty': True,
             'page_size': 10000,
         }
@@ -886,20 +796,20 @@ class CoinMetrics(DataVendor):
             DataFrame with DatetimeIndex (level 0), ticker (level 1), and bid/ask price and size values (cols).
         """
         # convert data request parameters to Coin Metrics format
-        cm_data_req = ConvertParams(data_req).to_coinmetrics()
+        self.data_req = ConvertParams(data_req).to_coinmetrics()
 
         # check params
         self.check_params(data_req, data_type='trades')
 
         # check tickers
-        tickers = self.check_tickers(data_req, data_type='trades')
-        sleep(0.6)
+        self.check_tickers(data_req, data_type='trades')
+        sleep(self.data_req.pause)
 
         # params
         params = {
-            'markets': ','.join(tickers),
-            'start_time': cm_data_req["start_date"],
-            'end_time': cm_data_req["end_date"],
+            'markets': ','.join(self.data_req.source_markets),
+            'start_time': self.data_req.source_start_date,
+            'end_time': self.data_req.source_end_date,
             'pretty': True,
             'page_size': 10000,
         }
@@ -927,21 +837,21 @@ class CoinMetrics(DataVendor):
             DataFrame with DatetimeIndex (level 0), ticker (level 1), and bid/ask price and size values (cols).
         """
         # convert data request parameters to Coin Metrics format
-        cm_data_req = ConvertParams(data_req).to_coinmetrics()
+        self.data_req = ConvertParams(data_req).to_coinmetrics()
 
         # check params
         self.check_params(data_req, data_type='quotes')
 
         # check tickers
-        tickers = self.check_tickers(data_req, data_type='quotes')
-        sleep(0.6)
+        self.check_tickers(data_req, data_type='quotes')
+        sleep(self.data_req.pause)
 
         # params
         params = {
-            'markets': ','.join(tickers),
-            'granularity': cm_data_req['freq'],
-            'start_time': cm_data_req["start_date"],
-            'end_time': cm_data_req["end_date"],
+            'markets': ','.join(self.data_req.source_markets),
+            'granularity': self.data_req.source_freq,
+            'start_time': self.data_req.source_start_date,
+            'end_time': self.data_req.source_end_date,
             'pretty': True,
             'page_size': 10000,
         }
@@ -970,16 +880,17 @@ class CoinMetrics(DataVendor):
             fields (cols), in tidy format.
         """
         # convert data request parameters to Coin Metrics format
-        cm_data_req = ConvertParams(data_req).to_coinmetrics()
+        self.data_req = ConvertParams(data_req).to_coinmetrics()
 
         # check if fields available
         self.get_fields_info(as_list=True)
-        sleep(0.6)
-        # if not all([field in self.fields for field in cm_data_req["fields"]]):
-        #     raise ValueError(
-        #         "Some selected fields are not available. Check available fields with"
-        #         " get_fields_info method and try again."
-        #     )
+        sleep(self.data_req.pause)
+
+        if not all([field in self.fields for field in self.data_req.source_fields]):
+            raise ValueError(
+                "Some selected fields are not available. Check available fields with"
+                " get_fields_info method and try again."
+            )
 
         # field lists
         ohlcv_list = ['price_open', 'price_close', 'price_high', 'price_low', 'vwap', 'volume',
@@ -991,9 +902,9 @@ class CoinMetrics(DataVendor):
 
         # get indexes data
         self.get_indexes_info(as_list=True)
-        sleep(0.6)
-        if any([ticker.upper() in self.indexes for ticker in cm_data_req["tickers"]]) and any(
-                [field in ohlcv_list for field in cm_data_req["fields"]]
+        sleep(self.data_req.pause)
+        if any([ticker.upper() in self.indexes for ticker in self.data_req.source_tickers]) and any(
+                [field in ohlcv_list for field in self.data_req.source_fields]
         ):
             df0 = self.get_indexes(data_req)
             df = pd.concat([df, df0])
@@ -1001,15 +912,15 @@ class CoinMetrics(DataVendor):
         # get OHLCV data
         self.get_assets_info(as_list=True)
         sleep(0.6)
-        if any([ticker in self.assets for ticker in cm_data_req["tickers"]]) and any(
-                [field in ohlcv_list for field in cm_data_req["fields"]]
+        if any([ticker in self.assets for ticker in self.data_req.source_tickers]) and any(
+                [field in ohlcv_list for field in self.data_req.source_fields]
         ):
             df1 = self.get_ohlcv(data_req)
             df = pd.concat([df, df1])
 
         # get on-chain data
-        if any([ticker in self.assets for ticker in cm_data_req["tickers"]]) and any(
-                [field in oc_list for field in cm_data_req["fields"]]
+        if any([ticker in self.assets for ticker in self.data_req.source_tickers]) and any(
+                [field in oc_list for field in self.data_req.source_fields]
         ):
             df2 = self.get_onchain(data_req)
             df = pd.concat([df, df2], axis=1)

cryptodatapy/extract/data_vendors/tiingo_api.py

@@ -549,7 +549,7 @@ class Tiingo(DataVendor):
                     df = pd.concat([df, df0])
 
         else:
-            for ticker in self.data_req.tickers:
+            for ticker in self.data_req.source_tickers:
                 try:
                     df0 = self.get_tidy_data(self.data_req, data_type, ticker)
                 except Exception as e:
@@ -679,7 +679,7 @@ class Tiingo(DataVendor):
         """
         self.data_req = ConvertParams(data_req).to_tiingo()
 
-        # get metada
+        # get metadata
         self.get_assets_info(as_list=True)
         self.get_fields_info()
 
@@ -690,11 +690,16 @@ class Tiingo(DataVendor):
             )
 
         # check assets
-        if not any([ticker.upper() in self.assets[self.data_req.cat] for ticker in self.data_req.tickers]) and \
-                data_req.cat != 'fx':
-            raise ValueError(
-                f"Selected tickers are not available. Use assets attribute to see available tickers."
-            )
+        if self.data_req.cat == 'eqty':
+            if not any([ticker.upper() in self.assets[self.data_req.cat] for ticker in self.data_req.source_tickers]):
+                raise ValueError(
+                    f"Selected eqty tickers are not available. Use assets attribute to see available eqty tickers."
+                )
+        elif self.data_req.cat == 'crypto':
+            if not any([ticker in self.assets[self.data_req.cat] for ticker in self.data_req.source_markets]):
+                raise ValueError(
+                    f"Selected crypto tickers are not available. Use assets attribute to see available crypto tickers."
+                )
 
         # check fields
         if not any([field in self.fields[data_req.cat] for field in self.data_req.fields]):

cryptodatapy/extract/datarequest.py

@@ -26,7 +26,6 @@ class DataRequest:
         end_date: Optional[Union[str, datetime, pd.Timestamp]] = None,
         fields: Union[str, List[str]] = ["close"],
         tz: Optional[str] = None,
-        inst: Optional[str] = None,
         cat: Optional[str] = None,
         trials: Optional[int] = 3,
         pause: Optional[float] = 0.1,
@@ -69,8 +68,6 @@ class DataRequest:
             Fields for data request. OHLC bars/fields are the most common fields for market data.
         tz: str, optional, default None
             Timezone for the start/end dates in tz database format.
-        inst: str, optional, default None
-            Name of institution from which to pull fund data, e.g. 'grayscale', 'purpose', etc.
         cat: str, optional, {'crypto', 'fx', 'cmdty', 'eqty', 'rates', 'bonds', 'credit', 'macro', 'alt'}, default None
             Category of data, e.g. crypto, fx, rates, or macro.
         trials: int, optional, default 3
@@ -107,7 +104,6 @@ class DataRequest:
         self.end_date = end_date  # end date
         self.fields = fields  # fields
         self.tz = tz  # tz
-        self.inst = inst  # institution
         self.cat = cat  # category of asset class or time series
         self.trials = trials  # number of times to try query request
         self.pause = pause  # number of seconds to pause between query request trials
@@ -412,25 +408,6 @@ class DataRequest:
         else:
             raise TypeError("Fields must be a string or list of strings.")
 
-    @property
-    def inst(self):
-        """
-        Returns institution name for data request.
-        """
-        return self._inst
-
-    @inst.setter
-    def inst(self, inst):
-        """
-        Sets institution's name for data request.
-        """
-        if inst is None:
-            self._inst = inst
-        elif isinstance(inst, str):
-            self._inst = inst
-        else:
-            raise TypeError("Institution must be a string.")
-
     @property
     def tz(self):
         """

cryptodatapy/extract/libraries/ccxt_api.py

@@ -1483,6 +1483,8 @@ class CCXT(Library):
         df: pd.DataFrame - MultiIndex
             DataFrame with DatetimeIndex (level 0), ticker (level 1), and values for selected fields (cols).
         """
+        logging.info("Retrieving data request from CCXT...")
+
         # get OHLCV
         if any([field in ["open", "high", "low", "close", "volume"] for field in data_req.fields]):
             df = await self.fetch_tidy_ohlcv_async(data_req)
@@ -1523,6 +1525,8 @@ class CCXT(Library):
         df: pd.DataFrame - MultiIndex
             DataFrame with DatetimeIndex (level 0), ticker (level 1), and values for selected fields (cols).
         """
+        logging.info("Retrieving data request from CCXT...")
+
         # get OHLCV
         if any([field in ["open", "high", "low", "close", "volume"] for field in data_req.fields]):
             df = self.fetch_tidy_ohlcv(data_req)

cryptodatapy/transform/convertparams.py

@@ -101,159 +101,134 @@ class ConvertParams:
             "source_fields": self.data_req.source_fields,
         }
 
-    def to_coinmetrics(self) -> Dict[str, Union[list, str, int, float, None]]:
+    def to_coinmetrics(self) -> DataRequest:
         """
         Convert tickers from CryptoDataPy to CoinMetrics format.
         """
-        # convert tickers
-        if self.data_req.source_tickers is not None:
-            tickers = self.data_req.source_tickers
-            self.data_req.tickers = self.data_req.source_tickers
-        else:
-            tickers = [ticker.lower() for ticker in self.data_req.tickers]
-        # convert freq
-        if self.data_req.source_freq is not None:
-            freq = self.data_req.source_freq
-            self.data_req.freq = self.data_req.source_freq
-        else:
+        # tickers
+        if self.data_req.source_tickers is None:
+            self.data_req.source_tickers = [ticker.lower() for ticker in self.data_req.tickers]
+
+        # freq
+        if self.data_req.source_freq is None:
             if self.data_req.freq is None:
-                freq = "1d"
+                self.data_req.source_freq = "1d"
             elif self.data_req.freq == "block":
-                freq = "1b"
+                self.data_req.source_freq = "1b"
             elif self.data_req.freq == "tick":
-                freq = "raw"
+                self.data_req.source_freq = "raw"
             elif self.data_req.freq[-1] == "s":
-                freq = "1s"
+                self.data_req.source_freq = "1s"
             elif self.data_req.freq[-3:] == "min":
-                freq = "1m"
+                self.data_req.source_freq = "1m"
             elif self.data_req.freq[-1] == "h":
-                freq = "1h"
+                self.data_req.source_freq = "1h"
             else:
-                freq = "1d"
-        # convert quote ccy
+                self.data_req.source_freq = "1d"
+
+        # quote ccy
         if self.data_req.quote_ccy is None:
-            quote_ccy = "usdt"
-        else:
-            quote_ccy = self.data_req.quote_ccy.lower()
-        # convert inst
-        if self.data_req.inst is None:
-            inst = "grayscale"
+            self.data_req.quote_ccy = "usdt"
         else:
-            inst = self.data_req.inst.lower()
-        # convert to exch
+            self.data_req.quote_ccy = self.data_req.quote_ccy.lower()
+
+        # exchange
         if self.data_req.exch is None:
-            exch = "binance"
+            self.data_req.exch = "binance"
         else:
-            exch = self.data_req.exch.lower()
+            self.data_req.exch = self.data_req.exch.lower()
+
         # fields
-        if self.data_req.source_fields is not None:
-            fields = self.data_req.source_fields
-            self.data_req.fields = self.data_req.source_fields
-        else:
-            fields = self.convert_fields(data_source='coinmetrics')
+        if self.data_req.source_fields is None:
+            self.data_req.source_fields = self.convert_fields(data_source='coinmetrics')
+
         # convert tz
         if self.data_req.tz is None:
-            tz = "UTC"
+            self.data_req.tz = "UTC"
         else:
-            tz = self.data_req.tz
-        # convert tickers to markets
-        mkts_list = []
+            self.data_req.tz = self.data_req.tz
 
-        if self.data_req.source_tickers is not None:
-            mkts_list = self.data_req.source_tickers
-            self.data_req.tickers = self.data_req.source_tickers
+        # markets
+        mkts_list = []
 
-        for ticker in self.data_req.tickers:
-            if self.data_req.mkt_type == "spot":
-                mkts_list.append(
-                    exch
-                    + "-"
-                    + ticker.lower()
-                    + "-"
-                    + quote_ccy.lower()
-                    + "-"
-                    + self.data_req.mkt_type.lower()
-                )
-            elif self.data_req.mkt_type == "perpetual_future":
-                if exch == "binance" or exch == "bybit" or exch == "bitmex":
-                    mkts_list.append(
-                        exch
-                        + "-"
-                        + ticker.upper()
-                        + quote_ccy.upper()
-                        + "-"
-                        + "future"
-                    )
-                elif exch == "ftx":
-                    mkts_list.append(
-                        exch + "-" + ticker.upper() + "-" + "PERP" + "-" + "future"
-                        )
-                elif exch == "okex":
-                    mkts_list.append(
-                        exch
-                        + "-"
-                        + ticker.upper()
-                        + "-"
-                        + quote_ccy.upper()
-                        + "-"
-                        + "SWAP"
-                        + "-"
-                        + "future"
-                    )
-                elif exch == "huobi":
+        if self.data_req.source_markets is None:
+            # loop through tickers
+            for ticker in self.data_req.tickers:
+                if self.data_req.mkt_type == "spot":
                     mkts_list.append(
-                        exch
-                        + "-"
-                        + ticker.upper()
+                        self.data_req.exch
                         + "-"
-                        + quote_ccy.upper()
-                        + "_"
-                        + "SWAP"
-                        + "-"
-                        + "future"
-                    )
-                elif exch == "hitbtc":
-                    mkts_list.append(
-                        exch
+                        + ticker.lower()
                         + "-"
-                        + ticker.upper()
-                        + quote_ccy.upper()
-                        + "_"
-                        + "PERP"
+                        + self.data_req.quote_ccy.lower()
                         + "-"
-                        + "future"
+                        + self.data_req.mkt_type.lower()
                     )
+                elif self.data_req.mkt_type == "perpetual_future":
+                    if (self.data_req.exch == "binance" or self.data_req.exch == "bybit" or
+                            self.data_req.exch == "bitmex"):
+                        mkts_list.append(
+                            self.data_req.exch
+                            + "-"
+                            + ticker.upper()
+                            + self.data_req.quote_ccy.upper()
+                            + "-"
+                            + "future"
+                        )
+                    elif self.data_req.exch == "ftx":
+                        mkts_list.append(
+                            self.data_req.exch + "-" + ticker.upper() + "-" + "PERP" + "-" + "future"
+                            )
+                    elif self.data_req.exch == "okex":
+                        mkts_list.append(
+                            self.data_req.exch
+                            + "-"
+                            + ticker.upper()
+                            + "-"
+                            + self.data_req.quote_ccy.upper()
+                            + "-"
+                            + "SWAP"
+                            + "-"
+                            + "future"
+                        )
+                    elif self.data_req.exch == "huobi":
+                        mkts_list.append(
+                            self.data_req.exch
+                            + "-"
+                            + ticker.upper()
+                            + "-"
+                            + self.data_req.quote_ccy.upper()
+                            + "_"
+                            + "SWAP"
+                            + "-"
+                            + "future"
+                        )
+                    elif self.data_req.exch == "hitbtc":
+                        mkts_list.append(
+                            self.data_req.exch
+                            + "-"
+                            + ticker.upper()
+                            + self.data_req.quote_ccy.upper()
+                            + "_"
+                            + "PERP"
+                            + "-"
+                            + "future"
+                        )
+            self.data_req.source_markets = mkts_list
+
         # start date
         if self.data_req.start_date is not None:
-            start_date = self.data_req.start_date.strftime('%Y-%m-%d')
+            self.data_req.source_start_date = self.data_req.start_date.strftime('%Y-%m-%d')
         else:
-            start_date = None
+            self.data_req.source_start_date = None
+
         # end date
         if self.data_req.end_date is not None:
-            end_date = self.data_req.end_date.strftime('%Y-%m-%d')
+            self.data_req.source_end_date = self.data_req.end_date.strftime('%Y-%m-%d')
         else:
-            end_date = None
+            self.data_req.source_end_date = None
 
-        return {
-            "tickers": tickers,
-            "freq": freq,
-            "quote_ccy": quote_ccy,
-            "exch": exch,
-            "ctys": None,
-            "mkt_type": self.data_req.mkt_type,
-            "mkts": mkts_list,
-            "start_date": start_date,
-            "end_date": end_date,
-            "fields": fields,
-            "tz": tz,
-            "inst": inst,
-            "cat": 'crypto',
-            "trials": self.data_req.trials,
-            "pause": self.data_req.pause,
-            "source_tickers": self.data_req.source_tickers,
-            "source_freq": self.data_req.source_freq,
-            "source_fields": self.data_req.source_fields,
-        }
+        return self.data_req
 
     def to_glassnode(self) -> Dict[str, Union[list, str, int, float, None]]:
         """
@@ -344,8 +319,20 @@ class ConvertParams:
         Convert tickers from CryptoDataPy to Tiingo format.
         """
         # tickers
-        if self.data_req.source_tickers is None:
-            self.data_req.source_tickers = [ticker.lower() for ticker in self.data_req.tickers]
+        with resources.path("cryptodatapy.conf", "tickers.csv") as f:
+            tickers_path = f
+        tickers_df = pd.read_csv(tickers_path, index_col=0, encoding="latin1")
+
+        if self.data_req.source_tickers is None and self.data_req.cat == 'eqty':
+            self.data_req.source_tickers = []
+            for ticker in self.data_req.tickers:
+                try:
+                    self.data_req.source_tickers.append(tickers_df.loc[ticker, "tiingo_id"])
+                except KeyError:
+                    logging.warning(
+                        f"{ticker} not found for Tiingo source. Check tickers in"
+                        f" data catalog and try again."
+                    )
 
         # freq
         if self.data_req.source_freq is None:

cryptodatapy/transform/impute.py

@@ -79,11 +79,18 @@ class Impute:
             order = 3
 
         # interpolate
-        self.imputed_df = self.filtered_df.unstack().interpolate(method=method, order=order, axis=axis,
-                                                                 limit=limit).stack().reindex(self.filtered_df.index)
+        self.imputed_df = (
+            self.filtered_df
+            .unstack()
+            .interpolate(method=method,
+                         order=order,
+                         axis=axis,
+                         limit=limit)
+            .stack(future_stack=True)
+            .reindex(self.filtered_df.index))
 
         # type conversion
-        self.imputed_df = self.imputed_df.apply(pd.to_numeric, errors="ignore").convert_dtypes()
+        self.imputed_df = self.imputed_df.convert_dtypes()
 
         # plot
         if self.plot:
@@ -123,7 +130,6 @@ class Impute:
         # type conversion
         self.imputed_df = self.imputed_df.convert_dtypes()
 
-
         # plot
         if self.plot:
             if not isinstance(self.plot_series, tuple):

cryptodatapy/transform/od.py

@@ -205,9 +205,9 @@ class OutlierDetection:
             med = np.exp(med)
 
         # type conversion
-        self.yhat = med.apply(pd.to_numeric, errors='coerce').convert_dtypes().sort_index()
-        self.outliers = out_df.apply(pd.to_numeric, errors='coerce').convert_dtypes().sort_index()
-        self.filtered_df = filt_df.apply(pd.to_numeric, errors='coerce').convert_dtypes().sort_index()
+        self.yhat = med.convert_dtypes().sort_index()
+        self.outliers = out_df.convert_dtypes().sort_index()
+        self.filtered_df = filt_df.convert_dtypes().sort_index()
 
         # plot
         if self.plot:
@@ -260,9 +260,9 @@ class OutlierDetection:
             med = np.exp(med)
 
         # type conversion
-        med = med.apply(pd.to_numeric, errors='coerce').convert_dtypes()
-        out_df = out_df.apply(pd.to_numeric, errors='coerce').convert_dtypes()
-        filt_df = filt_df.apply(pd.to_numeric, errors='coerce').convert_dtypes()
+        med = med.convert_dtypes()
+        out_df = out_df.convert_dtypes()
+        filt_df = filt_df.convert_dtypes()
 
         self.yhat = med.sort_index()
         self.outliers = out_df.sort_index()
@@ -334,9 +334,9 @@ class OutlierDetection:
             roll_mean = np.exp(roll_mean)
 
         # type conversion
-        roll_mean = roll_mean.apply(pd.to_numeric, errors='coerce').convert_dtypes()
-        out_df = out_df.apply(pd.to_numeric, errors='coerce').convert_dtypes()
-        filt_df = filt_df.apply(pd.to_numeric, errors='coerce').convert_dtypes()
+        roll_mean = roll_mean.convert_dtypes()
+        out_df = out_df.convert_dtypes()
+        filt_df = filt_df.convert_dtypes()
 
         self.yhat = roll_mean.sort_index()
         self.outliers = out_df.sort_index()
@@ -382,9 +382,9 @@ class OutlierDetection:
             ewma = np.exp(ewma)
 
         # type conversion
-        ewma = ewma.apply(pd.to_numeric, errors='coerce').convert_dtypes()
-        out_df = out_df.apply(pd.to_numeric, errors='coerce').convert_dtypes()
-        filt_df = filt_df.apply(pd.to_numeric, errors='coerce').convert_dtypes()
+        ewma = ewma.convert_dtypes()
+        out_df = out_df.convert_dtypes()
+        filt_df = filt_df.convert_dtypes()
 
         self.yhat = ewma.sort_index()
         self.outliers = out_df.sort_index()
@@ -491,14 +491,14 @@ class OutlierDetection:
         filt_df = self.df.unstack()[resid_df.abs() < self.thresh_val]
 
         # stack and reindex
-        out_df = out_df.stack().reindex(mult_idx)
-        filt_df = filt_df.stack().reindex(mult_idx)
-        yhat_df = yhat_df.stack().reindex(mult_idx)
+        out_df = out_df.stack(future_stack=True).reindex(mult_idx)
+        filt_df = filt_df.stack(future_stack=True).reindex(mult_idx)
+        yhat_df = yhat_df.stack(future_stack=True).reindex(mult_idx)
 
         # convert dtypes
-        yhat_df = yhat_df.apply(pd.to_numeric, errors="ignore").convert_dtypes()
-        out_df = out_df.apply(pd.to_numeric, errors="ignore").convert_dtypes()
-        filt_df = filt_df.apply(pd.to_numeric, errors="ignore").convert_dtypes()
+        yhat_df = yhat_df.convert_dtypes()
+        out_df = out_df.convert_dtypes()
+        filt_df = filt_df.convert_dtypes()
 
         self.yhat = yhat_df.sort_index()
         self.outliers = out_df.sort_index()
@@ -634,14 +634,14 @@ class OutlierDetection:
         filt_df = self.df.unstack()[resid_df.abs() < self.thresh_val]
 
         # stack and reindex
-        out_df = out_df.stack().reindex(mult_idx)
-        filt_df = filt_df.stack().reindex(mult_idx)
-        yhat_df = yhat_df.stack().reindex(mult_idx)
+        out_df = out_df.stack(future_stack=True).reindex(mult_idx)
+        filt_df = filt_df.stack(future_stack=True).reindex(mult_idx)
+        yhat_df = yhat_df.stack(future_stack=True).reindex(mult_idx)
 
         # convert dtypes
-        yhat_df = yhat_df.apply(pd.to_numeric, errors="ignore").convert_dtypes()
-        out_df = out_df.apply(pd.to_numeric, errors="ignore").convert_dtypes()
-        filt_df = filt_df.apply(pd.to_numeric, errors="ignore").convert_dtypes()
+        yhat_df = yhat_df.convert_dtypes()
+        out_df = out_df.convert_dtypes()
+        filt_df = filt_df.convert_dtypes()
 
         self.yhat = yhat_df.sort_index()
         self.outliers = out_df.sort_index()
@@ -744,14 +744,14 @@ class OutlierDetection:
         filt_df = self.df.unstack()[self.df.unstack().lt(yhat_upper) & self.df.unstack().gt(yhat_lower)]
 
         # stack and reindex
-        yhat_df = yhat_df.stack().reindex(mult_idx)
-        out_df = out_df.stack().reindex(mult_idx)
-        filt_df = filt_df.stack().reindex(mult_idx)
+        yhat_df = yhat_df.stack(future_stack=True).reindex(mult_idx)
+        out_df = out_df.stack(future_stack=True).reindex(mult_idx)
+        filt_df = filt_df.stack(future_stack=True).reindex(mult_idx)
 
         # convert dtypes
-        yhat_df = yhat_df.apply(pd.to_numeric, errors="ignore").convert_dtypes()
-        out_df = out_df.apply(pd.to_numeric, errors="ignore").convert_dtypes()
-        filt_df = filt_df.apply(pd.to_numeric, errors="ignore").convert_dtypes()
+        yhat_df = yhat_df.convert_dtypes()
+        out_df = out_df.convert_dtypes()
+        filt_df = filt_df.convert_dtypes()
 
         self.yhat = yhat_df.sort_index()
         self.outliers = out_df.sort_index()

cryptodatapy/transform/wrangle.py

@@ -528,7 +528,6 @@ class WrangleData:
         -------
         pd.DataFrame
             Wrangled dataframe into tidy data format.
-
         """
         # convert fields to lib
         self.convert_fields_to_lib(data_source='coinmetrics')
@@ -881,8 +880,17 @@ class WrangleData:
         self.data_resp.columns = self.data_req.tickers  # convert tickers to cryptodatapy format
 
         # resample to match end of reporting period, not beginning
-        self.data_resp = self.data_resp.resample('d').last().ffill().resample(self.data_req.freq).last().stack(). \
-            to_frame().reset_index()
+        self.data_resp = (
+            self.data_resp
+            .resample('d')
+            .last()
+            .ffill()
+            .resample(self.data_req.freq)
+            .last()
+            .stack(future_stack=True)
+            .to_frame()
+            .reset_index()
+        )
 
         # convert cols
         if self.data_req.cat == 'macro':
@@ -983,7 +991,7 @@ class WrangleData:
 
         # format index
         self.data_resp.index.name = 'date'  # rename
-        self.data_resp = self.data_resp.stack().to_frame('er')
+        self.data_resp = self.data_resp.stack(future_stack=True).to_frame('er')
         self.data_resp.index.names = ['date', 'ticker']
 
         # type and conversion to decimals
@@ -1010,7 +1018,7 @@ class WrangleData:
         with resources.path("cryptodatapy.conf", "tickers.csv") as f:
             tickers_path = f
         tickers_df = pd.read_csv(tickers_path, index_col=0, encoding="latin1")
-        self.data_resp = self.data_resp.stack().to_frame()  # stack df
+        self.data_resp = self.data_resp.stack(future_stack=True).to_frame()  # stack df
         # create list of tickers using tickers csv
         tickers = []
         for row in self.data_resp.iterrows():
@@ -1092,11 +1100,11 @@ class WrangleData:
         self.data_resp = df
         self.filter_dates()
         # stack df
-        self.data_resp = self.data_resp.stack().to_frame('er')
+        self.data_resp = self.data_resp.stack(future_stack=True).to_frame('er')
         # create multi index
         self.data_resp.index.names = ['date', 'ticker']
         # type and conversion to decimals
-        self.data_resp = self.data_resp.apply(pd.to_numeric, errors='coerce').convert_dtypes()
+        self.data_resp = self.data_resp.convert_dtypes()
         # remove bad data
         self.data_resp = self.data_resp[~self.data_resp.index.duplicated()]  # duplicate rows
         self.data_resp = self.data_resp.dropna(how='all').dropna(how='all', axis=1)  # entire row or col NaNs

{cryptodatapy-0.2.12.dist-info → cryptodatapy-0.2.14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: cryptodatapy
-Version: 0.2.12
+Version: 0.2.14
 Summary: Cryptoasset data library
 License: Apache-2.0
 Author: Systamental

{cryptodatapy-0.2.12.dist-info → cryptodatapy-0.2.14.dist-info}/RECORD

@@ -27,18 +27,18 @@ cryptodatapy/extract/data_vendors/.ipynb_checkpoints/InvestPy-checkpoint.ipynb,s
 cryptodatapy/extract/data_vendors/.ipynb_checkpoints/NasdaqDataLink-checkpoint.ipynb,sha256=hY2QkCcTiLgPnl8SQPsO8spio5-RBMGeBLYzAwgSWb4,147170
 cryptodatapy/extract/data_vendors/.ipynb_checkpoints/PandasDataReader-checkpoint.ipynb,sha256=n7vzOV6AxC_Ti5CLWW2ABMEEcbbBpiBBs4qTUBQinIg,24171
 cryptodatapy/extract/data_vendors/__init__.py,sha256=Nk6gcT43d0XOLfrlVA9r--5mvHCgHfq295IKL3Puu74,354
-cryptodatapy/extract/data_vendors/coinmetrics_api.py,sha256=2fnsgKkBWjzMa1jzfVa7UbJKTpMWzcFVjo0bKDEud8U,34991
+cryptodatapy/extract/data_vendors/coinmetrics_api.py,sha256=VdUjTn0DPsXFmwzD_JHZNhGUoaEAv1nwMYpT0ZcY2fs,32972
 cryptodatapy/extract/data_vendors/cryptocompare_api.py,sha256=3oBfQioBz1vrs9JNtwE0hBLI4BTtpFBBEEsDawmobE8,28872
 cryptodatapy/extract/data_vendors/datavendor.py,sha256=kGKxHcPng6JiGGhcuPx87ij0DXl4E-OSqxlvxhJ1HQo,12642
 cryptodatapy/extract/data_vendors/glassnode_api.py,sha256=PuuJOjHztoJyFijb5XU1zm1S_2NAj7MX-wC89DL_bWQ,13103
-cryptodatapy/extract/data_vendors/tiingo_api.py,sha256=aS7SzWjaPcWcSp7MMm329jW0_ukV5Bkr-WH7RWOG0P8,25047
-cryptodatapy/extract/datarequest.py,sha256=Yi1pVe-ljv_su6kwEw5uylhG3XtneujBaNS2pmAIyk0,25879
+cryptodatapy/extract/data_vendors/tiingo_api.py,sha256=kcrDZ3ndG-E6M8L9qnXYShgCdXDLWnq4npX2QAGmcgM,25413
+cryptodatapy/extract/datarequest.py,sha256=EPq_7itSjwoqLY1v3HLQRbiFbSMCOzFmA2xGpaM3PQc,25215
 cryptodatapy/extract/exchanges/__init__.py,sha256=VKTNzrbe-wltGHWH9lK5RLZoXCGHp-UGGZ4gMVHJXrQ,113
 cryptodatapy/extract/exchanges/dydx.py,sha256=Oifb4sKbPRKArdZBx9q5ob4yTFkd65n0zXiS7hga0mk,4199
 cryptodatapy/extract/exchanges/exchange.py,sha256=Cicj3KS4zLbwmXX5fu89byXNwqqU4TH31GFv0zj3D4s,13010
 cryptodatapy/extract/getdata.py,sha256=BQ-OCfoQqPTYN1GtSI8t93iPpCUbtwiXC0BDxbrdKKM,11477
 cryptodatapy/extract/libraries/__init__.py,sha256=9rJ_hFHWlvkPwyIkNG5bqH6HTY2jQNPIKQjzYEsVSDo,319
-cryptodatapy/extract/libraries/ccxt_api.py,sha256=bYQxmOHdw3uCYf8jUb3Nzng30lypYX7lemfxjqSLzd4,56642
+cryptodatapy/extract/libraries/ccxt_api.py,sha256=5aPGuZFQ1HwKCxE9Y5UlapNK77lMfnsWEi64HpSkK44,56766
 cryptodatapy/extract/libraries/dbnomics_api.py,sha256=M6kPIH-hKqkmeBQb-g56dY9jatqLCtSl_MnvPblHtAc,9421
 cryptodatapy/extract/libraries/investpy_api.py,sha256=qtGm3LDluXxJorvFv0w1bm1oBrcZIfE5cZSYzNYvttY,18409
 cryptodatapy/extract/libraries/library.py,sha256=eU8NnQZ9luLGdIF5hms6j8VPCWc50evkREc4xdh-g1I,12301
@@ -48,15 +48,15 @@ cryptodatapy/extract/web/aqr.py,sha256=LS1D7QzG6UWkLUfDMgBFtiHpznnnAUOpec5Sx3vRG
 cryptodatapy/extract/web/web.py,sha256=R1xEnHE1McxSWxp4vrTfgh9gW6FF6XDlp0gmp2NmWOM,12126
 cryptodatapy/transform/__init__.py,sha256=Spb5cGJ3V_o8hgSWOSrF8J_vsSZpFk0uzW7RpkgfbFE,131
 cryptodatapy/transform/clean.py,sha256=C9VypQOjdJ987TcD-qAHh7qYaoJBotvp3cWTr3ttSGM,12807
-cryptodatapy/transform/convertparams.py,sha256=P1ZOtbUf-2po0oerQvL0BIZekMD0zK6ujSvQI6nUbRQ,43319
+cryptodatapy/transform/convertparams.py,sha256=VWQMk2w5SOyRGXENy-TlOjeVmtwlcxg-DOTTnM_MFsE,43442
 cryptodatapy/transform/filter.py,sha256=KYYyta0uREAjBkYTVyvhOCCLSKR_qPSlqj5Nl7l4iBk,9064
-cryptodatapy/transform/impute.py,sha256=8vfmWLN--6MUOv3zrflfE_dM6f11GZQR_le2xzJHCnU,5482
-cryptodatapy/transform/od.py,sha256=z__CWiN70f1leqx12SS9pIvTggxpUPrg1falJIKMZCc,31031
-cryptodatapy/transform/wrangle.py,sha256=nBtUvqY0MOYC-KuNTH_78yCFfYaJRrSIgybPTu7G2s8,42254
+cryptodatapy/transform/impute.py,sha256=_0-SX5nnPrYgJYT-HKwBGNkmWXRMy9-C2oeU6VqkQp0,5537
+cryptodatapy/transform/od.py,sha256=4vxqxCKka8yzkcT9CJ1qthn8TSqo1-fnt0dIZrLl5_k,30386
+cryptodatapy/transform/wrangle.py,sha256=dnaBi3zOXoQymkxN7r5Eneb9UccGhfp7UdCS31T41i8,42396
 cryptodatapy/util/__init__.py,sha256=zSQ2HU2QIXzCuptJjknmrClwtQKCvIj4aNysZljIgrU,116
 cryptodatapy/util/datacatalog.py,sha256=qCCX6srXvaAbVAKuA0M2y5IK_2OEx5xA3yRahDZlC-g,13157
 cryptodatapy/util/datacredentials.py,sha256=fXuGgI2NKCLlcnK8M37CtdyAc3O_YCV23x3KTlfakjA,2160
-cryptodatapy-0.2.12.dist-info/LICENSE,sha256=sw4oVq8bDjT3uMtaFebQ-xeIVP4H-bXldTs9q-Jjeks,11344
-cryptodatapy-0.2.12.dist-info/METADATA,sha256=8y7UYpoTVqDUtDAC-n0uvJmBsyZIkcFdmEwDH7FryxI,6428
-cryptodatapy-0.2.12.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-cryptodatapy-0.2.12.dist-info/RECORD,,
+cryptodatapy-0.2.14.dist-info/LICENSE,sha256=sw4oVq8bDjT3uMtaFebQ-xeIVP4H-bXldTs9q-Jjeks,11344
+cryptodatapy-0.2.14.dist-info/METADATA,sha256=xqDhe1gQjohAbXUsIT9ami2dLsCX2f-D2zXFubcWtVk,6428
+cryptodatapy-0.2.14.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+cryptodatapy-0.2.14.dist-info/RECORD,,