arthur-client 1.3.0__py3-none-any.whl → 1.4.1055__py3-none-any.whl

{arthur_client-1.3.0.dist-info → arthur_client-1.4.1055.dist-info}/WHEEL

@@ -1,5 +1,4 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.42.0)
+Generator: poetry-core 2.1.3
 Root-Is-Purelib: true
 Tag: py3-none-any
-

arthur/client/__init__.py

@@ -1,3 +0,0 @@
-from . import auth
-from . import http
-from . import rest

arthur/client/auth/helpers.py

@@ -1,123 +0,0 @@
-from typing import Optional
-
-import requests
-
-from arthur.client.http.requests import HTTPClient
-from arthur.client.rest.admin.client import ArthurAdminClient
-from arthur.client.rest.admin.models import LoginRequest
-from arthur.client.rest.users.client import ArthurUsersClient
-from arthur.client.rest.users.models import AuthenticationInfo
-from arthur.common.exceptions import (
-    UserValueError,
-    ForbiddenError,
-    UnauthorizedError,
-    NotFoundError,
-    ArthurUnexpectedError,
-)
-
-
-# TODO: ask BE if this ever returns empty
-def get_current_org(
-    api_http_host: str, auth_token: str, verify_ssl: bool = True
-) -> Optional[str]:
-    """Get the current organization for the provided access key
-
-    :param api_http_host: base url of the host to connect to, including protocol (e.g. "https://app.arthur.ai")
-    :param auth_token: API Key to pass to the API
-    :param verify_ssl: Boolean for whether requests should verify that the SSL certificate is valid and not self-signed
-    :return: the organization ID associated with the provided access key, None if no such organization exists
-    """
-    auth_info = get_auth_info(api_http_host, auth_token, verify_ssl)
-    if auth_info is None:
-        raise ArthurUnexpectedError("Invalid / non-existent auth_info")
-    elif len(auth_info.organization_ids) == 1:
-        # If the user is authenticated into a single org, automatically select it as the user's current org
-        return auth_info.organization_ids[0]
-    elif len(auth_info.organization_ids) > 1:
-        # Raise exception and give the user options of available current organizations
-        authenticated_org_id_str = "".join(
-            f"{org_id}\n" for org_id in auth_info.organization_ids
-        )[:-1]
-        raise UserValueError(
-            f"Your access_key provides access to multiple organizations - please specify one of the following: "
-            + authenticated_org_id_str
-        )
-    else:  # len(auth_info.organization_ids) == 0
-        return None
-
-
-def get_auth_info(
-    api_http_host: str, auth_token: str, verify_ssl: bool = True
-) -> AuthenticationInfo:
-    """Get the AuthInfo struct associated with the provided access key
-
-    :param api_http_host: base url of the host to connect to, including protocol (e.g. "https://app.arthur.ai")
-    :param auth_token: Token to fetch authentication info for
-    :param verify_ssl: Boolean for whether requests should verify that the SSL certificate is valid and not self-signed
-    :return: the AuthInfo associated with the provided access key
-    :permissions: N/A
-    """
-    users_client = ArthurUsersClient(
-        HTTPClient(
-            base_url=api_http_host,
-            verify_ssl=verify_ssl,
-            default_headers={"Authorization": auth_token},
-        )
-    )
-
-    try:
-        auth_info = users_client.authenticate()
-    except requests.exceptions.SSLError as e:
-        raise UserValueError(
-            f"""SSL Error connecting to {api_http_host}, please connect to a secure server or use 
-                             verify_ssl=False to override security checks"""
-        ) from e
-    except requests.RequestException as e:
-        raise UserValueError(
-            f"Failed to connect to {api_http_host}, please ensure the URL is correct"
-        ) from e
-    except NotFoundError as e:
-        raise ArthurUnexpectedError(
-            "Auth Info endpoint not implemented by api-host"
-        ) from e
-
-    return auth_info
-
-
-def user_login(
-    api_http_host: str, login: str, password: str, verify_ssl: bool = True
-) -> str:
-    """Static convenience function to get a new auth token for the provided username and password
-
-    :param api_http_host: base url of the host to connect to, including protocol (e.g. "https://app.arthur.ai")
-    :param login: the username or password to use to log in
-    :param password: password for the user
-    :param verify_ssl: Boolean for whether requests should verify that the SSL certificate is valid and not self-signed
-    :return: an access_key
-    """
-
-    admin_client = ArthurAdminClient(
-        HTTPClient(base_url=api_http_host, verify_ssl=verify_ssl)
-    )
-    try:
-        _, login_cookies = admin_client.login(
-            LoginRequest(login=login, password=password)
-        )
-    # TODO: move all these checkings into the HTTPClient
-    except requests.exceptions.SSLError as e:
-        raise UserValueError(
-            f"""SSL Error connecting to {api_http_host}, please connect to a secure server or use 
-                             verify_ssl=False to override security checks"""
-        ) from e
-    except requests.RequestException as e:
-        raise UserValueError(
-            f"Failed to connect to {api_http_host}, please ensure the URL is correct"
-        ) from e
-    except ForbiddenError as e:
-        raise UserValueError(
-            f"Unauthorized, please ensure your username and password are correct"
-        ) from e
-
-    auth_token = login_cookies.get("Authorization")
-
-    return auth_token

arthur/client/auth/refresh.py

@@ -1,67 +0,0 @@
-from base64 import b64encode, b64decode
-from datetime import datetime, timedelta
-from typing import Dict, Tuple
-
-import jwt
-import pytz
-
-from arthur.client.auth.helpers import user_login
-
-
-# TODO: update to handle actual refresh here before and have the external caller simply fetch the recently created token
-#  or even better, have the external subscribe to fresh tokens and update accordingly
-#  this is necessary because we're now using this across many different HTTP Clients at once
-class AuthRefresher:
-    AUTH_KEY = "Authorization"
-    ALGORITHMS = ["HS256"]
-    MINS_BEFORE_EXPIRY_TO_REFRESH = 5
-
-    def __init__(self, url: str, login: str, password: str, verify_ssl: bool):
-        self._url = url
-        self._login = login
-        # encode password to obfuscate a bit
-        self._password_encoded = b64encode(password.encode())
-        self._verify_ssl = verify_ssl
-
-    @staticmethod
-    def _get_refresh_wait_time(current_token: str) -> timedelta:
-        """
-        Given a JWT token with an 'exp' field, return how long to wait before refreshing the token
-        :param current_token: the current token being used, containing an 'exp' field
-        :return: the amount of time to wait before fetching a new token
-        """
-        # see when the token expires
-        token_decoded = jwt.decode(
-            current_token,
-            algorithms=AuthRefresher.ALGORITHMS,
-            options={"verify_signature": False},
-        )
-        expiry = datetime.fromtimestamp(token_decoded["exp"], tz=pytz.UTC)
-        cur_time = datetime.now(tz=pytz.UTC)
-
-        time_to_briefly_before_expiry = (
-            expiry - timedelta(minutes=AuthRefresher.MINS_BEFORE_EXPIRY_TO_REFRESH)
-        ) - cur_time
-        # ensure time isn't negative
-        if time_to_briefly_before_expiry < timedelta():
-            return timedelta()
-        else:
-            return time_to_briefly_before_expiry
-
-    def refresh(self) -> Tuple[Dict[str, str], timedelta]:
-        """
-        Authorization header update function for an HTTPClient
-
-        Fetches a new session token and returns the new token, and how long to wait before refreshing
-        it (by calling this method again)
-        :return: Headers to update (Authorization), and time to wait before refreshing again
-        """
-        password = b64decode(self._password_encoded).decode()
-        auth_token = user_login(
-            api_http_host=self._url,
-            login=self._login,
-            password=password,
-            verify_ssl=self._verify_ssl,
-        )
-        next_refresh_wait_time = self._get_refresh_wait_time(auth_token)
-        return {self.AUTH_KEY: auth_token}, next_refresh_wait_time

arthur/client/helpers.py

@@ -1,48 +0,0 @@
-from typing import TypeVar, Callable, List, Protocol
-import inspect
-
-from arthur.common.exceptions import UnexpectedTypeError, UnexpectedValueError
-
-M = TypeVar("M")
-
-
-class PaginatedResponse(Protocol[M]):
-    data: List[M]
-
-
-def paginate(
-    func: Callable[..., PaginatedResponse[M]],
-    max_pages=100,
-    page_size=50,
-    page_start=1,
-    verify_end=True,
-    **func_kwargs,
-) -> List[M]:
-    # ensure the function has 'page' and 'page_size' inputs
-    func_args = inspect.getfullargspec(func).args
-    if not ("page" in func_args and "page_size" in func_args):
-        raise UnexpectedTypeError(
-            f"function {func.__name__} does not have 'page' and 'page_size' parameters, so cannot "
-            f"be used in paginate()"
-        )
-
-    # fetch results in pages
-    page = page_start
-    results: List[M] = []
-    cur_result: List[M] = []
-    while page <= max_pages:
-        func_kwargs.update({"page": page, "page_size": page_size})
-        cur_result = func(**func_kwargs).data
-        results.extend(cur_result)
-        page += 1
-
-    # ensure we didn't hit the end
-    if verify_end and page >= max_pages and len(cur_result) == page_size:
-        func_kwargs.update({"page": max_pages + 1})
-        if len(func(**func_kwargs).data) > 0:
-            raise UnexpectedValueError(
-                f"Results exist past last page, set verify_end=False to ignore or increase max "
-                f"pages"
-            )
-
-    return results

arthur/client/http/helper.py

@@ -1,47 +0,0 @@
-import logging
-from urllib.parse import urlparse
-
-from arthur.common.exceptions import UserValueError
-
-
-logger = logging.getLogger(__name__)
-
-
-def construct_url(*parts: str, validate=True, default_https=True) -> str:
-    """Construct a URL from various parts
-
-    Useful for joining pieces which may or may not have leading and/or trailing
-    slashes. e.g. construct_url("https://arthur.ai/", "/api/v3", "/users") will yield the same valid url as
-    construct_url("https://arthur.ai", "api/v3/", "users/"): "https://arthur.ai/api/v3/users".
-
-    :param validate: if True, validate that the URL is valid
-    :param default_https: if True, allow urls without a scheme and use https by default
-    :param parts: strings from which to construct the url
-    :return: a fully joined url, with NO trailing slash
-    """
-    # join parts
-    url = "/".join(s.strip("/") for s in parts)
-
-    # add scheme
-    parsed_url = urlparse(url)
-    if parsed_url.scheme is None or parsed_url.scheme == "":
-        if default_https:
-            logger.warning("No url scheme provided, defaulting to https")
-            url = "https://" + url
-            parsed_url = urlparse(url)
-        elif validate:
-            raise UserValueError(f"No scheme provided in URL {url}")
-
-    # validate
-    if validate and (
-        parsed_url.scheme is None
-        or parsed_url.scheme == ""
-        or parsed_url.netloc is None
-        or parsed_url.netloc == ""
-    ):
-        joiner = "', '"
-        raise UserValueError(
-            f"Invalid url, cannot construct URL from parts '{joiner.join(parts)}'"
-        )
-
-    return url