cryptodatapy 0.2.8__py3-none-any.whl → 0.2.10__py3-none-any.whl

cryptodatapy/extract/libraries/ccxt_api.py

@@ -1,11 +1,12 @@
 import logging
 from typing import Any, Dict, List, Optional, Union
-
 import pandas as pd
 import asyncio
+import random
+from time import sleep
 import ccxt
 import ccxt.async_support as ccxt_async
-from tqdm.asyncio import tqdm  # Progress bar for async
+from tqdm.asyncio import tqdm
 
 from cryptodatapy.extract.datarequest import DataRequest
 from cryptodatapy.extract.libraries.library import Library
@@ -21,6 +22,7 @@ class CCXT(Library):
     """
     Retrieves data from CCXT API.
     """
+
     def __init__(
             self,
             categories: Union[str, List[str]] = "crypto",
@@ -70,22 +72,10 @@ class CCXT(Library):
         rate_limit: Any, optional, Default None
             Number of API calls made and left, by time frequency.
         """
-        Library.__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.exchange = None
         self.exchange_async = None
         self.data_req = None
@@ -322,14 +312,27 @@ class CCXT(Library):
         if self.rate_limit is None:
             self.rate_limit = self.exchange.rateLimit
 
-    async def _fetch_ohlcv(self,
-                           ticker: str,
-                           freq: str,
-                           start_date: str,
-                           end_date: str,
-                           exch: str,
-                           trials: int = 3
-                           ) -> List:
+    @staticmethod
+    def exponential_backoff_with_jitter(base_delay: float, max_delay: int, attempts: int) -> None:
+        delay = min(max_delay, base_delay * (2 ** attempts))
+        delay_with_jitter = delay + random.uniform(0, delay * 0.5)
+        sleep(delay_with_jitter)
+
+    @staticmethod
+    async def exponential_backoff_with_jitter_async(base_delay: float, max_delay: int, attempts: int) -> None:
+        delay = min(max_delay, base_delay * (2 ** attempts))
+        delay_with_jitter = delay + random.uniform(0, delay * 0.5)
+        await asyncio.sleep(delay_with_jitter)
+
+    async def _fetch_ohlcv_async(self,
+                                 ticker: str,
+                                 freq: str,
+                                 start_date: str,
+                                 end_date: str,
+                                 exch: str,
+                                 trials: int = 3,
+                                 pause: int = 1
+                                 ) -> List:
         """
         Fetches OHLCV data for a specific ticker.
 
@@ -347,6 +350,8 @@ class CCXT(Library):
             Name of exchange.
         trials: int, default 3
             Number of attempts to fetch data.
+        pause: int, default 60
+            Pause in seconds to respect the rate limit.
 
         Returns
         -------
@@ -367,7 +372,7 @@ class CCXT(Library):
             while start_date < end_date and attempts < trials:
 
                 try:
-                    data_resp = await getattr(self.exchange_async, 'fetchOHLCV')(
+                    data_resp = await self.exchange_async.fetch_ohlcv(
                         ticker,
                         freq,
                         since=start_date,
@@ -375,48 +380,139 @@ class CCXT(Library):
                         params={'until': end_date}
                     )
 
+                    # add data to list
+                    if data_resp:
+                        start_date = data_resp[-1][0] + 1
+                        data.extend(data_resp)
+                    else:
+                        if not data:
+                            logging.warning(f"No OHLCV data available for {ticker}.")
+                        break
+
                 except Exception as e:
                     logging.warning(
-                        f"Failed to get OHLCV data from {self.exchange_async.id} for {ticker} on attempt #{attempts+1}."
+                        f"Failed to get OHLCV data from {self.exchange_async.id} for {ticker} "
+                        f"on attempt #{attempts + 1}: {e}."
                     )
-                    logging.warning(e)
                     attempts += 1
-                    if attempts == trials:
+                    if attempts >= trials:
                         logging.warning(
                             f"Failed to get OHLCV data from {self.exchange_async.id} "
                             f"for {ticker} after {trials} attempts."
                         )
-                        return data
+                        break
 
-                    await asyncio.sleep(self.exchange_async.rateLimit / 1000)
-                    continue
+                finally:
+                    await self.exponential_backoff_with_jitter_async(self.exchange_async.rateLimit / 1000,
+                                                                     pause,
+                                                                     attempts)
 
-                else:
-                    # check if data resp is empty
-                    if len(data_resp):
-                        # next start date
+            await self.exchange_async.close()
+            return data
+
+        else:
+            logging.warning(f"OHLCV data is not available for {self.exchange_async.id}.")
+            return None
+
+    def _fetch_ohlcv(self,
+                     ticker: str,
+                     freq: str,
+                     start_date: str,
+                     end_date: str,
+                     exch: str,
+                     trials: int = 3,
+                     pause: int = 1
+                     ) -> List:
+        """
+        Fetches OHLCV data for a specific ticker.
+
+        Parameters
+        ----------
+        ticker: str
+            Ticker symbol.
+        freq: str
+            Frequency of data, e.g. '1m', '5m', '1h', '1d'.
+        start_date: str
+            Start date in integers in milliseconds since Unix epoch.
+        end_date: str
+            End date in integers in milliseconds since Unix epoch.
+        exch: str
+            Name of exchange.
+        trials: int, default 3
+            Number of attempts to fetch data.
+        pause: int, default 60
+            Pause in seconds to respect the rate limit.
+
+        Returns
+        -------
+        data: list
+            List of timestamps with OHLCV data.
+        """
+        attempts = 0
+        data = []
+
+        # inst exch
+        if self.exchange is None:
+            self.exchange = getattr(ccxt, exch)()
+
+        # fetch data
+        if self.exchange.has['fetchOHLCV']:
+
+            # while loop to fetch all data
+            while start_date < end_date and attempts < trials:
+
+                try:
+                    data_resp = self.exchange.fetch_ohlcv(
+                        ticker,
+                        freq,
+                        since=start_date,
+                        limit=self.max_obs_per_call,
+                        params={
+                            'until': end_date,
+                            'paginate': True
+                        }
+                    )
+
+                    # add data to list
+                    if data_resp:
                         start_date = data_resp[-1][0] + 1
                         data.extend(data_resp)
-                        await asyncio.sleep(self.exchange_async.rateLimit / 1000)
-
                     else:
+                        if not data:
+                            logging.warning(f"No OHLCV data available for {ticker}.")
                         break
 
+                except Exception as e:
+                    logging.warning(
+                        f"Failed to get OHLCV data from {self.exchange.id} for {ticker} "
+                        f"on attempt #{attempts + 1}: {e}."
+                    )
+                    attempts += 1
+                    if attempts >= trials:
+                        logging.warning(
+                            f"Failed to get OHLCV data from {self.exchange.id} "
+                            f"for {ticker} after {trials} attempts."
+                        )
+                        break
+
+                finally:
+                    self.exponential_backoff_with_jitter(self.exchange.rateLimit / 1000, pause, attempts)
+
             return data
 
         else:
-            logging.warning(f"OHLCV data is not available for {self.exchange_async.id}.")
+            logging.warning(f"OHLCV data is not available for {self.exchange.id}.")
             return None
 
-    async def fetch_all_ohlcv(self,
-                              tickers,
-                              freq: str,
-                              start_date: str,
-                              end_date: str,
-                              exch: str,
-                              trials: int = 3,
-                              pause: int = 0.5
-                              ):
+    async def _fetch_all_ohlcv_async(self,
+                                     tickers,
+                                     freq: str,
+                                     start_date: str,
+                                     end_date: str,
+                                     exch: str,
+                                     trials: int = 3,
+                                     pause: int = 1
+                                     ):
         """
         Fetches OHLCV data for a list of tickers.
 
@@ -453,22 +549,70 @@ class CCXT(Library):
 
         # loop through tickers
         for ticker in tickers:
-            data_resp = await self._fetch_ohlcv(ticker, freq, start_date, end_date, trials=trials, exch=exch)
+            data_resp = await self._fetch_ohlcv_async(ticker, freq, start_date, end_date, trials=trials, exch=exch)
+            await asyncio.sleep(pause)
             data.append(data_resp)
             pbar.update(1)
-            await asyncio.sleep(pause)  # pause between ticker requests to respect the rate limit
 
         await self.exchange_async.close()
 
         return data
 
-    async def _fetch_funding_rates(self,
-                                   ticker: str,
-                                   start_date: str,
-                                   end_date: str,
-                                   exch: str,
-                                   trials: int = 3
-                                   ) -> List:
+    def _fetch_all_ohlcv(self,
+                         tickers,
+                         freq: str,
+                         start_date: str,
+                         end_date: str,
+                         exch: str,
+                         trials: int = 3,
+                         pause: int = 1
+                         ):
+        """
+        Fetches OHLCV data for a list of tickers.
+
+        Parameters
+        ----------
+        tickers: list
+            List of ticker symbols.
+        freq: str
+            Frequency of data, e.g. '1m', '5m', '1h', '1d'.
+        start_date: str
+            Start date in integers in milliseconds since Unix epoch.
+        end_date: str
+            End date in integers in milliseconds since Unix epoch.
+        exch: str
+            Name of exchange.
+        trials: int, default 3
+            Number of attempts to fetch data.
+        pause: int, default 0.5
+            Pause in seconds to respect the rate limit.
+        """
+        # inst exch
+        if self.exchange is None:
+            self.exchange = getattr(ccxt, exch)()
+
+        data = []
+
+        # create progress bar
+        pbar = tqdm(total=len(tickers), desc="Fetching OHLCV data", unit="ticker")
+
+        # loop through tickers
+        for ticker in tickers:
+            data_resp = self._fetch_ohlcv(ticker, freq, start_date, end_date, trials=trials, exch=exch)
+            sleep(pause)
+            data.append(data_resp)
+            pbar.update(1)
+
+        return data
+
+    async def _fetch_funding_rates_async(self,
+                                         ticker: str,
+                                         start_date: str,
+                                         end_date: str,
+                                         exch: str,
+                                         trials: int = 3,
+                                         pause: int = 1
+                                         ) -> List:
         """
         Fetches funding rates data for a specific ticker.
 
@@ -482,6 +626,8 @@ class CCXT(Library):
             End date in integers in milliseconds since Unix epoch.
         trials: int, default 3
             Number of attempts to fetch data.
+        pause: int, default 1
+            Pause in seconds to respect the rate limit.
 
         Returns
         -------
@@ -502,54 +648,136 @@ class CCXT(Library):
             while start_date < end_date and attempts < trials:
 
                 try:
-                    data_resp = await getattr(self.exchange_async, 'fetchFundingRateHistory')(
+                    data_resp = await self.exchange_async.fetch_funding_rate_history(
                         ticker,
                         since=start_date,
                         limit=self.max_obs_per_call,
                         params={'until': end_date}
                     )
 
+                    # add data to list
+                    if data_resp:
+                        start_date = data_resp[-1]['timestamp'] + 1
+                        data.extend(data_resp)
+                    else:
+                        if not data:
+                            logging.warning(f"No funding rates data available for {ticker}.")
+                        break
+
                 except Exception as e:
                     logging.warning(
-                        f"Failed to get funding rates from {self.exchange_async.id} "
-                        f"for {ticker} on attempt #{attempts+1}."
+                        f"Failed to get funding rates from {self.exchange_async.id} for {ticker} "
+                        f"on attempt #{attempts + 1}: {e}."
                     )
-                    logging.warning(e)
                     attempts += 1
-                    if attempts == trials:
+                    if attempts >= trials:
                         logging.warning(
                             f"Failed to get funding rates from {self.exchange_async.id} "
                             f"for {ticker} after {trials} attempts."
                         )
-                        return data
+                        break
 
-                    await asyncio.sleep(self.exchange_async.rateLimit / 1000)
-                    continue
+                finally:
+                    await self.exponential_backoff_with_jitter_async(self.exchange_async.rateLimit / 1000,
+                                                                     pause,
+                                                                     attempts)
 
-                else:
-                    # check if data resp is empty
-                    if len(data_resp):
-                        # next start date
+            await self.exchange_async.close()
+            return data
+
+        else:
+            logging.warning(f"Funding rates are not available for {self.exchange_async.id}.")
+            return None
+
+    def _fetch_funding_rates(self,
+                             ticker: str,
+                             start_date: str,
+                             end_date: str,
+                             exch: str,
+                             trials: int = 3,
+                             pause: int = 1
+                             ) -> List:
+        """
+        Fetches funding rates data for a specific ticker.
+
+        Parameters
+        ----------
+        ticker: str
+            Ticker symbol.
+        start_date: str
+            Start date in integers in milliseconds since Unix epoch.
+        end_date: str
+            End date in integers in milliseconds since Unix epoch.
+        trials: int, default 3
+            Number of attempts to fetch data.
+        pause: int, default 1
+            Pause in seconds to respect the rate limit.
+
+        Returns
+        -------
+        data: list
+            List of dictionaries with timestamps and funding rates data.
+        """
+        attempts = 0
+        data = []
+
+        # inst exch
+        if self.exchange is None:
+            self.exchange = getattr(ccxt, exch)()
+
+        # fetch data
+        if self.exchange.has['fetchFundingRateHistory']:
+
+            # while loop to get all data
+            while start_date < end_date and attempts < trials:
+
+                try:
+                    data_resp = self.exchange.fetch_funding_rate_history(
+                        ticker,
+                        since=start_date,
+                        limit=self.max_obs_per_call,
+                        params={'until': end_date}
+                    )
+
+                    # add data to list
+                    if data_resp:
                         start_date = data_resp[-1]['timestamp'] + 1
                         data.extend(data_resp)
-                        await asyncio.sleep(self.exchange_async.rateLimit / 1000)
                     else:
+                        if not data:
+                            logging.warning(f"No funding rates data available for {ticker}.")
                         break
 
+                except Exception as e:
+                    logging.warning(
+                        f"Failed to get funding rates from {self.exchange.id} for {ticker} "
+                        f"on attempt #{attempts + 1}: {e}."
+                    )
+                    attempts += 1
+                    if attempts >= trials:
+                        logging.warning(
+                            f"Failed to get funding rates from {self.exchange.id} "
+                            f"for {ticker} after {trials} attempts."
+                        )
+                        break
+
+                finally:
+                    self.exponential_backoff_with_jitter(self.exchange.rateLimit / 1000, pause, attempts)
+
             return data
 
         else:
-            logging.warning(f"Funding rates are not available for {self.exchange_async.id}.")
+            logging.warning(f"Funding rates are not available for {self.exchange.id}.")
             return None
 
-    async def fetch_all_funding_rates(self,
-                                      tickers,
-                                      start_date: str,
-                                      end_date: str,
-                                      exch: str,
-                                      trials: int = 3,
-                                      pause: int = 0.5
-                                      ):
+    async def _fetch_all_funding_rates_async(self,
+                                             tickers,
+                                             start_date: str,
+                                             end_date: str,
+                                             exch: str,
+                                             trials: int = 3,
+                                             pause: int = 1
+                                             ):
         """
         Fetches funding rates data for a list of tickers.
 
@@ -584,23 +812,74 @@ class CCXT(Library):
 
         # loop through tickers
         for ticker in tickers:
-            data_resp = await self._fetch_funding_rates(ticker, start_date, end_date, trials=trials, exch=exch)
+            data_resp = await self._fetch_funding_rates_async(ticker, start_date, end_date, trials=trials, exch=exch)
             data.append(data_resp)
             pbar.update(1)
-            await asyncio.sleep(pause)  # pause between ticker requests to respect the rate limit
+            await asyncio.sleep(pause)
 
         await self.exchange_async.close()
 
         return data
 
-    async def _fetch_open_interest(self,
-                                   ticker: str,
-                                   freq: str,
-                                   start_date: str,
-                                   end_date: str,
-                                   exch: str,
-                                   trials: int = 3
-                                   ) -> List:
+    def _fetch_all_funding_rates(self,
+                                 tickers,
+                                 start_date: str,
+                                 end_date: str,
+                                 exch: str,
+                                 trials: int = 3,
+                                 pause: int = 1
+                                 ):
+        """
+        Fetches funding rates data for a list of tickers.
+
+        Parameters
+        ----------
+        tickers: list
+            List of ticker symbols.
+        start_date: str
+            Start date in integers in milliseconds since Unix epoch.
+        end_date: str
+            End date in integers in milliseconds since Unix epoch.
+        exch: str
+            Name of exchange.
+        trials: int, default 3
+            Number of attempts to fetch data.
+        pause: int, default 0.5
+            Pause in seconds to respect the rate limit.
+
+        Returns
+        -------
+        data: list
+            List of lists of dictionaries with timestamps and funding rates data for each ticker.
+        """
+
+        # inst exch
+        if self.exchange is None:
+            self.exchange = getattr(ccxt, exch)()
+
+        data = []
+
+        # create progress bar
+        pbar = tqdm(total=len(tickers), desc="Fetching funding rates", unit="ticker")
+
+        # loop through tickers
+        for ticker in tickers:
+            data_resp = self._fetch_funding_rates(ticker, start_date, end_date, trials=trials, exch=exch)
+            data.append(data_resp)
+            pbar.update(1)
+            sleep(pause)
+
+        return data
+
+    async def _fetch_open_interest_async(self,
+                                         ticker: str,
+                                         freq: str,
+                                         start_date: str,
+                                         end_date: str,
+                                         exch: str,
+                                         trials: int = 3,
+                                         pause: int = 1
+                                         ) -> List:
         """
         Fetches open interest data for a specific ticker.
 
@@ -618,6 +897,8 @@ class CCXT(Library):
             Name of exchange.
         trials: int, default 3
             Number of attempts to fetch data.
+        pause: int, default 1
+            Pause in seconds to respect the rate limit.
 
         Returns
         -------
@@ -639,7 +920,7 @@ class CCXT(Library):
             while start_date < end_date and attempts < trials:
 
                 try:
-                    data_resp = await getattr(self.exchange_async, 'fetchOpenInterestHistory')(
+                    data_resp = await self.exchange_async.fetch_open_interest_history(
                         ticker,
                         freq,
                         since=start_date,
@@ -647,49 +928,138 @@ class CCXT(Library):
                         params={'until': end_date}
                     )
 
+                    # add data to list
+                    if data_resp:
+                        start_date = data_resp[-1]['timestamp'] + 1
+                        data.extend(data_resp)
+                    else:
+                        if not data:
+                            logging.warning(f"No open interest data available for {ticker}.")
+                        break
+
                 except Exception as e:
                     logging.warning(
-                        f"Failed to get open interest from {self.exchange_async.id} "
-                        f"for {ticker} on attempt #{attempts + 1}."
+                        f"Failed to get open interest from {self.exchange_async.id} for {ticker} "
+                        f"on attempt #{attempts + 1}: {e}."
                     )
-                    logging.warning(e)
                     attempts += 1
-                    if attempts == trials:
+                    if attempts >= trials:
                         logging.warning(
                             f"Failed to get open interest from {self.exchange_async.id} "
                             f"for {ticker} after {trials} attempts."
                         )
-                        return data
+                        break
 
-                    await asyncio.sleep(self.exchange_async.rateLimit / 1000)
-                    continue
+                finally:
+                    await self.exponential_backoff_with_jitter_async(self.exchange_async.rateLimit / 1000,
+                                                                     pause,
+                                                                     attempts)
+                    # await asyncio.sleep(self.exchange_async.rateLimit / 1000)
 
-                else:
-                    # check if data resp is empty
-                    if len(data_resp):
-                        # next start date
+            await self.exchange_async.close()
+            return data
+
+        else:
+            logging.warning(f"Open interest is not available for {self.exchange_async.id}.")
+            return None
+
+    def _fetch_open_interest(self,
+                             ticker: str,
+                             freq: str,
+                             start_date: str,
+                             end_date: str,
+                             exch: str,
+                             trials: int = 3,
+                             pause: int = 1
+                             ) -> List:
+        """
+        Fetches open interest data for a specific ticker.
+
+        Parameters
+        ----------
+        ticker: str
+            Ticker symbol.
+        freq: str
+            Frequency of data, e.g. '1m', '5m', '1h', '1d'.
+        start_date: str
+            Start date in integers in milliseconds since Unix epoch.
+        end_date: str
+            End date in integers in milliseconds since Unix epoch.
+        exch: str
+            Name of exchange.
+        trials: int, default 3
+            Number of attempts to fetch data.
+        pause: int, default 1
+            Pause in seconds to respect the rate limit.
+
+        Returns
+        -------
+        data: list
+            List of dictionaries with timestamps and open interest data.
+        """
+        # number of attempts
+        attempts = 0
+        data = []
+
+        # inst exch
+        self.exchange = getattr(ccxt, exch)()
+
+        # fetch data
+        if self.exchange.has['fetchOpenInterestHistory']:
+
+            # while loop to get all data
+            while start_date < end_date and attempts < trials:
+
+                try:
+                    data_resp = self.exchange.fetch_open_interest_history(
+                        ticker,
+                        freq,
+                        since=start_date,
+                        limit=500,
+                        params={'until': end_date}
+                    )
+
+                    # add data to list
+                    if data_resp:
                         start_date = data_resp[-1]['timestamp'] + 1
                         data.extend(data_resp)
-                        await asyncio.sleep(self.exchange_async.rateLimit / 1000)
                     else:
+                        if not data:
+                            logging.warning(f"No open interest data available for {ticker}.")
                         break
 
+                except Exception as e:
+                    logging.warning(
+                        f"Failed to get open interest from {self.exchange.id} for {ticker} "
+                        f"on attempt #{attempts + 1}: {e}."
+                    )
+                    attempts += 1
+                    if attempts >= trials:
+                        logging.warning(
+                            f"Failed to get open interest from {self.exchange.id} "
+                            f"for {ticker} after {trials} attempts."
+                        )
+                        break
+
+                finally:
+                    self.exponential_backoff_with_jitter(self.exchange.rateLimit / 1000, pause, attempts)
+                    # sleep(self.exchange.rateLimit / 1000)
+
             return data
 
         else:
-            logging.warning(f"Open interest is not available for {self.exchange_async.id}.")
+            logging.warning(f"Open interest is not available for {self.exchange.id}.")
             return None
 
-    async def fetch_all_open_interest(self,
-                                      tickers,
-                                      freq: str,
-                                      start_date: str,
-                                      end_date: str,
-                                      exch: str,
-                                      trials: int = 3,
-                                      pause: int = 0.5
-                                      ):
-
+    async def _fetch_all_open_interest_async(self,
+                                             tickers,
+                                             freq: str,
+                                             start_date: str,
+                                             end_date: str,
+                                             exch: str,
+                                             trials: int = 3,
+                                             pause: int = 1
+                                             ):
         """
         Fetches open interest data for a list of tickers.
 
@@ -726,15 +1096,68 @@ class CCXT(Library):
 
         # loop through tickers
         for ticker in tickers:
-            data_resp = await self._fetch_open_interest(ticker, freq, start_date, end_date, trials=trials, exch=exch)
+            data_resp = await self._fetch_open_interest_async(ticker, freq, start_date, end_date, trials=trials,
+                                                              exch=exch)
             data.append(data_resp)
             pbar.update(1)
-            await asyncio.sleep(pause)  # pause between ticker requests to respect the rate limit
+            await asyncio.sleep(pause)
 
         await self.exchange_async.close()
 
         return data
 
+    def _fetch_all_open_interest(self,
+                                 tickers,
+                                 freq: str,
+                                 start_date: str,
+                                 end_date: str,
+                                 exch: str,
+                                 trials: int = 3,
+                                 pause: int = 1
+                                 ):
+        """
+        Fetches open interest data for a list of tickers.
+
+        Parameters
+        ----------
+        tickers: list
+            List of ticker symbols.
+        freq: str
+            Frequency of data, e.g. '1m', '5m', '1h', '1d'.
+        start_date: str
+            Start date in integers in milliseconds since Unix epoch.
+        end_date: str
+            End date in integers in milliseconds since Unix epoch.
+        exch: str
+            Name of exchange.
+        trials: int, default 3
+            Number of attempts to fetch data.
+        pause: int, default 0.5
+            Pause in seconds to respect the rate limit.
+
+        Returns
+        -------
+        data: list
+            List of lists of dictionaries with timestamps and open interest data for each ticker.
+        """
+        # inst exch
+        if self.exchange is None:
+            self.exchange = getattr(ccxt, exch)()
+
+        data = []
+
+        # create progress bar
+        pbar = tqdm(total=len(tickers), desc="Fetching open interest", unit="ticker")
+
+        # loop through tickers
+        for ticker in tickers:
+            data_resp = self._fetch_open_interest(ticker, freq, start_date, end_date, trials=trials, exch=exch)
+            data.append(data_resp)
+            pbar.update(1)
+            sleep(pause)
+
+        return data
+
     def convert_params(self, data_req: DataRequest) -> DataRequest:
         """
         Converts data request parameters to CCXT format.
@@ -767,14 +1190,6 @@ class CCXT(Library):
                 f"Use the '.frequencies' attribute to check available frequencies."
             )
 
-        # check quote ccy
-        if self.data_req.quote_ccy is not None:
-            if self.data_req.quote_ccy not in self.assets:
-                raise ValueError(
-                    f"{self.data_req.quote_ccy} is not supported. "
-                    f"Use the '.assets' attribute to check supported currencies."
-                )
-
         # check mkt type
         if self.data_req.mkt_type not in self.market_types:
             raise ValueError(
@@ -853,7 +1268,41 @@ class CCXT(Library):
 
         return WrangleData(self.data_req, data_resp).ccxt(data_type=data_type)
 
-    async def fetch_tidy_ohlcv(self, data_req: DataRequest) -> pd.DataFrame:
+    async def fetch_tidy_ohlcv_async(self, data_req: DataRequest) -> pd.DataFrame:
+        """
+        Gets entire OHLCV history and wrangles the data response into tidy data format.
+
+        Parameters
+        ----------
+        data_req: DataRequest
+            Parameters of data request in CryptoDataPy format.
+
+        Returns
+        -------
+        df: pd.DataFrame
+            Dataframe with entire OHLCV data history retrieved and wrangled into tidy data format.
+        """
+        # convert data request parameters to CCXT format
+        if self.data_req is None:
+            self.convert_params(data_req)
+
+        # get entire data history
+        data_resp = await self._fetch_all_ohlcv_async(self.data_req.source_markets,
+                                                      self.data_req.source_freq,
+                                                      self.data_req.source_start_date,
+                                                      self.data_req.source_end_date,
+                                                      self.data_req.exch,
+                                                      trials=self.data_req.trials,
+                                                      pause=self.data_req.pause)
+
+        # wrangle df
+        if any(data_resp):
+            df = self.wrangle_data_resp(data_resp, data_type='ohlcv')
+            return df
+        else:
+            logging.warning("Failed to get requested OHLCV data.")
+
+    def fetch_tidy_ohlcv(self, data_req: DataRequest) -> pd.DataFrame:
         """
         Gets entire OHLCV history and wrangles the data response into tidy data format.
 
@@ -872,13 +1321,13 @@ class CCXT(Library):
             self.convert_params(data_req)
 
         # get entire data history
-        data_resp = await self.fetch_all_ohlcv(self.data_req.source_markets,
-                                               self.data_req.source_freq,
-                                               self.data_req.source_start_date,
-                                               self.data_req.source_end_date,
-                                               self.data_req.exch,
-                                               trials=self.data_req.trials,
-                                               pause=self.data_req.pause)
+        data_resp = self._fetch_all_ohlcv(self.data_req.source_markets,
+                                          self.data_req.source_freq,
+                                          self.data_req.source_start_date,
+                                          self.data_req.source_end_date,
+                                          self.data_req.exch,
+                                          trials=self.data_req.trials,
+                                          pause=self.data_req.pause)
 
         # wrangle df
         if any(data_resp):
@@ -887,7 +1336,40 @@ class CCXT(Library):
         else:
             logging.warning("Failed to get requested OHLCV data.")
 
-    async def fetch_tidy_funding_rates(self, data_req: DataRequest) -> pd.DataFrame:
+    async def fetch_tidy_funding_rates_async(self, data_req: DataRequest) -> pd.DataFrame:
+        """
+        Gets entire funding rates history and wrangles the data response into tidy data format.
+
+        Parameters
+        ----------
+        data_req: DataRequest
+            Parameters of data request in CryptoDataPy format.
+
+        Returns
+        -------
+        df: pd.DataFrame
+            Dataframe with entire data history retrieved and wrangled into tidy data format.
+        """
+        # convert data request parameters to CCXT format
+        if self.data_req is None:
+            self.convert_params(data_req)
+
+        # get entire data history
+        data_resp = await self._fetch_all_funding_rates_async(self.data_req.source_markets,
+                                                              self.data_req.source_start_date,
+                                                              self.data_req.source_end_date,
+                                                              self.data_req.exch,
+                                                              trials=self.data_req.trials,
+                                                              pause=self.data_req.pause)
+
+        # wrangle df
+        if any(data_resp):
+            df = self.wrangle_data_resp(data_resp, data_type='funding_rates')
+            return df
+        else:
+            logging.warning("Failed to get requested funding rates.")
+
+    def fetch_tidy_funding_rates(self, data_req: DataRequest) -> pd.DataFrame:
         """
         Gets entire funding rates history and wrangles the data response into tidy data format.
 
@@ -906,12 +1388,12 @@ class CCXT(Library):
             self.convert_params(data_req)
 
         # get entire data history
-        data_resp = await self.fetch_all_funding_rates(self.data_req.source_markets,
-                                                       self.data_req.source_start_date,
-                                                       self.data_req.source_end_date,
-                                                       self.data_req.exch,
-                                                       trials=self.data_req.trials,
-                                                       pause=self.data_req.pause)
+        data_resp = self._fetch_all_funding_rates(self.data_req.source_markets,
+                                                  self.data_req.source_start_date,
+                                                  self.data_req.source_end_date,
+                                                  self.data_req.exch,
+                                                  trials=self.data_req.trials,
+                                                  pause=self.data_req.pause)
 
         # wrangle df
         if any(data_resp):
@@ -920,7 +1402,7 @@ class CCXT(Library):
         else:
             logging.warning("Failed to get requested funding rates.")
 
-    async def fetch_tidy_open_interest(self, data_req: DataRequest) -> pd.DataFrame:
+    async def fetch_tidy_open_interest_async(self, data_req: DataRequest) -> pd.DataFrame:
         """
         Gets entire open interest history and wrangles the data response into tidy data format.
 
@@ -939,13 +1421,13 @@ class CCXT(Library):
             self.convert_params(data_req)
 
         # get entire data history
-        data_resp = await self.fetch_all_open_interest(self.data_req.source_markets,
-                                                       self.data_req.source_freq,
-                                                       self.data_req.source_start_date,
-                                                       self.data_req.source_end_date,
-                                                       self.data_req.exch,
-                                                       trials=self.data_req.trials,
-                                                       pause=self.data_req.pause)
+        data_resp = await self._fetch_all_open_interest_async(self.data_req.source_markets,
+                                                              self.data_req.source_freq,
+                                                              self.data_req.source_start_date,
+                                                              self.data_req.source_end_date,
+                                                              self.data_req.exch,
+                                                              trials=self.data_req.trials,
+                                                              pause=self.data_req.pause)
 
         # wrangle df
         if any(data_resp):
@@ -954,7 +1436,81 @@ class CCXT(Library):
         else:
             logging.warning("Failed to get requested open interest.")
 
-    async def get_data(self, data_req: DataRequest) -> pd.DataFrame:
+    def fetch_tidy_open_interest(self, data_req: DataRequest) -> pd.DataFrame:
+        """
+        Gets entire open interest history and wrangles the data response into tidy data format.
+
+        Parameters
+        ----------
+        data_req: DataRequest
+            Parameters of data request in CryptoDataPy format.
+
+        Returns
+        -------
+        df: pd.DataFrame
+            Dataframe with entire data history retrieved and wrangled into tidy data format.
+        """
+        # convert data request parameters to CCXT format
+        if self.data_req is None:
+            self.convert_params(data_req)
+
+        # get entire data history
+        data_resp = self._fetch_all_open_interest(self.data_req.source_markets,
+                                                  self.data_req.source_freq,
+                                                  self.data_req.source_start_date,
+                                                  self.data_req.source_end_date,
+                                                  self.data_req.exch,
+                                                  trials=self.data_req.trials,
+                                                  pause=self.data_req.pause)
+
+        # wrangle df
+        if any(data_resp):
+            df = self.wrangle_data_resp(data_resp, data_type='open_interest')
+            return df
+        else:
+            logging.warning("Failed to get requested open interest.")
+
+    async def get_data_async(self, data_req: DataRequest) -> pd.DataFrame:
+        """
+        Get data specified by data request.
+
+        Parameters
+        data_req: DataRequest
+            Parameters of data request in CryptoDataPy format.
+
+        Returns
+        -------
+        df: pd.DataFrame - MultiIndex
+            DataFrame with DatetimeIndex (level 0), ticker (level 1), and values for selected fields (cols).
+        """
+        # 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)
+            self.data = pd.concat([self.data, df])
+
+        # get funding rates
+        if any([field == "funding_rate" for field in data_req.fields]):
+            df = await self.fetch_tidy_funding_rates_async(data_req)
+            self.data = pd.concat([self.data, df], axis=1)
+
+        # get open interest
+        if any([field == "oi" for field in data_req.fields]):
+            df = await self.fetch_tidy_open_interest_async(data_req)
+            self.data = pd.concat([self.data, df], axis=1)
+
+        # check df
+        if self.data.empty:
+            raise Exception(
+                "No data returned. Check data request parameters and try again."
+            )
+
+        # filter df for desired fields and typecast
+        fields = [field for field in data_req.fields if field in self.data.columns]
+        self.data = self.data.loc[:, fields]
+
+        return self.data.sort_index()
+
+    def get_data(self, data_req: DataRequest) -> pd.DataFrame:
         """
         Get data specified by data request.
 
@@ -969,17 +1525,17 @@ class CCXT(Library):
         """
         # get OHLCV
         if any([field in ["open", "high", "low", "close", "volume"] for field in data_req.fields]):
-            df = await self.fetch_tidy_ohlcv(data_req)
+            df = self.fetch_tidy_ohlcv(data_req)
             self.data = pd.concat([self.data, df])
 
         # get funding rates
         if any([field == "funding_rate" for field in data_req.fields]):
-            df = await self.fetch_tidy_funding_rates(data_req)
+            df = self.fetch_tidy_funding_rates(data_req)
             self.data = pd.concat([self.data, df], axis=1)
 
         # get open interest
         if any([field == "oi" for field in data_req.fields]):
-            df = await self.fetch_tidy_open_interest(data_req)
+            df = self.fetch_tidy_open_interest(data_req)
             self.data = pd.concat([self.data, df], axis=1)
 
         # check df