scalekit-sdk-python 1.0.0__py3-none-any.whl

scalekit/common/scalekit.py

@@ -0,0 +1,49 @@
+from enum import Enum
+from typing import Optional
+
+
+class GrantType(Enum):
+    """Enum class definition for Grant Types"""
+
+    AuthorizationCode = "authorization_code"
+    RefreshToken = "refresh_token"
+    ClientCredentials = "client_credentials"
+
+
+class AuthorizationUrlOptions:
+    """Class definition for Authorization URL params"""
+
+    def __init__(self):
+        """ """
+        self.connection_id: Optional[str] = None
+        self.organization_id: Optional[str] = None
+        self.scopes: Optional[str] = None
+        self.state: Optional[str] = None
+        self.nonce: Optional[str] = None
+        self.domain_hint: Optional[str] = None
+        self.login_hint: Optional[str] = None
+
+
+class CodeAuthenticationOptions:
+    """Class definition for Code Authentication URL params"""
+
+    def __init__(self):
+        """ """
+        self.code_verifier: Optional[str] = None
+
+
+class RefreshTokenAuthenticationOptions:
+    """Class definition for Refresh Authentication option params"""
+
+    def __init__(self):
+        """ """
+        self.code: Optional[str] = None
+        self.redirect_uri: Optional[str] = None
+
+
+class AuthenticationOptions:
+    """Class definition for Authentication option params"""
+
+    def __init__(self):
+        """ """
+        self.refresh_token: Optional[str] = None

scalekit/common/user.py

@@ -0,0 +1,75 @@
+from typing import Optional
+
+
+class User:
+    def __init__(self):
+        """Class definition for user params"""
+        self.id: str
+        self.username: Optional[str] = None
+        self.name: Optional[str] = None
+        self.given_name: Optional[str] = None
+        self.family_name: Optional[str] = None
+        self.email: str
+        self.email_verified = bool
+        self.phone_number: Optional[str] = None
+        self.phone_number_verified = bool | None
+        self.profile: Optional[str] = None
+        self.picture: Optional[str] = None
+        self.gender: Optional[str] = None
+        self.birth_date: Optional[str] = None
+        self.zone_info: Optional[str] = None
+        self.locale: Optional[str] = None
+        self.updated_at: Optional[str] = None
+        self.identities = Identity()
+        self.metadata: Optional[str] = None
+
+
+class Identity:
+    """Class definition for identity params"""
+
+    def __init__(self):
+        """ """
+        self.connection_id = str
+        self.organization_id = str
+        self.connection_type = str
+        self.provider_name = str
+        self.social = bool
+        self.provider_raw_attributes = str
+
+
+class IdTokenClaimIdentity:
+    """Class definition for ID token claim identity params"""
+
+    def __init__(self):
+        """ """
+        self.connection_id = str
+        self.organization_id = str
+        self.connection_type = str
+        self.provider_name = str
+        self.social = bool
+        self.provider_raw_attributes = str
+
+
+class IdTokenClaim:
+    """ """
+
+    def __init__(self):
+        """Class definition for ID token claim params"""
+        self.sub = str
+        self.name = str
+        self.preferred_username: Optional[str] = None
+        self.given_name = str
+        self.family_name: Optional[str] = None
+        self.email = str
+        self.email_verified = bool
+        self.phone_number: Optional[str] = None
+        self.phone_number_verified = bool | None
+        self.profile: Optional[str] = None
+        self.picture: Optional[str] = None
+        self.gender: Optional[str] = None
+        self.birth_date: Optional[str] = None
+        self.zone_info: Optional[str] = None
+        self.locale: Optional[str] = None
+        self.updated_at: Optional[str] = None
+        self.identities: IdTokenClaimIdentity = None
+        self.metadata: Optional[str] = None

scalekit/connection.py

@@ -0,0 +1,103 @@
+from scalekit.core import CoreClient
+from scalekit.v1.connections.connections_pb2 import *
+from scalekit.v1.connections.connections_pb2_grpc import ConnectionServiceStub
+
+
+class ConnectionClient:
+    """Class definition for Connection Client"""
+
+    def __init__(self, core_client: CoreClient):
+        """
+        Initializer for connection client
+
+        :param core_client    : CoreClient Object
+        :type                 : ``` obj ```
+        :returns
+            None
+        """
+        self.core_client = core_client
+        self.connection_service = ConnectionServiceStub(
+            self.core_client.grpc_secure_channel
+        )
+
+    def get_connection(
+        self, organization_id: str, conn_id: str
+    ) -> GetConnectionResponse:
+        """
+        Method to get connection object
+
+        :param organization_id  : Client organization id to get connection
+        :type                   : ``` str ```
+        :param conn_id          : Client connection id to get connection
+        :type                   : ``` str ```
+        :returns
+            Connection Response
+        """
+        return self.core_client.grpc_exec(
+            self.connection_service.GetConnection.with_call,
+            GetConnectionRequest(organization_id=organization_id, id=conn_id),
+        )
+
+    def list_connections_by_domain(self, domain: str) -> ListConnectionsResponse:
+        """
+        Method to get connection object by domain
+
+        :param domain     : Client domain id to get connection
+        :type             : ``` str ```
+        :returns
+            List Connections Response
+        """
+        return self.core_client.grpc_exec(
+            self.connection_service.ListConnections.with_call,
+            ListConnectionsRequest(domain=domain),
+        )
+
+    def list_connections(self, organization_id: str) -> ListConnectionsResponse:
+        """
+        Method to list connections
+
+        :param organization_id : Client organization id to get connection
+        :type                  : ``` str ```
+        :returns:
+            List Connections Response
+        """
+        return self.core_client.grpc_exec(
+            self.connection_service.ListConnections.with_call,
+            ListConnectionsRequest(organization_id=organization_id),
+        )
+
+    def enable_connection(
+        self, organization_id: str, conn_id: str
+    ) -> ToggleConnectionResponse:
+        """
+        Method to enable connection
+
+        :param organization_id  : Client organization id to enable connection
+        :type                   : ``` str ```
+        :param conn_id          : Client connection id to enable connection
+        :type                   : ``` str ```
+        :returns
+            Enable Connection Response
+        """
+        return self.core_client.grpc_exec(
+            self.connection_service.EnableConnection.with_call,
+            ToggleConnectionRequest(organization_id=organization_id, id=conn_id),
+        )
+
+    def disable_connection(
+        self, organization_id: str, conn_id: str
+    ) -> ToggleConnectionResponse:
+        """
+        Method to disable connection
+
+        :param organization_id  : Client organization id to disable connection
+        :type                   : ``` str ```
+        :param conn_id          : Client connection id to disable connection
+        :type                   : ``` str ```
+        :returns
+            Disable Connection Response
+        """
+        return self.core_client.grpc_exec(
+            self.connection_service.DisableConnection.with_call,
+            ToggleConnectionRequest(organization_id=organization_id, id=conn_id),
+        )

scalekit/constants/user.py

@@ -0,0 +1,21 @@
+
+id_token_claim_to_user_map = {
+      "sub": "id",
+      "name": "name",
+      "preferred_username": "username",
+      "given_name": "givenName",
+      "family_name": "familyName",
+      "email": "email",
+      "email_verified": "emailVerified",
+      "phone_number": "phoneNumber",
+      "phone_number_verified": "phoneNumberVerified",
+      "profile": 'profile',
+      "picture": "picture",
+      "gender": "gender",
+      "birthdate": "birthDate",
+      "zoneinfo": "zoneInfo",
+      "locale": "locale",
+      "updated_at": "updatedAt",
+      "identities": "identities",
+      "metadata": "metadata"
+}

scalekit/core.py

@@ -0,0 +1,169 @@
+from typing import TypeVar, Optional, Protocol
+
+import grpc
+import jwt
+import json
+import requests
+import platform
+from urllib.parse import urlparse
+from grpc_status import rpc_status
+from scalekit.common.scalekit import GrantType
+from scalekit.v1.errdetails.errdetails_pb2 import ErrorInfo
+
+TRequest = TypeVar("TRequest")
+TResponse = TypeVar("TResponse")
+TMetadata = TypeVar("TMetadata")
+
+TOKEN_ENDPOINT = "/oauth/token"
+JWKS_ENDPOINT = "/keys"
+
+
+class WithCall(Protocol):
+    def __call__(self, request: TRequest, metadata: TMetadata) -> TResponse: ...
+
+
+class CoreClient:
+    """Class definition for Core Client"""
+
+    sdk_version = "Scalekit-Python/0.1"
+    api_version = "20240430"
+    user_agent = f"{sdk_version} Python/{platform.python_version()} ({platform.system()}; {platform.architecture()}"
+
+    def __init__(self, env_url, client_id, client_secret):
+        """
+        Initializer for Core client
+
+        :param env_url        : Environment URL
+        :type                 : ``` str ```
+        :param client_id      : Client ID
+        :type                 : ``` str ```
+        :param client_secret  : Client Secret
+        :type                 : ``` str ```
+        :returns
+            None
+        """
+        parsed_url = urlparse(env_url)
+        self.host = parsed_url.netloc
+        self.env_url = env_url
+        self.client_id = client_id
+        self.client_secret = client_secret
+        self.keys = {}
+        self.access_token = None
+        self.grpc_secure_channel = None
+        self.__authenticate_client()
+        self.__grpc_secure_channel()
+
+    def __grpc_secure_channel(self):
+        """
+        Method to authenticate grpc and create secure grpc channel
+        :params
+            None
+        :returns
+            None
+        """
+        channel_credentials = grpc.ssl_channel_credentials()
+        call_credentials = grpc.access_token_call_credentials(self.access_token)
+        composite_credentials = grpc.composite_channel_credentials(
+            channel_credentials,
+            call_credentials,
+        )
+        self.grpc_secure_channel = grpc.secure_channel(self.host, composite_credentials)
+
+    def __authenticate_client(self):
+        """
+        Method to authenticate client  and return access token
+
+        :returns
+            access_token
+        """
+        params = {
+            "grant_type": GrantType.ClientCredentials.value,
+            "client_id": self.client_id,
+            "client_secret": self.client_secret,
+        }
+
+        response = self.authenticate(data=json.dumps(params))
+        response = json.loads(response.content)
+        self.access_token = response["access_token"]
+
+    def authenticate(self, data: str):
+        """
+        Method to execute post request for authentication with given user params
+
+        :param data : params for authentication request
+        :type       : ``` str ```
+        """
+        headers = {"Content-Type": "application/x-www-form-urlencoded"}
+        response = requests.post(
+            self.env_url + TOKEN_ENDPOINT,
+            headers=self.get_headers(headers=headers),
+            data=json.loads(data),
+            verify=True,
+        )
+        return response
+
+    def get_jwks(self):
+        """Method to get JWT Keys"""
+        if self.keys and len(self.keys) > 0:
+            return
+        response = requests.get(
+            self.env_url + JWKS_ENDPOINT, headers=self.get_headers()
+        )
+        response = json.loads(response.content)
+        keys = response["keys"]
+
+        for key in keys:
+            kid = key["kid"]
+            self.keys[kid] = jwt.algorithms.RSAAlgorithm.from_jwk(json.dumps(key))
+
+    def grpc_exec(
+        self,
+        func: WithCall,
+        data: TRequest,
+        retry=1,
+    ) -> TResponse:
+        try:
+            resp = func(
+                data,
+                metadata=tuple(self.get_headers().items()),
+            )
+            return resp
+        except grpc.RpcError as exp:
+            if retry > 0:
+                return self.grpc_exec(func, data, retry=retry - 1)
+            else:
+                status_code = exp.code()
+                status = rpc_status.from_call(exp)
+                messages = [status.message]
+                if status_code == grpc.StatusCode.INVALID_ARGUMENT:
+                    for detail in status.details:
+                        if detail.Is(ErrorInfo.DESCRIPTOR):
+                            info = ErrorInfo()
+                            detail.Unpack(info)
+                            if info.validation_error_info:
+                                for fv in info.validation_error_info.field_violations:
+                                    messages.append(f"{fv.field}: {fv.description}")
+
+                raise Exception("\n".join(messages))
+        except Exception as exp:
+            raise exp
+
+    def get_headers(self, headers: Optional[dict] = None) -> dict:
+        """
+        Method to get user defined headers and returns collated header params
+
+        :param headers : User defined header dictionary
+        :type          : ``` dict ```
+        :returns
+            dict
+        """
+        default_headers = {
+            "user-agent": f"{self.user_agent}",
+            "x-api-version": f"{self.api_version}",
+            "x-sdk-version": f"{self.sdk_version}",
+        }
+        if self.access_token:
+            default_headers.update({"authorization": f"Bearer {self.access_token}"})
+        if headers:
+            return {**default_headers, **headers}
+        return default_headers

scalekit/domain.py

@@ -0,0 +1,73 @@
+
+from scalekit.core import CoreClient
+from scalekit.v1.domains.domains_pb2 import *
+from scalekit.v1.domains.domains_pb2_grpc import DomainServiceStub
+
+
+class DomainClient:
+    """Class definition for Domain Client"""
+
+    def __init__(self, core_client: CoreClient):
+        """
+        Initializer for Domain Client
+
+        :param core_client    : CoreClient Object
+        :type                 : ``` obj ```
+        :returns
+            None
+        """
+        self.core_client = core_client
+        self.domain_service = DomainServiceStub(
+            self.core_client.grpc_secure_channel
+        )
+
+    def create_domain(
+        self, organization_id: str, domain_name: str
+    ) -> CreateDomainResponse:
+        """
+        Method to create domain
+
+        :param organization_id  : Organization id to create domain for
+        :type                   : ``` str ```
+        :param domain_name      : Domain name for new creation
+        :type                   : ``` str ```
+        :returns
+            Domain Response
+        """
+        return self.core_client.grpc_exec(
+            self.domain_service.CreateDomain.with_call,
+            CreateDomainRequest(
+                organization_id=organization_id,
+                domain=CreateDomain(domain=domain_name),
+            ),
+        )
+
+    def list_domains(self, organization_id: str) -> ListDomainResponse:
+        """
+        Method to list existing domains
+
+        :param organization_id  : Organization id to list domains for
+        :type                   : ``` str ```
+        :returns
+            List Domain Response
+        """
+        return self.core_client.grpc_exec(
+            self.domain_service.ListDomains.with_call,
+            ListDomainRequest(organization_id=organization_id),
+            )
+
+    def get_domain(self, organization_id: str, domain_id: str) -> GetDomainResponse:
+        """
+        Method to list existing domains
+
+        :param organization_id  : Organization id to list domains for
+        :type                   : ``` str ```
+        :param domain_id        : Domain name for new creation
+        :type                   : ``` str ```
+        :returns
+            Get Domain Response
+        """
+        return self.core_client.grpc_exec(
+            self.domain_service.GetDomain.with_call,
+            GetDomainRequest(organization_id=organization_id, id=domain_id),
+        )

scalekit/organization.py

@@ -0,0 +1,181 @@
+from typing import Optional
+
+from scalekit.core import CoreClient
+from scalekit.v1.organizations.organizations_pb2 import *
+from scalekit.v1.organizations.organizations_pb2_grpc import OrganizationServiceStub
+
+
+class OrganizationClient:
+    """Class definition for Organization Client"""
+
+    def __init__(self, core_client: CoreClient):
+        """
+        Initializer for Organization Client
+
+        :param core_client    : CoreClient Object
+        :type                 : ``` obj ```
+        :returns
+            None
+        """
+        self.core_client = core_client
+        self.organization_service = OrganizationServiceStub(
+            self.core_client.grpc_secure_channel
+        )
+
+    def list_organizations(
+        self, page_size: int, page_token: Optional[str] = None
+    ) -> CreateOrganizationResponse:
+        """
+        Method to list organizations
+
+        :param page_size  : page size for org list fetch
+        :type             : ``` int ```
+        :param page_token : page token for org list fetch
+        :type             : ``` str ```
+        :returns:
+             list of organizations
+        """
+        return self.core_client.grpc_exec(
+            self.organization_service.ListOrganization.with_call,
+            ListOrganizationsRequest(page_size=page_size, page_token=page_token),
+        )
+
+    def create_organization(
+        self, name: str, options: CreateOrganization
+    ) -> CreateOrganizationResponse:
+        """
+        Method to create organization based on given data
+
+        :param name     : Name of the org to be created
+        :type           : ``` str ```
+        :param options  : Additional details for org to be created
+        :type           : ``` obj ```
+        :returns:
+            Create Organization Response
+        """
+        return self.core_client.grpc_exec(
+            self.organization_service.CreateOrganization.with_call,
+            CreateOrganizationRequest(
+                organization={"displayName": name, "externalId": options.external_id}
+            ),
+        )
+
+    def update_organization(
+        self, organization_id: str, organization: UpdateOrganization
+    ) -> UpdateOrganizationResponse:
+        """
+        Method to update organization based on given data
+
+        :param organization_id       : Organization id to update
+        :type               : ``` str ```
+        :param organization : Optional params for update organization operation
+        :type               : ``` obj ```
+        :returns:
+            Update Organization Response
+        """
+        return self.core_client.grpc_exec(
+            self.organization_service.UpdateOrganization.with_call,
+            UpdateOrganizationRequest(id=organization_id, organization=organization),
+        )
+
+    def update_organization_by_external_id(
+        self, external_id: str
+    ) -> UpdateOrganizationResponse:
+        """
+        Method to update organization based on external id
+
+        :param external_id  : External id to update org
+        :type               : ``` str ```
+        :returns:
+            Update Organization Response
+        """
+        return self.core_client.grpc_exec(
+            self.organization_service.UpdateOrganization.with_call,
+            UpdateOrganizationRequest(external_id=external_id),
+        )
+
+    def get_organization(self, organization_id: str) -> GetOrganizationResponse:
+        """
+        Method to get organization based on given org id
+
+        :param organization_id  : Organization id
+        :type          : ``` str ```
+        :returns:
+            Get Organization Response
+        """
+        return self.core_client.grpc_exec(
+            self.organization_service.GetOrganization.with_call,
+            GetOrganizationRequest(id=organization_id),
+        )
+
+    def get_organization_by_external_id(self, external_id: str):
+        """
+        Method to get organization based on given org id
+
+        :param external_id  : External id to fetch org details
+        :type               : ``` str ```
+        :returns:
+            Get Organization Response
+        """
+        return self.core_client.grpc_exec(
+            self.organization_service.GetOrganization.with_call,
+            GetOrganizationRequest(external_id=external_id),
+        )
+
+    def delete_organization(self, organization_id: str) -> None:
+        """
+        Method to delete organization based on given org id
+
+        :param organization_id  : Organization id
+        :type          : ``` str ```
+        :returns:
+            None
+        """
+        self.core_client.grpc_exec(
+            self.organization_service.DeleteOrganization.with_call,
+            DeleteOrganizationRequest(id=organization_id),
+        )
+
+    def generate_portal_link(self, organization_id: str) -> GeneratePortalLinkResponse:
+        """
+        Method to generate customer portal link
+
+        :param organization_id       : Organization id to fetch portal link for
+        :type               : ``` str ```
+        :return:
+        """
+        response = self.core_client.grpc_exec(
+            self.organization_service.GeneratePortalLink.with_call,
+            GeneratePortalLinkRequest(id=organization_id),
+        )
+        if not response.link:
+            raise Exception("Error generating portal link")
+        return response.link
+
+    def get_portal_links(self, organization_id: str) -> GetPortalLinksResponse:
+        """
+        Method to get customer portal links
+
+        :param organization_id       : Organization id to fetch portal link for
+        :type               : ``` str ```
+        :return:
+        """
+        response = self.core_client.grpc_exec(
+            self.organization_service.GetPortalLinks.with_call,
+            GetPortalLinkRequest(id=organization_id),
+        )
+        return response.links
+
+    def delete_portal_link(self, organization_id: str) -> None:
+        """
+        Method to delete customer portal link
+
+        :param organization_id       : Organization id to delete portal link for
+        :type               : ``` str ```
+        :returns:
+            None
+        """
+        self.core_client.grpc_exec(
+            self.organization_service.DeletePortalLink.with_call,
+            DeletePortalLinkRequest(id=organization_id),
+        )