d2spy 0.0.1__tar.gz

d2spy-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Geospatial Data Science Lab
+
+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.

d2spy-0.0.1/PKG-INFO

@@ -0,0 +1,32 @@
+Metadata-Version: 2.1
+Name: d2spy
+Version: 0.0.1
+Summary: Python package for interacting with a Data to Science instance.
+License: MIT
+Keywords: python,data to science,uas
+Author: Ben Hancock
+Author-email: hancocb@purdue.edu
+Requires-Python: >=3.11,<4.0
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Requires-Dist: requests (>=2.31.0,<3.0.0)
+Description-Content-Type: text/markdown
+
+# Building with poetry
+
+Run the following from the root directory to build the source and wheels archives: `poetry build`
+
+This will create a `dist` directory containing a `.tar.gz` archive of the source code and a `.whl` file.
+
+# Installing d2spy package with pip
+
+The d2spy package can be installed with pip using the `.whl` in the build's `dist` directory. Inside a Python virtual environment, run `python -m pip install d2spy_pkg-VERSION-py3-none-any.whl` to install d2spy.
+

d2spy-0.0.1/README.md

@@ -0,0 +1,9 @@
+# Building with poetry
+
+Run the following from the root directory to build the source and wheels archives: `poetry build`
+
+This will create a `dist` directory containing a `.tar.gz` archive of the source code and a `.whl` file.
+
+# Installing d2spy package with pip
+
+The d2spy package can be installed with pip using the `.whl` in the build's `dist` directory. Inside a Python virtual environment, run `python -m pip install d2spy_pkg-VERSION-py3-none-any.whl` to install d2spy.

d2spy-0.0.1/d2spy/api_client.py

@@ -0,0 +1,64 @@
+import requests
+
+
+class APIClient:
+    """Makes API requests to D2S API."""
+
+    def __init__(self, base_url: str, session: requests.Session):
+        """Constructor for APIClient class.
+
+        Args:
+            base_url (str): Base URL for D2S instance.
+            session (requests.Session): Session set by Auth.
+
+        Raises:
+            ValueError: Raised if access token missing from session.
+        """
+        self.base_url = base_url
+        self.session = session
+
+        # Check if access token in session cookies
+        if not self.session.cookies.get("access_token"):
+            raise ValueError("Session missing access token. Must sign in first.")
+
+    def make_get_request(self, endpoint: str) -> requests.Response:
+        """Makes GET request to D2S API.
+
+        Args:
+            endpoint (str): D2S endpoint for request.
+
+        Returns:
+            requests.Response: Response from D2S API to request.
+        """
+        url = self.base_url + endpoint
+        response = self.session.get(url)
+
+        return response
+
+    def make_post_request(self, endpoint: str, **kwargs) -> requests.Response:
+        """Make POST request to D2S API.
+
+        Args:
+            endpoint (str): D2S endpoint for request.
+
+        Returns:
+            requests.Response: Response from D2S API to request.
+        """
+        url = self.base_url + endpoint
+        response = self.session.post(url, **kwargs)
+
+        return response
+
+    def make_put_request(self, endpoint: str, **kwargs) -> requests.Response:
+        """Make PUT request to D2S API.
+
+        Args:
+            endpoint (str): _description_
+
+        Returns:
+            requests.Response: _description_
+        """
+        url = self.base_url + endpoint
+        response = self.session.put(url, **kwargs)
+
+        return response

d2spy-0.0.1/d2spy/auth.py

@@ -0,0 +1,108 @@
+import getpass
+import json
+import requests
+from typing import Dict, Union
+from urllib.parse import urlparse
+
+from .extras.utils import pretty_print_response
+from .models.user import User
+
+
+class Auth:
+    """Authenticates with D2S."""
+
+    def __init__(self, base_url: str) -> None:
+        """Constructor for Auth class.
+
+        Args:
+            base_url (str): Base URL for D2S instance.
+
+        Raises:
+            ValueError: Raised if unable to communicate with host.
+        """
+        self.base_url: str = base_url
+
+        if test_base_url(self.base_url) is False:
+            raise ValueError("unable to connect to provided host")
+
+        self.session: requests.Session = requests.session()
+
+    def login(self, email: str) -> Union[User, None]:
+        """Login to D2S platform with email and password.
+
+        Args:
+            email (str): Email address used to sign in to D2S.
+
+        Returns:
+            Union[User, None]: User object or None.
+        """
+        # Request password from user
+        password = getpass.getpass(prompt="Enter your D2S password:")
+        # Credentials that will be sent to D2S auth API
+        credentials = {"username": email, "password": password}
+        # URL for D2S access-token endpoint
+        url = f"{self.base_url}/api/v1/auth/access-token"
+        # Post credentials to access-token endpoint
+        response = requests.post(url, data=credentials)
+        # JWT access token returned for successful request
+        if response.status_code == 200 and "access_token" in response.cookies:
+            # Add JWT access token to session cookies
+            self.session.cookies.set(
+                "access_token", response.cookies.get("access_token")
+            )
+            # Fetch user object associated with access token
+            user = self.get_current_user()
+            # Return dictionary of user attributes and values
+            if user:
+                return User.from_dict(user)
+            else:
+                return None
+        else:
+            # Print response if request fails
+            pretty_print_response(response)
+            return None
+
+    def logout(self) -> None:
+        """Logout of D2S platform."""
+        # Delete access-token cookie from session and end session
+        self.session.cookies.clear(domain="", path="/", name="access_token")
+        self.session.close()
+        print("session ended")
+
+    def get_current_user(self) -> Union[User, None]:
+        """Get user object for logged in user.
+
+        Returns:
+            Union[User, None]: User object or None.
+        """
+        # D2S endpoint for fetching user object for signed in user
+        url = f"{self.base_url}/api/v1/users/current"
+        # Request user object from D2S instance
+        response = self.session.get(url)
+        # Return user object if request successful
+        if response.status_code == 200:
+            return response.json()
+        else:
+            # Print response if request fails
+            pretty_print_response(response)
+            return None
+
+
+def test_base_url(base_url: str) -> bool:
+    """Return true if base_url returns HTTP 200 else false.
+
+    Args:
+        base_url (str): Base URL for D2S instance.
+
+    Returns:
+        bool: Returns True if D2S instance returns status OK, otherwise False
+    """
+    response: Union[requests.Response, None] = None
+    try:
+        response = requests.get(base_url)
+    except requests.exceptions.ConnectionError:
+        response = None
+    finally:
+        if response and response.status_code == 200:
+            return True
+    return False

d2spy-0.0.1/d2spy/extras/third_party/tusclient/__init__.py

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

d2spy-0.0.1/d2spy/extras/third_party/tusclient/client.py

@@ -0,0 +1,77 @@
+from typing import Dict, Optional
+
+from d2spy.extras.third_party.tusclient.uploader import Uploader
+
+
+class TusClient:
+    """
+    Object representation of Tus client.
+
+    :Attributes:
+        - url (str):
+            represents the tus server's create extension url. On instantiation this argument
+            must be passed to the constructor.
+        - headers (dict):
+            This can be used to set the server specific headers. These headers would be sent
+            along with every request made by the client to the server. This may be used to set
+            authentication headers. These headers should not include headers required by tus
+            protocol. If not set this defaults to an empty dictionary.
+        - cookies (dict):
+            This can be used to set the server specific cookies. These cookies would be sent
+            along with every request made by the client to the server. This may be used to set
+            authorization cookies.
+
+    :Constructor Args:
+        - url (str)
+        - headers (Optional[dict])
+        - cookies (Optional[dict])
+    """
+
+    def __init__(
+        self,
+        url: str,
+        headers: Optional[Dict[str, str]] = None,
+        cookies: Optional[Dict[str, str]] = None,
+    ):
+        self.url = url
+        self.headers = headers or {}
+        self.cookies = cookies or {}
+
+    def set_headers(self, headers: Dict[str, str]):
+        """
+        Set tus client headers.
+
+        Update and/or set new headers that would be sent along with every request made
+        to the server.
+
+        :Args:
+            - headers (dict):
+                key, value pairs of the headers to be set. This argument is required.
+        """
+        self.headers.update(headers)
+
+    def set_cookies(self, cookies: Dict[str, str]):
+        """
+        Set tus client cookies.
+
+        Update and/or set new cookies that would be sent along with every request made
+        to the server.
+
+        :Args:
+            - cookies (dict):
+                key, value pairs of the cookies to be set. This argument is required.
+        """
+        self.cookies.update(cookies)
+
+    def uploader(self, *args, **kwargs) -> Uploader:
+        """
+        Return uploader instance pointing at current client instance.
+
+        Return uploader instance with which you can control the upload of a specific
+        file. The current instance of the tus client is passed to the uploader on creation.
+
+        :Args:
+            see tusclient.uploader.Uploader for required and optional arguments.
+        """
+        kwargs["client"] = self
+        return Uploader(*args, **kwargs)

d2spy-0.0.1/d2spy/extras/third_party/tusclient/exceptions.py

@@ -0,0 +1,35 @@
+"""
+Global Tusclient exception and warning classes.
+"""
+
+
+class TusCommunicationError(Exception):
+    """
+    Should be raised when communications with tus-server behaves
+    unexpectedly.
+
+    :Attributes:
+        - message (str):
+            Main message of the exception
+        - status_code (int):
+            Status code of response indicating an error
+        - response_content (str):
+            Content of response indicating an error
+    :Constructor Args:
+        - message (Optional[str])
+        - status_code (Optional[int])
+        - response_content (Optional[str])
+    """
+
+    def __init__(self, message, status_code=None, response_content=None):
+        default_message = "Communication with tus server failed with status {}".format(
+            status_code
+        )
+        message = message or default_message
+        super(TusCommunicationError, self).__init__(message)
+        self.status_code = status_code
+        self.response_content = response_content
+
+
+class TusUploadFailed(TusCommunicationError):
+    """Should be raised when an attempted upload fails"""

d2spy-0.0.1/d2spy/extras/third_party/tusclient/request.py

@@ -0,0 +1,93 @@
+from typing import Optional
+import base64
+from functools import wraps
+
+import requests
+
+from d2spy.extras.third_party.tusclient.exceptions import TusUploadFailed, TusCommunicationError
+
+
+# Catches requests exceptions and throws custom tuspy errors.
+def catch_requests_error(func):
+    """Deocrator to catch requests exceptions"""
+
+    @wraps(func)
+    def _wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except requests.exceptions.RequestException as error:
+            raise TusCommunicationError(error)
+
+    return _wrapper
+
+
+class BaseTusRequest:
+    """
+    Http Request Abstraction.
+
+    Sets up tus custom http request on instantiation.
+
+    requires argument 'uploader' an instance of tusclient.uploader.Uploader
+    on instantiation.
+
+    :Attributes:
+        - response_headers (dict)
+        - file (file):
+            The file that is being uploaded.
+    """
+
+    def __init__(self, uploader):
+        self._url = uploader.url
+        self.response_headers = {}
+        self.status_code = None
+        self.response_content = None
+        self.verify_tls_cert = bool(uploader.verify_tls_cert)
+        self.file = uploader.get_file_stream()
+        self.file.seek(uploader.offset)
+
+        self._request_headers = {
+            "upload-offset": str(uploader.offset),
+            "Content-Type": "application/offset+octet-stream",
+        }
+        self._request_cookies = {}
+        self._request_headers.update(uploader.get_headers())
+        self._request_cookies.update(uploader.get_cookies())
+        self._content_length = uploader.get_request_length()
+        self._upload_checksum = uploader.upload_checksum
+        self._checksum_algorithm = uploader.checksum_algorithm
+        self._checksum_algorithm_name = uploader.checksum_algorithm_name
+
+    def add_checksum(self, chunk: bytes):
+        if self._upload_checksum:
+            self._request_headers["upload-checksum"] = " ".join(
+                (
+                    self._checksum_algorithm_name,
+                    base64.b64encode(self._checksum_algorithm(chunk).digest()).decode(
+                        "ascii"
+                    ),
+                )
+            )
+
+
+class TusRequest(BaseTusRequest):
+    """Class to handle async Tus upload requests"""
+
+    def perform(self):
+        """
+        Perform actual request.
+        """
+        try:
+            chunk = self.file.read(self._content_length)
+            self.add_checksum(chunk)
+            resp = requests.patch(
+                self._url,
+                data=chunk,
+                headers=self._request_headers,
+                cookies=self._request_cookies,
+                verify=self.verify_tls_cert,
+            )
+            self.status_code = resp.status_code
+            self.response_content = resp.content
+            self.response_headers = {k.lower(): v for k, v in resp.headers.items()}
+        except requests.exceptions.RequestException as error:
+            raise TusUploadFailed(error)

d2spy-0.0.1/d2spy/extras/third_party/tusclient/uploader/__init__.py

@@ -0,0 +1 @@
+from d2spy.extras.third_party.tusclient.uploader.uploader import Uploader