bigdata-corp-api 0.16__tar.gz

bigdata_corp_api-0.16/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2023, Murabei Data Science
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

bigdata_corp_api-0.16/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: bigdata-corp-api
+Version: 0.16
+Summary: Python API to facilitate interaction with BigDataCorp end-points
+License: BSD-3-Clause License
+License-File: LICENSE
+Author: André Andrade Baceti
+Author-email: a.baceti@murabei.com
+Requires-Python: >=3.6
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Dist: requests
+Description-Content-Type: text/markdown
+
+# bigdata-corp-api
+Python API to facilitate interaction with BigDataCorp end-points
+

bigdata_corp_api-0.16/README.md

@@ -0,0 +1,2 @@
+# bigdata-corp-api
+Python API to facilitate interaction with BigDataCorp end-points

bigdata_corp_api-0.16/pyproject.toml

@@ -0,0 +1,72 @@
+[project]
+name = "bigdata-corp-api"
+version = "0.16"
+description = "Python API to facilitate interaction with BigDataCorp end-points"
+readme = "README.md"
+requires-python = ">=3.6"
+license = { text = "BSD-3-Clause License" }
+authors = [
+    {name = "André Andrade Baceti", email = "a.baceti@murabei.com"}
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "requests"
+]
+
+[tool.poetry]
+packages = [{include = "bigdatacorp_api", from = "src"}]
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.ruff]
+line-length = 79 # Quantidade de caracteres que o linter irá considerar na linha
+indent-width = 4
+
+# Pastas onde o linter não atuara. Por padrão ele só lê arquivos python e ignora tudo dentro do .gitignore
+exclude = [
+  "secrets/",
+  "__init__.py",
+  "setup_template.py",
+  "setup.py"
+]
+
+# Lista de linters que serão aplicados. o ruff da suporte a vários e eles podem ser adicionados aqui.
+[tool.ruff.lint]
+select = [
+    "F", # Pyflakes - Procura bugs básicos no codigo
+    "E", # pycodestyle - Pep8
+    "W", # pycodestyle - Pep8
+    "D", # pydocstyle - Docstring
+    "I", # Isort - Imports
+    "PD", # pandas-vet - linter de pandas (não deixa usar inplace nem df como nome de variavel)
+    "N", # pep8-naming - nomes seguindo pep8
+    "S", # flake8-bandit - linter de vulnerabilidade (nmao deixa usar assert)
+]
+
+# Os códigos de erros colocados aqui são ignorados pelo linter. O erro abaixo é em relação ao assert. Está comentado por padrão.
+ignore = [
+  # "S101" # Use of `assert` detected
+  "E402", "N806", "I001"
+]
+
+# ativa um modo plus do ruff
+preview = true
+
+[tool.ruff.format]
+indent-style = "space"
+
+[tool.ruff.lint.pydocstyle]
+convention = "google" # seleciona as docstrings do google como padrão
+
+[tool.ruff.lint.isort]
+no-sections = true
+
+[dependency-groups]
+docs = [
+    "mkdocs (>=1.6.1,<2.0.0)"
+]

bigdata_corp_api-0.16/src/bigdatacorp_api/data.py

@@ -0,0 +1,734 @@
+"""BigDataCorp Python API."""
+import os
+import time
+import json
+import time
+import datetime
+import requests
+from bigdatacorp_api.exceptions import (
+    BigDataCorpAPIException, BigDataCorpAPIInvalidDocumentException,
+    BigDataCorpAPIMinorDocumentException,
+    BigDataCorpAPIInvalidDatabaseException,
+    BigDataCorpAPIMaxRetryException,
+    BigDataCorpAPIInvalidInputException,
+    BigDataCorpAPILoginProblemException,
+    BigDataCorpAPIProblemAPIException,
+    BigDataCorpAPIOnDemandQueriesException,
+    BigDataCorpAPIMonitoringAPIException,
+    BigDataCorpAPIUnmappedErrorException,
+    BigDataCorpAPIEmptyEnrichedProcessException)
+
+
+class BigDataCorpAPI:
+    CPF_DATABASES = [
+        "government_debtors",
+        "election_candidate_data",
+        "circles_college_class",
+        "circles_coworkers",
+        "circles_household",
+        "circles_relatives",
+        "circles_lawsuit_parties",
+        "circles_partners",
+        "circles_neighbors",
+        "circles_building",
+        "basic_data",
+        "occupation_data",
+        "electoral_donors",
+        "related_people_emails",
+        "addresses_extended",
+        "related_people_addresses",
+        "media_profile_and_exposure",
+        "company_group_employed",
+        "company_group_family_ownership",
+        "company_group_sued",
+        "company_group_ownership",
+        "historical_basic_data",
+        "financial_data",
+        "demographic_data",
+        "licenses_and_authorizations",
+        "life_stages",
+        "collections",
+        "electoral_providers",
+        "indebtedness_question",
+        "processes",
+        "first_level_relatives_lawsuit_data",
+        "business_relationships",
+        "related_people",
+        "phones_extended",
+        "related_people_phones",
+        "vehicles",
+        "registration_data"]
+
+    CNPJ_DATABASES = [
+        "partner_murabei_credit_score_company",
+        "government_debtors",
+        "syndicate_agreements",
+        "investment_fund_data",
+        'electoral_donors',
+        'owners_electoral_donors',
+        'company_evolution',
+        'activity_indicators',
+        'interests_and_behaviors',
+        'licenses_and_authorizations',
+        "financial_market",
+        'electoral_providers',
+        'industrial_property',
+        'employees_industrial_property',
+        'owners_industrial_property',
+        'domains',
+        'domains_extended',
+        'emails_extended',
+        'related_people_emails',
+        'addresses_extended',
+        'related_people_addresses',
+        'phones_extended',
+        'related_people_phones',
+        'basic_data',
+        'history_basic_data',
+        'media_profile_and_exposure',
+        'kyc_dtec_flex_news',
+        'kyc',
+        'economic_group_kyc',
+        'employees_kyc',
+        'owners_kyc',
+        'online_ads',
+        'marketplace_data',
+        'apps_networks_and_platforms',
+        'collections',
+        'owners_lawsuits',
+        'processes',
+        'reputations_and_reviews',
+        "social_conscience",
+        "awards_and_certifications",
+        'circles_employees',
+        'circles_legal_representatives',
+        'circles_first_level_owners',
+        'economic_group_full_extended',
+        'economic_group_first_level_extended',
+        'economic_group_second_level_extended',
+        'economic_group_third_level_extended',
+        'company_group_household_activity',
+        'company_group_rfcontact',
+        'company_group_household',
+        'company_group_tradename',
+        'company_group_tradename_city',
+        'company_group_building',
+        'company_group_documentroot',
+        'company_group_officialname',
+        'company_group_legal_representative',
+        'company_group_owners',
+        'company_group_household_owners_surname',
+        'relationships',
+        'economic_group_relationships',
+        "registration_data"]
+
+    MARKETPLACE_DATABASES = [
+        "partner_murabei_credit_score_company"
+    ]
+
+    PROCESS_DATABASES = [
+        'basic_data',
+        'cade_processes_data'
+    ]
+
+    def __init__(self, bigdata_auth_token: str):
+        """
+        __init__.
+
+        Args:
+            bigdata_auth_token [str]: Authentication token for BigData API.
+        """
+        self._bigdata_auth_token = bigdata_auth_token
+
+    def list_cpf_dataset(self) -> list:
+        """
+        Return avaiable BigData CPF Datasets.
+
+        Args:
+            No Args
+        Kwargs:
+            No Kwargs
+        Return:
+            Return a list with avaiable datasets.
+        """
+        return self.CPF_DATABASES
+
+    def list_cnpj_dataset(self) -> list:
+        """
+        Return avaiable BigData CNPJ Datasets.
+
+        Args:
+            No Args
+        Kwargs:
+            No Kwargs
+        Return:
+            Return a list with avaiable datasets.
+        """
+        return self.CNPJ_DATABASES
+
+    def list_process_dataset(self) -> list:
+        """
+        Return avaiable BigData process Datasets.
+
+        Args:
+            No Args
+        Kwargs:
+            No Kwargs
+        Return:
+            Return a list with avaiable datasets.
+        """
+        return self.PROCESS_DATABASES
+
+    def get_cpf_dataset(self, cpf: str, dataset: str) -> dict:
+        """
+        Call BigData API to fecth a database for a CPF.
+
+        Retry for 5 times sleeping 1 second when errors are raised.
+
+        Args:
+            cpf [str]: Person's CPF.
+            dataset [str]: Dataset on BigData that user should be fetched.
+        Return [dict]:
+            Information avaiable on BigData.
+        Raise:
+            BigDataCorpAPIException: Raise if errors in API occour.
+        """
+        if dataset not in self.CPF_DATABASES:
+            msg = (
+                "dataset [{dataset}] not avaiable on bigboost for CPF, "
+                "avaiable datasets:\n{datasets}").format(
+                dataset=dataset, datasets=", ".join(self.CPF_DATABASES))
+            raise BigDataCorpAPIException(msg)
+
+        url = "https://bigboost.bigdatacorp.com.br/peoplev2"
+        payload = {
+            "Datasets": dataset,
+            "q": "doc{" + cpf + "}",
+            "Limit": 1}
+        headers = {
+            "accept": "application/json",
+            "content-type": "application/json",
+            "AccessToken": self._bigdata_auth_token}
+
+        error_msgs = []
+        for i in range(5):
+            try:
+                response = requests.post(url, json=payload, headers=headers)
+                response.raise_for_status()
+                response_json = response.json()
+                status_data = response_json['Status']
+
+                # Treat minor validation error
+                birth_validation = status_data.get('date_of_birth_validation')
+                if birth_validation is not None:
+                    raise BigDataCorpAPIMinorDocumentException(
+                        message="this cpf belongs to a minor",
+                        payload=birth_validation[0])
+
+                login_entry = status_data.get("login")
+                if login_entry is not None:
+                    login_return = login_entry[0]
+                    if login_return["Code"] == -101:
+                        msg = "BigBoost user has expired"
+                        raise BigDataCorpAPILoginProblemException(msg)
+
+                # Check if the CPF has a match
+                status = status_data[dataset][0]
+                if status['Code'] == 0:
+                    return response.json()
+
+                elif status['Code'] >= -202 and status['Code'] <= -100:
+                    raise BigDataCorpAPIInvalidInputException(
+                        message="error related to input data",
+                        payload={
+                            'bigdata_status': status,
+                            'cpf': cpf,
+                            'dataset': dataset})
+
+                elif status['Code'] >= -1002 and status['Code'] <= -1000:
+                    raise BigDataCorpAPILoginProblemException(
+                        message="error related to login problem",
+                        payload={
+                            'bigdata_status': status,
+                            'cpf': cpf,
+                            'dataset': dataset
+                        })
+                elif status['Code'] >= -2999 and status['Code'] <= -2000:
+                    raise BigDataCorpAPIProblemAPIException(
+                        message="error related to internal problems in APIs "
+                                "or services",
+                        payload={
+                            'bigdata_status': status,
+                            'cpf': cpf,
+                            'dataset': dataset
+                        })
+                elif status['Code'] >= -1999 and status['Code'] <= -1200:
+                    raise BigDataCorpAPIOnDemandQueriesException(
+                        message="error related to on-demand queries",
+                        payload={
+                            'bigdata_status': status,
+                            'cpf': cpf,
+                            'dataset': dataset
+                        })
+                elif status['Code'] <= -3000:
+                    raise BigDataCorpAPIMonitoringAPIException(
+                        message="error related to problems in the Monitoring "
+                                "API or Asynchronous Calls",
+                        payload={
+                            'bigdata_status': status,
+                            'cpf': cpf,
+                            'dataset': dataset
+                        })
+                else:
+                    raise BigDataCorpAPIUnmappedErrorException(
+                        message="unmapped error",
+                        payload={
+                            'bigdata_status': status,
+                            'cpf': cpf,
+                            'dataset': dataset
+                        })
+
+            # Raise if document is invalid
+            except BigDataCorpAPIException as e:
+                raise e
+
+            # Raise if document is invalid
+            except BigDataCorpAPILoginProblemException as e:
+                raise e
+
+            # Raise if document is from an under age (age < 18)
+            except BigDataCorpAPIMinorDocumentException as e:
+                raise e
+
+            except Exception as e:
+                error_msgs.append(str(e))
+                print("!!Error fetching BigData API:", str(e))
+
+        msg = (
+            "Untreated error on API with max 5 retries:{}\n".format(
+                "\n".join(error_msgs)))
+        raise BigDataCorpAPIMaxRetryException(
+            message=msg, payload={"errors": error_msgs})
+
+    def get_cnpj_dataset(self, cnpj: str, dataset: str) -> dict:
+        """
+        Call BigData API to fecth a database for a CNPJ.
+
+        Retry for 5 times sleeping 1 second when errors are raised.
+
+        Args:
+            cnpj [str]: Company CNPJ.
+            dataset [str]: Dataset on BigData that user should be fetched.
+        Return [dict]:
+            Information avaiable on BigData.
+        Raise:
+            BigDataCorpAPIException: Raise if errors in API occour.
+        """
+        if dataset not in self.CNPJ_DATABASES:
+            msg = (
+                "dataset [{dataset}] not avaiable on bigboost for CNPJ, "
+                "avaiable datasets:\n{datasets}").format(
+                dataset=dataset, datasets=", ".join(self.CNPJ_DATABASES))
+            raise BigDataCorpAPIException(msg)
+
+        if dataset in self.MARKETPLACE_DATABASES:
+            url = "https://plataforma.bigdatacorp.com.br/marketplace"
+        else:
+            url = "https://bigboost.bigdatacorp.com.br/companies"
+
+        payload = {
+            "Datasets": dataset,
+            "q": "doc{" + cnpj + "}",
+            "Limit": 1}
+        headers = {
+            "accept": "application/json",
+            "content-type": "application/json",
+            "AccessToken": self._bigdata_auth_token}
+
+        error_msgs = []
+        for i in range(5):
+            try:
+                response = requests.post(url, json=payload, headers=headers)
+                response.raise_for_status()
+                response_json = response.json()
+                status_data = response_json['Status']
+
+                login_entry = status_data.get("login")
+                if login_entry is not None:
+                    login_return = login_entry[0]
+                    if login_return["Code"] == -101:
+                        msg = "BigBoost user has expired"
+                        raise BigDataCorpAPILoginProblemException(msg)
+
+                # Check if the CNPJ has a match
+                status = status_data[dataset][0]
+                if status['Code'] == 0:
+                    return response.json()
+                elif status['Code'] >= -202 and status['Code'] <= -100:
+                    raise BigDataCorpAPIInvalidInputException(
+                        message="error related to input data",
+                        payload={
+                            'bigdata_status': status,
+                            'cnpj': cnpj,
+                            'dataset': dataset
+                        })
+                elif status['Code'] >= -1002 and status['Code'] <= -1000:
+                    raise BigDataCorpAPILoginProblemException(
+                        message="error related to login problem",
+                        payload={
+                            'bigdata_status': status,
+                            'cnpj': cnpj,
+                            'dataset': dataset
+                        })
+                elif status['Code'] >= -2999 and status['Code'] <= -2000:
+                    raise BigDataCorpAPIProblemAPIException(
+                        message="error related to internal problems in APIs "
+                                "or services",
+                        payload={
+                            'bigdata_status': status,
+                            'cnpj': cnpj,
+                            'dataset': dataset
+                        })
+                elif status['Code'] >= -1999 and status['Code'] <= -1200:
+                    raise BigDataCorpAPIOnDemandQueriesException(
+                        message="error related to on-demand queries",
+                        payload={
+                            'bigdata_status': status,
+                            'cnpj': cnpj,
+                            'dataset': dataset
+                        })
+                elif status['Code'] <= -3000:
+                    raise BigDataCorpAPIMonitoringAPIException(
+                        message="error related to problems in the Monitoring "
+                                "API or Asynchronous Calls",
+                        payload={
+                            'bigdata_status': status,
+                            'cnpj': cnpj,
+                            'dataset': dataset
+                        })
+                else:
+                    raise BigDataCorpAPIUnmappedErrorException(
+                        message="unmapped error",
+                        payload={
+                            'bigdata_status': status,
+                            'cnpj': cnpj,
+                            'dataset': dataset
+                        })
+
+            # Raise if document is invalid
+            except BigDataCorpAPIException as e:
+                raise e
+
+            except Exception as e:
+                error_msgs.append(str(e))
+                print("!!Error fetching BigData API:", str(e))
+
+        msg = (
+            "Untreated error on API with max 5 retries:{}\n".format(
+                "\n".join(error_msgs)))
+        raise BigDataCorpAPIMaxRetryException(
+            message=msg, payload={"errors": error_msgs})
+
+
+    def get_process_dataset(self, process: str, dataset: str) -> dict:
+        """Call BigData API to fecth a database for a process.
+
+        Retry for 5 times sleeping 1 second when errors are raised.
+
+        Args:
+            process [str]: process number.
+            dataset [str]: Dataset on BigData that user should be fetched.
+        Return [dict]:
+            Information avaiable on BigData.
+        Raise:
+            BigDataCorpAPIException: Raise if errors in API occour.
+        """
+        if dataset not in self.PROCESS_DATABASES:
+            msg = (
+                "dataset [{dataset}] not avaiable on bigboost for process, "
+                "avaiable datasets:\n{datasets}").format(
+                dataset=dataset, datasets=", ".join(self.PROCESS_DATABASES))
+            raise BigDataCorpAPIException(msg)
+
+        url = "https://plataforma.bigdatacorp.com.br/processos"
+
+        payload = {
+            "Datasets": dataset,
+            "q": "processnumber{" + process + "}",
+            "Limit": 1}
+        headers = {
+            "accept": "application/json",
+            "content-type": "application/json",
+            "AccessToken": self._bigdata_auth_token}
+
+        error_msgs = []
+        for i in range(5):
+            try:
+                response = requests.post(url, json=payload, headers=headers)
+                response.raise_for_status()
+                response_json = response.json()
+                status_data = response_json['Status']
+                result_data = response_json.\
+                    get('Result', [{}])[0].\
+                    get('BasicData', {})
+
+                login_entry = status_data.get("login")
+                if login_entry is not None:
+                    login_return = login_entry[0]
+                    if login_return["Code"] == -101:
+                        msg = "BigBoost user has expired"
+                        raise BigDataCorpAPILoginProblemException(msg)
+
+                # Check if the process has a match
+                status = status_data[dataset][0]
+                if status['Code'] == 0 and result_data:
+                    return response.json()
+                elif not result_data:
+                    raise BigDataCorpAPIEmptyEnrichedProcessException(
+                        message="no process data returned",
+                        payload={
+                            'bigdata_status': status,
+                            'process_number': process,
+                            'dataset': dataset
+                        })
+                elif status['Code'] >= -202 and status['Code'] <= -100:
+                    raise BigDataCorpAPIInvalidInputException(
+                        message="error related to input data",
+                        payload={
+                            'bigdata_status': status,
+                            'process_number': process,
+                            'dataset': dataset
+                        })
+                elif status['Code'] >= -1002 and status['Code'] <= -1000:
+                    raise BigDataCorpAPILoginProblemException(
+                        message="error related to login problem",
+                        payload={
+                            'bigdata_status': status,
+                            'process_number': process,
+                            'dataset': dataset
+                        })
+                elif status['Code'] >= -2999 and status['Code'] <= -2000:
+                    raise BigDataCorpAPIProblemAPIException(
+                        message="error related to internal problems in APIs "
+                                "or services",
+                        payload={
+                            'bigdata_status': status,
+                            'process_number': process,
+                            'dataset': dataset
+                        })
+                elif status['Code'] >= -1999 and status['Code'] <= -1200:
+                    raise BigDataCorpAPIOnDemandQueriesException(
+                        message="error related to on-demand queries",
+                        payload={
+                            'bigdata_status': status,
+                            'process_number': process,
+                            'dataset': dataset
+                        })
+                elif status['Code'] <= -3000:
+                    raise BigDataCorpAPIMonitoringAPIException(
+                        message="error related to problems in the Monitoring "
+                                "API or Asynchronous Calls",
+                        payload={
+                            'bigdata_status': status,
+                            'process_number': process,
+                            'dataset': dataset
+                        })
+                else:
+                    raise BigDataCorpAPIUnmappedErrorException(
+                        message="unmapped error",
+                        payload={
+                            'bigdata_status': status,
+                            'process_number': process,
+                            'dataset': dataset
+                        })
+
+            # Raise if document is invalid
+            except BigDataCorpAPIException as e:
+                raise e
+
+            except Exception as e:
+                error_msgs.append(str(e))
+                print("!!Error fetching BigData API:", str(e))
+
+        msg = (
+            "Untreated error on API with max 5 retries:{}\n".format(
+                "\n".join(error_msgs)))
+        raise BigDataCorpAPIMaxRetryException(
+            message=msg, payload={"errors": error_msgs})
+
+    def get_cpf_datasets(self, cpf: str, datasets: list,
+                         verbosity: bool = False) -> dict:
+        """
+        Fetch a list of datasets and return a dictionary with all info.
+
+        Args:
+            cpf [str]: Person's CPF.
+            datasets [list[str]]: List of all datasets to be fetched.
+        Kwargs:
+            verbosity [bool]: If set true will print a msg for each dataset
+                fetch.
+        Returns [dict]:
+            Return a dictionary with all dataset information, with keys
+            corresponding to dataset name.
+        """
+        response_dict = {}
+        for db in datasets:
+            if verbosity:
+                print("Fetching dataset:", db)
+            response_dict[db] = self.get_cpf_dataset(
+                cpf=cpf, dataset=db)
+        return response_dict
+
+    def get_cnpj_datasets(self, cnpj: str, datasets: list,
+                          verbosity: bool = False) -> dict:
+        """
+        Fetch a list of datasets and return a dictionary with all info.
+
+        Args:
+            cnpj [str]: Company cnpj.
+            datasets [list[str]]: List of all datasets to be fetched.
+        Kwargs:
+            verbosity [bool]: If set true will print a msg for each dataset
+                fetch.
+        Returns [dict]:
+            Return a dictionary with all dataset information, with keys
+            corresponding to dataset name.
+        """
+        cnpj = cnpj.replace(".", "").replace("/", "").replace("-", "")
+        response_dict = {}
+        for db in datasets:
+            if verbosity:
+                print("Fetching dataset:", db)
+            response_dict[db] = self.get_cnpj_dataset(
+                cnpj=cnpj, dataset=db)
+        return response_dict
+
+
+    def get_process_datasets(self, process: str, datasets: list,
+                             verbosity: bool = False) -> dict:
+        """Fetch a list of datasets and return a dictionary with all info.
+
+        Args:
+            process [str]: process number.
+            datasets [list[str]]: List of all datasets to be fetched.
+        Kwargs:
+            verbosity [bool]: If set true will print a msg for each dataset
+                fetch.
+        Returns [dict]:
+            Return a dictionary with all dataset information, with keys
+            corresponding to dataset name.
+        """
+        process = process.replace(".", "").replace("/", "").replace("-", "")
+        response_dict = {}
+        for db in datasets:
+            if verbosity:
+                print("Fetching dataset:", db)
+            response_dict[db] = self.get_process_dataset(
+                process=process, dataset=db)
+        return response_dict
+
+
+    def get_usage(self, initial_date: str, final_date: str):
+        """
+        Retrieves usage data for a specified date range.
+
+        Parameters:
+        - initial_date (str): The initial date of the range in the format
+            'yyyy-MM-dd'.
+        - final_date (str): The final date of the range in the format
+            'yyyy-MM-dd'.
+
+        Returns:
+        - results (list): A list of dictionaries containing the usage data for
+            each API and endpoint.
+          Each dictionary has the following keys:
+            - 'api_type' (str): The type of API ('people' or 'companies').
+            - 'end_point' (str): The endpoint of the API.
+            - 'successful_requests' (int): The total number of successful
+                requests made.
+            - 'requests_with_error' (int): The total number of requests
+                with errors.
+            - 'queries_charged' (int): The total number of queries charged.
+            - 'queries_not_charged' (int): The total number of queries
+                not charged.
+            - 'estimated_price' (float): The total estimated price
+                for the usage.
+
+        """
+        results = []
+        url = "https://plataforma.bigdatacorp.com.br/usage"
+
+        headers = {
+            "accept": "application/json",
+            "content-type": "application/json",
+            "AccessToken": self._bigdata_auth_token,
+        }
+
+        payload = {
+            "InitialReferenceDate": initial_date,
+            "FinalReferenceDate": final_date,
+            "DateFormat": "yyyy-MM-dd"
+        }
+
+        for api in self.CPF_DATABASES:
+            payload["Api"] = "people"
+            payload["Datasets"] = api
+            try:
+                response = requests.post(url, headers=headers, json=payload)
+                if response.status_code == 500:
+                    response.raise_for_status()
+
+                if response.status_code != 200:
+                    raise BigDataCorpAPIException(
+                        response.json()['Status']['Message'])
+
+                results.append({
+                    'api_type': "people",
+                    'end_point': api,
+                    "successful_requests": response.json()["UsageData"]
+                                            ["TotalSuccessfulRequests"],
+                    "requests_with_error": response.json()["UsageData"]
+                                            ["TotalRequestsWithError"],
+                    "queries_charged": response.json()["UsageData"]
+                                            ["TotalQueriesCharged"],
+                    "queries_not_charged": response.json()["UsageData"]
+                                            ["TotalQueriesNotCharged"],
+                    "estimated_price": response.json()["UsageData"]
+                                            ["TotalEstimatedPrice"],
+                })
+
+            except Exception as err:
+                print(err)
+
+        for api in self.CNPJ_DATABASES:
+            payload["Api"] = "companies"
+            payload["Datasets"] = api
+            try:
+                response = requests.post(url, headers=headers, json=payload)
+
+                if response.status_code == 500:
+                    response.raise_for_status()
+
+                if response.status_code != 200:
+                    raise BigDataCorpAPIException(
+                        response.json()['Status']['Message'])
+
+                results.append({
+                    'api_type': "companies",
+                    'end_point': api,
+                    "successful_requests": response.json()["UsageData"]
+                                            ["TotalSuccessfulRequests"],
+                    "requests_with_error": response.json()["UsageData"]
+                                            ["TotalRequestsWithError"],
+                    "queries_charged": response.json()["UsageData"]
+                                            ["TotalQueriesCharged"],
+                    "queries_not_charged": response.json()["UsageData"]
+                                            ["TotalQueriesNotCharged"],
+                    "estimated_price": response.json()["UsageData"]
+                                        ["TotalEstimatedPrice"],
+                })
+
+            except Exception as err:
+                print(err)
+
+        return results

bigdata_corp_api-0.16/src/bigdatacorp_api/exceptions.py

@@ -0,0 +1,66 @@
+"""Custom exceptions for BigDataCorpAPI."""
+
+
+class BigDataCorpAPIException(Exception):
+    def __repr__(self):
+        template = "{class_name}: {message}"
+        return template.format(
+            class_name=self.__class__.__name__,
+            message=self.message)
+
+    def __str__(self):
+        return self.__repr__()
+
+    def __init__(self, message: str, payload: dict = {}):
+        self.message = message
+        self.payload = payload
+
+    def to_dict(self):
+        rv = {
+            "payload": self.payload,
+            "type": self.__class__.__name__,
+            "message": self.message}
+        return rv
+
+
+class BigDataCorpAPIInvalidDocumentException(BigDataCorpAPIException):
+    pass
+
+
+class BigDataCorpAPIInvalidDatabaseException(BigDataCorpAPIException):
+    pass
+
+
+class BigDataCorpAPIMinorDocumentException(BigDataCorpAPIException):
+    pass
+
+
+class BigDataCorpAPIMaxRetryException(BigDataCorpAPIException):
+    pass
+
+
+class BigDataCorpAPILoginProblemException(BigDataCorpAPIException):
+    pass
+
+
+class BigDataCorpAPIProblemAPIException(BigDataCorpAPIException):
+    pass
+
+
+class BigDataCorpAPIOnDemandQueriesException(BigDataCorpAPIException):
+    pass
+
+
+class BigDataCorpAPIMonitoringAPIException(BigDataCorpAPIException):
+    pass
+
+
+class BigDataCorpAPIUnmappedErrorException(BigDataCorpAPIException):
+    pass
+
+
+class BigDataCorpAPIInvalidInputException(BigDataCorpAPIException):
+    pass
+
+class BigDataCorpAPIEmptyEnrichedProcessException(BigDataCorpAPIException):
+    pass

bigdata_corp_api-0.16/src/bigdatacorp_api/tests/test__bigdata_api.py

@@ -0,0 +1,30 @@
+"""Test BigDataCorpAPI."""
+import os
+import unittest
+from bigdatacorp_api.data import BigDataCorpAPI
+from bigdatacorp_api.exceptions import (
+    BigDataCorpAPIException, BigDataCorpAPIInvalidDocumentException,
+    BigDataCorpAPIMaxRetryException)
+
+
+BIGDATA_AUTH_TOKEN = os.environ.get("BIGDATA_AUTH_TOKEN")
+TEST_CPF = os.environ.get("TEST_CPF")
+
+
+class TestBigDataCorpAPI(unittest.TestCase):
+    """Test process Calendar input data."""
+
+    def test__ok(self):
+        bigdata_api = BigDataCorpAPI(
+            bigdata_auth_token=BIGDATA_AUTH_TOKEN)
+        bigdata_api.get_cpf_dataset(
+            cpf=TEST_CPF, dataset="basic_data")
+
+    def test__invalid(self):
+        bigdata_api = BigDataCorpAPI(
+            bigdata_auth_token=BIGDATA_AUTH_TOKEN)
+        with self.assertRaises(
+                BigDataCorpAPIInvalidDocumentException) as context:
+            bigdata_api.get_cpf_dataset(
+                cpf=TEST_CPF + "0", dataset="basic_data")
+        self.assertEqual(context.exception.message, 'cpf is invalid')