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

aplos_nca_saas_sdk-0.0.13.dist-info/RECORD

@@ -0,0 +1,51 @@
+aplos_nca_saas_sdk/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+aplos_nca_saas_sdk/run_analysis_execution.py,sha256=cYzGdAHOriDI7UHNFwzeaR6sHhiwNysx3__eMze8hZc,4445
+aplos_nca_saas_sdk/version.py,sha256=jlXzv0jZuOy0IB5ancPlhN-0-xre_EGv3QEfLys8N-c,172
+aplos_nca_saas_sdk/integration_testing/integration_test_base.py,sha256=ci3oOfz_McdDKGSrqOHF7F_vrvgTWo7HzxydNdPSHLs,2787
+aplos_nca_saas_sdk/integration_testing/integration_test_configurations.py,sha256=gHQE1l9l7qunlg0APfYE2JZzdhYHMz-RJiXIiQu6l2U,1634
+aplos_nca_saas_sdk/integration_testing/integration_test_factory.py,sha256=HdcGQycsBNv-cLGXfL3yVpRjLaj-QkAv1ih0L8yVXA0,2203
+aplos_nca_saas_sdk/integration_testing/integration_test_response.py,sha256=Ocn2q_kdgEJB-4Ol-V3dh8MEkf6CJdrIiQVURUeM62o,819
+aplos_nca_saas_sdk/integration_testing/integration_test_suite.py,sha256=L1ZFp3tE9zUnaCyzfTfKTYkgR_ksrIOi5YK7qViwKes,4413
+aplos_nca_saas_sdk/integration_testing/main.py,sha256=ACYtOZS-S0d1ZXZGzIMKxo1MPkK9CnsSzq7E5nMwhYE,2040
+aplos_nca_saas_sdk/integration_testing/readme.md,sha256=USg_Z8C3hYgOGgmDsv7DNR2IxRV0Xg6NvOYrwTBqZRE,626
+aplos_nca_saas_sdk/integration_testing/configs/_config_base.py,sha256=PyXCiEbvM5usN8sbtVSEL0g1iqGh9bdE31kPORMJBIs,480
+aplos_nca_saas_sdk/integration_testing/configs/app_settings_config.py,sha256=wgRjf98enkob2mfAV0bzjmfhMbovFsuMiURKyW9n83w,2611
+aplos_nca_saas_sdk/integration_testing/configs/config_sample.json,sha256=5n56K0mh33n5Po8uFbYE_ChIGbLuuxhVlhFwrbdrqNA,3568
+aplos_nca_saas_sdk/integration_testing/configs/file_upload_config.py,sha256=kODsim7yQVnXthBtbWwmRGfZFVN-QIevhQjSHdep6_4,3066
+aplos_nca_saas_sdk/integration_testing/configs/login_config.py,sha256=HqPjYBiagGSKaPFForO_eF0oKQqZzc3WEr4jEzh9kBc,3560
+aplos_nca_saas_sdk/integration_testing/configs/nca_execution_config.py,sha256=gS9W6nJ4ypgGqWcRTpVHpiEVcKsTuyI6zmvL_U5Bqhs,5769
+aplos_nca_saas_sdk/integration_testing/files/executions/config1.json,sha256=m6-wSzfrB-7w4CgIGpmT9y0_zevp-Q6So9eXU9HsVpQ,945
+aplos_nca_saas_sdk/integration_testing/files/uploads/input1.csv,sha256=9TGDiMkft7ltFFKk_8RyzuhuloIpe_fZs0Nw0PN3BkM,263
+aplos_nca_saas_sdk/integration_testing/files/uploads/input1.dat,sha256=9TGDiMkft7ltFFKk_8RyzuhuloIpe_fZs0Nw0PN3BkM,263
+aplos_nca_saas_sdk/integration_testing/files/uploads/input1.sas7bdat,sha256=bh4w5QPHwjgLEhk752BmUwztkcBmx8iAywZdiiWZuw0,16384
+aplos_nca_saas_sdk/integration_testing/files/uploads/input1.xls,sha256=ymFgWvoUC--OxsXrj2JInjK3eSbR7jnGbpHEpiadNCI,26624
+aplos_nca_saas_sdk/integration_testing/files/uploads/input1.xlsx,sha256=i8pOYfA-muNxrtCKfUfi4Hi3JvSx49ZgtfvIUQTzRJo,10481
+aplos_nca_saas_sdk/integration_testing/files/uploads/input1.xpt,sha256=vve5eYrs3nEuGGQgm710tzzYkhrn3cfcy3--CVe4IGs,1920
+aplos_nca_saas_sdk/integration_testing/tests/app_configuration_test.py,sha256=rzGWSCJPah7C8htp1atsaWKtkyRdfyd3ku8UTYQ20mc,1569
+aplos_nca_saas_sdk/integration_testing/tests/app_login_test.py,sha256=NLI4DUICspa_uZi-w2Q3XufDL0ERLVvn1DavNpYDK7I,1650
+aplos_nca_saas_sdk/integration_testing/tests/file_upload_test.py,sha256=v3-5vEVPVREQDBColJeAGg2grG3c8A4WTxZnE3_ki9c,3936
+aplos_nca_saas_sdk/integration_testing/tests/nca_analysis_test.py,sha256=RIxarfp_ggD4HgVb8xnMynIDZG2HZ0hmv6sZj1-T73c,3261
+aplos_nca_saas_sdk/integration_testing/tests/validation_test.py,sha256=68BRZbjPa7p_n5CQeEzSP5hwPAZ921NP8vbmCaCn2pQ,150
+aplos_nca_saas_sdk/nca_resources/_api_base.py,sha256=qxMSiHV4014L733ii4EJ2JUwQwKkuHi5Rm6cPEdS3cA,1278
+aplos_nca_saas_sdk/nca_resources/aws_cognito.py,sha256=lc6GCvoTBx_Dmezoxt80xksiuxXjSwkynj-1Sg0vzwY,6576
+aplos_nca_saas_sdk/nca_resources/aws_s3_presigned_payload.py,sha256=S9LvUEjzJqLYob-JmNXdIe0Uj__fVtcF4LDQB5538vk,2001
+aplos_nca_saas_sdk/nca_resources/aws_s3_presigned_upload.py,sha256=ExZUjJ4Yyu-oQyVMNtyl7KqxFfr4hIwIN31RFxg6EfM,4476
+aplos_nca_saas_sdk/nca_resources/nca_analysis.py,sha256=Fx-M7mkNKho0IbxLz7swSgexAlIXm-XeDxFchTOhHrI,10630
+aplos_nca_saas_sdk/nca_resources/nca_app_configuration.py,sha256=VZNZi0_NV4QjNgBSM9csq5qedc6-qvzaXwXyLfymB6M,1845
+aplos_nca_saas_sdk/nca_resources/nca_authenticator.py,sha256=3mXHs2zMsvo2zirudpgynC3Y9woFrfkmo3mysqfJyxk,3126
+aplos_nca_saas_sdk/nca_resources/nca_endpoints.py,sha256=lYtktEG0yXleRoFLkab3fw7MaaaZIjdvPB2iZVlIg1s,2373
+aplos_nca_saas_sdk/nca_resources/nca_file_download.py,sha256=_ryJta9f6CBOh0OsE6P4FMGZggjYWu_kj1ZuzVVuruc,4190
+aplos_nca_saas_sdk/nca_resources/nca_file_upload.py,sha256=dqETMtnzYZilPlFfLKW7o3DrrBLObeIGgILWPyD-3ZI,1653
+aplos_nca_saas_sdk/nca_resources/nca_validations.py,sha256=INv3bIHH3caOjByDknTqogDjqaYmHtZCDldc2AKpqOM,785
+aplos_nca_saas_sdk/sample_files/analysis_files/single_ev/config.json,sha256=lLnRV0jwzaSn32D8NlOekOF5oGFfUwugUlvlwoKz540,986
+aplos_nca_saas_sdk/sample_files/analysis_files/single_ev/input.csv,sha256=qFSAlgLOmERsabMmp1X6PAZa-8yFthZlHacM_f7_AOY,6528
+aplos_nca_saas_sdk/sample_files/analysis_files/single_ev/meta_data.json,sha256=p1KYOAe5Cl3rjtfF1t96oRG-QtFJJCo9otReRPNtvIk,447
+aplos_nca_saas_sdk/utilities/commandline_args.py,sha256=7HgB4AhQHHovqz_VOf6ndLubPhHQFHX5DhWz7Dx0OMo,10909
+aplos_nca_saas_sdk/utilities/environment_services.py,sha256=eKlaz-3VAPHUe-MN0rc_AdJfzdiej86vhARE-ulWL5A,3375
+aplos_nca_saas_sdk/utilities/environment_vars.py,sha256=aXheFXg6FVMaSYLe2LmoWRF5Ks9vwxDazO4XYb4vLjc,1132
+aplos_nca_saas_sdk/utilities/file_utility.py,sha256=EUvQ65aXN6OdILniuiDQ2rPRA9sFmvUoAehifEjRgUY,1025
+aplos_nca_saas_sdk/utilities/http_utility.py,sha256=DQ-ClLOmNoyPn5vhrSh4q-2wi4ViP_gplJD9asEKDM8,464
+aplos_nca_saas_sdk-0.0.13.dist-info/METADATA,sha256=pZU_i1FxKlTBfAeTwcrBdN9ix9OA1tG4Jt4PeGb4ZRU,3792
+aplos_nca_saas_sdk-0.0.13.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+aplos_nca_saas_sdk-0.0.13.dist-info/licenses/LICENSE,sha256=JQMpBrnqu_m2tISmyh6_dTgb8-m3HNnA51fuOh2TzkE,1076
+aplos_nca_saas_sdk-0.0.13.dist-info/RECORD,,

{aplos_nca_saas_sdk-0.0.11.dist-info → aplos_nca_saas_sdk-0.0.13.dist-info}/licenses/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) [year] [fullname]
+Copyright (c) 2024-2025 Aplos Analytics
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

aplos_nca_saas_sdk/integration_testing/configs/app_settings.py

@@ -1,88 +0,0 @@
-"""
-Copyright 2024 Aplos Analytics
-All Rights Reserved.   www.aplosanalytics.com   LICENSED MATERIALS
-Property of Aplos Analytics, Utah, USA
-"""
-
-from typing import List, Dict, Any
-from aplos_nca_saas_sdk.integration_testing.configs._config_base import ConfigBase
-
-
-class ApplicationDomain(ConfigBase):
-    """
-    Application Domain: Defines the domains that the application configuration tests will check against
-
-    """
-
-    def __init__(self, domain: str | None = None):
-        super().__init__()
-        self.__domain: str | None = domain
-
-    @property
-    def domain(self) -> str:
-        """The domain to validate"""
-        if self.__domain is None:
-            raise RuntimeError("Domain is not set")
-        return self.__domain
-
-    @domain.setter
-    def domain(self, value: str):
-        self.__domain = value
-
-
-class ApplicationDomains(ConfigBase):
-    """
-    Application ApplicationDomain: Defines the Domains that the application configuration tests will check against
-
-    """
-
-    def __init__(self):
-        super().__init__()
-        self.__domains: List[ApplicationDomain] = []
-
-    @property
-    def list(self) -> List[ApplicationDomain]:
-        """List the logins"""
-        return self.__domains
-
-    def add(self, *, domain: str, enabled: bool = True):
-        """Add a loging"""
-        app_domain = ApplicationDomain()
-        app_domain.domain = domain
-        app_domain.enabled = enabled
-        self.__domains.append(app_domain)
-
-    def load(self, test_config: Dict[str, Any]):
-        """Load the logins from a list of dictionaries"""
-        # self.enabled = bool(test_config.get("enabled", True))
-        super().load(test_config)
-        domains: List[Dict[str, Any]] = test_config.get("domains", [])
-
-        domain: Dict[str, Any]
-        for domain in domains:
-            app_domain = ApplicationDomain()
-            app_domain.domain = domain.get("domain", None)
-            app_domain.enabled = bool(domain.get("enabled", True))
-
-            self.__domains.append(app_domain)
-
-
-class ApplicationSettings(ConfigBase):
-    """
-    Application Settings: Defines the domains that the application settings (configuration endpoint) tests will check against
-
-    """
-
-    def __init__(self):
-        super().__init__()
-        self.__domains: ApplicationDomains = ApplicationDomains()
-
-    @property
-    def domains(self) -> ApplicationDomains:
-        """List of the domain"""
-        return self.__domains
-
-    def load(self, test_config: Dict[str, Any]):
-        """Load the domains from the config"""
-        super().load(test_config)
-        self.domains.load(test_config)

aplos_nca_saas_sdk/integration_testing/configs/file_upload.py

@@ -1,104 +0,0 @@
-"""
-Copyright 2024 Aplos Analytics
-All Rights Reserved.   www.aplosanalytics.com   LICENSED MATERIALS
-Property of Aplos Analytics, Utah, USA
-"""
-
-import os
-from typing import List, Dict, Any
-from aplos_nca_saas_sdk.integration_testing.configs._config_base import ConfigBase
-from aplos_nca_saas_sdk.integration_testing.configs.login import Login
-from aplos_nca_saas_sdk.utilities.environment_services import EnvironmentServices
-
-
-class FileUpload(ConfigBase):
-    """
-    File Upload: Defines the login that the application configuration tests will check against
-
-    """
-
-    def __init__(self, login: Login, filepath: str):
-        super().__init__()
-        if login is None:
-            raise RuntimeError("Login is required")
-        self.__login = login
-        if filepath is None:
-            raise RuntimeError("Filepath is required")
-        self.__filepath = filepath
-
-    @property
-    def login(self) -> Login:
-        """The users login"""
-        return self.__login
-
-    @property
-    def filepath(self) -> str:
-        """The file path to file being uploaded"""
-        path = self.__load_filepath(self.__filepath)
-
-        if not os.path.exists(path):
-            raise RuntimeError(f"The Upload File was not found: {path}")
-
-        return path
-
-    def __load_filepath(self, filepath: str) -> str:
-        """Load the filepath"""
-        if filepath is None:
-            raise RuntimeError("Filepath is required")
-        elif filepath.startswith("${module}"):
-            # find the path
-            es: EnvironmentServices = EnvironmentServices()
-            root = es.find_module_path()
-            filepath = filepath.replace("${module}", root)
-
-        # get the correct os path separator
-        filepath = os.path.normpath(filepath)
-        return filepath
-
-
-class FileUploads(ConfigBase):
-    """
-    File Uploads: Defines the files that the application file upload tests will check against
-
-    """
-
-    def __init__(self):
-        super().__init__()
-        self.__fileuploads: List[FileUpload] = []
-
-    @property
-    def list(self) -> List[FileUpload]:
-        """List the file uploads"""
-        return filter(lambda x: x.enabled, self.__fileuploads)
-
-    def add(self, *, filepath: str, login: Login, enabled: bool = True):
-        """Add a file upload"""
-        fileupload = FileUpload(login, filepath)
-        fileupload.enabled = enabled
-        self.__fileuploads.append(fileupload)
-
-    def load(self, test_config: Dict[str, Any]):
-        """Load the file uploads from a list of dictionaries"""
-
-        super().load(test_config)
-        test_config_login: Login = self.try_load_login(test_config.get("login", None))
-        fileuploads: List[Dict[str, Any]] = test_config.get("files", [])
-        login: Login = None
-        for fileupload in fileuploads:
-            enabled = bool(fileupload.get("enabled", True))
-            if "login" in fileupload:
-                login = self.try_load_login(fileupload["login"])
-            else:
-                login = test_config_login
-
-            self.add(filepath=fileupload["file"], login=login, enabled=enabled)
-
-    def try_load_login(self, login_config: Dict[str, Any]) -> Login | None:
-        """Attempts to intialize a Login from a configuration object"""
-        login: Login = None
-        if login_config is not None:
-            username = login_config.get("username", None)
-            password = login_config.get("password", None)
-            domain = login_config.get("domain", None)
-            login = Login(username, password, domain)
-        return login

aplos_nca_saas_sdk/integration_testing/tests/app_validation_test.py

@@ -1,5 +0,0 @@
-"""
-Copyright 2024 Aplos Analytics
-All Rights Reserved.   www.aplosanalytics.com   LICENSED MATERIALS
-Property of Aplos Analytics, Utah, USA
-"""

aplos_nca_saas_sdk/nca_resources/nca_executions.py

@@ -1,387 +0,0 @@
-"""
-Copyright 2024 Aplos Analytics
-All Rights Reserved.   www.aplosanalytics.com   LICENSED MATERIALS
-Property of Aplos Analytics, Utah, USA
-"""
-
-import json
-import os
-import time
-import zipfile
-from datetime import datetime, timedelta
-from pathlib import Path
-from typing import Any, Dict
-
-import requests
-
-from aplos_nca_saas_sdk.aws_resources.aws_cognito import CognitoAuthenication
-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
-
-
-class NCAEngine:
-    """NCA Engine Access"""
-
-    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.verbose: bool = False
-
-        self.cognito: CognitoAuthenication = CognitoAuthenication(
-            client_id=cognito_client_id, region=region
-        )
-
-        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."
-            )
-
-    @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}"
-            )
-
-        raise RuntimeError("Missing Aplos Api Domain")
-
-    def execute(
-        self,
-        username: str,
-        password: str,
-        input_file_path: str,
-        config_data: dict,
-        *,
-        meta_data: str | dict | None = None,
-        wait_for_results: bool = True,
-        output_directory: str | None = None,
-        unzip_after_download: bool = False,
-    ) -> None:
-        """_summary_
-
-        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
-            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)
-            unzip_after_download (bool): Results are downloaded as a zip file, this option will unzip them automatically.  Defaults to False
-        """
-        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))
-        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", ""),
-            config_data=config_data,
-            meta_data=meta_data,
-        )
-
-        if execution_id and wait_for_results:
-            # wait for it
-            download_url = self.wait_for_results(execution_id=execution_id)
-            # download the files
-            if download_url:
-                if self.verbose:
-                    print("\tDownloading the results.")
-                self.download_file(
-                    download_url,
-                    output_directory=output_directory,
-                    do_unzip=unzip_after_download,
-                )
-
-    def run_analysis(
-        self,
-        file_id: str,
-        config_data: dict,
-        meta_data: str | dict | None = None,
-    ) -> str:
-        """
-        Run the analysis
-
-        Args:
-            bucket_name (str): s3 bucket name for your organization. this is returned to you
-            object_key (str): 3s object key for the file you are running an analysis on.
-            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
-        """
-
-        if not file_id:
-            raise ValueError("Missing file_id.  Please provide a valid file_id.")
-
-        if not config_data:
-            raise ValueError(
-                "Missing config_data.  Please provide a valid config_data."
-            )
-        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
-
-        submission = {
-            "file": {"id": file_id},
-            "configuration": config_data,
-            "meta_data": meta_data,
-        }
-        url = f"{str(self.api_root)}/{Routes.NCA_EXECUTIONS}"
-        response: requests.Response = requests.post(
-            url, headers=headers, data=json.dumps(submission), timeout=30
-        )
-        json_response: dict = response.json()
-
-        if response.status_code == 403:
-            raise PermissionError(
-                "Failed to execute.  A 403 response occured.  "
-                "This could a token issue or a url path issue  "
-                "By default unknown gateway calls return 403 errors. "
-            )
-        elif response.status_code != 200:
-            raise RuntimeError(
-                f"Unknown Error occured during executions: {response.status_code}. "
-                f"Reason: {response.reason}"
-            )
-
-        execution_id = str(json_response.get("execution_id"))
-        if self.verbose:
-            print(f"\tExecution {execution_id} started.")
-
-        return execution_id
-
-    def wait_for_results(
-        self, execution_id: str, max_wait_in_minutes: int = 15
-    ) -> str | None:
-        """
-        Wait for results
-        Args:
-            execution_id (str): the analysis execution id
-
-        Returns:
-            str | None: on success: a url for download, on failure: None
-        """
-
-        url = f"{self.api_root}/{Routes.NCA_EXECUTIONS}/{execution_id}"
-
-        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)
-
-        # Add the timedelta to the current time
-        max_time = current_time + time_delta
-
-        complete = False
-        while not complete:
-            response = requests.get(url, headers=headers, timeout=30)
-            json_response: dict = response.json()
-            status = json_response.get("status")
-            complete = status == "complete"
-            elapsed = (
-                json_response.get("times", {}).get("elapsed", "0:00:00") or "--:--"
-            )
-            if status == "failed" or complete:
-                break
-            if not complete:
-                if self.verbose:
-                    print(f"\t\twaiting for results.... {status}: {elapsed}")
-                time.sleep(5)
-            if datetime.now() > max_time:
-                status = "timeout"
-                break
-            if status is None and elapsed is None:
-                # we have a problem
-                status = "unknown issue"
-                break
-
-        if status == "complete":
-            if self.verbose:
-                print("\tExecution complete.")
-                print(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
-
-    def download_file(
-        self,
-        presigned_download_url: str,
-        output_directory: str | None = None,
-        do_unzip: bool = False,
-    ) -> str | None:
-        """
-        # Step 5
-        Download completed analysis files
-
-        Args:
-            presigned_download_url (str): presigned download url
-            output_directory (str | None): optional output directory
-
-        Returns:
-            str: file path to results or None
-        """
-        if output_directory is None:
-            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"
-
-            output_file = os.path.join(output_directory, output_file)
-            os.makedirs(output_directory, exist_ok=True)
-
-            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)
-
-            # 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"
-
-            if self.verbose:
-                print(f"\tResults file downloaded {unzipped_state}.")
-                print(f"\t\tResults are available in: {output_directory}")
-
-            return output_directory
-        else:
-            return None
-
-
-def main():
-    try:
-        print("Welcome to the NCA Engine Upload & Execution Demo")
-        args = CommandlineArgs()
-        files_path = os.path.join(Path(__file__).parent, "files")
-
-        args.analysis_file_default = os.path.join(files_path, "single_ev.csv")
-        args.config_file_default = os.path.join(
-            files_path, "configuration_single_ev.json"
-        )
-        args.metadata_file_default = os.path.join(files_path, "meta_data.json")
-        if not args.is_valid():
-            print("\n\n")
-            print("Missing some arguments.")
-            exit()
-
-        engine = NCAEngine(
-            api_domain=args.api_domain,
-            cognito_client_id=args.cognito_client_id,
-            region=args.aws_region,
-        )
-
-        print("\tLoading analysis configurations")
-        print(f"\t\t{args.config_file}")
-        config_data: dict = read_json_file(str(args.config_file))
-
-        print("\tLoading analysis meta data")
-        print(f"\t\t{args.metadata_file}")
-        meta_data = optional_json_loads(read_text_file(str(args.metadata_file)))
-
-        engine.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),
-        )
-        print("Thank you for using the NCA Engine Upload and Execution Demo")
-    except Exception as e:  # pylint: disable=w0718
-        print("An error occured ... exiting with an error")
-        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()