arthur-client 0.12.0__tar.gz → 1.0.0__tar.gz

{arthur-client-0.12.0 → arthur-client-1.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: arthur-client
-Version: 0.12.0
+Version: 1.0.0
 Summary: Arthur API Python Client
 Author-email: Arthur <info@arthur.ai>
 License: MIT

{arthur-client-0.12.0 → arthur-client-1.0.0}/arthur/client/auth/helpers.py

@@ -4,7 +4,9 @@ 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, AuthenticationInfo
+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,
@@ -55,15 +57,16 @@ def get_auth_info(
     :return: the AuthInfo associated with the provided access key
     :permissions: N/A
     """
-    admin_client = ArthurAdminClient(
+    users_client = ArthurUsersClient(
         HTTPClient(
             base_url=api_http_host,
             verify_ssl=verify_ssl,
             default_headers={"Authorization": auth_token},
         )
     )
+
     try:
-        auth_info = admin_client.authenticate()
+        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 

{arthur-client-0.12.0 → arthur-client-1.0.0}/arthur/client/rest/__init__.py

@@ -12,4 +12,6 @@ from . import metrics
 from . import model_groups
 from . import models
 from . import query
+from . import users
+
 # end import subpackages

{arthur-client-0.12.0 → arthur-client-1.0.0}/arthur/client/rest/admin/client.py

@@ -7,30 +7,22 @@ from requests import Response
 from arthur.client.http.requests import HTTPClient
 
 from arthur.client.rest.admin.models import (
-    AuthenticationInfo,
     CustomRBACRequest,
-    InviteRequest,
-    InviteResponse,
     LoginRequest,
     NewOrganizationRequest,
-    NewUserRequest,
     OrgExpand,
     Organization,
     OrganizationLimits,
     OrganizationUsage,
     PaginatedOrganizations,
     PaginatedUsageResponse,
-    PaginatedUsers,
     PermissionRequest,
     RolesRequest,
     SetCurrentOrganizationRequest,
-    UpdateCurrentUserRequest,
     UpdateOrganizationRequest,
-    UpdateUserRequest,
     UsageCategory,
     UsageRollups,
     User,
-    UserResponse,
 )
 
 
@@ -66,17 +58,6 @@ class ArthurAdminClient:
         )
         return User(**raw_resp.json()), raw_resp.cookies
 
-    def authenticate(self) -> AuthenticationInfo:
-        """
-        Returns authentication info for the calling, token-bearing user
-
-        """
-
-        parsed_resp: Dict[str, Any] = self.http_client.get(  # type: ignore
-            f"/v3/users/me/auth_info", validation_response_code=200
-        )
-        return AuthenticationInfo(**parsed_resp)
-
     def get_paginated_organizations(
         self,
         name: Optional[str] = None,
@@ -237,129 +218,6 @@ class ArthurAdminClient:
         )
         return List[Organization](**parsed_resp)
 
-    def get_paginated_users(
-        self,
-        page: Optional[int] = None,
-        page_size: Optional[int] = None,
-        sort: Optional[str] = None,
-    ) -> PaginatedUsers:
-        """
-        Returns a paginated list of users
-
-        :param page:
-        :param page_size:
-        :param sort: Must be supplied in the format [column_name] to denote asc sort by this column OR -[column_name] to denote desc sort by this column
-        """
-
-        params: Dict[str, Any] = {}
-        if page is not None:
-            params["page"] = page
-        if page_size is not None:
-            params["page_size"] = page_size
-        if sort is not None:
-            params["sort"] = sort
-
-        parsed_resp: Dict[str, Any] = self.http_client.get(  # type: ignore
-            f"/v3/users", params=params, validation_response_code=200
-        )
-        return PaginatedUsers(**parsed_resp)
-
-    def create_user(self, json_body: NewUserRequest) -> User:
-        """
-        Creates a new user
-
-        :param json_body:
-        """
-
-        parsed_resp: Dict[str, Any] = self.http_client.post(  # type: ignore
-            f"/v3/users",
-            json=json_body.dict(by_alias=True, exclude_none=True),
-            validation_response_code=201,
-        )
-        return User(**parsed_resp)
-
-    def get_current_user(self) -> UserResponse:
-        """
-        Returns the currently authenticated user
-
-        """
-
-        parsed_resp: Dict[str, Any] = self.http_client.get(  # type: ignore
-            f"/v3/users/me", validation_response_code=200
-        )
-        return UserResponse(**parsed_resp)
-
-    def update_current_user(self, json_body: UpdateCurrentUserRequest) -> UserResponse:
-        """
-        Updates the currently authenticated user
-
-        :param json_body:
-        """
-
-        parsed_resp: Dict[str, Any] = self.http_client.patch(  # type: ignore
-            f"/v3/users/me",
-            json=json_body.dict(by_alias=True, exclude_none=True),
-            validation_response_code=200,
-        )
-        return UserResponse(**parsed_resp)
-
-    def get_user_by_id(self, user_id: str) -> User:
-        """
-        Returns a single user
-
-        :param user_id:
-        """
-
-        parsed_resp: Dict[str, Any] = self.http_client.get(  # type: ignore
-            f"/v3/users/{user_id}", validation_response_code=200
-        )
-        return User(**parsed_resp)
-
-    def delete_user(self, user_id: str) -> Response:
-        """
-        Deletes a user (by marking them as inactive) and invalidates any existing api keys
-
-        :param user_id:
-        """
-
-        raw_resp: Response = self.http_client.delete(  # type: ignore
-            f"/v3/users/{user_id}",
-            validation_response_code=204,
-            return_raw_response=True,
-        )
-        return raw_resp
-
-    def update_user(self, user_id: str, json_body: UpdateUserRequest) -> User:
-        """
-        Updates a user
-
-        Request to update the password must include the old password unless a super admin is making the request.
-
-        :param user_id:
-        :param json_body:
-        """
-
-        parsed_resp: Dict[str, Any] = self.http_client.patch(  # type: ignore
-            f"/v3/users/{user_id}",
-            json=json_body.dict(by_alias=True, exclude_none=True),
-            validation_response_code=200,
-        )
-        return User(**parsed_resp)
-
-    def send_user_invites(self, json_body: InviteRequest) -> InviteResponse:
-        """
-        Send email invitations to have users join the requesters organization
-
-        :param json_body:
-        """
-
-        parsed_resp: Dict[str, Any] = self.http_client.post(  # type: ignore
-            f"/v3/users/invite_users",
-            json=json_body.dict(by_alias=True, exclude_none=True),
-            validation_response_code=200,
-        )
-        return InviteResponse(**parsed_resp)
-
     def authorize_user_caller(self, json_body: PermissionRequest) -> Response:
         """
         Endpoint for validating a requesting caller has the permissions on the supplied action and resource

{arthur-client-0.12.0 → arthur-client-1.0.0}/arthur/client/rest/admin/models.py

@@ -1,12 +1,12 @@
 # generated by datamodel-codegen:
 #   filename:  admin.yaml
-#   timestamp: 2023-12-21T22:07:15+00:00
+#   timestamp: 2024-01-09T15:45:36+00:00
 
 from __future__ import annotations
 
 from datetime import datetime
 from enum import Enum
-from typing import Any, Dict, List, Optional
+from typing import Any, List, Optional
 from uuid import UUID
 
 from arthur.client.rest.common.models import Page, PageSize, TotalCount, TotalPages
@@ -25,43 +25,8 @@ class PermissionRequest(BaseModel):
 
 
 class UsageRollups(str, Enum):
-    Organization = 'organization'
-    Model = 'model'
-
-
-class UpdateCurrentUserRequest(BaseModel):
-    old_password: Optional[str] = None
-    """
-    The user's old password.
-    """
-    new_password: Optional[str] = None
-    """
-    The user's new password
-    """
-    first_name: Optional[str] = None
-    """
-    The user's first name
-    """
-    last_name: Optional[str] = None
-    """
-    The user's last name
-    """
-    email: Optional[str] = None
-    """
-    The user's email
-    """
-    username: Optional[str] = None
-    """
-    The username the user will use to login
-    """
-    show_intro_sequence: Optional[bool] = None
-    """
-    Used by the Arthur dashboard to determine whether the user should be shown the intro sequence upon login
-    """
-    help_mode_enabled: Optional[bool] = None
-    """
-    Used by the Arthur dashboard to determine whether or not to show dashboard tooltips
-    """
+    Organization = "organization"
+    Model = "model"
 
 
 class RolesRequest(BaseModel):
@@ -75,59 +40,12 @@ class RolesRequest(BaseModel):
     """
 
 
-class UpdateUserRequest(BaseModel):
-    old_password: Optional[str] = None
-    """
-    The user's old password. Not required to update the password if the caller is a super admin.
-    """
-    new_password: Optional[str] = None
-    """
-    The user's new password
-    """
-    first_name: Optional[str] = None
-    """
-    The user's first name
-    """
-    last_name: Optional[str] = None
-    """
-    The user's last name
-    """
-    email: Optional[str] = None
-    """
-    The user's email
-    """
-    username: Optional[str] = None
-    """
-    The username the user will use to login
-    """
-    roles: Optional[List[str]] = None
-    show_intro_sequence: Optional[bool] = None
-    """
-    Used by the Arthur dashboard to determine whether the user should be shown the intro sequence upon login
-    """
-    help_mode_enabled: Optional[bool] = None
-    """
-    Used by the Arthur dashboard to determine whether or not to show dashboard tooltips
-    """
-
-
-class UserContext(BaseModel):
-    name: Optional[str] = None
-    """
-    Name of the context.
-    """
-    id: Optional[str] = None
-    """
-    UUID of the context.
-    """
-
-
 class UsageCategory(Enum):
-    Inferences = 'inferences'
-    Explanations = 'explanations'
-    Organization = 'organization'
-    GroundTruth = 'ground_truth'
-    ReferenceData = 'reference_data'
+    Inferences = "inferences"
+    Explanations = "explanations"
+    Organization = "organization"
+    GroundTruth = "ground_truth"
+    ReferenceData = "reference_data"
 
 
 class User(BaseModel):
@@ -174,7 +92,7 @@ class User(BaseModel):
 
 
 class UsageMetric(BaseModel):
-    name: str = Field(..., example='record_counts')
+    name: str = Field(..., example="record_counts")
     """
     Name of the metric. For inferences, explanations, and ground_truth this will be either bytes or record_count. For organizational metrics this will be user_count and/or model_count.
     """
@@ -190,7 +108,7 @@ class LoginRequest(BaseModel):
 
 
 class LoginFailureResponse(BaseModel):
-    error: Optional[str] = Field(None, example='unauthorized')
+    error: Optional[str] = Field(None, example="unauthorized")
     """
     Error message
     """
@@ -198,7 +116,7 @@ class LoginFailureResponse(BaseModel):
 
 class LoginLockoutResponse(BaseModel):
     error: Optional[str] = Field(
-        None, example='User locked out, please try again after 10 minutes'
+        None, example="User locked out, please try again after 10 minutes"
     )
     """
     Error message
@@ -207,7 +125,7 @@ class LoginLockoutResponse(BaseModel):
 
 class OrganizationUsage(BaseModel):
     organization_id: Optional[UUID] = Field(
-        None, example='12345678-90ab-cdef-1234-567890abcdef'
+        None, example="12345678-90ab-cdef-1234-567890abcdef"
     )
     """
     Unique UUID for the organization
@@ -264,17 +182,6 @@ class OrganizationUsage(BaseModel):
     """
 
 
-class InviteResponse(BaseModel):
-    """
-    returned if and only if return_direct_links is set to true; returns a map of emails to invite links
-    """
-
-    user_invite_links: Optional[Dict[str, Any]] = None
-    """
-    a mapping where each email signup is a key and its corresponding signup invite link is the value
-    """
-
-
 class RoleDefinitionRequest(BaseModel):
     role_name: str
     """
@@ -295,12 +202,12 @@ class UsageData(BaseModel):
     explanations: Optional[List[UsageMetric]] = None
     organization: Optional[List[UsageMetric]] = None
     ground_truth: Optional[List[UsageMetric]] = None
-    id: UUID = Field(..., example='19e2716a-02a0-4b52-9ff2-540c1e685be6')
+    id: UUID = Field(..., example="19e2716a-02a0-4b52-9ff2-540c1e685be6")
     """
     When rollup = "model", this will be the model id. When rollup = "organization", this will be the organization id.
     """
-    name: str = Field(..., example='Model A')
-    organization_id: UUID = Field(..., example='dc355b20-9163-4619-a0b8-4bf2cd8d62d7')
+    name: str = Field(..., example="Model A")
+    organization_id: UUID = Field(..., example="dc355b20-9163-4619-a0b8-4bf2cd8d62d7")
     """
     In the case where rollup = "model", this will be the organization id for the model referenced by "id". In the case where rollup = "organization", this will be the same value as the "id" field.
     """
@@ -308,12 +215,12 @@ class UsageData(BaseModel):
 
 class OrganizationLimits(BaseModel):
     organization_id: Optional[UUID] = Field(
-        None, example='12345678-90ab-cdef-1234-567890abcdef'
+        None, example="12345678-90ab-cdef-1234-567890abcdef"
     )
     """
     Unique UUID for the organization
     """
-    plan: Optional[str] = Field(None, example='enterprise')
+    plan: Optional[str] = Field(None, example="enterprise")
     """
     The organization's license plan for platform usage
     """
@@ -475,158 +382,10 @@ class OrganizationLimits(BaseModel):
     """
 
 
-class AuthenticationInfo(BaseModel):
-    organization_ids: List[str]
-    """
-    A list of organization IDs.
-    """
-    issuer: str
-    """
-    The identifier of the IDP managing this user.
-    """
-    external_user_id: Optional[str] = None
-    """
-    An identifier for an external-IdP token bearer. Populated if this user's token came from an IDP and the IDP configuration specified an oidc.CustomClaimNames that mapped UserID to a claim.
-    """
-    internal_user_id: Optional[str] = None
-    """
-    An identifier for an Arthur-internal user. Populated for Arthur-authenticated users with user tokens.
-    """
-    service_account_id: Optional[str] = None
-    """
-    An identifier for an Arthur service account. Populated for Arthur-authenticated service account tokens.
-    """
-    username: str
-    """
-    Either the Arthur username or the username specified by an external IDP. This will be set to arthur.ServiceAccountName for service account tokens.
-    """
-    first_name: str
-    """
-    The first name of the Arthur authenticated user, or the first name claim if the external IDP is configured with one.
-    """
-    last_name: str
-    """
-    The last name of the Arthur authenticated user, or the last name claim if the external IDP is configured with one.
-    """
-    email: str
-    """
-    The email of the Arthur authenticated user or the email of the external IDP user if the IDP is configured with that claim. For Arthur service accounts, this will be empty.
-    """
-    roles: List[str]
-    """
-    The list of roles that this user has. For Arthur tokens, there will always be one role in this array; however, there can be more than one for external providers.
-    """
-
-
-class NewUserRequest(BaseModel):
-    first_name: Optional[str] = None
-    """
-    The user's first name
-    """
-    last_name: Optional[str] = None
-    """
-    The user's last name
-    """
-    email: str
-    """
-    The user's email
-    """
-    username: str
-    """
-    The username the user will use to login
-    """
-    password: str
-    """
-    The user's password
-    """
-    roles: List[str]
-    """
-    Available Standard Roles are [Administrator, Model Owner, User].
-    """
-    alert_notifications_enabled: Optional[bool] = None
-    """
-    Whether or not the user will receive email notifications when alerts are triggered, defaults to 'false'
-    """
-
-
 class SetCurrentOrganizationRequest(BaseModel):
     organization_id: str
 
 
-class UserResponse(BaseModel):
-    """
-    Represents an application user, if the client is using a service token then only organization_id and roles will be populated in the object
-    """
-
-    id: Optional[str] = None
-    """
-    the unique id of the user
-    """
-    organization_id: str
-    """
-    The ID of the users current context
-    """
-    organization_name: Optional[str] = None
-    """
-    The name of the users current context
-    """
-    first_name: Optional[str] = None
-    """
-    The user's first name
-    """
-    last_name: Optional[str] = None
-    """
-    The user's last name
-    """
-    email: Optional[str] = None
-    """
-    The user's email
-    """
-    username: Optional[str] = None
-    """
-    The username the user can use to login
-    """
-    roles: List[str]
-    """
-    The user's roles
-    """
-    alert_notifications_enabled: Optional[bool] = None
-    """
-    Whether or not the user will receive email notifications when alerts are triggered, defaults to 'false'
-    """
-    show_intro_sequence: Optional[bool] = None
-    """
-    used by the Arthur dashboard to determine whether the user should be shown the intro sequence upon login
-    """
-    help_mode_enabled: Optional[bool] = None
-    """
-    Used by the Arthur dashboard to determine whether or not to show dashboard tooltips
-    """
-    plan: Optional[str] = None
-    """
-    string representation of what plan the org of the returned user is associated with (ie. self-service or paidSaas)
-    """
-    created_at: Optional[datetime] = None
-    """
-    UTC timestamp of when the user was created
-    """
-    contexts: Optional[List[UserContext]] = None
-    """
-    Contexts that the user has permissions in.
-    """
-
-
-class PaginatedUsers(BaseModel):
-    data: List[User]
-    """
-    List of users.
-    """
-    page: Page
-    page_size: PageSize
-    total_pages: Optional[TotalPages] = None
-    total_count: Optional[TotalCount] = None
-
-
 class NewOrganizationRequest(BaseModel):
     name: str
     roles: Optional[List[RoleDefinitionRequest]] = None
@@ -640,41 +399,20 @@ class UpdateOrganizationRequest(BaseModel):
     plan: Optional[str] = None
 
 
-class InviteRequest(BaseModel):
-    invite_emails: List[str]
-    """
-    A list of emails to invite to the organization of the inviting user
-    """
-    return_direct_links: Optional[bool] = Field(False, example=True)
-    """
-    If set to true, invite emails will not be sent; instead, the signup links will be returned directly in the api response. If set to false email invites will be sent and the response body will be null.
-    """
-    custom_dashboard_url: Optional[str] = Field(None, example='beta.kots.dev.arthur.ai')
-    """
-    Set this if you want the invite links to be prefixed with a URL different from the default
-    """
-    organization_id: Optional[UUID] = Field(
-        None, example='b4e2c14d-85f6-405a-b184-ca9fbca2604f'
-    )
-    """
-    Set this if and only if calling as superadmin, otherwise it will return an error; this specifies the org to invite the users to
-    """
-
-
 class OrgExpand(str, Enum):
-    LicensePlan = 'license_plan'
-    Roles = 'roles'
+    LicensePlan = "license_plan"
+    Roles = "roles"
 
 
 class Organization(BaseModel):
-    id: UUID = Field(..., example='12345678-90ab-cdef-1234-567890abcdef')
+    id: UUID = Field(..., example="12345678-90ab-cdef-1234-567890abcdef")
     """
     Unique UUID for the organization
     """
     name: str
     bucket_name: Optional[str] = None
     bucket_url: Optional[str] = None
-    plan: Optional[str] = Field(None, example='enterprise')
+    plan: Optional[str] = Field(None, example="enterprise")
     """
     The organization's license plan for platform usage
     """
@@ -703,7 +441,7 @@ class CustomRBACRequest(BaseModel):
 class PaginatedUsageResponse(BaseModel):
     data: List[UsageData]
     total_count: int
-    rollup: str = Field(..., example='model')
+    rollup: str = Field(..., example="model")
     interval_start: datetime
     interval_end: datetime