datamaxi 0.1.0__py3-none-any.whl

datamaxi/__version__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

datamaxi/api.py

@@ -0,0 +1,144 @@
+import os
+import json
+from json import JSONDecodeError
+import logging
+import requests
+from .__version__ import __version__
+from datamaxi.error import ClientError, ServerError
+from datamaxi.lib.utils import cleanNoneValue
+from datamaxi.lib.utils import encoded_string
+
+
+class API(object):
+    """The base class for all DataMaxi+ Python clients. `api_key` can be set
+    as an environment variable `NEVEREST_API_KEY`.
+    """
+
+    def __init__(
+        self,
+        api_key=None,
+        base_url=None,
+        timeout=None,
+        proxies=None,
+        show_limit_usage=False,
+        show_header=False,
+    ):
+        """Client API constructor. `api_key` can be set
+        as an environment variable `NEVEREST_API_KEY`.
+
+        Args:
+            api_key (str): The API key for the DataMaxi+ API.
+            base_url (str): The base URL for the DataMaxi+ API.
+            timeout (int): The timeout for the requests.
+            proxies (dict): The proxies for the requests.
+            show_limit_usage (bool): Show the limit usage.
+            show_header (bool): Show the header.
+        """
+        self.api_key = api_key or os.environ.get("NEVEREST_API_KEY")
+        self.base_url = base_url
+        self.timeout = timeout
+        self.proxies = None
+        self.show_limit_usage = False
+        self.show_header = False
+
+        self.session = requests.Session()
+        self.session.headers.update(
+            {
+                "Content-Type": "application/json;charset=utf-8",
+                "User-Agent": "datamaxi/" + __version__,
+                "Authorization": "X-NVRST-APIKEY " + str(self.api_key),
+            }
+        )
+
+        if show_limit_usage is True:
+            self.show_limit_usage = True
+
+        if show_header is True:
+            self.show_header = True
+
+        if type(proxies) is dict:
+            self.proxies = proxies
+
+        self._logger = logging.getLogger(__name__)
+        return
+
+    def query(self, url_path, payload=None):
+        return self.send_request("GET", url_path, payload=payload)
+
+    def send_request(self, http_method, url_path, payload=None):
+        if payload is None:
+            payload = {}
+        url = self.base_url + url_path
+        self._logger.debug("url: " + url)
+        params = cleanNoneValue(
+            {
+                "url": url,
+                "params": self._prepare_params(payload),
+                "timeout": self.timeout,
+                "proxies": self.proxies,
+            }
+        )
+        response = self._dispatch_request(http_method)(**params)
+        self._logger.debug("raw response from server:" + response.text)
+        self._handle_exception(response)
+
+        try:
+            data = response.json()
+        except ValueError:
+            data = response.text
+        result = {}
+
+        if self.show_limit_usage:
+            limit_usage = {}
+            for key in response.headers.keys():
+                key = key.lower()
+                if (
+                    key.startswith("x-ratelimit-limit")
+                    or key.startswith("x-ratelimit-remaining")
+                    or key.startswith("x-ratelimit-reset")
+                ):
+                    limit_usage[key] = response.headers[key]
+            result["limit_usage"] = limit_usage
+
+        if self.show_header:
+            result["header"] = response.headers
+
+        if len(result) != 0:
+            result["data"] = data
+            return result
+
+        return data
+
+    def _prepare_params(self, params):
+        return encoded_string(cleanNoneValue(params))
+
+    def _dispatch_request(self, http_method):
+        return {
+            "GET": self.session.get,
+            "DELETE": self.session.delete,
+            "PUT": self.session.put,
+            "POST": self.session.post,
+        }.get(http_method, "GET")
+
+    def _handle_exception(self, response):
+        status_code = response.status_code
+        if status_code < 400:
+            return
+        if 400 <= status_code < 500:
+            try:
+                err = json.loads(response.text)
+            except JSONDecodeError:
+                raise ClientError(
+                    status_code, None, response.text, None, response.headers
+                )
+            error_data = None
+            if "data" in err:
+                error_data = err["data"]
+            raise ClientError(
+                status_code,
+                err["code"],
+                err["msg"],
+                response.headers,
+                error_data,
+            )
+        raise ServerError(status_code, response.text)

datamaxi/binance/__init__.py

@@ -0,0 +1,56 @@
+from typing import Any, List, Union
+import pandas as pd
+from datamaxi.api import API
+from datamaxi.lib.utils import check_required_parameters
+from datamaxi.lib.utils import postprocess
+from datamaxi.lib.constants import BASE_URL
+
+
+class Binance(API):
+    """Client to fetch Binance data from DataMaxi+ API."""
+
+    def __init__(self, api_key=None, **kwargs: Any):
+        """Initialize the object.
+
+        Args:
+            api_key (str): The DataMaxi+ API key
+            **kwargs: Keyword arguments used by `datamaxi.api.API`.
+        """
+        if "base_url" not in kwargs:
+            kwargs["base_url"] = BASE_URL
+            super().__init__(api_key, **kwargs)
+
+    def symbols(self) -> List[str]:
+        """Supported Binance supported symbols
+
+        `GET /v1/raw/binance/symbols`
+
+        <https://docs.neverest.finance/cex/binance/symbols>
+
+        Returns:
+            List of supported Binance symbols
+        """
+        url_path = "/v1/raw/binance/symbols"
+        return self.query(url_path)
+
+    @postprocess()
+    def kline(
+        self, symbol: str, interval: str = "1d", pandas: bool = True
+    ) -> Union[List, pd.DataFrame]:
+        """Get Binance k-line data
+
+        `GET /v1/raw/binance/kline`
+
+        <https://docs.neverest.finance/cex/binance/kline>
+
+        Args:
+            symbol (str): Binance symbol
+            interval (str): Kline interval
+            pandas (bool): Return data as pandas DataFrame
+
+        Returns:
+            Binance kline data for a given symbol and interval in pandas DataFrame
+        """
+        check_required_parameters([[symbol, "symbol"], [interval, "interval"]])
+        params = {"symbol": symbol, "interval": interval}
+        return self.query("/v1/raw/binance/kline", params)

datamaxi/defillama/__init__.py

@@ -0,0 +1,499 @@
+from typing import Any, List, Union
+import pandas as pd
+from datamaxi.api import API
+from datamaxi.lib.utils import check_required_parameter
+from datamaxi.lib.utils import check_required_parameters
+from datamaxi.lib.utils import check_required_parameter_list
+from datamaxi.lib.utils import encode_string_list
+from datamaxi.lib.utils import make_list
+from datamaxi.lib.utils import postprocess
+from datamaxi.lib.constants import BASE_URL
+
+
+class Defillama(API):
+    """Client to fetch Defillama data from DataMaxi+ API."""
+
+    def __init__(self, api_key=None, **kwargs: Any):
+        """Initialize the object.
+
+        Args:
+            api_key (str): The DataMaxi+ API key
+            **kwargs: Keyword arguments used by `datamaxi.api.API`.
+        """
+        if "base_url" not in kwargs:
+            kwargs["base_url"] = BASE_URL
+            super().__init__(api_key, **kwargs)
+
+    def protocols(self) -> List[str]:
+        """Get supported protocols
+
+        `GET /v1/defillama/protocol`
+
+        <https://docs.neverest.finance/defillama/protocol>
+
+        Returns:
+            List of supported protocols
+        """
+        url_path = "/v1/defillama/protocol"
+        return self.query(url_path)
+
+    def chains(self) -> List[str]:
+        """Get supported chains
+
+        `GET /v1/defillama/chain`
+
+        <https://docs.neverest.finance/defillama/chain>
+
+        Returns:
+            List of supported chains
+        """
+        url_path = "/v1/defillama/chain"
+        return self.query(url_path)
+
+    def tokens(self) -> List[str]:
+        """Get supported tokens
+
+        `GET /v1/defillama/token`
+
+        <https://docs.neverest.finance/defillama/token>
+
+        Returns:
+            List of supported tokens
+        """
+        url_path = "/v1/defillama/token"
+        return self.query(url_path)
+
+    def pools(self) -> List[str]:
+        """Get supported pools
+
+        `GET /v1/defillama/pool`
+
+        <https://docs.neverest.finance/defillama/pool>
+
+        Returns:
+            List of supported pools
+        """
+        url_path = "/v1/defillama/pool"
+        return self.query(url_path)
+
+    def stablecoins(self) -> List[str]:
+        """Get supported stablecoins
+
+        `GET /v1/defillama/stablecoin`
+
+        <https://docs.neverest.finance/defillama/stablecoin>
+
+        Returns:
+            List of supported stablecoins
+        """
+        url_path = "/v1/defillama/stablecoin"
+        return self.query(url_path)
+
+    @postprocess()
+    def tvl(self, pandas: bool = True) -> Union[List, pd.DataFrame]:
+        """Get total TVL across all chains and protocols
+
+        `GET /v1/defillama/tvl`
+
+        <https://docs.neverest.finance/defillama/tvl>
+
+        Args:
+            pandas (bool): Return data as pandas DataFrame
+
+        Returns:
+            Timeseries of total TVL
+        """
+        url_path = "/v1/defillama/tvl"
+        return self.query(url_path)
+
+    @postprocess()
+    def protocol_tvl(
+        self, protocols: Union[str, List[str]] = None, pandas: bool = True
+    ) -> Union[List, pd.DataFrame]:
+        """Get TVL for given protocols
+
+        `GET /v1/defillama/tvl`
+
+        <https://docs.neverest.finance/defillama/tvl>
+
+        Args:
+            protocols (Union[str, List[str]]): single protocol or multiple protocol names
+            pandas (bool): Return data as pandas DataFrame
+
+        Returns:
+            Timeseries of protocol TVLs
+        """
+        protocols = make_list(protocols)
+        check_required_parameter_list(protocols, "protocols")
+        params = {"protocols": encode_string_list(protocols)}
+        return self.query("/v1/defillama/tvl", params)
+
+    @postprocess()
+    def chain_tvl(
+        self, chains: Union[str, List[str]] = None, pandas: bool = True
+    ) -> Union[List, pd.DataFrame]:
+        """Get TVL for given chains
+
+        `GET /v1/defillama/tvl`
+
+        <https://docs.neverest.finance/defillama/tvl>
+
+        Args:
+            chains (Union[str, List[str]]): single chain or multiple chain names
+            pandas (bool): Return data as pandas DataFrame
+
+        Returns:
+            Timeseries of chain TVLs
+        """
+        chains = make_list(chains)
+        check_required_parameter_list(chains, "chains")
+        params = {"chains": encode_string_list(chains)}
+        return self.query("/v1/defillama/tvl", params)
+
+    @postprocess()
+    def protocol_chain_tvl(
+        self, protocol: str, chain: str, pandas: bool = True
+    ) -> Union[List, pd.DataFrame]:
+        """Get TVL for given protocol and chain
+
+        `GET /v1/defillama/tvl`
+
+        <https://docs.neverest.finance/defillama/tvl>
+
+        Args:
+            protocol (str): protocol name
+            chain (str): chain name
+            pandas (bool): Return data as pandas DataFrame
+
+        Returns:
+            Timeseries of protocol TVL on a given chain
+        """
+        check_required_parameters([[protocol, "protocol"], [chain, "chain"]])
+        params = {"chain": chain, "protocol": protocol}
+        return self.query("/v1/defillama/tvl", params)
+
+    @postprocess(num_index=2)
+    def protocol_token_tvl(
+        self, protocol: str, usd: bool = True, pandas: bool = True
+    ) -> Union[List, pd.DataFrame]:
+        """Get token TVL on a given protocol
+
+        `GET /v1/defillama/tvl`
+
+        <https://docs.neverest.finance/defillama/tvl>
+
+        Args:
+            protocol (str): protocol name
+            usd (bool): Convert to USD otherwise return token amount
+            pandas (bool): Return data as pandas DataFrame
+
+        Returns:
+            Timeseries of token TVL for a given protocol
+        """
+        check_required_parameters([[protocol, "protocol"], [usd, "usd"]])
+        params = {
+            "protocol": protocol,
+            "token": "true",
+            "usd": str(usd).lower(),
+        }
+        return self.query("/v1/defillama/tvl", params)
+
+    @postprocess(num_index=2)
+    def protocol_chain_token_tvl(
+        self, protocol: str, chain: str, usd: bool = True, pandas: bool = True
+    ) -> Union[List, pd.DataFrame]:
+        """Get token TVL on a given protocol and chain
+
+        `GET /v1/defillama/tvl`
+
+        <https://docs.neverest.finance/defillama/tvl>
+
+        Args:
+            protocol (str): protocol name
+            chain (str): chain name
+            usd (bool): Convert to USD otherwise return token amount
+            pandas (bool): Return data as pandas DataFrame
+
+        Returns:
+            Timeseries of token TVL for a given protocol and chain
+        """
+        check_required_parameters(
+            [[protocol, "protocol"], [chain, "chain"], [usd, "usd"]]
+        )
+        params = {
+            "protocol": protocol,
+            "chain": chain,
+            "token": "true",
+            "usd": str(usd).lower(),
+        }
+        return self.query("/v1/defillama/tvl", params)
+
+    @postprocess()
+    def protocol_mcap(
+        self, protocols: Union[str, List[str]] = None, pandas: bool = True
+    ) -> Union[List, pd.DataFrame]:
+        """Get market cap for given protocols
+
+        `GET /v1/defillama/mcap`
+
+        <https://docs.neverest.finance/defillama/mcap>
+
+        Args:
+            protocols (Union[str, List[str]]): single protocol or multiple protocol names
+            pandas (bool): Return data as pandas DataFrame
+
+        Returns:
+            Timeseries of market cap for given protocols
+        """
+        protocols = make_list(protocols)
+        check_required_parameter_list(protocols, "protocols")
+        params = {
+            "protocols": encode_string_list(protocols),
+        }
+        return self.query("/v1/defillama/mcap", params)
+
+    @postprocess()
+    def token_price(
+        self, addresses: Union[str, List[str]] = None, pandas: bool = True
+    ) -> Union[List, pd.DataFrame]:
+        """Get token prices
+
+        `GET /v1/defillama/token`
+
+        <https://docs.neverest.finance/defillama/token-price>
+
+        Args:
+            addresses (Union[str, List[str]]): single address or multiple addresses
+            pandas (bool): Return data as pandas DataFrame
+
+        Returns:
+            Timeseries of token prices
+        """
+        addresses = make_list(addresses)
+        check_required_parameter_list(addresses, "addresses")
+        params = {
+            "addresses": encode_string_list(addresses),
+        }
+        return self.query("/v1/defillama/token", params)
+
+    # def yields(self, pools: Union[str, List[str]]=None) -> pd.DataFrame:
+    #     pools = make_list(pools)
+    #     check_required_parameter_list(pools, "pools")
+    #     params = {
+    #         "poolIds": encode_string_list(pools),
+    #     }
+    #     return self.query("/v1/defillama/yield", params)
+
+    @postprocess()
+    def stablecoin_mcap(
+        self, stablecoin: str = None, pandas: bool = True
+    ) -> Union[List, pd.DataFrame]:
+        """Get market cap for given stablecoin
+
+        `GET /v1/defillama/stablecoin`
+
+        <https://docs.neverest.finance/defillama/stablecoin-mcap>
+
+        Args:
+            stablecoin (str): stablecoin name
+            pandas (bool): Return data as pandas DataFrame
+
+        Returns:
+            Timeseries of market cap for given stablecoin
+        """
+        check_required_parameter_list(stablecoin, "stablecoin")
+        params = {
+            "stablecoin": stablecoin,
+        }
+        return self.query("/v1/defillama/stablecoin", params)
+
+    @postprocess()
+    def stablecoin_chain_mcap(
+        self, stablecoin: str, chain: str, pandas: bool = True
+    ) -> Union[List, pd.DataFrame]:
+        """Get market cap for a given stablecoin on a specific chain
+
+        `GET /v1/defillama/stablecoin`
+
+        <https://docs.neverest.finance/defillama/stablecoin-mcap>
+
+        Args:
+            stablecoin (str): stablecoin name
+            chain (str): chain name
+            pandas (bool): Return data as pandas DataFrame
+
+        Returns:
+            Timeseries of market cap for given stablecoin on a specific chain
+        """
+        check_required_parameters([[stablecoin, "stablecoin"], [chain, "chain"]])
+        params = {
+            "stablecoin": stablecoin,
+            "chain": chain,
+        }
+        return self.query("/v1/defillama/stablecoin", params)
+
+    @postprocess()
+    def stablecoin_price(
+        self, stablecoins: Union[str, List[str]] = None, pandas: bool = True
+    ) -> Union[List, pd.DataFrame]:
+        """Get price for given stablecoins
+
+        `GET /v1/defillama/stablecoin/price`
+
+        <https://docs.neverest.finance/defillama/stablecoin-price>
+
+        Args:
+            stablecoins (Union[str, List[str]]): single stablecoin or multiple stablecoin names
+            pandas (bool): Return data as pandas DataFrame
+
+        Returns:
+            Timeseries of stablecoin prices
+        """
+        stablecoins = make_list(stablecoins)
+        check_required_parameter_list(stablecoins, "stablecoins")
+        params = {
+            "stablecoins": encode_string_list(stablecoins),
+        }
+        return self.query("/v1/defillama/stablecoin/price", params)
+
+    @postprocess()
+    def fee(
+        self,
+        protocols: Union[str, List[str]] = None,
+        chains: Union[str, List[str]] = None,
+        daily: bool = True,
+        pandas: bool = True,
+    ) -> Union[List, pd.DataFrame]:
+        """Get fee for given protocols or chains
+
+        `GET /v1/defillama/fee`
+
+        <https://docs.neverest.finance/defillama/fee>
+
+        Args:
+            protocols (Union[str, List[str]]): single protocol or multiple protocol names
+            chains (Union[str, List[str]]): single chain or multiple chain names
+            daily (bool): daily fee or total fee
+            pandas (bool): Return data as pandas DataFrame
+
+        Returns:
+            Timeseries of protocol or fees
+        """
+        check_required_parameter(daily, "daily")
+        params = {
+            "daily": str(daily).lower(),
+        }
+
+        if not ((protocols is None) ^ (chains is None)):
+            raise ValueError("Either protocols or chains should be provided")
+
+        if protocols is not None:
+            protocols = make_list(protocols)
+            check_required_parameter_list(protocols, "protocols")
+            params["protocols"] = encode_string_list(protocols)
+        elif chains is not None:
+            chains = make_list(chains)
+            check_required_parameter_list(chains, "chains")
+            params["chains"] = encode_string_list(chains)
+
+        return self.query("/v1/defillama/fee", params)
+
+    @postprocess()
+    def revenue(
+        self,
+        protocols: Union[str, List[str]] = None,
+        chains: Union[str, List[str]] = None,
+        daily: bool = True,
+        pandas: bool = True,
+    ) -> Union[List, pd.DataFrame]:
+        """Get revenue for given protocols or chains
+
+        `GET /v1/defillama/revenue`
+
+        <https://docs.neverest.finance/defillama/revenue>
+
+        Args:
+            protocols (Union[str, List[str]]): single protocol or multiple protocol names
+            chains (Union[str, List[str]]): single chain or multiple chain names
+            daily (bool): daily revenue or total revenue
+            pandas (bool): Return data as pandas DataFrame
+
+        Returns:
+            Timeseries of protocol or chain revenues
+        """
+        check_required_parameter(daily, "daily")
+        params = {
+            "daily": str(daily).lower(),
+        }
+
+        if not ((protocols is None) ^ (chains is None)):
+            raise ValueError("Either protocols or chains should be provided")
+
+        if protocols is not None:
+            protocols = make_list(protocols)
+            check_required_parameter_list(protocols, "protocols")
+            params["protocols"] = encode_string_list(protocols)
+        elif chains is not None:
+            chains = make_list(chains)
+            check_required_parameter_list(chains, "chains")
+            params["chains"] = encode_string_list(chains)
+
+        return self.query("/v1/defillama/revenue", params)
+
+    @postprocess(num_index=4)
+    def fee_detail(
+        self, protocol: str, chain: str = None, daily: bool = True, pandas: bool = True
+    ) -> Union[List, pd.DataFrame]:
+        """Get fee detail for given protocol and chain
+
+        `GET /v1/defillama/fee/detail`
+
+        <https://docs.neverest.finance/defillama/fee-detail>
+
+        Args:
+            protocol (str): protocol name
+            chain (str): chain name (optional)
+            daily (bool): daily fee or total fee
+            pandas (bool): Return data as pandas DataFrame
+
+        Returns:
+            Timeseries of fee detail for a given protocol and chain
+        """
+        check_required_parameters([[protocol, "protocol"], [daily, "daily"]])
+        params = {
+            "protocol": protocol,
+            "daily": str(daily).lower(),
+        }
+        if chain is not None:
+            params["chain"] = chain
+
+        return self.query("/v1/defillama/fee/detail", params)
+
+    @postprocess(num_index=4)
+    def revenue_detail(
+        self, protocol: str, chain: str = None, daily: bool = True, pandas: bool = True
+    ) -> Union[List, pd.DataFrame]:
+        """Get revenue detail for given protocol and chain
+
+        `GET /v1/defillama/revenue/detail`
+
+        <https://docs.neverest.finance/defillama/revenue-detail>
+
+        Args:
+            protocol (str): protocol name
+            chain (str): chain name (optional)
+            daily (bool): daily revenue or total revenue
+            pandas (bool): Return data as pandas DataFrame
+
+        Returns:
+            Timeseries of revenue detail for a given protocol and chain
+        """
+        check_required_parameters([[protocol, "protocol"], [daily, "daily"]])
+        params = {
+            "protocol": protocol,
+            "daily": str(daily).lower(),
+        }
+        if chain is not None:
+            params["chain"] = chain
+
+        return self.query("/v1/defillama/revenue/detail", params)

datamaxi/error.py

@@ -0,0 +1,30 @@
+class Error(Exception):
+    pass
+
+
+class ClientError(Error):
+    def __init__(self, status_code, error_code, error_message, header, error_data=None):
+        # https status code
+        self.status_code = status_code
+        # error code returned from server
+        self.error_code = error_code
+        # error message returned from server
+        self.error_message = error_message
+        # the whole response header returned from server
+        self.header = header
+        # return data if it's returned from server
+        self.error_data = error_data
+
+
+class ServerError(Error):
+    def __init__(self, status_code, message):
+        self.status_code = status_code
+        self.message = message
+
+
+class ParameterRequiredError(Error):
+    def __init__(self, params):
+        self.params = params
+
+    def __str__(self):
+        return "%s is mandatory, but received empty." % (", ".join(self.params))

datamaxi/google/__init__.py

@@ -0,0 +1,53 @@
+from typing import Any, List, Union
+import pandas as pd
+from datamaxi.api import API
+from datamaxi.lib.utils import check_required_parameter
+from datamaxi.lib.utils import postprocess
+from datamaxi.lib.constants import BASE_URL
+
+
+class Google(API):
+    """Client to fetch Google trend data from DataMaxi+ API."""
+
+    def __init__(self, api_key=None, **kwargs: Any):
+        """Initialize the object.
+
+        Args:
+            api_key (str): The DataMaxi+ API key
+            **kwargs: Keyword arguments used by `datamaxi.api.API`.
+        """
+        if "base_url" not in kwargs:
+            kwargs["base_url"] = BASE_URL
+            super().__init__(api_key, **kwargs)
+
+    def keywords(self) -> List[str]:
+        """Get Google trend supported keywords
+
+        `GET /v1/google/keywords`
+
+        <https://docs.datamaxi.finance/google/keywords>
+
+        Returns:
+            List of supported Google trend keywords
+        """
+        url_path = "/v1/google/keywords"
+        return self.query(url_path)
+
+    @postprocess()
+    def trend(self, keyword: str, pandas: bool = True) -> Union[List, pd.DataFrame]:
+        """Get Google trend for given keyword
+
+        `GET /v1/google/trend`
+
+        <https://docs.datamaxi.finance/google/trend>
+
+        Args:
+            keyword (str): keyword to search for
+            pandas (bool): Return data as pandas DataFrame
+
+        Returns:
+            Google trend data
+        """
+        check_required_parameter(keyword, "keyword")
+        params = {"keyword": keyword}
+        return self.query("/v1/google/trend", params)

datamaxi/lib/constants.py

@@ -0,0 +1 @@
+BASE_URL = "http://api.neverest.finance"

datamaxi/lib/utils.py

@@ -0,0 +1,109 @@
+from typing import List
+from urllib.parse import urlencode
+import pandas as pd
+from functools import wraps
+from datamaxi.error import ParameterRequiredError
+
+
+def to_float(x):
+    return float(x)
+
+
+def to_int(x):
+    return int(x)
+
+
+def cleanNoneValue(d) -> dict:
+    out = {}
+    for k in d.keys():
+        if d[k] is not None:
+            out[k] = d[k]
+    return out
+
+
+def check_required_parameter(value, name: str):
+    if not value and value != 0:
+        raise ParameterRequiredError([name])
+
+
+def check_required_parameters(params):
+    """Validate multiple parameters
+    params = [
+        ['btcusdt', 'symbol'],
+        [10, 'price']
+    ]
+
+    """
+    for p in params:
+        check_required_parameter(p[0], p[1])
+
+
+def check_required_parameter_list(values: List, name: str):
+    if len(values) == 0:
+        raise ParameterRequiredError([name])
+
+    for value in values:
+        check_required_parameter(value, name)
+
+
+def encode_string_list(L: List):
+    return "[" + ",".join(f'"{i}"' for i in L) + "]"
+
+
+def encoded_string(query):
+    return urlencode(query, True).replace("%40", "@")
+
+
+def convert_to_df(data, header: bool, index: str = None, apply_fn={}):
+    df = pd.DataFrame(data)
+
+    if header:
+        new_header = df.iloc[0]
+        df = df[1:]
+        df.columns = new_header
+
+    if index is not None:
+        df = df.set_index(index)
+
+    for idx, fn in apply_fn.items():
+        if isinstance(idx, str):
+            df[idx] = df[idx].apply(fn)
+        else:
+            df[df.columns[idx]] = df[df.columns[idx]].apply(fn)
+
+    return df
+
+
+def make_list(value):
+    if not isinstance(value, list):
+        value = [value]
+    return value
+
+
+def _postprocess(data, index):
+    apply_fn = {}
+    for idx in range(len(data[0]) - len(index)):
+        apply_fn[idx] = to_float
+
+    return convert_to_df(data, header=True, index=index, apply_fn=apply_fn)
+
+
+def postprocess(num_index: int = 1):
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*arg, **kwarg):
+            res = func(*arg, **kwarg)
+
+            if not kwarg.get("pandas", True):
+                return res
+
+            if isinstance(res, dict):
+                res["data"] = _postprocess(res["data"], res["data"][0][:num_index])
+            else:
+                res = _postprocess(res, res[0][:num_index])
+
+            return res
+
+        return wrapper
+
+    return decorator

datamaxi/naver/__init__.py

@@ -0,0 +1,53 @@
+from typing import Any, List, Union
+import pandas as pd
+from datamaxi.api import API
+from datamaxi.lib.utils import check_required_parameter
+from datamaxi.lib.constants import BASE_URL
+from datamaxi.lib.utils import postprocess
+
+
+class Naver(API):
+    """Client to fetch Naver trend data from DataMaxi+ API."""
+
+    def __init__(self, api_key=None, **kwargs: Any):
+        """Initialize the object.
+
+        Args:
+            api_key (str): The DataMaxi+ API key
+            **kwargs: Keyword arguments used by `datamaxi.api.API`.
+        """
+        if "base_url" not in kwargs:
+            kwargs["base_url"] = BASE_URL
+            super().__init__(api_key, **kwargs)
+
+    def keywords(self) -> List[str]:
+        """Get Naver trend supported keywords
+
+        `GET /v1/naver/keywords`
+
+        <https://docs.datamaxi.finance/naver/keywords>
+
+        Returns:
+            List of supported Naver trend keywords
+        """
+        url_path = "/v1/naver/keywords"
+        return self.query(url_path)
+
+    @postprocess()
+    def trend(self, keyword: str, pandas: bool = True) -> Union[List, pd.DataFrame]:
+        """Get Naver trend for given keyword
+
+        `GET /v1/naver/trend`
+
+        <https://docs.neverest.finance/naver/trend>
+
+        Args:
+            keyword (str): keyword to search for
+            pandas (bool): Return data as pandas DataFrame
+
+        Returns:
+            Naver trend data
+        """
+        check_required_parameter(keyword, "keyword")
+        params = {"keyword": keyword}
+        return self.query("/v1/naver/trend", params)

datamaxi-0.1.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Bisonai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

datamaxi-0.1.0.dist-info/METADATA

@@ -0,0 +1,127 @@
+Metadata-Version: 2.1
+Name: datamaxi
+Version: 0.1.0
+Summary: Official Python client for DataMaxi+ API
+Author-email: Bisonai <business@bisonai.com>
+Project-URL: Homepage, https://github.com/bisonai/datamaxi-python
+Project-URL: Issues, https://github.com/bisonai/datamaxi-python/issues
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests >=2.31.0
+Requires-Dist: pandas
+
+# DataMaxi+ Python Client
+[![PyPI version](https://img.shields.io/pypi/v/datamaxi)](https://pypi.python.org/pypi/datamaxi)
+[![Python version](https://img.shields.io/pypi/pyversions/datamaxi)](https://www.python.org/downloads/)
+[![Documentation](https://img.shields.io/badge/docs-latest-blue)](https://datamaxi.readthedocs.io/en/stable/)
+[![Code Style](https://img.shields.io/badge/code_style-black-black)](https://black.readthedocs.io/en/stable/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+This is the official implementation of Python client for DataMaxi+ API.
+The package can be used to fetch both historical and latest data using [DataMaxi+ API](https://docs.neverest.finance/).
+This package is compatible with Python v3.8+.
+
+* [Installation](#installation)
+* [Configuration](#configuration)
+  * [Environment Variables](#environment-variables)
+* [Quickstart](#quickstart)
+* [Local Development](#local-development)
+  * [Setup](#setup)
+  * [Testing](#testing)
+* [Links](#links)
+* [Contributing](#contributing)
+* [License](#license)
+
+## Installation
+
+```shell
+pip install datamaxi
+```
+
+## Configuration
+
+Access to DataMaxi+ is protected by API Key.
+If you are interested to try DataMaxi+, you can request your API key at [business@bisonai.com](mailto:business@bisonai.com).
+
+| Option             | Explanation                                                                           |
+|--------------------|---------------------------------------------------------------------------------------|
+| `api_key`          | Your API key                                                                          |
+| `base_url`         | If `base_url` is not provided, it defaults to `api.neverest.finance`.                 |
+| `timeout`          | Number of seconds to wait for a server response. By default requests do not time out. |
+| `proxies`          | Proxy through which the request is queried                                            |
+| `show_limit_usage` | Return response as dictionary including including `"limit_usage"` and `"data"` keys   |
+| `show_header`      | Return response as dictionary including including `"header"` and `"data"` keys        |
+
+### Environment Variables
+
+You may use environment variables to configure the DataMaxi+ client to avoid any inline boilerplate.
+
+| Env                | Description                                  |
+|--------------------|----------------------------------------------|
+| `NEVEREST_API_KEY` | Used instead of `api_key` if none is passed. |
+
+## Quickstart
+
+DataMaxi+ Python package currently includes the following clients:
+
+* `Binance`
+* `Defillama`
+* `Naver`
+* `Google`
+
+All clients accept the same parameters that are described at [Configuration](#configuration) section.
+First, import the clients,
+
+```python
+from datamaxi.binance import Binance
+from datamaxi.defillama import Defillama
+from datamaxi.naver import Naver
+from datamaxi.google import Google
+```
+
+and initialize them.
+
+```python
+binance = Binance(api_key=api_key)
+defillama = Defillama(api_key=api_key)
+naver = Naver(api_key=api_key)
+google = Google(api_key=api_key)
+```
+
+## Local Development
+
+### Setup
+
+If you wish to work on local development please clone/fork the git repo and use `pip install -r requirements.txt` to setup the project.
+
+### Testing
+
+```shell
+# In case packages are not installed yet
+pip install -r requirements/requirements-test.txt
+
+python -m pytest tests/
+```
+
+## Links
+
+* [DataMaxi+](https://datamaxiplus.com/)
+* [DataMaxi+ API](https://api.neverest.finance/)
+* [DataMaxi+ API Documentation](https://docs.neverest.finance/)
+
+## Contributing
+
+We welcome contributions!
+If you discover a bug in this project, please feel free to open an issue to discuss the changes you would like to propose.
+
+## License
+
+[MIT License](LICENSE)

datamaxi-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+datamaxi/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datamaxi/__version__.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+datamaxi/api.py,sha256=GDqbaPpseouOAdC3d94kuRSXIdWiPUnZE4-_hKOKrCk,4549
+datamaxi/error.py,sha256=b6HanzbJGnJdjmVxsj-Tx0S2g6qmrPnwOzQVLJapXz0,907
+datamaxi/binance/__init__.py,sha256=ZLKtIwpMm-4R9edQ2wfatuA1j0vfcDuPenqJQi6Obvo,1749
+datamaxi/defillama/__init__.py,sha256=MckStB_FFRrn4wsCETbmZSMChCHpoLjD0lcj4iTzjsM,15894
+datamaxi/google/__init__.py,sha256=Ub5LzCykc0FkOFqc490Ebr688eoMQG_gmzuJJJqsgJk,1573
+datamaxi/lib/constants.py,sha256=M_rPOUd8vhCyCqU5hEynA9JqwTaRqJTwwEhvn2Dc3Vg,41
+datamaxi/lib/utils.py,sha256=qvN_NjUXUiOzGAkxpvuzgEyhV6IpH9hDqv1AZpWTgHA,2379
+datamaxi/naver/__init__.py,sha256=qoHOjBNZONlC4OLI-WDuGRCmQzrSScL0ILLLYv0nNRM,1561
+datamaxi-0.1.0.dist-info/LICENSE,sha256=1J0wkcNPh72_zZZ3QLCIdpWQ8-qyV3z0GBLhWwRpFsU,1064
+datamaxi-0.1.0.dist-info/METADATA,sha256=ucW1ed_84gOcyurvvVJ3HAib2zGMoLNis7bqjYhHfZ4,4635
+datamaxi-0.1.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+datamaxi-0.1.0.dist-info/top_level.txt,sha256=tUTuDxSB4RdO2TFQk3HpdrlnS6oi6KCz_LJTgzp-JoE,9
+datamaxi-0.1.0.dist-info/RECORD,,

datamaxi-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.43.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

datamaxi-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+datamaxi