aplos-nca-saas-sdk 0.0.12__py3-none-any.whl → 0.0.14__py3-none-any.whl

aplos_nca_saas_sdk/nca_resources/{nca_login.py → nca_authenticator.py}

@@ -1,25 +1,25 @@
 """
-Copyright 2024 Aplos Analytics
+Copyright 2024-2025 Aplos Analytics
 All Rights Reserved.   www.aplosanalytics.com   LICENSED MATERIALS
 Property of Aplos Analytics, Utah, USA
 """
 
 from typing import Optional
-from aplos_nca_saas_sdk.aws_resources.aws_cognito import CognitoAuthentication
+from aplos_nca_saas_sdk.nca_resources.aws_cognito import CognitoAuthentication
 from aplos_nca_saas_sdk.nca_resources.nca_app_configuration import (
     NCAAppConfiguration,
 )
 
 
-class NCALogin:
-    """NCA Login"""
+class NCAAuthenticator:
+    """NCA Authenticator"""
 
     def __init__(
         self,
         *,
         cognito_client_id: Optional[str] = None,
         cognito_region: Optional[str] = None,
-        aplos_saas_domain: Optional[str] = None,
+        host: Optional[str] = None,
     ) -> None:
         """
         NCA SaaS Login
@@ -27,18 +27,16 @@ class NCALogin:
         Args:
             cognito_client_id (Optional[str], optional): Cognito Client Id. Defaults to None.
             cognito_region (Optional[str], optional): Cognito Region. Defaults to None.
-            aplos_saas_domain (Optional[str], optional): Aplos NCA SaaS domain. Defaults to None.
+            host (Optional[str], optional): Aplos NCA SaaS host. Defaults to None.
 
         Requirements:
             Either pass in the cognito_client_id and cognito_region.
-            or set the aplos_saas_domain to automatically get the client_id and region.
+            or set the host to automatically get the client_id and region.
         """
-        self.jwt: str
-        self.access_token: Optional[str] = None
-        self.refresh_token: Optional[str] = None
+
         self.__cognito_client_id = cognito_client_id
         self.__region = cognito_region
-        self.__domain: Optional[str] = aplos_saas_domain
+        self.__host: Optional[str] = host
         self.__cognito: Optional[CognitoAuthentication] = None
         self.__config: Optional[NCAAppConfiguration] = None
 
@@ -53,19 +51,19 @@ class NCALogin:
             self.__cognito = CognitoAuthentication(
                 client_id=self.__cognito_client_id,
                 region=self.__region,
-                aplos_domain=self.__domain,
+                aplos_domain=self.__host,
             )
 
         return self.__cognito
 
     @property
-    def domain(self) -> str | None:
+    def host(self) -> str | None:
         """
         Domain
         Returns:
-            str: the domain
+            str: the host
         """
-        return self.__domain
+        return self.__host
 
     @property
     def config(self) -> NCAAppConfiguration:
@@ -75,13 +73,13 @@ class NCALogin:
             NCAAppConfiguration: object to handle the NCA App Configuration
         """
         if self.__config is None:
-            if self.__domain is None:
+            if self.__host is None:
                 raise RuntimeError(
                     "Failed to get Aplos Configuration.  The Domain is not set."
                 )
 
             self.__config = NCAAppConfiguration(
-                aplos_saas_domain=self.__domain,
+                host=self.__host,
             )
 
         return self.__config
@@ -96,9 +94,14 @@ class NCALogin:
         Args:
             username (str): the username
             password (str): the users password
-
+        Returns:
+            str: JWT (JSON Web Token)
         """
+        if not username:
+            raise ValueError("Missing username.  Please provide a valid username.")
+        if not password:
+            raise ValueError("Missing password.  Please provide a valid password.")
 
-        self.jwt = self.cognito.login(username=username, password=password)
+        self.cognito.login(username=username, password=password)
 
-        return self.jwt
+        return self.cognito.jwt

aplos_nca_saas_sdk/nca_resources/nca_endpoints.py

@@ -1,5 +1,5 @@
 """
-Copyright 2024 Aplos Analytics
+Copyright 2024-2025 Aplos Analytics
 All Rights Reserved.   www.aplosanalytics.com   LICENSED MATERIALS
 Property of Aplos Analytics, Utah, USA
 """
@@ -8,51 +8,77 @@ Property of Aplos Analytics, Utah, USA
 class NCAEndpoints:
     """Aplos NCA SaaS Endpoints"""
 
-    def __init__(self, *, aplos_saas_domain: str):
-        self.__domain: str = aplos_saas_domain
+    def __init__(
+        self, *, host: str, tenant_id: str | None = None, user_id: str | None = None
+    ):
+        self.__host: str = host
         self.__protocal: str = "https://"
+        self.tenant_id: str | None = tenant_id
+        self.user_id: str | None = user_id
 
-    def __base(self, tenant_id: str | None = None, user_id: str | None = None) -> str:
-        """Returns the base endpoint"""
-        route = f"{self.__protocal}{self.__domain}"
+    @property
+    def origin(self) -> str:
+        """The origin path e.g. https://api.aplos-nca.com"""
+        base = f"{self.__protocal}{self.__host}"
+        return base
 
-        if tenant_id:
-            route = f"{route}/tenants/{tenant_id}"
-        if user_id:
-            if not tenant_id:
-                raise ValueError("Tenant ID is required on the users path")
-            route = f"{route}/users/{user_id}"
+    @property
+    def tenant_path(self) -> str:
+        """Returns the tenant path"""
 
-        return route
+        if not self.tenant_id:
+            raise ValueError("Missing Tenant Id")
 
-    def tenant(self, tenant_id: str) -> str:
+        return f"{self.origin}/tenants/{self.tenant_id}"
+
+    @property
+    def user_path(self) -> str:
+        """Returns the user path"""
+
+        if not self.user_id:
+            raise ValueError("Missing User Id")
+        return f"{self.tenant_path}/users/{self.user_id}"
+
+    @property
+    def tenant(self) -> str:
         """Returns the tenant endpoint"""
-        return f"{self.__base(tenant_id=tenant_id)}"
+        return f"{self.tenant_path}"
 
+    @property
     def app_configuration(self) -> str:
-        """Returns the configuration endpoint"""
-        return f"{self.__base()}/app/configuration"
+        """
+        Returns the configuration endpoint.  This is a public endpoint.
+        """
+        return f"{self.origin}/app/configuration"
 
-    def user(self, tenant_id: str, user_id: str) -> str:
+    @property
+    def user(self) -> str:
         """Returns the user endpoint"""
-        return f"{self.__base(tenant_id=tenant_id, user_id=user_id)}"
+        return f"{self.user_path}"
 
-    def executions(self, tenant_id: str, user_id: str) -> str:
+    @property
+    def executions(self) -> str:
         """Returns the executions endpoint"""
-        return f"{self.__base(tenant_id=tenant_id, user_id=user_id)}/nca/executions"
+        return f"{self.user_path}/nca/executions"
 
-    def execution(self, tenant_id: str, user_id: str, execution_id: str) -> str:
+    def execution(self, execution_id: str) -> str:
         """Returns the executions endpoint"""
-        return f"{self.executions(tenant_id=tenant_id, user_id=user_id)}/{execution_id}"
+        return f"{self.executions}/{execution_id}"
 
-    def files(self, tenant_id: str, user_id: str) -> str:
+    @property
+    def validations(self) -> str:
+        """Returns the validations endpoint"""
+        return f"{self.user_path}/nca/validations"
+
+    @property
+    def files(self) -> str:
         """Returns the files endpoint"""
-        return f"{self.__base(tenant_id=tenant_id, user_id=user_id)}/nca/files"
+        return f"{self.user_path}/nca/files"
 
-    def file(self, tenant_id: str, user_id: str, file_id: str) -> str:
+    def file(self, file_id: str) -> str:
         """Returns the file endpoint"""
-        return f"{self.files(tenant_id=tenant_id, user_id=user_id)}/{file_id}"
-    
-    def file_data(self, tenant_id: str, user_id: str, file_id: str) -> str:
+        return f"{self.files}/{file_id}"
+
+    def file_data(self, file_id: str) -> str:
         """Returns get file data endpoint"""
-        return f"{self.__base(tenant_id=tenant_id, user_id=user_id)}/nca/files/{file_id}/data"
+        return f"{self.files}/{file_id}/data"

aplos_nca_saas_sdk/nca_resources/nca_file_download.py

@@ -0,0 +1,130 @@
+"""
+Copyright 2024-2025 Aplos Analytics
+All Rights Reserved.   www.aplosanalytics.com   LICENSED MATERIALS
+Property of Aplos Analytics, Utah, USA
+"""
+
+import time
+from typing import Any, Dict, List
+from datetime import datetime, timedelta
+from aws_lambda_powertools import Logger
+from aplos_nca_saas_sdk.nca_resources._api_base import NCAApiBaseClass
+from aplos_nca_saas_sdk.nca_resources.aws_s3_presigned_upload import (
+    S3PresignedUrlUpload,
+)
+
+from aplos_nca_saas_sdk.utilities.http_utility import HttpUtilities
+import requests
+
+logger = Logger(service="nca-file-download")
+
+
+class NCAFileDownload(NCAApiBaseClass):
+    """NCA File Download"""
+
+    def __init__(self, host: str) -> None:
+        super().__init__(host)
+
+    def upload(
+        self,
+        input_file_path: str,
+        user_name: str | None = None,
+        password: str | None = None,
+    ) -> Dict[str, Any]:
+        """
+        Uploads a file to the Aplos NCA Cloud
+
+        Args:
+            input_file_path (str): local path to the file
+
+        Raises:
+            ValueError: _description_
+
+        Returns:
+            Dict: {"file_id": id, "statu_code": 204}
+        """
+        if input_file_path is None or not input_file_path:
+            raise ValueError("Valid input_file_path is required.")
+
+        if not self.authenticator.cognito.jwt:
+            if not user_name or not password:
+                raise ValueError(
+                    "Valid user_name and password are required or you can set the authenticator object."
+                )
+            self.authenticator.authenticate(username=user_name, password=password)
+
+        uploader: S3PresignedUrlUpload = S3PresignedUrlUpload(self.host)
+        uploader.authenticator = self.authenticator
+
+        upload_response: Dict[str, Any] = uploader.upload_file(
+            input_file=input_file_path
+        )
+
+        return upload_response
+
+    def download(
+        self,
+        file_id: str,
+        user_name: str | None = None,
+        password: str | None = None,
+    ) -> Dict[str, Any]:
+        """
+        Downloads a file from the Aplos NCA Cloud
+
+        Args:
+            file_id (str): the id of the file to download
+
+        Raises:
+            ValueError: _description_
+
+        Returns:
+            Dict: {"file_id": id, "statu_code": 204}
+        """
+
+        logger.info({"message": "Downloading file", "file_id": file_id})
+
+        file_info_endpoint = self.endpoints.file(
+            file_id,
+        )
+
+        if not self.authenticator.cognito.jwt:
+            if not user_name or not password:
+                raise ValueError(
+                    "Valid user_name and password are required or you can set the authenticator object."
+                )
+            self.authenticator.authenticate(username=user_name, password=password)
+
+        max_wait_in_minutes: int = 3
+        headers = HttpUtilities.get_headers(self.authenticator.cognito.jwt)
+        current_time = datetime.now()
+
+        # Create a timedelta object representing 3 minutes
+        time_delta = timedelta(minutes=max_wait_in_minutes)
+        # Add the timedelta to the current time
+        max_time = current_time + time_delta
+
+        complete = False
+        json_response: Dict[str, Any] = {}
+        while not complete:
+            response = requests.get(file_info_endpoint, headers=headers, timeout=60)
+            json_response: dict = response.json()
+            errors: List[Dict[str, Any]] = []
+            errors.extend(json_response.get("errors") or [])
+            status = json_response.get("workable_state")
+            complete = status == "ready"
+
+            if status == "invalid" or len(errors) > 0:
+                break
+            if complete:
+                break
+            if not complete:
+                time.sleep(5)
+            if datetime.now() > max_time:
+                error = (
+                    "Timeout attempting to get conversion file status. "
+                    f"The current timeout limit is {max_wait_in_minutes} minutes. "
+                    "You may need to up the timeout period, or check for errors. "
+                )
+                raise RuntimeError(error)
+
+        return json_response

aplos_nca_saas_sdk/nca_resources/nca_file_upload.py

@@ -1,41 +1,28 @@
 """
-Copyright 2024 Aplos Analytics
+Copyright 2024-2025 Aplos Analytics
 All Rights Reserved.   www.aplosanalytics.com   LICENSED MATERIALS
 Property of Aplos Analytics, Utah, USA
 """
 
 from typing import Any, Dict
-from aplos_nca_saas_sdk.aws_resources.aws_s3_presigned_upload import S3PresignedUpload
-from aplos_nca_saas_sdk.nca_resources.nca_login import NCALogin
-from aplos_nca_saas_sdk.utilities.http_utility import HttpUtilities
+from aplos_nca_saas_sdk.nca_resources._api_base import NCAApiBaseClass
+from aplos_nca_saas_sdk.nca_resources.aws_s3_presigned_upload import (
+    S3PresignedUrlUpload,
+)
 
 
-class NCAFileUpload:
+class NCAFileUpload(NCAApiBaseClass):
     """NCA File Upload"""
 
-    def __init__(self, nca_login: NCALogin) -> None:
-        if nca_login is None or nca_login.jwt is None or not nca_login.jwt:
-            raise ValueError("Authenticated nca_login is required.")
+    def __init__(self, host: str) -> None:
+        super().__init__(host)
 
-        self.__api_domain: str = nca_login.domain or ""
-        self.__tenant_id: str = nca_login.cognito.tenant_id
-        self.__user_id: str = nca_login.cognito.user_id
-        self.__jwt: str = nca_login.jwt
-
-    @property
-    def api_root(self) -> str:
-        """Gets the base url"""
-
-        if self.__api_domain is None:
-            raise RuntimeError("Missing Aplos Api Domain")
-
-        url = HttpUtilities.build_url(
-            self.__api_domain, self.__tenant_id, self.__user_id
-        )
-
-        return url
-
-    def upload(self, input_file_path: str) -> Dict[str, Any]:
+    def upload(
+        self,
+        input_file_path: str,
+        user_name: str | None = None,
+        password: str | None = None,
+    ) -> Dict[str, Any]:
         """
         Uploads a file to the Aplos NCA Cloud
 
@@ -51,7 +38,18 @@ class NCAFileUpload:
         if input_file_path is None or not input_file_path:
             raise ValueError("Valid input_file_path is required.")
 
-        uploader: S3PresignedUpload = S3PresignedUpload(self.__jwt, str(self.api_root))
-        upload_response: Dict[str, Any] = uploader.upload_file(input_file_path)
+        if not self.authenticator.cognito.jwt:
+            if not user_name or not password:
+                raise ValueError(
+                    "Valid user_name and password are required or you can set the authenticator object."
+                )
+            self.authenticator.authenticate(username=user_name, password=password)
+
+        uploader: S3PresignedUrlUpload = S3PresignedUrlUpload(self.host)
+        uploader.authenticator = self.authenticator
+
+        upload_response: Dict[str, Any] = uploader.upload_file(
+            input_file=input_file_path
+        )
 
         return upload_response

aplos_nca_saas_sdk/nca_resources/nca_validations.py

@@ -0,0 +1,34 @@
+"""
+Copyright 2024-2025 Aplos Analytics
+All Rights Reserved.   www.aplosanalytics.com   LICENSED MATERIALS
+Property of Aplos Analytics, Utah, USA
+"""
+
+import requests
+
+from aplos_nca_saas_sdk.nca_resources._api_base import NCAApiBaseClass
+
+
+class NCAValidation(NCAApiBaseClass):
+    """NCA Analysis Validation API"""
+
+    def __init__(self, host: str) -> None:
+        super().__init__(host)
+
+    def validate(self, jwt: str) -> bool:
+        """
+        Validates the JWT
+
+        Args:
+            jwt (str): JWT
+
+        Returns:
+            bool: True if the JWT is valid
+        """
+        url = self.endpoints.validations
+        response = requests.post(url, json={"jwt": jwt}, timeout=30)
+
+        if response.status_code != 200:
+            return False
+
+        return True

aplos_nca_saas_sdk/run_analysis_execution.py

@@ -0,0 +1,148 @@
+"""
+Copyright 2024-2025 Aplos Analytics
+All Rights Reserved.   www.aplosanalytics.com   LICENSED MATERIALS
+Property of Aplos Analytics, Utah, USA
+"""
+
+import json
+import os
+from pathlib import Path
+
+from aws_lambda_powertools import Logger
+
+from aplos_nca_saas_sdk.nca_resources.nca_analysis import NCAAnalysis
+from aplos_nca_saas_sdk.utilities.commandline_args import CommandlineArgs
+
+logger = Logger()
+
+
+def main():
+    """Run Main when then file is run directly"""
+    try:
+        print("Welcome to the NCA Engine Upload & Execution Demo")
+        args = CommandlineArgs()
+        files_path = os.path.join(
+            Path(__file__).parent, "sample_files", "analysis_files", "single_ev"
+        )
+
+        # set up some defaults to make the demos quicker
+        args.analysis_file_default = os.path.join(files_path, "input.csv")
+        args.config_file_default = os.path.join(files_path, "config.json")
+        args.metadata_file_default = os.path.join(files_path, "meta_data.json")
+        args.output_directory_default = os.path.join(files_path, ".output")
+        if not args.is_valid():
+            print("\n\n")
+            print("Missing some arguments.")
+            exit()
+
+        analysis_api = NCAAnalysis(host=str(args.host))
+        analysis_api.verbose = True
+
+        print("\tLoading analysis configurations")
+        print(f"\t\t...{os.path.basename(args.config_file)}")
+        config_data: dict = read_json_file(str(args.config_file))
+
+        print("\tLoading analysis meta data")
+        print(f"\t\t...{os.path.basename(args.metadata_file)}")
+        meta_data = optional_json_loads(read_text_file(str(args.metadata_file)))
+
+        wait_for_results = True
+        max_wait_in_seconds = 900  # 15 minutes
+        resutls = analysis_api.execute(
+            username=str(args.username),
+            password=str(args.password),
+            input_file_path=str(args.analysis_file),
+            config_data=config_data,
+            meta_data=meta_data,
+            output_directory=str(args.output_directory),
+            wait_for_results=wait_for_results,
+            max_wait_in_seconds=max_wait_in_seconds,
+        )
+
+        if not wait_for_results:
+            exec_id = resutls.get("execution", {}).get("execution_id", "")
+            print(
+                "Analysis execution has been queued.  We're not waiting for the results."
+            )
+            print(f"Please check your results with execution id {exec_id}.")
+
+        print("🙌 Thank you for using the NCA API for an Analysis Execution Demo. 🙌")
+    except Exception as e:  # pylint: disable=w0718
+        print(
+            "🚨 An error occured ... exiting with an error.  Please check your settings and try again."
+        )
+        print(
+            "If you believe this is bug please create a support ticket and include the execution id (if available)."
+        )
+        print(
+            "If it's not reported in the error below check your account for the failed execution."
+        )
+
+        print(str(e))
+
+
+def optional_json_loads(data: str | dict) -> str | dict:
+    """
+    Attempts to load the data as json, fails gracefull and retuns the data is if it fails
+    Args:
+        data (str): data as string
+
+    Returns:
+        str | dict: either the data as is or a converted dictionary/json object
+    """
+    if isinstance(data, dict):
+        return data
+
+    try:
+        data = json.loads(str(data))
+    finally:
+        pass
+    return data
+
+
+def read_json_file(file_path: str) -> dict:
+    """
+    Reads a file and returns the json
+    Args:
+        file_path (str): _description_
+
+    Raises:
+        FileNotFoundError: _description_
+
+    Returns:
+        dict: _description_
+    """
+    if not os.path.exists(file_path):
+        raise FileNotFoundError(f"File Not Found: {file_path}")
+
+    data = None
+    with open(file_path, mode="r", encoding="utf8") as file:
+        data = json.load(file)
+
+    return data
+
+
+def read_text_file(file_path: str) -> str:
+    """
+    Read files contents
+    Args:
+        file_path (str): path to the file
+
+    Raises:
+        FileNotFoundError: if the file is not found
+
+    Returns:
+        str: the files data
+    """
+    if not os.path.exists(file_path):
+        raise FileNotFoundError(f"File Not Found: {file_path}")
+
+    data = None
+    with open(file_path, mode="r", encoding="utf8") as file:
+        data = file.read()
+
+    return data
+
+
+if __name__ == "__main__":
+    main()