cryptodatapy.extract.adapters.vendors.defillama_adapter ======================================================= .. py:module:: cryptodatapy.extract.adapters.vendors.defillama_adapter Attributes ---------- .. autoapisummary:: cryptodatapy.extract.adapters.vendors.defillama_adapter.logger cryptodatapy.extract.adapters.vendors.defillama_adapter.data_cred Classes ------- .. autoapisummary:: cryptodatapy.extract.adapters.vendors.defillama_adapter.DefiLlamaAdapter Module Contents --------------- .. py:data:: logger .. py:data:: data_cred .. py:class:: DefiLlamaAdapter(config: Optional[Dict[str, Any]] = None) Bases: :py:obj:`cryptodatapy.extract.adapters.base_adapter.BaseAPIAdapter` Adapter class for retrieving data from DefiLlama API. Implements the BaseAdapter contract via BaseAPIAdapter. .. py:attribute:: assets :value: None .. py:attribute:: fields :value: None .. py:attribute:: stablecoins :value: None .. py:attribute:: yields :value: None .. py:method:: _fetch_raw_meta(info_type: str) -> Dict[str, Any] Helper method to fetch raw metadata (chains, protocols, fees, etc.) :param info_type: The type of metadata to fetch ('chains', 'protocols', 'fees', 'stablecoins', 'yields'). :type info_type: str :returns: The raw metadata response from DefiLlama. :rtype: Dict[str, Any] .. py:method:: get_chains_info(as_list: bool = False, remove_missing: Optional[list] = None) -> Union[pandas.DataFrame, list] Get DefiLlama chains information. :param as_list: If True, returns the chains information as a list. :type as_list: bool, default False :param remove_missing: List of fields (column names) to check for missing values to filter out. Default is None. :type remove_missing: Optional[list], optional :returns: The requested chains information. :rtype: Union[pd.DataFrame, list] .. py:method:: get_protocols_info(as_list: bool = False, remove_missing: Optional[list] = None) -> Union[pandas.DataFrame, list] Get DefiLlama protocols information. :param as_list: If True, returns the chains information as a list. :type as_list: bool, default False :param remove_missing: List of fields (column names) to check for missing values to filter out. Default is None. :type remove_missing: Optional[list], optional :returns: The requested protocols information. :rtype: Union[pd.DataFrame, list] .. py:method:: get_fees_info(as_list: bool = False, remove_missing: Optional[list] = None) -> Union[pandas.DataFrame, list] Get DefiLlama fees information. :param as_list: If True, returns the fees information as a list. :type as_list: bool, default False :param remove_missing: List of fields (column names) to check for missing values to filter out. Default is None. :type remove_missing: Optional[list], optional :returns: The requested fees information. :rtype: Union[pd.DataFrame, list] .. py:method:: get_stablecoins_info(as_list: bool = False, remove_missing: Optional[list] = None) -> Union[pandas.DataFrame, list] Get DefiLlama stablecoins information. :param as_list: If True, returns the stablecoins information as a list. :type as_list: bool, default False :param remove_missing: List of fields (column names) to check for missing values to filter out. Default is None. :type remove_missing: Optional[list], optional :returns: The requested stablecoins information. :rtype: Union[pd.DataFrame, list] .. py:method:: get_yields_info() -> Union[pandas.DataFrame, list] Get DefiLlama yields information. :returns: The requested yields information. :rtype: Union[pd.DataFrame, list] .. py:method:: _normalize_protocols(protocols_df: pandas.DataFrame) -> pandas.DataFrame :staticmethod: Processes raw protocols endpoint data, selecting only high-value (Rating 4+) fields for identification, classification, and cross-referencing. :param protocols_df: Raw protocols DataFrame from DefiLlama. :type protocols_df: pd.DataFrame :returns: Normalized protocols DataFrame. :rtype: pd.DataFrame .. py:method:: _normalize_chains(chains_df: pandas.DataFrame) -> pandas.DataFrame :staticmethod: Normalizes the raw chain data, adds the 'dataEndpoint' tag, and applies manual ticker corrections (e.g., TRON -> TRX). :param chains_df: Raw chains DataFrame from DefiLlama. :type chains_df: pd.DataFrame :returns: Normalized chains DataFrame. :rtype: pd.DataFrame .. py:method:: _normalize_stablecoins(stablecoins_df: pandas.DataFrame) -> pandas.DataFrame :staticmethod: Normalizes the raw stablecoins data. :param stablecoins_df: Raw stablecoins DataFrame from DefiLlama. :type stablecoins_df: pd.DataFrame :returns: Normalized stablecoins DataFrame. :rtype: pd.DataFrame .. py:method:: _unify_assets(df_protocols: pandas.DataFrame, df_chains: pandas.DataFrame) -> pandas.DataFrame :staticmethod: Merges and concatenates protocols and chains data, applying the slug hierarchy, resolving collisions, and establishing a canonical ticker precedence based on Type, Category, and TVL. :param df_protocols: Normalized protocols DataFrame. :type df_protocols: pd.DataFrame :param df_chains: Normalized chains DataFrame. :type df_chains: pd.DataFrame :returns: Unified assets DataFrame with canonical tickers. :rtype: pd.DataFrame .. py:method:: get_assets_info(as_list: bool = False) -> Union[pandas.DataFrame, list] Get DefiLlama assets information. Note that DefiLlama does not have a direct "assets" endpoint. This method synthesizes the assets list by combining and normalizing data from the protocols and chains endpoints. It applies a hierarchy to resolve slugs and ticker collisions, establishing a canonical ticker based on asset type, category, and TVL. :param as_list: If True, returns the assets information as a list. :type as_list: bool, default False :returns: The requested assets information. :rtype: pd.DataFrame .. py:method:: get_fields_info(as_list: bool = False) -> Union[pandas.DataFrame, list] Gets DefiLlama fields information. :param as_list: If True, returns the fields information as a list. :type as_list: bool, default False :returns: The requested fields information. :rtype: pd.DataFrame .. py:method:: get_rate_limit_info() -> Optional[Any] DefiLlama credits left in the api key, these reset on the 1st of each month. .. py:method:: _build_single_request_params(single_request_dict: Dict[str, Any]) -> tuple[str, Dict[str, Any]] Builds the URL and parameters for a single request object generated by the converter. This resolves the full path and query parameters for one API call. :param single_request_dict: A dictionary representing a single request with keys: - 'endpoint': The API endpoint path. - 'slug': The slug to append to the endpoint. - 'query_params': A dictionary of query parameters specific to this request. :type single_request_dict: Dict[str, Any] :returns: A tuple containing the full URL and the parameters dictionary for the request. :rtype: tuple[str, Dict[str, Any]] .. py:method:: _fetch_all_raw_data(requests_list: List[Dict[str, Any]]) -> List[Dict[str, Any]] Fetches raw data for all requests in the list, implementing rate limiting. :param requests_list: A list of request dictionaries generated by the converter. :type requests_list: List[Dict[str, Any]] :returns: A list of raw data responses corresponding to each request. :rtype: List[Dict[str, Any]] .. py:method:: _convert_params_to_vendor(data_req: cryptodatapy.core.data_request.DataRequest) -> Dict[str, Any] Converts the DataRequest object into the vendor's specific API parameters. DefiLlama URLs rely heavily on protocol or chain name being part of the path. :param data_req: The standardized DataRequest object containing user-specified parameters. :type data_req: DataRequest :returns: A dictionary of vendor-specific parameters including the full request list. :rtype: Dict[str, Any] .. py:method:: _fetch_raw_data(params: Dict[str, Any]) -> Union[Dict[str, Any], List[Dict[str, Any]]] Submits the vendor-specific parameters to the API and returns the raw responses. :param params: The vendor-specific parameters including the full request list. :type params: Dict[str, Any] :returns: The raw data responses from DefiLlama. :rtype: Union[Dict[str, Any], List[Dict[str, Any]]] .. py:method:: _transform_raw_response(data_req: cryptodatapy.core.data_request.DataRequest, raw_data: Any) -> pandas.DataFrame Processes the raw data responses into the package's standardized tidy DataFrame format using the dedicated DefiLlamaWrangler. :param data_req: The original DataRequest object. :type data_req: DataRequest :param raw_data: The raw data response from DefiLlama. :type raw_data: Any :returns: The transformed tidy DataFrame. :rtype: pd.DataFrame