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

aplos_nca_saas_sdk/integration_testing/main.py

@@ -36,13 +36,12 @@ def main():
     )
     # load it so we can see what it looks like
     config.load(file_path=config_file)
-
+    
     # override the configuration
     # override_config(config)
 
     its.test(test_config=config)
 
-
 def override_config(config: TestConfiguration):
     """Override the configuration for the tests"""
     username = os.getenv("TEST_USERNAME")

aplos_nca_saas_sdk/integration_testing/tests/app_login_test.py

@@ -39,7 +39,7 @@ class TestAppLogin(IntegrationTestBase):
                 token = nca_login.authenticate(
                     username=login.username, password=login.password
                 )
-                test_response.response = token
+
                 if not token:
                     test_response.error = "Failed to authenticate"
 

aplos_nca_saas_sdk/integration_testing/tests/file_upload_test.py

@@ -6,11 +6,11 @@ Property of Aplos Analytics, Utah, USA
 
 import time
 from datetime import datetime, timedelta
-from typing import Any, Dict
+from typing import Any, Dict, List
 
 import requests
 from aws_lambda_powertools import Logger
-from aplos_nca_saas_sdk.integration_testing.configs.login import Login
+from aplos_nca_saas_sdk.integration_testing.configs.login_config import LoginConfig
 from aplos_nca_saas_sdk.integration_testing.integration_test_base import (
     IntegrationTestBase,
 )
@@ -35,28 +35,31 @@ class FileUploadTest(IntegrationTestBase):
 
         self.results.clear()
 
-        for fileupload in self.config.file_uploads.list:
+        for file_upload in self.config.file_uploads.list:
             test_response: IntegrationTestResponse = IntegrationTestResponse()
             test_response.name = self.name
             try:
                 # Confirm Login
-                nca_login = self.__login(fileupload.login)
+                nca_login = self.__login(file_upload.login)
                 if not nca_login.jwt:
                     test_response.error = "Failed to authenticate"
                 else:
                     # Confirm Upload
                     upload_response: Dict[str, Any] = self.__upload(
-                        nca_login, fileupload.filepath
+                        nca_login, file_upload.file_path
                     )
                     if upload_response is None:
                         test_response.error = "Failed to upload"
                     else:
                         # Confirm conversion and download
                         # Allow time buffer so file data is available
+                        file_id: str = upload_response.get("file_id", "")
+                        if not file_id:
+                            raise RuntimeError(
+                                "Failed to get a file_id from the upload"
+                            )
                         time.sleep(3)
-                        self.__download(
-                            nca_login, upload_response.get("file_id"), test_response
-                        )
+                        self.__download(nca_login, file_id, test_response)
 
             except Exception as e:  # pylint: disable=w0718
                 test_response.error = str(e)
@@ -65,7 +68,7 @@ class FileUploadTest(IntegrationTestBase):
 
         return self.success()
 
-    def __login(self, login: Login) -> NCALogin:
+    def __login(self, login: LoginConfig) -> NCALogin:
         nca_login = NCALogin(aplos_saas_domain=login.domain)
         nca_login.authenticate(username=login.username, password=login.password)
         return nca_login
@@ -108,7 +111,7 @@ class FileUploadTest(IntegrationTestBase):
         while not complete:
             response = requests.get(file_info_endpoint, headers=headers, timeout=60)
             json_response: dict = response.json()
-            errors = []
+            errors: List[Dict[str, Any]] = []
             errors.extend(json_response.get("errors") or [])
             status = json_response.get("workable_state")
             complete = status == "ready"

aplos_nca_saas_sdk/integration_testing/tests/nca_analysis_test.py

@@ -0,0 +1,89 @@
+"""
+Copyright 2024 Aplos Analytics
+All Rights Reserved.   www.aplosanalytics.com   LICENSED MATERIALS
+Property of Aplos Analytics, Utah, USA
+"""
+
+from pathlib import Path
+
+from aws_lambda_powertools import Logger
+
+from aplos_nca_saas_sdk.integration_testing.integration_test_base import (
+    IntegrationTestBase,
+)
+from aplos_nca_saas_sdk.integration_testing.integration_test_response import (
+    IntegrationTestResponse,
+)
+from aplos_nca_saas_sdk.nca_resources.nca_analysis import NCAAnalysis
+from aplos_nca_saas_sdk.utilities.file_utility import FileUtility
+
+logger = Logger(service="NCAAnalysisTest")
+
+
+class NCAAnalysisTest(IntegrationTestBase):
+    """NCA Execution Test Container"""
+
+    def __init__(self):
+        super().__init__("nca-execution")
+
+    def test(self) -> bool:
+        """Test Engine Execution"""
+
+        self.results.clear()
+
+        for nca_execution_config in self.config.nca_executions.list:
+            test_response: IntegrationTestResponse = IntegrationTestResponse()
+            test_response.name = self.name
+
+            input_file_path = (
+                FileUtility.load_filepath(nca_execution_config.input_file_path),
+            )
+            logger.info(
+                {
+                    "message": "Creating NCA Analysis Execution for input file.",
+                    "path": input_file_path,
+                    "path2": nca_execution_config.input_file_path,
+                }
+            )
+            try:
+                # Create new NCA Execution
+                nca_execution: NCAAnalysis = NCAAnalysis(
+                    nca_execution_config.login.domain
+                )
+
+                # Initialize Configuration Data
+
+                # Execute, the execution should raise errors that will fail the test
+                logger.info({"message": "Invoking Execution"})
+                execution_response = nca_execution.execute(
+                    username=nca_execution_config.login.username,
+                    password=nca_execution_config.login.password,
+                    input_file_path=FileUtility.load_filepath(
+                        nca_execution_config.input_file_path
+                    ),
+                    config_data=nca_execution_config.config_data,
+                    meta_data=nca_execution_config.meta_data,
+                    wait_for_results=True,
+                    output_directory=nca_execution_config.output_dir,
+                    unzip_after_download=False,
+                )
+
+                # Verify Download
+                logger.info(
+                    {"message": "Execution complete. Verifying results download."}
+                )
+
+                expected_output_file = execution_response.get("results", {}).get("file")
+                if expected_output_file is None:
+                    raise RuntimeError(
+                        "Expected populated output_file from NCAExecution was None."
+                    )
+                elif not Path(expected_output_file).is_file():
+                    raise RuntimeError("Expected downloaded file does not exist.")
+
+            except Exception as e:  # pylint: disable=w0718
+                test_response.error = str(e)
+
+            self.results.append(test_response)
+
+        return self.success()

aplos_nca_saas_sdk/nca_resources/{nca_executions.py → nca_analysis.py}

@@ -11,52 +11,61 @@ import zipfile
 from datetime import datetime, timedelta
 from pathlib import Path
 from typing import Any, Dict
-
+from aws_lambda_powertools import Logger
 import requests
 
-from aplos_nca_saas_sdk.aws_resources.aws_cognito import CognitoAuthenication
+from aplos_nca_saas_sdk.aws_resources.aws_cognito import CognitoAuthentication
 from aplos_nca_saas_sdk.aws_resources.aws_s3_presigned_upload import (
     S3PresignedUpload,
 )
 from aplos_nca_saas_sdk.utilities.commandline_args import CommandlineArgs
 from aplos_nca_saas_sdk.utilities.http_utility import HttpUtilities, Routes
+from aplos_nca_saas_sdk.utilities.environment_vars import EnvironmentVars
+
+logger = Logger()
+
+
+class NCAAnalysis:
+    """NCA Analysis API Access"""
 
+    def __init__(self, api_domain: str) -> None:
+        self.__jwt: str
 
-class NCAEngine:
-    """NCA Engine Access"""
+        if not api_domain:
+            raise ValueError("Missing Aplos Api Domain")
 
-    def __init__(
-        self, api_domain: str | None, cognito_client_id: str | None, region: str | None
-    ) -> None:
-        self.jwt: str
-        self.access_token: str | None = None
-        self.refresh_token: str | None = None
-        self.__api_domain: str | None = api_domain
+        self.__api_domain: str = api_domain
         self.verbose: bool = False
+        self.__cognito: CognitoAuthentication | None = None
 
-        self.cognito: CognitoAuthenication = CognitoAuthenication(
-            client_id=cognito_client_id, region=region
-        )
+    @property
+    def cognito(self) -> CognitoAuthentication:
+        """Gets the cognito authentication object"""
 
         if not self.__api_domain:
             raise RuntimeError(
-                "Missing Aplos Api Domain. "
-                "Pass in the api_domain as a command arg or set the APLOS_API_DOMAIN environment var."
+                "Missing Aplos Api Domain. Set the internal property of __api_domain first."
+                "This is required to make an authentication connection"
             )
 
+        if self.__cognito is None:
+            self.__cognito = CognitoAuthentication(
+                client_id=None, region=None, aplos_domain=self.__api_domain
+            )
+
+        return self.__cognito
+
     @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)
-        if isinstance(url, str):
-            return (
-                f"{url}/tenants/{self.cognito.tenant_id}/users/{self.cognito.user_id}"
-            )
+        url = HttpUtilities.build_url(
+            self.__api_domain, self.cognito.tenant_id, self.cognito.user_id
+        )
 
-        raise RuntimeError("Missing Aplos Api Domain")
+        return url
 
     def execute(
         self,
@@ -67,59 +76,101 @@ class NCAEngine:
         *,
         meta_data: str | dict | None = None,
         wait_for_results: bool = True,
+        max_wait_in_seconds: int = 900,
         output_directory: str | None = None,
         unzip_after_download: bool = False,
-    ) -> None:
-        """_summary_
+    ) -> Dict[str, Any]:
+        """
+        Executes an analsysis.
+            - Uploads an analysis file.
+            - Adds the execution to the queue.
 
         Args:
             username (str): the username
             password (str): the users password
-            input_file_path (str): the path to the input (anlysis) file
-            config_data (dict): analysis configuration infomration
+            input_file_path (str): the path to the input (analysis) file
+            config_data (dict): analysis configuration information
             meta_data (str | dict | None, optional): meta data attached to the execution. Defaults to None.
             wait_for_results (bool, optional): should the program wait for results. Defaults to True.
-            output_directory (str, optional): the output directory. Defaults to None (the local directy is used)
+            max_wait_in_seconds (int optional): the max time to wait for a download
+            output_directory (str, optional): the output directory. Defaults to None (the local directory is used)
             unzip_after_download (bool): Results are downloaded as a zip file, this option will unzip them automatically.  Defaults to False
+
+        Returns:
+            Dict[str, Any]: The execution response.  If you wait for the completion
         """
-        if self.verbose:
-            print("\tLogging in.")
-        self.jwt = self.cognito.login(username=username, password=password)
 
-        if self.verbose:
-            print("\tUploading the analysis file.")
-        uploader: S3PresignedUpload = S3PresignedUpload(self.jwt, str(self.api_root))
+        self.log(f"\tLogging into {self.__api_domain}.")
+
+        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.log("\tUploading the analysis file.")
+        uploader: S3PresignedUpload = S3PresignedUpload(self.__jwt, str(self.api_root))
         upload_response: Dict[str, Any] = uploader.upload_file(input_file_path)
 
-        if self.verbose:
-            print("\tStarting the execution.")
-        execution_id = self.run_analysis(
-            file_id=upload_response.get("file_id", ""),
+        file_id: str = upload_response.get("file_id", "")
+        if not file_id:
+            raise RuntimeError(
+                "Unexpected empty file_id when attempting to upload file."
+            )
+
+        self.log("\tAdding analyis to the queue.")
+        execution_response: Dict[str, Any] = self.__add_to_queue(
+            file_id=file_id,
             config_data=config_data,
             meta_data=meta_data,
         )
 
-        if execution_id and wait_for_results:
+        execution_id: str = execution_response.get("execution_id", "")
+
+        response = {
+            "execution": execution_response,
+            "upload": upload_response,
+            "results": {"file": None},
+        }
+
+        if not execution_id:
+            raise RuntimeError(
+                "Unexpected empty execution_id when attempting to execute analysis."
+            )
+
+        if wait_for_results:
             # wait for it
-            download_url = self.wait_for_results(execution_id=execution_id)
+            download_url = self.wait_for_results(
+                execution_id=execution_id, max_wait_in_seconds=max_wait_in_seconds
+            )
             # download the files
-            if download_url:
-                if self.verbose:
-                    print("\tDownloading the results.")
-                self.download_file(
+            if download_url is None:
+                raise RuntimeError(
+                    "Unexpected empty download_url when attempting to download results."
+                )
+            else:
+                self.log("\tDownloading the results.")
+                file_path = self.download_file(
                     download_url,
                     output_directory=output_directory,
                     do_unzip=unzip_after_download,
                 )
 
-    def run_analysis(
+                response["results"]["file"] = file_path
+        else:
+            self.log("Bypassed results download.")
+
+        return response
+
+    def __add_to_queue(
         self,
         file_id: str,
         config_data: dict,
         meta_data: str | dict | None = None,
-    ) -> str:
+    ) -> Dict[str, Any]:
         """
-        Run the analysis
+        Adds the analysis to the execution queue.
 
         Args:
             bucket_name (str): s3 bucket name for your organization. this is returned to you
@@ -127,7 +178,7 @@ class NCAEngine:
             config_data (dict): the config_data for the analysis file
             meta_data (str | dict): Optional.  Any meta data you'd like attached to this execution
         Returns:
-            str: the execution id
+            Dict[str, Any]: the api response
         """
 
         if not file_id:
@@ -137,7 +188,7 @@ class NCAEngine:
             raise ValueError(
                 "Missing config_data.  Please provide a valid config_data."
             )
-        headers = HttpUtilities.get_headers(self.jwt)
+        headers = HttpUtilities.get_headers(self.__jwt)
         # to start a new execution we need the location of the file (s3 bucket and object key)
         # you basic configuration
         # optional meta data
@@ -166,13 +217,13 @@ class NCAEngine:
             )
 
         execution_id = str(json_response.get("execution_id"))
-        if self.verbose:
-            print(f"\tExecution {execution_id} started.")
 
-        return execution_id
+        self.log(f"\tExecution {execution_id} started.")
+
+        return json_response
 
     def wait_for_results(
-        self, execution_id: str, max_wait_in_minutes: int = 15
+        self, execution_id: str, max_wait_in_seconds: float = 900
     ) -> str | None:
         """
         Wait for results
@@ -185,10 +236,10 @@ class NCAEngine:
 
         url = f"{self.api_root}/{Routes.NCA_EXECUTIONS}/{execution_id}"
 
-        headers = HttpUtilities.get_headers(self.jwt)
+        headers = HttpUtilities.get_headers(self.__jwt)
         current_time = datetime.now()
         # Create a timedelta object representing 15 minutes
-        time_delta = timedelta(minutes=max_wait_in_minutes)
+        time_delta = timedelta(seconds=max_wait_in_seconds)
 
         # Add the timedelta to the current time
         max_time = current_time + time_delta
@@ -205,8 +256,7 @@ class NCAEngine:
             if status == "failed" or complete:
                 break
             if not complete:
-                if self.verbose:
-                    print(f"\t\twaiting for results.... {status}: {elapsed}")
+                self.log(f"\t\twaiting for results.... {status}: {elapsed}")
                 time.sleep(5)
             if datetime.now() > max_time:
                 status = "timeout"
@@ -217,16 +267,13 @@ class NCAEngine:
                 break
 
         if status == "complete":
-            if self.verbose:
-                print("\tExecution complete.")
-                print(f"\tExecution duration = {elapsed}.")
+            self.log("\tExecution complete.")
+            self.log(f"\tExecution duration = {elapsed}.")
             return json_response["presigned"]["url"]
         else:
-            if self.verbose:
-                print(
-                    f"\tExecution failed. Execution ID = {execution_id}. reason: {json_response.get('errors')}"
-                )
-            return None
+            raise RuntimeError(
+                f"\tExecution failed. Execution ID = {execution_id}. reason: {json_response.get('errors')}"
+            )
 
     def download_file(
         self,
@@ -249,31 +296,47 @@ class NCAEngine:
             output_directory = str(Path(__file__).parent.parent)
             output_directory = os.path.join(output_directory, ".aplos-nca-output")
 
-        if presigned_download_url:
-            output_file = f"results-{time.strftime('%Y-%m-%d-%Hh%Mm%Ss')}.zip"
+        if EnvironmentVars.is_running_in_aws_lambda():
+            # /tmp is the only directory we can write to unless we mount an external drive
+            # TODO: allow for external mapped drives, perhaps test if we can write to it
 
-            output_file = os.path.join(output_directory, output_file)
-            os.makedirs(output_directory, exist_ok=True)
+            output_directory = os.path.join("/tmp", ".aplos-nca-output")
 
-            response = requests.get(presigned_download_url, timeout=60)
-            # write the zip to a file
-            with open(output_file, "wb") as f:
-                f.write(response.content)
+            self.log(
+                f"\t\tRunning in AWS Lambda.  Setting output directory to {output_directory}"
+            )
 
-            # optionally, extract all the files from the zip
-            if do_unzip:
-                with zipfile.ZipFile(output_file, "r") as zip_ref:
-                    zip_ref.extractall(output_file.replace(".zip", ""))
+        output_file = f"results-{time.strftime('%Y-%m-%d-%Hh%Mm%Ss')}.zip"
 
-            unzipped_state = "and unzipped" if do_unzip else "in zip format"
+        output_file = os.path.join(output_directory, output_file)
+        os.makedirs(output_directory, exist_ok=True)
 
-            if self.verbose:
-                print(f"\tResults file downloaded {unzipped_state}.")
-                print(f"\t\tResults are available in: {output_directory}")
+        response = requests.get(presigned_download_url, timeout=60)
+        # write the zip to a file
+        with open(output_file, "wb") as f:
+            f.write(response.content)
 
-            return output_directory
-        else:
-            return None
+        # optionally, extract all the files from the zip
+        if do_unzip:
+            with zipfile.ZipFile(output_file, "r") as zip_ref:
+                zip_ref.extractall(output_file.replace(".zip", ""))
+
+        unzipped_state = "and unzipped" if do_unzip else "in zip format"
+
+        self.log(f"\tResults file downloaded {unzipped_state}.")
+        self.log(f"\t\tResults are available in: {output_directory}")
+
+        return output_file
+
+    def log(self, message: str | Dict[str, Any]):
+        """Log the message"""
+        logger.debug(message)
+
+        if isinstance(message, dict):
+            message = json.dumps(message, indent=2)
+
+        if self.verbose:
+            print(message)
 
 
 def main():
@@ -292,10 +355,8 @@ def main():
             print("Missing some arguments.")
             exit()
 
-        engine = NCAEngine(
-            api_domain=args.api_domain,
-            cognito_client_id=args.cognito_client_id,
-            region=args.aws_region,
+        engine = NCAAnalysis(
+            api_domain=str(args.api_domain),
         )
 
         print("\tLoading analysis configurations")

aplos_nca_saas_sdk/nca_resources/nca_file_upload.py

@@ -17,7 +17,7 @@ class NCAFileUpload:
         if nca_login is None or nca_login.jwt is None or not nca_login.jwt:
             raise ValueError("Authenticated nca_login is required.")
 
-        self.__api_domain: str = nca_login.domain
+        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
@@ -29,11 +29,11 @@ class NCAFileUpload:
         if self.__api_domain is None:
             raise RuntimeError("Missing Aplos Api Domain")
 
-        url = HttpUtilities.build_url(self.__api_domain)
-        if isinstance(url, str):
-            return f"{url}/tenants/{self.__tenant_id}/users/{self.__user_id}"
+        url = HttpUtilities.build_url(
+            self.__api_domain, self.__tenant_id, self.__user_id
+        )
 
-        raise RuntimeError("Missing Aplos Api Domain")
+        return url
 
     def upload(self, input_file_path: str) -> Dict[str, Any]:
         """

aplos_nca_saas_sdk/nca_resources/nca_login.py

@@ -5,7 +5,7 @@ Property of Aplos Analytics, Utah, USA
 """
 
 from typing import Optional
-from aplos_nca_saas_sdk.aws_resources.aws_cognito import CognitoAuthenication
+from aplos_nca_saas_sdk.aws_resources.aws_cognito import CognitoAuthentication
 from aplos_nca_saas_sdk.nca_resources.nca_app_configuration import (
     NCAAppConfiguration,
 )
@@ -39,18 +39,18 @@ class NCALogin:
         self.__cognito_client_id = cognito_client_id
         self.__region = cognito_region
         self.__domain: Optional[str] = aplos_saas_domain
-        self.__cognito: Optional[CognitoAuthenication] = None
+        self.__cognito: Optional[CognitoAuthentication] = None
         self.__config: Optional[NCAAppConfiguration] = None
 
     @property
-    def cognito(self) -> CognitoAuthenication:
+    def cognito(self) -> CognitoAuthentication:
         """
         Cognito Authentication
         Returns:
             CognitoAuthenication: object to handle cognito authentication
         """
         if self.__cognito is None:
-            self.__cognito = CognitoAuthenication(
+            self.__cognito = CognitoAuthentication(
                 client_id=self.__cognito_client_id,
                 region=self.__region,
                 aplos_domain=self.__domain,