cryptodatapy 0.2.15__py3-none-any.whl → 0.2.17__py3-none-any.whl

cryptodatapy/extract/data_vendors/cryptocompare_api.py

@@ -1,6 +1,6 @@
 import logging
 from time import sleep
-from typing import Dict, Optional, Union, Any
+from typing import Dict, Optional, Union, Any, List
 
 import pandas as pd
 
@@ -13,13 +13,6 @@ from cryptodatapy.util.datacredentials import DataCredentials
 # data credentials
 data_cred = DataCredentials()
 
-# url endpoints
-urls = {'exchanges_info': 'exchanges/general', 'indexes_info': 'index/list', 'assets_info': 'all/coinlist',
-        'markets_info': 'v2/cccagg/pairs', 'on-chain_tickers_info': 'blockchain/list',
-        'on-chain_info': 'blockchain/latest?fsym=BTC', 'social_info': 'social/coin/histo/day',
-        'news': 'v2/news/?lang=EN', 'news_sources': 'news/feeds', 'rate_limit_info': 'rate/limit',
-        'top_mkt_cap_info': 'top/mktcapfull?', 'indexes': 'index/'}
-
 
 class CryptoCompare(DataVendor):
     """
@@ -28,15 +21,16 @@ class CryptoCompare(DataVendor):
 
     def __init__(
             self,
-            categories=None,
+            categories: 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'],
             fields: Optional[list[str]] = None,
-            frequencies=None,
+            frequencies: List[str] = ['1min', '1h', 'd'],
             base_url: str = data_cred.cryptocompare_base_url,
+            api_endpoints: Dict[str, str] = data_cred.cryptomcompare_endpoints,
             api_key: str = data_cred.cryptocompare_api_key,
             max_obs_per_call: int = 2000,
             rate_limit: Optional[pd.DataFrame] = None
@@ -65,6 +59,9 @@ class CryptoCompare(DataVendor):
             '8h', 'd', 'w', 'm']
         base_url: str
             Base url used for GET requests. If not provided, default is set to base_url stored in DataCredentials.
+        api_endpoints: dict, optional, default None
+            Dictionary with available API endpoints. If not provided, default is set to api_endpoints stored in
+            DataCredentials.
         api_key: str
             Api key, e.g. 'dcf13983adf7dfa79a0dfa35adf'. If not provided, default is set to
             api_key stored in DataCredentials.
@@ -74,31 +71,17 @@ class CryptoCompare(DataVendor):
         rate_limit: pd.DataFrame, 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)
-
-        if frequencies is None:
-            self.frequencies = ['1min', '1h', 'd']
-        if market_types is None:
-            self.market_types = ['spot']
-        if categories is None:
-            self.categories = ['crypto']
+        super().__init__(
+            categories, exchanges, indexes, assets, markets, market_types,
+            fields, frequencies, base_url, api_endpoints, api_key, max_obs_per_call, rate_limit
+        )
         if api_key is None:
             raise TypeError("Set your CryptoCompare api key in environment variables as 'CRYPTOCOMPARE_API_KEY' or "
                             "add it as an argument when instantiating the class. To get an api key, visit: "
                             "https://min-api.cryptocompare.com/")
-        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)
-        if rate_limit is None:
-            self.rate_limit = self.get_rate_limit_info()
+        self.data_req = None
+        self.data_resp = None
+        self.data = pd.DataFrame()
 
     def req_meta(self, info_type: str) -> Dict[str, Any]:
         """
@@ -116,7 +99,9 @@ class CryptoCompare(DataVendor):
         meta: dictionary
             Metadata in JSON format.
         """
-        return DataRequest().get_req(url=self.base_url + urls[info_type], params={'api_key': self.api_key})
+        self.data_resp = DataRequest().get_req(url=self.base_url + self.api_endpoints[info_type],
+                                               params={'api_key': self.api_key})
+        return self.data_resp
 
     def get_exchanges_info(self, as_list: bool = False) -> Union[list[str], pd.DataFrame]:
         """
@@ -133,11 +118,11 @@ class CryptoCompare(DataVendor):
             List or dataframe with info on available indexes.
         """
         # data req
-        data_resp = self.req_meta(info_type='exchanges_info')
+        self.req_meta(info_type='exchanges_info')
         # wrangle data resp
-        exch = WrangleInfo(data_resp).cc_exch_info(as_list=as_list)
+        self.exchanges = WrangleInfo(self.data_resp).cc_exch_info(as_list=as_list)
 
-        return exch
+        return self.exchanges
 
     def get_indexes_info(self, as_list: bool = False) -> Union[list[str], pd.DataFrame]:
         """
@@ -154,11 +139,11 @@ class CryptoCompare(DataVendor):
             List or dataframe with info on available indexes.
         """
         # data req
-        data_resp = self.req_meta(info_type='indexes_info')
+        self.req_meta(info_type='indexes_info')
         # wrangle data resp
-        indexes = WrangleInfo(data_resp).cc_indexes_info(as_list=as_list)
+        self.indexes = WrangleInfo(self.data_resp).cc_indexes_info(as_list=as_list)
 
-        return indexes
+        return self.indexes
 
     def get_assets_info(self, as_list: bool = False) -> Union[list[str], pd.DataFrame]:
         """
@@ -175,11 +160,11 @@ class CryptoCompare(DataVendor):
             List or dataframe with info on available assets.
         """
         # data req
-        data_resp = self.req_meta(info_type='assets_info')
+        self.req_meta(info_type='assets_info')
         # wrangle data resp
-        assets = WrangleInfo(data_resp).cc_assets_info(as_list=as_list)
+        self.assets = WrangleInfo(self.data_resp).cc_assets_info(as_list=as_list)
 
-        return assets
+        return self.assets
 
     def get_markets_info(self, as_list: bool = False) -> Union[list[str], dict[str]]:
         """
@@ -196,11 +181,11 @@ class CryptoCompare(DataVendor):
             Dictionary or list with info on available markets.
         """
         # data req
-        data_resp = self.req_meta(info_type='markets_info')
+        self.req_meta(info_type='markets_info')
         # wrangle data resp
-        mkts = WrangleInfo(data_resp).cc_mkts_info(as_list=as_list)
+        self.markets = WrangleInfo(self.data_resp).cc_mkts_info(as_list=as_list)
 
-        return mkts
+        return self.markets
 
     def get_onchain_tickers_info(self, as_list: bool = False) -> Union[list[str], pd.DataFrame]:
         """
@@ -217,18 +202,12 @@ class CryptoCompare(DataVendor):
             list or dataframe with info on tickers with available on-chain data.
         """
         # data req
-        data_resp = self.req_meta(info_type='on-chain_tickers_info')
+        self.req_meta(info_type='on-chain_tickers_info')
         # wrangle data resp
-        tickers = WrangleInfo(data_resp).cc_onchain_tickers_info(as_list=as_list)
+        tickers = WrangleInfo(self.data_resp).cc_onchain_tickers_info(as_list=as_list)
 
         return tickers
 
-    def req_onchain(self) -> Dict[str, Any]:
-        """
-        Get request for on-chain info.
-        """
-        return DataRequest().get_req(url=self.base_url + urls['on-chain_info'], params={'api_key': self.api_key})
-
     def get_onchain_info(self) -> list[str]:
         """
         Get on-chain fields info.
@@ -239,9 +218,9 @@ class CryptoCompare(DataVendor):
             List of available on-chain fields.
         """
         # data req
-        data_resp = self.req_meta(info_type='on-chain_info')
+        self.req_meta(info_type='on-chain_info')
         # wrangle data resp
-        onchain_fields = WrangleInfo(data_resp).cc_onchain_info()
+        onchain_fields = WrangleInfo(self.data_resp).cc_onchain_info()
 
         return onchain_fields
 
@@ -255,9 +234,9 @@ class CryptoCompare(DataVendor):
             List of available social fields.
         """
         # data req
-        data_resp = self.req_meta(info_type='social_info')
+        self.req_meta(info_type='social_info')
         # wrangle data resp
-        social_fields = WrangleInfo(data_resp).cc_social_info()
+        social_fields = WrangleInfo(self.data_resp).cc_social_info()
 
         return social_fields
 
@@ -277,24 +256,26 @@ class CryptoCompare(DataVendor):
         """
         ohlcv_list = ['open', 'high', 'low', 'close', 'volumefrom']
 
-        # fields list
+        # fields
         if data_type == 'market':
-            fields_list = ohlcv_list
+            self.fields = ohlcv_list
         elif data_type == 'on-chain':
-            fields_list = self.get_onchain_info()
+            self.fields = self.get_onchain_info()
         elif data_type == 'off-chain':
-            fields_list = self.get_social_info()
+            self.fields = self.get_social_info()
         else:
-            fields_list = ohlcv_list + self.get_onchain_info() + self.get_social_info()
+            self.fields = ohlcv_list + self.get_onchain_info() + self.get_social_info()
 
-        return fields_list
+        return self.fields
 
     def req_rate_limit(self) -> Dict[str, Any]:
         """
         Get request for rate limit info.
         """
-        return DataRequest().get_req(url=self.base_url.replace('data', 'stats') + urls['rate_limit_info'],
-                                     params={'api_key': self.api_key})
+        self.data_resp = DataRequest().get_req(url=self.base_url.replace('data', 'stats') +
+                                               self.api_endpoints['rate_limit_info'],
+                                               params={'api_key': self.api_key})
+        return self.data_resp
 
     def get_rate_limit_info(self) -> pd.DataFrame:
         """
@@ -306,11 +287,11 @@ class CryptoCompare(DataVendor):
             DataFrame with API calls left and made by period (hour, day, month).
         """
         # data req
-        data_resp = self.req_rate_limit()
+        self.req_rate_limit()
         # wrangle data resp
-        rate_limit = WrangleInfo(data_resp).cc_rate_limit_info()
+        self.rate_limit = WrangleInfo(self.data_resp).cc_rate_limit_info()
 
-        return rate_limit
+        return self.rate_limit
 
     def get_news(self) -> pd.DataFrame:
         """
@@ -322,9 +303,9 @@ class CryptoCompare(DataVendor):
             News articles from various sources with title, source, body, ...
         """
         # data req
-        data_resp = self.req_meta(info_type='news')
+        self.req_meta(info_type='news')
         # wrangle data resp
-        news = WrangleInfo(data_resp).cc_news()
+        news = WrangleInfo(self.data_resp).cc_news()
 
         return news
 
@@ -338,9 +319,9 @@ class CryptoCompare(DataVendor):
             News source info.
         """
         # data req
-        data_resp = self.req_meta(info_type='news_sources')
+        self.req_meta(info_type='news_sources')
         # wrangle data resp
-        news_sources = WrangleInfo(data_resp).cc_news_sources()
+        news_sources = WrangleInfo(self.data_resp).cc_news_sources()
 
         return news_sources
 
@@ -348,12 +329,15 @@ class CryptoCompare(DataVendor):
         """
         Get request for top mkt cap coins info.
         """
-        return DataRequest().get_req(url=self.base_url + urls['top_mkt_cap_info'],
-                                     params={
-                                         'limit': n,
-                                         'tsym': 'USD',
-                                         'api_key': self.api_key
-                                     })
+        self.data_resp = DataRequest().get_req(
+            url=self.base_url + self.api_endpoints['top_mkt_cap_info'],
+            params={
+                'limit': n,
+                'tsym': 'USD',
+                'api_key': self.api_key
+            }
+        )
+        return self.data_resp
 
     def get_top_mkt_cap_info(self, n: int = 100) -> list[str]:
         """
@@ -374,13 +358,13 @@ class CryptoCompare(DataVendor):
             raise ValueError("Maximum number of assets is 100. Change n parameter and try again.")
 
         # date req
-        data_resp = self.req_top_mkt_cap(n=n)
+        self.req_top_mkt_cap(n=n)
         # wrangle data resp
-        tickers = WrangleInfo(data_resp).cc_top_mkt_cap_info()
+        tickers = WrangleInfo(self.data_resp).cc_top_mkt_cap_info()
 
         return tickers
 
-    def set_urls_params(self, data_req: DataRequest, data_type: str, ticker: str) -> Dict[str, Union[str, int]]:
+    def set_urls_params(self, data_req: DataRequest, data_type: str, ticker: str) -> Dict[str, Union[str, Any]]:
         """
         Sets url and params for get request.
 
@@ -400,25 +384,26 @@ class CryptoCompare(DataVendor):
 
         """
         # convert data req params
-        cc_data_req = ConvertParams(data_req).to_cryptocompare()
+        self.data_req = ConvertParams(data_req).to_cryptocompare()
 
         # set params
         if data_type == 'indexes':
-            url = self.base_url + urls['indexes'] + cc_data_req['freq'][:5] + "/" + cc_data_req['freq'][5:]
+            url = (self.base_url + self.api_endpoints['indexes'] + self.data_req.source_freq[:5] + "/" +
+                   self.data_req.source_freq[5:])
             params = {
                 'indexName': ticker,
-                'toTs': cc_data_req['end_date'],
+                'toTs': self.data_req.source_end_date,
                 'limit': self.max_obs_per_call,
                 'api_key': self.api_key
             }
         elif data_type == 'ohlcv':
-            url = self.base_url + f"v2/{cc_data_req['freq']}"
+            url = self.base_url + f"v2/{self.data_req.source_freq}"
             params = {
                 'fsym': ticker,
-                'tsym': cc_data_req['quote_ccy'],
+                'tsym': self.data_req.quote_ccy,
                 'limit': self.max_obs_per_call,
-                'e': cc_data_req['exch'],
-                'toTs': cc_data_req['end_date'],
+                'e': self.data_req.exch,
+                'toTs': self.data_req.source_end_date,
                 'api_key': self.api_key
             }
 
@@ -427,16 +412,16 @@ class CryptoCompare(DataVendor):
             params = {
                 'fsym': ticker,
                 'limit': self.max_obs_per_call,
-                'toTs': cc_data_req['end_date'],
+                'toTs': self.data_req.source_end_date,
                 'api_key': self.api_key
             }
 
         elif data_type == 'social':
-            url = self.base_url + "social/coin/" + cc_data_req['freq'][:5] + '/' + cc_data_req['freq'][5:]
+            url = self.base_url + "social/coin/" + self.data_req.source_freq[:5] + '/' + self.data_req.source_freq[5:]
             params = {
                 'coinId': int(self.get_assets_info().loc[ticker.upper(), 'Id']),
                 'limit': self.max_obs_per_call,
-                'toTs': cc_data_req['end_date'],
+                'toTs': self.data_req.source_end_date,
                 'api_key': self.api_key
             }
 
@@ -444,7 +429,7 @@ class CryptoCompare(DataVendor):
             url = self.base_url
             params = {}
 
-        return {'url': url, 'params': params}
+        return url, params
 
     def req_data(self, data_req: DataRequest, data_type: str, ticker: str) -> Dict[str, Any]:
         """
@@ -465,13 +450,12 @@ class CryptoCompare(DataVendor):
             Data response in JSON format.
         """
         # set params
-        urls_params = self.set_urls_params(data_req, data_type, ticker)
-        url, params = urls_params['url'], urls_params['params']
+        url, params = self.set_urls_params(data_req, data_type, ticker)
 
         # data req
-        data_resp = DataRequest().get_req(url=url, params=params)
+        self.data_req = data_req.get_req(url=url, params=params)
 
-        return data_resp
+        return self.data_req
 
     def get_all_data_hist(self, data_req: DataRequest, data_type: str, ticker: str) -> pd.DataFrame:
         """
@@ -494,11 +478,10 @@ class CryptoCompare(DataVendor):
 
         """
         # convert data req params
-        cc_data_req = ConvertParams(data_req).to_cryptocompare()
+        self.data_req = ConvertParams(data_req).to_cryptocompare()
 
         # set params
-        urls_params = self.set_urls_params(data_req, data_type, ticker)
-        url, params = urls_params['url'], urls_params['params']
+        url, params = self.set_urls_params(data_req, data_type, ticker)
 
         # create empty df
         df = pd.DataFrame()
@@ -509,26 +492,25 @@ class CryptoCompare(DataVendor):
         while missing_vals:
 
             # data req
-            data_resp = DataRequest().get_req(url=url, params=params)
+            self.data_resp = DataRequest().get_req(url=url, params=params)
 
             # add data resp to df
-            if data_resp:
+            if self.data_resp:
                 if data_type == 'indexes' or data_type == 'social':
-                    df1 = pd.DataFrame(data_resp['Data'])
+                    df1 = pd.DataFrame(self.data_resp['Data'])
                 else:
-                    df1 = pd.DataFrame(data_resp['Data']['Data'])
+                    df1 = pd.DataFrame(self.data_resp['Data']['Data'])
                 df = pd.concat([df, df1])  # add data to empty df
 
                 # check if all data has been extracted
-                if len(df1) < (self.max_obs_per_call - 1) or df1.time[0] <= cc_data_req['start_date'] or \
+                if len(df1) < (self.max_obs_per_call - 1) or df1.time[0] <= self.data_req.source_start_date or \
                         all(df1.drop(columns=['time']).iloc[0] == 0) or \
                         all(df1.drop(columns=['time']).iloc[0].astype(str) == 'nan'):
                     missing_vals = False
                 # reset end date and pause before calling API again
                 else:
-                    # change end date
                     params['toTs'] = df1.time[0]
-                    sleep(0.1)
+                    sleep(self.data_req.pause)
 
         return df
 
@@ -549,7 +531,6 @@ class CryptoCompare(DataVendor):
         df: pd.DataFrame
             Wrangled dataframe with DatetimeIndex and values in tidy format.
         """
-
         return WrangleData(data_req, data_resp).cryptocompare()
 
     def get_tidy_data(self, data_req: DataRequest, data_type: str, ticker: str) -> pd.DataFrame:
@@ -595,18 +576,18 @@ class CryptoCompare(DataVendor):
             Dataframe with DatetimeIndex (level 0), ticker (level 1) and values for fields (cols), in tidy data format.
         """
         # convert data request parameters to CryptoCompare format
-        cc_data_req = ConvertParams(data_req).to_cryptocompare()
+        self.data_req = ConvertParams(data_req).to_cryptocompare()
 
         # empty df to add data
         df = pd.DataFrame()
 
         # loop through tickers
-        for ticker in cc_data_req['tickers']:
+        for ticker in self.data_req.source_tickers:
 
             try:
                 df0 = self.get_tidy_data(data_req, data_type, ticker)
-            except Exception:
-                logging.info(f"Failed to get {data_type} data for {ticker} after many attempts.")
+            except Exception as e:
+                logging.info(f"Failed to get {data_type} data for {ticker} after many attempts: {e}.")
             else:
                 # add ticker to index
                 df0['ticker'] = ticker
@@ -630,23 +611,16 @@ class CryptoCompare(DataVendor):
         df: pd.DataFrame - MultiIndex
             DataFrame with DatetimeIndex (level 0), ticker (level 1), and index values (cols), in tidy format.
         """
-        # convert data request parameters to CryptoCompare format
-        cc_data_req = ConvertParams(data_req).to_cryptocompare()
-
-        # fields list
-        market_fields = self.get_fields_info(data_type='market')
-
-        # check if tickers and fields are correct
-        if any([ticker in self.indexes for ticker in cc_data_req['tickers']]) and \
-                any([field in market_fields for field in cc_data_req['fields']]):
-            try:
-                df = self.get_all_tickers(data_req, data_type='indexes')
+        # convert params
+        self.data_req = ConvertParams(data_req).to_cryptocompare()
 
-            except Exception as e:
-                logging.warning(e)
+        # get indexes
+        try:
+            df = self.get_all_tickers(data_req, data_type='indexes')
+            return df
 
-            else:
-                return df
+        except Exception as e:
+            logging.warning(e)
 
     def get_ohlcv(self, data_req: DataRequest) -> pd.DataFrame:
         """
@@ -662,23 +636,16 @@ class CryptoCompare(DataVendor):
         df: pd.DataFrame - MultiIndex
             DataFrame with DatetimeIndex (level 0), ticker (level 1), and OHLCV values (cols), in tidy format.
         """
-        # convert data request parameters to CryptoCompare format
-        cc_data_req = ConvertParams(data_req).to_cryptocompare()
-
-        # fields list
-        market_fields = self.get_fields_info(data_type='market')
+        # convert params
+        self.data_req = ConvertParams(data_req).to_cryptocompare()
 
-        # check if tickers and fields are correct
-        if any([ticker in self.assets for ticker in cc_data_req['tickers']]) and \
-                any([field in market_fields for field in cc_data_req['fields']]):
-            try:
-                df = self.get_all_tickers(data_req, data_type='ohlcv')
-
-            except Exception as e:
-                logging.warning(e)
+        # get ohlcv
+        try:
+            df = self.get_all_tickers(data_req, data_type='ohlcv')
+            return df
 
-            else:
-                return df
+        except Exception as e:
+            logging.warning(e)
 
     def get_onchain(self, data_req: DataRequest) -> pd.DataFrame:
         """
@@ -695,28 +662,16 @@ class CryptoCompare(DataVendor):
             DataFrame with DatetimeIndex (level 0), ticker (level 1), and values for on-chain fields (cols),
             in tidy format.
         """
-        # convert data request parameters to CryptoCompare format
-        cc_data_req = ConvertParams(data_req).to_cryptocompare()
-
-        # check if frequency daily
-        if cc_data_req['freq'] != 'histoday':
-            raise ValueError(f"On-chain data is only available on a daily frequency."
-                             f" Change data request frequency to 'd' and try again.")
+        # convert params
+        self.data_req = ConvertParams(data_req).to_cryptocompare()
 
-        # fields list
-        onchain_fields = self.get_fields_info(data_type='on-chain')
-
-        # check if tickers and fields are correct
-        if any([ticker in self.assets for ticker in cc_data_req['tickers']]) and \
-                any([field in onchain_fields for field in cc_data_req['fields']]):
-            try:
-                df = self.get_all_tickers(data_req, data_type='on-chain')
-
-            except Exception as e:
-                logging.warning(e)
+        # get on-chain
+        try:
+            df = self.get_all_tickers(data_req, data_type='on-chain')
+            return df
 
-            else:
-                return df
+        except Exception as e:
+            logging.warning(e)
 
     def get_social(self, data_req: DataRequest) -> pd.DataFrame:
         """
@@ -733,50 +688,53 @@ class CryptoCompare(DataVendor):
             DataFrame with DatetimeIndex (level 0), ticker (level 1), and values for social media fields (cols),
             in tidy format.
         """
-        # convert data request parameters to CryptoCompare format
-        cc_data_req = ConvertParams(data_req).to_cryptocompare()
-
-        # check frequency
-        if cc_data_req['freq'] == 'histominute':
-            raise ValueError(f"Social media data is only available on a daily and hourly frequency."
-                             f" Change data request frequency to 'd' or '1h' and try again.")
-
-        # fields list
-        social_fields = self.get_fields_info(data_type='off-chain')
-
-        # check if tickers and fields are correct
-        if any([ticker in self.assets for ticker in cc_data_req['tickers']]) and \
-                any([field in social_fields for field in cc_data_req['fields']]):
-            try:
-                df = self.get_all_tickers(data_req, data_type='social')
-
-            except Exception as e:
-                logging.warning(e)
+        # convert params
+        self.data_req = ConvertParams(data_req).to_cryptocompare()
 
-            else:
-                return df
+        # get social
+        try:
+            df = self.get_all_tickers(data_req, data_type='social')
+            return df
+        except Exception as e:
+            logging.warning(e)
 
     def check_params(self, data_req: DataRequest) -> None:
         """
         Checks the parameters of the data request before requesting data to reduce API calls
         and improve efficiency.
         """
-        # convert data request parameters to CryptoCompare format
-        cc_data_req = ConvertParams(data_req).to_cryptocompare()
+        # convert params
+        self.data_req = ConvertParams(data_req).to_cryptocompare()
 
-        # tickers lists
-        assets_list = self.assets
-        idx_list = self.indexes
-        tickers_list = assets_list + idx_list
+        # tickers list
+        self.get_assets_info(as_list=True)
+        self.get_indexes_info(as_list=True)
+        tickers_list = self.assets + self.indexes
 
-        # check tickers and fields
-        if not all([ticker in tickers_list for ticker in cc_data_req['tickers']]):
+        # tickers
+        if not all([ticker in tickers_list for ticker in self.data_req.source_tickers]):
             raise ValueError("Some assets are not available. "
-                             "Check assets and indexes attributes to see all available asset and indexes.")
+                             "Check available assets and indexes with get_assets_info() or get_indexes_info().")
 
-        if len(cc_data_req['fields']) == 0:
+        # fields
+        if not all([field in self.get_fields_info() for field in self.data_req.source_fields]):
             raise ValueError("Some fields are not available. "
-                             "Check fields attribute to see all available fields.")
+                             "Check available fields with get_fields_info().")
+
+        # check freq
+        if self.data_req.source_freq not in ['histoday', 'histohour', 'histominute']:
+            raise ValueError(f"Frequency {self.data_req.source_freq} not available. "
+                             f"Check available frequencies with get_frequencies().")
+
+        # on-chain freq
+        if self.data_req.source_fields in self.get_onchain_info() and self.data_req.source_freq != 'histoday':
+            raise ValueError(f"On-chain data is only available on a daily frequency."
+                             f" Change data request frequency to 'd' and try again.")
+
+        # social freq
+        if self.data_req.source_fields in self.get_social_info() and self.data_req.source_freq == 'histominute':
+            raise ValueError(f"Social media data is only available on a daily and hourly frequency."
+                             f" Change data request frequency to 'd' or '1h' and try again.")
 
     def get_data(self, data_req: DataRequest) -> pd.DataFrame:
         """
@@ -798,16 +756,13 @@ class CryptoCompare(DataVendor):
         # check data req params
         self.check_params(data_req)
 
-        # df to store data
-        df = pd.DataFrame()
-
         # get indexes
         try:
             df0 = self.get_indexes(data_req)
         except Exception as e:
             logging.warning(e)
         else:
-            df = pd.concat([df, df0])
+            self.data = pd.concat([self.data, df0])
 
         # get ohlcv
         try:
@@ -815,7 +770,7 @@ class CryptoCompare(DataVendor):
         except Exception as e:
             logging.warning(e)
         else:
-            df = pd.concat([df, df1])
+            self.data = pd.concat([self.data, df1])
 
         # get onchain
         try:
@@ -823,7 +778,7 @@ class CryptoCompare(DataVendor):
         except Exception as e:
             logging.warning(e)
         else:
-            df = pd.concat([df, df2], axis=1)
+            self.data = pd.concat([self.data, df2], axis=1)
 
         # get social
         try:
@@ -831,16 +786,16 @@ class CryptoCompare(DataVendor):
         except Exception as e:
             logging.warning(e)
         else:
-            df = pd.concat([df, df3], axis=1)
+            self.data = pd.concat([self.data, df3], axis=1)
 
         # check if df empty
-        if df.empty:
+        if self.data.empty:
             raise Exception('No data returned. Check data request parameters and try again.')
 
         # filter df for desired fields and sort index by date
-        fields = [field for field in data_req.fields if field in df.columns]
-        df = df.loc[:, fields]
+        fields = [field for field in data_req.fields if field in self.data.columns]
+        self.data = self.data.loc[:, fields].sort_index()
 
         logging.info("Data retrieved from CryptoCompare.")
 
-        return df.sort_index()
+        return self.data