chainalysis 0.0.1__tar.gz

chainalysis-0.0.1/.github/workflow.yml

@@ -0,0 +1,17 @@
+name: Do Nothing Workflow
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+
+jobs:
+  do-nothing:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Do nothing step
+      run: echo "This workflow does nothing."

chainalysis-0.0.1/.gitignore

@@ -0,0 +1,14 @@
+# python
+venv
+env
+.env
+.venv
+__pycache__
+*.pyc
+*.egg-info
+
+# misc
+.DS_Store
+
+docs
+dist

chainalysis-0.0.1/.pre-commit-config.yaml

@@ -0,0 +1,39 @@
+repos:
+-   repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v2.3.0
+    hooks:
+    -   id: check-yaml
+    -   id: end-of-file-fixer
+    -   id: trailing-whitespace
+-   repo: https://github.com/pycqa/isort
+    rev: 5.12.0
+    hooks:
+      - id: isort
+        args: ["--profile", "black"]
+        name: isort (python)
+-   repo: https://github.com/psf/black
+    rev: 22.3.0
+    hooks:
+    - id: black
+-   repo: local
+    hooks:
+    - id: autoflake
+      name: autoflake
+      entry: autoflake
+      language: python
+      "types": [python]
+      require_serial: true
+      args:
+        - "--in-place"
+        - "--expand-star-imports"
+        - "--remove-duplicate-keys"
+        - "--remove-unused-variables"
+        - "--remove-all-unused-imports"
+- repo: local
+  hooks:
+    - id: run-tests
+      name: Run tests
+      entry: make test
+      language: system
+      pass_filenames: false
+      stages: [commit]

chainalysis-0.0.1/.vscode/settings.json

@@ -0,0 +1,5 @@
+{
+    "python.analysis.extraPaths": [
+        "./src"
+    ]
+}

chainalysis-0.0.1/LICENCE

@@ -0,0 +1,19 @@
+Copyright (c) 2018 The Python Packaging Authority
+
+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.

chainalysis-0.0.1/Makefile

@@ -0,0 +1,4 @@
+.PHONY: test
+
+test:
+	python -m unittest discover test/

chainalysis-0.0.1/PKG-INFO

@@ -0,0 +1,23 @@
+Metadata-Version: 2.3
+Name: chainalysis
+Version: 0.0.1
+Summary: SDK functions for users to query Data Solutions databases.
+Project-URL: Homepage, https://github.com/TransposeData/chainalysis-data-solutions-python-sdk
+Author-email: "Rah Tarar (musa-tarar)" <musa.nishat@chainalysis.com>
+License-File: LICENCE
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+![Transpose Banner](https://files.readme.io/c019281-Main_Docs_Banners_v1.png)
+
+# Welcome to the Transpose Python SDK
+A modern python wrapper for the Transpose API Suite.
+
+## Installation
+
+```bash
+pip install DataSolutions
+```

chainalysis-0.0.1/README.md

@@ -0,0 +1,10 @@
+![Transpose Banner](https://files.readme.io/c019281-Main_Docs_Banners_v1.png)
+
+# Welcome to the Transpose Python SDK
+A modern python wrapper for the Transpose API Suite.
+
+## Installation
+
+```bash
+pip install DataSolutions
+```

chainalysis-0.0.1/playground/play.py

@@ -0,0 +1,21 @@
+import os
+
+from chainalysis.DataSolutions import DataSolutions
+
+
+def main():
+    ds = DataSolutions(os.environ.get("API_KEY"))
+    block_numbers = [1, 2, 3]
+    analytical_result = ds.sql.analytical(
+        "SELECT * from {{chain}}.electrum_observations WHERE block_number in {{block_number}}",
+        parameters={
+            "chain": "bitcoin",
+            "block_number": ds.utils.stringify.lists(block_numbers),
+        },
+    )
+    # This should return a bad request error
+    print(analytical_result.json())
+
+
+if __name__ == "__main__":
+    main()

chainalysis-0.0.1/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = [
+  "hatchling", 
+  "pandas==2.2.2",
+  "requests==2.32.3",
+  "tenacity==9.0.0",
+  "autoflake==2.3.1"
+]
+build-backend = "hatchling.build"
+
+[project]
+name = "chainalysis"
+version = "0.0.1"
+authors = [
+  { name = "Rah Tarar (musa-tarar)", email = "musa.nishat@chainalysis.com" },
+]
+description = "SDK functions for users to query Data Solutions databases."
+readme = "README.md"
+requires-python = ">=3.8"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+[project.urls]
+Homepage = "https://github.com/TransposeData/chainalysis-data-solutions-python-sdk"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/chainalysis"]

chainalysis-0.0.1/requirements.txt

@@ -0,0 +1,5 @@
+pandas==2.2.2
+requests==2.32.3
+python-dotenv==1.0.1
+tenacity==9.0.0
+autoflake==2.3.1

chainalysis-0.0.1/src/chainalysis/DataSolutions.py

@@ -0,0 +1,22 @@
+from chainalysis.sql.sql import Sql
+from chainalysis.utils.utils import Utils
+
+
+class DataSolutionsClient:
+    """
+    This class provides SDK functions for users to query
+    Data Solutions databases.
+
+    The Analytical class queries the Data Solutions Databricks table.
+    The Transactional class queries the Data Solutions Postgres table.
+    """
+
+    def __init__(
+        self,
+        api_key: str,
+    ):
+        self.api_key = api_key
+
+        # Define SDK function classes
+        self.sql = Sql(api_key)
+        self.utils = Utils()

chainalysis-0.0.1/src/chainalysis/__init__.py

@@ -0,0 +1,3 @@
+from chainalysis import *
+from sql import *
+from utils import *

chainalysis-0.0.1/src/chainalysis/constants.py

@@ -0,0 +1,12 @@
+BASE_URL = {
+    "base_url": "https://api.transpose.io",
+}
+
+ANALYTICAL_ENDPOINTS = {
+    "async_query_execution": "sql/analytical/async",
+    "async_query_status": "sql/analytical/status",
+}
+
+TRANSACTIONAL_ENDPOINTS = {
+    "query_execution": "sql/transactional",
+}

chainalysis-0.0.1/src/chainalysis/sql/__init__.py

@@ -0,0 +1 @@
+from chainalysis.sql import *

chainalysis-0.0.1/src/chainalysis/sql/analytical.py

@@ -0,0 +1,234 @@
+from time import sleep
+
+import pandas as pd
+
+from chainalysis.constants import ANALYTICAL_ENDPOINTS, BASE_URL
+from chainalysis.util_functions.exceptions import (
+    BadRequest,
+    DataSolutionsAPIException,
+    DataSolutionsSDKException,
+    UnhandledException,
+)
+from chainalysis.util_functions.requests import issue_request
+
+
+class Analytical:
+    """
+    This class provides methods to execute SQL queries on Data Solutions
+    DataBricks tables. It supports fetching results as JSON or a
+    pandas DataFrame, and provides query execution statistics.
+    """
+
+    def __init__(self, api_key: str):
+        """
+        Initialize the Analytical class with the provided API key.
+
+        :param api_key: The API key for accessing the analytical service.
+        :type api_key: str
+        """
+
+        self.api_key = api_key
+        self._status_code = 0
+        self.results = {}
+        self._stats = {}
+        self.json_response = {}
+        self.dataframe_data = None
+        self._status = "error"
+        self.next = ""
+        self._total_pages = 0
+        self.query_id = None
+        self.exception = UnhandledException()
+
+    def __call__(
+        self,
+        query: str,
+        parameters: dict[str] = {},
+        polling_interval_sec: int = 5,
+    ):
+        """
+        Execute a SQL query asynchronously using the provided parameters
+        and polling interval.
+
+        :param query: The SQL query to be executed.
+        :type query: str
+        :param parameters: A dictionary of parameters to be used in the query.
+        :type parameters: dict[str], optional
+        :param polling_interval_sec: The interval in seconds between status checks.
+        :type polling_interval_sec: int, optional
+        :return: An instance of the Analytical class with query results.
+        :rtype: Analytical
+        """
+
+        query_execution_url = (
+            f"{BASE_URL['base_url']}/{ANALYTICAL_ENDPOINTS['async_query_execution']}"
+        )
+
+        body = {
+            "sql": query,
+            "parameters": parameters,
+        }
+
+        async_response = issue_request(
+            api_key=self.api_key,
+            url=query_execution_url,
+            body=body,
+            method="POST",
+        )
+
+        self.query_id = async_response.get("query_id")
+        if not self.query_id:
+            raise DataSolutionsAPIException(
+                "Unexpected response. Query ID was not returned."
+            )
+        async_query_status_url = f"{BASE_URL['base_url']}/{ANALYTICAL_ENDPOINTS['async_query_status']}?query_id={self.query_id}"
+
+        try:
+            while True:
+                self.json_response = issue_request(
+                    api_key=self.api_key,
+                    url=async_query_status_url,
+                    method="GET",
+                )
+
+                self._status = self.json_response["status"]
+
+                if self._status == "running" or self._status == "pending":
+                    sleep(polling_interval_sec)
+                elif self._status == "error":
+                    self.error_message = self.json_response["message"]
+                    self.error_details = self.json_response.get("details")
+                    break
+                elif self._status == "success":
+                    self._status_code = 200
+                    self._stats = self.json_response["stats"]
+                    self.results = self.json_response["results"]
+                    self.next_url = self.json_response["next"]
+                    self._total_pages = self._stats["total_pages"]
+                    break
+        except DataSolutionsSDKException as e:
+            self.exception = e.get_exception()
+            self._status_code = e.status_code
+        except Exception as e:
+            self.exception = UnhandledException(
+                details=e,
+            )
+        return self
+
+    def next_page(self):
+        """
+        Fetch the next page of DataBricks query results.
+
+        :return: An instance of the Analytical class with the next page of results.
+        :rtype: Analytical
+        """
+
+        if self.next_url:
+
+            self.json_response = issue_request(
+                api_key=self.api_key,
+                url=self.next_url,
+                method="GET",
+            )
+            self._status = self.json_response["status"]
+
+            if self._status == "error":
+                self.error_message = self.json_response["message"]
+                self.error_details = self.json_response.get("details")
+            elif self._status == "success":
+                self._status = self._status
+                self._stats = self.json_response["stats"]
+                self.results = self.json_response["results"]
+                self.next_url = self.json_response["next"]
+        else:
+            raise BadRequest(
+                "No next page available. Use the method has_next() to check if there is a next page that can be retrieved."
+            )
+        return self
+
+    def json(self):
+        """
+        Return results as a JSON.
+
+        :raises Exception: Raises an exception if the query resulted in an error.
+        :return: Results of the SQL query as a JSON.
+        :rtype: dict
+        """
+
+        if self._status != "error":
+            return self.results
+        else:
+            raise self.exception
+
+    def df(self):
+        """
+        Convert query results into a pandas DataFrame.
+
+        :raises Exception: Raises an exception if the query resulted in an error.
+        :return: DataFrame containing the results of the SQL query.
+        :rtype: pd.DataFrame
+        """
+
+        if self._status != "error":
+            if self.dataframe_data:
+                return self.dataframe_data
+            self.dataframe_data = pd.DataFrame(self.results)
+            return self.dataframe_data
+        else:
+            raise self.exception
+
+    def stats(self):
+        """
+        Get the statistics of the executed query.
+
+        :return: Statistics of the query execution.
+        :rtype: dict
+        """
+
+        if self._status != "error":
+            return self._stats
+        else:
+            raise self.exception
+
+    def status_code(self):
+        """
+        Get the HTTP status code of the response.
+
+        :return: HTTP status code.
+        :rtype: int
+        """
+
+        return self._status_code
+
+    def was_successful(self):
+        """
+        Determine if the query executed successfully.
+
+        :return: True if the query was successful, False otherwise.
+        :rtype: bool
+        """
+
+        if self._status != "error":
+            return True
+        return False
+
+    def total_pages(self) -> int:
+        """
+        Return total number of pages.
+
+        :return: Number of pages.
+        :rtype: int
+        """
+
+        return self._total_pages
+
+    def has_next(self) -> bool:
+        """
+        Return if the next page exists.
+
+        :return: Whether next page exists.
+        :rtype: bool
+        """
+
+        if self.next_url:
+            return True
+        return False

chainalysis-0.0.1/src/chainalysis/sql/sql.py

@@ -0,0 +1,8 @@
+from chainalysis.sql.analytical import Analytical
+from chainalysis.sql.transactional import Transactional
+
+
+class Sql:
+    def __init__(self, api_key: str):
+        self.transactional = Transactional(api_key)
+        self.analytical = Analytical(api_key)

chainalysis-0.0.1/src/chainalysis/sql/transactional.py

@@ -0,0 +1,145 @@
+import pandas as pd
+
+from chainalysis.constants import BASE_URL, TRANSACTIONAL_ENDPOINTS
+from chainalysis.util_functions.exceptions import (
+    DataSolutionsSDKException,
+    UnhandledException,
+)
+from chainalysis.util_functions.requests import issue_request
+
+
+class Transactional:
+    """
+    This class provides methods to handle transactional queries.
+    It supports fetching results as JSON or pandas DataFrame,
+    and provides query execution statistics.
+    """
+
+    def __init__(self, api_key: str):
+        """
+        Initialize the Transactional object with an API key.
+
+        :param api_key: API key for authenticating requests.
+        :type api_key: str
+        """
+        self.api_key = api_key
+        self._status_code = 0
+        self.results = {}
+        self._stats = {}
+        self.json_response = {}
+        self.status = "error"
+        self.dataframe_data = None
+
+    def __call__(
+        self, query: str, parameters: dict[str, str] = {}, options: dict[str, str] = {}
+    ) -> "Transactional":
+        """
+        Execute a SQL query using the provided parameters and options.
+
+        :param query: SQL query template with placeholders for parameters.
+        :type query: str
+        :param parameters: Parameters to format the SQL query.
+        :type parameters: dict[str, str]
+        :param options: Additional options for query execution.
+        :type options: dict[str, str]
+        :return: Returns self for chaining or method chaining.
+        :rtype: Transactional
+        """
+
+        query_execution_url = (
+            f"{BASE_URL['base_url']}/{TRANSACTIONAL_ENDPOINTS['query_execution']}"
+        )
+
+        body = {
+            "sql": query,
+            "parameters": parameters,
+            "options": options,
+        }
+
+        try:
+            self.json_response = issue_request(
+                api_key=self.api_key,
+                url=query_execution_url,
+                body=body,
+                method="POST",
+            )
+            self.status = self.json_response["status"]
+            if self.status == "error":
+                self.error_message = self.json_response["message"]
+                self.error_details = self.json_response.get("details")
+                self.exception = DataSolutionsSDKException(self.error_message)
+            else:
+                self._stats = self.json_response["stats"]
+                self.results = self.json_response["results"]
+                self._status_code = 200
+
+        except DataSolutionsSDKException as e:
+            self.exception = e.get_exception()
+            self._status_code = e.status_code
+        except Exception as e:
+            self.exception = UnhandledException(
+                details=e,
+            )
+        return self
+
+    def json(self) -> dict:
+        """
+        Return the JSON data of the results.
+
+        :raises Exception: Raises an exception if the query resulted in an error.
+        :return: JSON results of the SQL query.
+        :rtype: dict
+        """
+
+        if self.status != "error":
+            return self.results
+        else:
+            raise self.exception
+
+    def df(self) -> pd.DataFrame:
+        """
+        Convert query results into a pandas DataFrame.
+
+        :raises Exception: Raises an exception if the query resulted in an error.
+        :return: DataFrame containing the results of the SQL query.
+        :rtype: pd.DataFrame
+        """
+        if self.status != "error":
+            if self.dataframe_data:
+                return self.dataframe_data
+            self.dataframe_data = pd.DataFrame(self.results)
+            return self.dataframe_data
+        elif self.exception:
+            raise self.exception
+
+    def stats(self) -> dict:
+        """
+        Get the statistics of the executed query.
+
+        :return: Statistics of the query execution.
+        :rtype: dict
+        """
+        if self.status != "error":
+            return self._stats
+        else:
+            raise self.exception
+
+    def was_successful(self) -> bool:
+        """
+        Determine if the query executed successfully.
+
+        :return: True if the query was successful, False otherwise.
+        :rtype: bool
+        """
+        if self.status != "error":
+            return True
+        return False
+
+    def status_code(self) -> int:
+        """
+        Return the status code of the query.
+
+        :return: The status code of the query.
+        :rtype: int
+        """
+        return self._status_code

chainalysis-0.0.1/src/chainalysis/util_functions/check_list_type.py

@@ -0,0 +1,18 @@
+from typing import Any, List, Type
+
+from chainalysis.util_functions.exceptions import BadRequest
+
+
+def get_list_type(my_list: List[Any]) -> Type:
+    """Return the type of list elements if all are the same type, otherwise raise an error."""
+    if not my_list:
+        raise ValueError("The list is empty and has no element type.")
+
+    element_types = {type(item) for item in my_list}
+
+    if len(element_types) > 1:
+        raise BadRequest(
+            f"The list contains multiple types: {element_types}. Enter a list with only numbers, strings, or bools."
+        )
+
+    return element_types.pop()