cryptodatapy 0.2.5__py3-none-any.whl → 0.2.6__py3-none-any.whl

cryptodatapy/extract/data_vendors/coinmetrics_api.py

@@ -1,4 +1,5 @@
 import logging
+from time import sleep
 from typing import Any, Dict, List, Optional, Union
 
 import pandas as pd
@@ -12,6 +13,7 @@ from cryptodatapy.util.datacredentials import DataCredentials
 
 # data credentials
 data_cred = DataCredentials()
+
 # CoinMetrics community API client:
 client = CoinMetricsClient()
 
@@ -23,16 +25,17 @@ class CoinMetrics(DataVendor):
 
     def __init__(
             self,
-            categories=None,
+            categories: Union[str, List[str]] = "crypto",
             exchanges: Optional[List[str]] = None,
             indexes: Optional[List[str]] = None,
             assets: Optional[List[str]] = None,
             markets: Optional[List[str]] = None,
-            market_types=None,
+            market_types: List[str] = ["spot", "perpetual_future", "future", "option"],
             fields: Optional[List[str]] = None,
-            frequencies=None,
-            base_url: Optional[str] = None,
-            api_key: Optional[str] = None,
+            frequencies: List[str] = ["tick", "block", "1s", "1min", "5min", "10min", "15min", "30min",
+                                      "1h", "2h", "4h", "8h", "d", "w", "m", "q"],
+            base_url: Optional[str] = data_cred.coinmetrics_base_url,
+            api_key: Optional[str] = data_cred.coinmetrics_api_key,
             max_obs_per_call: Optional[int] = None,
             rate_limit: Optional[Any] = None,
     ):
@@ -84,40 +87,6 @@ class CoinMetrics(DataVendor):
             rate_limit,
         )
 
-        if frequencies is None:
-            self.frequencies = [
-                "tick",
-                "block",
-                "1s",
-                "1min",
-                "5min",
-                "10min",
-                "15min",
-                "30min",
-                "1h",
-                "2h",
-                "4h",
-                "8h",
-                "d",
-                "w",
-                "m",
-                "q",
-            ]
-        if market_types is None:
-            self.market_types = ["spot", "perpetual_future", "future", "option"]
-        if categories is None:
-            self.categories = ["crypto"]
-        if exchanges is None:
-            self._exchanges = self.get_exchanges_info(as_list=True)
-        if indexes is None:
-            self._indexes = self.get_indexes_info(as_list=True)
-        if assets is None:
-            self._assets = self.get_assets_info(as_list=True)
-        if markets is None:
-            self._markets = self.get_markets_info(as_list=True)
-        if fields is None:
-            self._fields = self.get_fields_info(data_type=None, as_list=True)
-
     @staticmethod
     def req_meta(data_type: str) -> Dict[str, Any]:
         """
@@ -161,9 +130,9 @@ class CoinMetrics(DataVendor):
         # req data
         exch = self.req_meta(data_type='catalog_exchanges')
         # wrangle data resp
-        exch = WrangleInfo(exch).cm_meta_resp(as_list=as_list, index_name='exchange')
+        self.exchanges = WrangleInfo(exch).cm_meta_resp(as_list=as_list, index_name='exchange')
 
-        return exch
+        return self.exchanges
 
     def get_indexes_info(self, as_list: bool = False) -> Union[List[str], pd.DataFrame]:
         """
@@ -182,11 +151,11 @@ class CoinMetrics(DataVendor):
         # req data
         indexes = self.req_meta(data_type='catalog_indexes')
         # wrangle data resp
-        indexes = WrangleInfo(indexes).cm_meta_resp(as_list=as_list, index_name='ticker')
+        self.indexes = WrangleInfo(indexes).cm_meta_resp(as_list=as_list, index_name='ticker')
 
-        return indexes
+        return self.indexes
 
-    def get_assets_info(self, as_list: bool = False, ) -> Union[List[str], pd.DataFrame]:
+    def get_assets_info(self, as_list: bool = False) -> Union[List[str], pd.DataFrame]:
         """
         Get assets info.
 
@@ -203,9 +172,9 @@ class CoinMetrics(DataVendor):
         # req data
         assets = self.req_meta(data_type='catalog_assets')
         # wrangle data resp
-        assets = WrangleInfo(assets).cm_meta_resp(as_list=as_list, index_name='ticker')
+        self.assets = WrangleInfo(assets).cm_meta_resp(as_list=as_list, index_name='ticker')
 
-        return assets
+        return self.assets
 
     def get_inst_info(self, as_dict: bool = False) -> Union[Dict[str, List[str]], pd.DataFrame]:
         """
@@ -243,11 +212,11 @@ class CoinMetrics(DataVendor):
             List or dataframe with info on available markets, by exchange.
         """
         # req data
-        mkts = self.req_meta(data_type='catalog_markets')
+        markets = self.req_meta(data_type='catalog_markets')
         # wrangle data resp
-        mkts = WrangleInfo(mkts).cm_meta_resp(as_list=as_list)
+        self.markets = WrangleInfo(markets).cm_meta_resp(as_list=as_list)
 
-        return mkts
+        return self.markets
 
     def get_onchain_fields_info(self, as_list: bool = False) -> Union[List[str], pd.DataFrame]:
         """
@@ -289,29 +258,29 @@ 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 = list(self.get_inst_info(as_dict=True).values())[0]  # inst 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":
-            fields = onchain_fields[onchain_fields.category == "Market"]
+            self.fields = onchain_fields[onchain_fields.category == "Market"]
         elif data_type == "off-chain":
-            fields = inst_fields
+            self.fields = inst_fields
         else:
-            fields = onchain_fields
+            self.fields = onchain_fields
 
         # fields list
         if as_list:
             if data_type == "market":
-                fields = ohlcv_fields + list(fields.index)
+                self.fields = ohlcv_fields + list(self.fields.index)
             elif data_type == "on-chain":
-                fields = list(fields.index)
+                self.fields = list(self.fields.index)
             elif data_type == "off-chain":
-                fields = inst_fields
+                self.fields = inst_fields
             else:
-                fields = ohlcv_fields + list(fields.index) + inst_fields
+                self.fields = ohlcv_fields + list(self.fields.index) + inst_fields
 
-        return fields
+        return self.fields
 
     def get_onchain_tickers_list(self, data_req: DataRequest) -> List[str]:
         """
@@ -332,12 +301,15 @@ class CoinMetrics(DataVendor):
         # fields param
         fields = cm_data_req["fields"]
 
+        # fields info
+        self.get_fields_info()
         # fields dict
         fields_dict = {}
         for field in fields:
-            df = self.get_fields_info().loc[field]  # get fields info
-            # add to dict
-            fields_dict[field] = df["frequencies"][0]["assets"]
+            if field in self.fields.index:
+                df = self.fields.loc[field]  # get fields metadata
+                # add to dict
+                fields_dict[field] = df["frequencies"][0]["assets"]
 
         # asset list
         asset_list = list(set.intersection(*(set(val) for val in fields_dict.values())))
@@ -354,51 +326,67 @@ class CoinMetrics(DataVendor):
         """
         return None
 
-    @staticmethod
-    def req_data(data_type: str, **kwargs) -> pd.DataFrame:
+    def get_metadata(self) -> None:
+        """
+        Get CoinMetrics metadata.
+        """
+        if self.exchanges is None:
+            self.get_exchanges_info(as_list=True)
+        if self.indexes is None:
+            self.get_indexes_info(as_list=True)
+        if self.assets is None:
+            self.get_assets_info(as_list=True)
+        if self.markets is None:
+            self.get_markets_info(as_list=True)
+        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:
         """
         Sends data request to Python client.
 
         Parameters
         ----------
-        data_type: str, {'get_index_levels', 'get_institution_metrics', 'get_market_candles', 'get_asset_metrics',
-                         'get_market_open_interest', 'get_market_funding_rates', 'get_market_trades',
-                         'get_market_quotes'}
+        data_type: str
             Data type to retrieve.
-
-        Other Parameters
-        ----------------
-        indexes: list
-            List of indexes.
-        assets: list
-            List of assets.
-        markets: list
-            List of markets.
-        metrics: list
-            List of metrics.
-        frequency: str
-            Frequency of data observations.
-        start_time: str, pd.Timestamp, datetime
-            Start datetime.
-        end_time: str, pd.Timestamp, datetime
-            End datetime.
-        timezone: str
-            Timezone.
+        params: dict
+            Dictionary containing parameter values for get request.
 
         Returns
         -------
         df: pd.DataFrame
             Dataframe with datetime, ticker/identifier, and field/col values.
         """
-        try:
-            df = getattr(client, data_type)(**kwargs).to_dataframe()
-            assert not df.empty
+        # url
+        url = self.base_url + data_type
 
-        except Exception as e:
-            logging.warning(f"Failed to {data_type}.")
-            logging.warning(e)
+        # data request
+        data_resp = DataRequest().get_req(url=url, params=params)
 
+        # raise error if data is None
+        if data_resp is None:
+            raise Exception("Failed to fetch data after multiple attempts.")
+        # retrieve data
         else:
+            # data
+            data, next_page_url = data_resp.get('data', []), data_resp.get('next_page_url')
+
+            # while loop
+            while next_page_url:
+                # wait to avoid exceeding rate limit
+                sleep(0.6)
+
+                # request next page
+                next_page_data_resp = DataRequest(pause=0.6).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')
+
+                # add data to list
+                data.extend(next_page_data)
+
+            # convert to df
+            df = pd.DataFrame(data)
+
             return df
 
     @staticmethod
@@ -424,7 +412,7 @@ class CoinMetrics(DataVendor):
 
         return df
 
-    def get_tidy_data(self, data_req: DataRequest, data_type: str, **kwargs) -> pd.DataFrame:
+    def get_tidy_data(self, data_req: DataRequest, data_type: str, params: dict) -> pd.DataFrame:
         """
         Gets data and wrangles it into tidy data format.
 
@@ -436,7 +424,8 @@ class CoinMetrics(DataVendor):
                          'get_market_open_interest', 'get_market_funding_rates', 'get_market_trades',
                          'get_market_quotes'}
             Data type to retrieve.
-        **kwargs: other parameters
+        params: dict
+            Dictionary containing parameter values for get request.
 
         Returns
         -------
@@ -444,15 +433,15 @@ 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, **kwargs)
+        df = self.req_data(data_type, params)
         # wrangle df
         df = self.wrangle_data_resp(data_req, df)
 
         return df
 
-    def filter_tickers(self, data_req: DataRequest, data_type: str) -> List[str]:
+    def check_tickers(self, data_req: DataRequest, data_type: str) -> List[str]:
         """
-        Filters tickers to only those with data available.
+        Checks tickers for data availability.
 
         Parameters
         ----------
@@ -465,47 +454,45 @@ class CoinMetrics(DataVendor):
         Returns
         -------
         tickers: list
-            List of filtered tickers.
+            List of available tickers.
         """
         # convert params
         cm_data_req = ConvertParams(data_req).to_coinmetrics()
         # tickers
         tickers = []
 
-        # check if tickers indexes
+        # check indexes
         if data_type == 'indexes':
-            idx_list, tickers = self.indexes, []
-            for ticker in cm_data_req["tickers"]:
-                if ticker.upper() in idx_list:
-                    tickers.append(ticker)  # keep only avail tickers
+            self.get_indexes_info(as_list=True)
+            # avail tickers
+            tickers = [ticker for ticker in cm_data_req["tickers"] if ticker.upper() in self.indexes]
 
-        # check if tickers assets
+        # 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':
-            asset_list, tickers = self.assets, []
-            for asset, ticker in zip(cm_data_req["tickers"], cm_data_req["mkts"]):
-                if asset in asset_list:
-                    tickers.append(ticker)  # keep only avail asset tickers
+            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]
 
-        # check if tickers assets
+        # check assets
         elif data_type == 'asset_metrics':
-            asset_list, tickers = self.assets, []
-            for ticker in cm_data_req["tickers"]:
-                if ticker in asset_list:
-                    tickers.append(ticker)  # keep only asset tickers
+            self.get_assets_info(as_list=True)
+            # avail tickers
+            tickers = [ticker for ticker in cm_data_req["tickers"] if ticker in self.assets]
 
-        # raise error if no tickers are indexes
+        # raise error if no tickers available
         if len(tickers) == 0:
             raise ValueError(
-                f"{data_req.tickers} are not valid tickers for requested data type."
-                f" Use attributes to get a list of available indexes and assets."
+                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
 
-    def filter_fields(self, data_req: DataRequest, data_type: str) -> List[str]:
+    def check_fields(self, data_req: DataRequest, data_type: str) -> List[str]:
         """
-        Filters fields to only those with data available.
+        Checks fields for data availability.
 
         Parameters
         ----------
@@ -518,31 +505,30 @@ class CoinMetrics(DataVendor):
         Returns
         -------
         fields: list
-            List of filtered fields.
+            List of avaialble fields.
         """
         # convert params
         cm_data_req = ConvertParams(data_req).to_coinmetrics()
         # fields
         fields = []
 
-        # check if fields inst
+        # check instution
         if data_type == 'institutions':
-            fields, inst_list = ([], list(self.get_inst_info(as_dict=True).values())[0])
-            for field in cm_data_req["fields"]:
-                if field in inst_list:
-                    fields.append(field)  # keep only inst fields
+            # 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]
 
+        # check on-chain metrics
         elif data_type == 'asset_metrics':
-            onchain_list, fields = (self.get_fields_info(data_type="on-chain", as_list=True), [])
-            for field in cm_data_req["fields"]:
-                if field in onchain_list:
-                    fields.append(field)  # keep only on-chain fields
+            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]
 
         # raise error if fields is empty
         if len(fields) == 0:
             raise ValueError(
-                f"{data_req.fields} are not valid institution fields."
-                f" Use the fields property to get a list of available source fields."
+                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
@@ -550,7 +536,7 @@ class CoinMetrics(DataVendor):
     @staticmethod
     def check_params(data_req: DataRequest, data_type: str) -> None:
         """
-        Checks if valid parameters for request.
+        Checks data request parameters.
 
         Parameters
         ----------
@@ -611,14 +597,22 @@ class CoinMetrics(DataVendor):
                     f" 'option' market types. Change 'mkt_type' in data request and try again."
                 )
 
-        # trades & quotes
-        elif data_type == 'trades' or data_type == 'quotes':
-            if cm_data_req["freq"] != "tick":
+        # trades
+        elif data_type == 'trades':
+            if cm_data_req["freq"] != "raw":
                 raise ValueError(
                     f"{data_type} data is only available at the 'tick' frequency."
                     f" Change data request frequency and try again."
                 )
 
+        # quotes
+        elif data_type == 'quotes':
+            if cm_data_req["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."
+                )
+
         return None
 
     def get_indexes(self, data_req: DataRequest) -> pd.DataFrame:
@@ -638,20 +632,27 @@ class CoinMetrics(DataVendor):
         # convert data request parameters to Coin Metrics format
         cm_data_req = ConvertParams(data_req).to_coinmetrics()
 
-        # check freq
+        # check params
         self.check_params(data_req, data_type='indexes')
 
-        # filter tickers
-        tickers = self.filter_tickers(data_req, data_type='indexes')
+        # check tickers
+        tickers = self.check_tickers(data_req, data_type='indexes')
+        sleep(0.6)
+
+        # params
+        params = {
+            'indexes': ','.join(tickers),
+            '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 indexes
+        # get tidy data
         df = self.get_tidy_data(data_req,
-                                data_type='get_index_levels',
-                                indexes=tickers,
-                                frequency=cm_data_req["freq"],
-                                start_time=cm_data_req["start_date"],
-                                end_time=cm_data_req["end_date"],
-                                )
+                                data_type='/timeseries/index-levels',
+                                params=params)
 
         return df
 
@@ -672,21 +673,28 @@ class CoinMetrics(DataVendor):
         # convert data request parameters to Coin Metrics format
         cm_data_req = ConvertParams(data_req).to_coinmetrics()
 
-        # check freq
+        # check params
         self.check_params(data_req, data_type='institutions')
 
-        # filter fields
-        fields = self.filter_fields(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='get_institution_metrics',
-                                institutions=cm_data_req["inst"],
-                                metrics=fields,
-                                frequency=cm_data_req["freq"],
-                                start_time=cm_data_req["start_date"],
-                                end_time=cm_data_req["end_date"],
-                                )
+                                data_type='/timeseries/institution-metrics',
+                                params=params)
 
         return df
 
@@ -710,17 +718,24 @@ class CoinMetrics(DataVendor):
         # check freq
         self.check_params(data_req, data_type='market_candles')
 
-        # filter tickers
-        tickers = self.filter_tickers(data_req, data_type='market_candles')
+        # check tickers
+        tickers = self.check_tickers(data_req, data_type='market_candles')
+        sleep(0.6)
+
+        # params
+        params = {
+            'markets': ','.join(tickers),
+            '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='get_market_candles',
-                                markets=tickers,
-                                frequency=cm_data_req["freq"],
-                                start_time=cm_data_req["start_date"],
-                                end_time=cm_data_req["end_date"],
-                                )
+                                data_type='/timeseries/market-candles',
+                                params=params)
 
         return df
 
@@ -741,22 +756,35 @@ class CoinMetrics(DataVendor):
         # convert data request parameters to Coin Metrics format
         cm_data_req = ConvertParams(data_req).to_coinmetrics()
 
-        # check freq
+        # check params
         self.check_params(data_req, data_type='asset_metrics')
 
-        # filter tickers
-        tickers = self.filter_tickers(data_req, data_type='asset_metrics')
-        # filter fields
-        fields = self.filter_fields(data_req, data_type='asset_metrics')
+        # check tickers
+        tickers = self.check_tickers(data_req, data_type='asset_metrics')
+        sleep(0.6)
+
+        # check fields
+        fields = self.check_fields(data_req, data_type='asset_metrics')
+        sleep(0.6)
+
+        # 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"],
+            'pretty': True,
+            'page_size': 10000,
+            'ignore_forbidden_errors': True,
+            'ignore_unsupported_errors': True
+
+        }
 
         # get tidy data
         df = self.get_tidy_data(data_req,
-                                data_type='get_asset_metrics',
-                                assets=tickers,
-                                metrics=fields,
-                                frequency=cm_data_req["freq"],
-                                start_time=cm_data_req["start_date"],
-                                end_time=cm_data_req["end_date"],
+                                data_type='/timeseries/asset-metrics',
+                                params=params
                                 )
 
         return df
@@ -778,18 +806,26 @@ class CoinMetrics(DataVendor):
         # convert data request parameters to Coin Metrics format
         cm_data_req = ConvertParams(data_req).to_coinmetrics()
 
-        # check mkt type
+        # check params
         self.check_params(data_req, data_type='open_interest')
 
-        # filter tickers
-        tickers = self.filter_tickers(data_req, data_type='open_interest')
+        # check tickers
+        tickers = self.check_tickers(data_req, data_type='open_interest')
+        sleep(0.6)
+
+        # params
+        params = {
+            'markets': ','.join(tickers),
+            'start_time': cm_data_req["start_date"],
+            'end_time': cm_data_req["end_date"],
+            'pretty': True,
+            'page_size': 10000,
+        }
 
-        # get indexes
+        # get tidy data
         df = self.get_tidy_data(data_req,
-                                data_type='get_market_open_interest',
-                                markets=tickers,
-                                start_time=cm_data_req["start_date"],
-                                end_time=cm_data_req["end_date"],
+                                data_type='/timeseries/market-openinterest',
+                                params=params
                                 )
 
         return df
@@ -811,18 +847,26 @@ class CoinMetrics(DataVendor):
         # convert data request parameters to Coin Metrics format
         cm_data_req = ConvertParams(data_req).to_coinmetrics()
 
-        # check mkt type
+        # check params
         self.check_params(data_req, data_type='funding_rates')
 
-        # filter tickers
-        tickers = self.filter_tickers(data_req, data_type='funding_rates')
+        # check tickers
+        tickers = self.check_tickers(data_req, data_type='funding_rates')
+        sleep(0.6)
 
-        # get indexes
+        # params
+        params = {
+            'markets': ','.join(tickers),
+            '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='get_market_funding_rates',
-                                markets=tickers,
-                                start_time=cm_data_req["start_date"],
-                                end_time=cm_data_req["end_date"],
+                                data_type='/timeseries/market-funding-rates',
+                                params=params
                                 )
 
         return df
@@ -844,17 +888,26 @@ class CoinMetrics(DataVendor):
         # convert data request parameters to Coin Metrics format
         cm_data_req = ConvertParams(data_req).to_coinmetrics()
 
-        # check mkt type
+        # check params
         self.check_params(data_req, data_type='trades')
 
-        # filter tickers
-        tickers = self.filter_tickers(data_req, data_type='trades')
+        # check tickers
+        tickers = self.check_tickers(data_req, data_type='trades')
+        sleep(0.6)
+
+        # params
+        params = {
+            'markets': ','.join(tickers),
+            'start_time': cm_data_req["start_date"],
+            'end_time': cm_data_req["end_date"],
+            'pretty': True,
+            'page_size': 10000,
+        }
 
-        # get indexes
+        # get tidy data
         df = self.get_tidy_data(data_req,
-                                data_type='get_market_trades',
-                                markets=tickers,
-                                start_time=cm_data_req["start_date"]
+                                data_type='/timeseries/market-trades',
+                                params=params
                                 )
 
         return df
@@ -876,17 +929,27 @@ class CoinMetrics(DataVendor):
         # convert data request parameters to Coin Metrics format
         cm_data_req = ConvertParams(data_req).to_coinmetrics()
 
-        # check mkt type
+        # check params
         self.check_params(data_req, data_type='quotes')
 
-        # filter tickers
-        tickers = self.filter_tickers(data_req, data_type='quotes')
+        # check tickers
+        tickers = self.check_tickers(data_req, data_type='quotes')
+        sleep(0.6)
+
+        # params
+        params = {
+            'markets': ','.join(tickers),
+            'granularity': cm_data_req['freq'],
+            'start_time': cm_data_req["start_date"],
+            'end_time': cm_data_req["end_date"],
+            'pretty': True,
+            'page_size': 10000,
+        }
 
-        # get indexes
+        # get tidy data
         df = self.get_tidy_data(data_req,
-                                data_type='get_market_quotes',
-                                markets=tickers,
-                                start_time=cm_data_req["start_date"]
+                                data_type='/timeseries/market-quotes',
+                                params=params
                                 )
 
         return df
@@ -910,20 +973,25 @@ class CoinMetrics(DataVendor):
         cm_data_req = ConvertParams(data_req).to_coinmetrics()
 
         # check if fields available
-        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"
-                " fields property and try again."
-            )
-
-        # fields list
+        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."
+        #     )
+
+        # field lists
         ohlcv_list = ['price_open', 'price_close', 'price_high', 'price_low', 'vwap', 'volume',
                       'candle_usd_volume', 'candle_trades_count']
         oc_list = [field for field in self.fields if field not in ohlcv_list]
+
         # empty df
         df = pd.DataFrame()
 
         # 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"]]
         ):
@@ -931,6 +999,8 @@ class CoinMetrics(DataVendor):
             df = pd.concat([df, df0])
 
         # 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"]]
         ):