aplos-nca-saas-sdk 0.0.11__tar.gz → 0.0.13__tar.gz

{aplos_nca_saas_sdk-0.0.11 → aplos_nca_saas_sdk-0.0.13}/.gitignore

@@ -11,4 +11,7 @@ dist/
 # don't track environment files
 .env
 .env.*
-.config.*
+.config.*
+# exclude any output generated
+.aplos-nca-output
+.output

{aplos_nca_saas_sdk-0.0.11 → aplos_nca_saas_sdk-0.0.13}/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-0.0.11 → aplos_nca_saas_sdk-0.0.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aplos_nca_saas_sdk
-Version: 0.0.11
+Version: 0.0.13
 Summary: Aplos NCA SaaS SDK
 Project-URL: Homepage, https://aplosanalytics.com/
 Project-URL: Documentation, https://docs.aplosanalytics.com/

{aplos_nca_saas_sdk-0.0.11 → aplos_nca_saas_sdk-0.0.13}/pyproject.toml

@@ -26,7 +26,7 @@ keywords = [
     "Clinical Trials"
 ]
 
-version = "0.0.11"
+version = "0.0.13"
 authors = [
   { name="Eric Wilson", email="eric.wilson@aplosanalytics.com" }
 ]

{aplos_nca_saas_sdk-0.0.11 → aplos_nca_saas_sdk-0.0.13}/src/aplos_nca_saas_sdk/integration_testing/configs/_config_base.py

@@ -1,5 +1,10 @@
-from typing import Dict
-from typing import Any
+"""
+Copyright 2024-2025 Aplos Analytics
+All Rights Reserved.   www.aplosanalytics.com   LICENSED MATERIALS
+Property of Aplos Analytics, Utah, USA
+"""
+
+from typing import Dict, Any
 
 
 class ConfigBase:

aplos_nca_saas_sdk-0.0.13/src/aplos_nca_saas_sdk/integration_testing/configs/app_settings_config.py

@@ -0,0 +1,88 @@
+"""
+Copyright 2024-2025 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 ApplicationHostConfig(ConfigBase):
+    """
+    Application host: Defines the domains that the application configuration tests will check against
+
+    """
+
+    def __init__(self, host: str | None = None):
+        super().__init__()
+        self.__host: str | None = host
+
+    @property
+    def host(self) -> str:
+        """The host to validate"""
+        if self.__host is None:
+            raise RuntimeError("host is not set")
+        return self.__host
+
+    @host.setter
+    def host(self, value: str):
+        self.__host = value
+
+
+class ApplicationDomainConfigs(ConfigBase):
+    """
+    Application ApplicationDomain: Defines the Domains that the application configuration tests will check against
+
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.__hosts: List[ApplicationHostConfig] = []
+
+    @property
+    def list(self) -> List[ApplicationHostConfig]:
+        """List the logins"""
+        return self.__hosts
+
+    def add(self, *, host: str, enabled: bool = True):
+        """Add a loging"""
+        app_domain = ApplicationHostConfig()
+        app_domain.host = host
+        app_domain.enabled = enabled
+        self.__hosts.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", [])
+
+        host: Dict[str, Any]
+        for host in domains:
+            app_domain = ApplicationHostConfig()
+            app_domain.host = host.get("host", None)
+            app_domain.enabled = bool(host.get("enabled", True))
+
+            self.__hosts.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.__hosts: ApplicationDomainConfigs = ApplicationDomainConfigs()
+
+    @property
+    def domains(self) -> ApplicationDomainConfigs:
+        """List of the host"""
+        return self.__hosts
+
+    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-0.0.11 → aplos_nca_saas_sdk-0.0.13}/src/aplos_nca_saas_sdk/integration_testing/configs/config_sample.json

@@ -3,15 +3,15 @@
         "purpose": "Tests the application configuration endpoints",
         "domains": [
             {
-                "domain": "api.example.com",
-                "expected_results" : {
+                "host": "api.example.com",
+                "expected_results": {
                     "status_code": 200
                 },
                 "enabled": true
             },
             {
-                "domain": "XXXXXXXXXXXXXXXXXXXXX",
-                "expected_results" : {
+                "host": "XXXXXXXXXXXXXXXXXXXXX",
+                "expected_results": {
                     "status_code": 403
                 },
                 "enabled": false
@@ -24,23 +24,22 @@
             {
                 "username": "foo",
                 "password": "barr",
-                "domain": "api.example.com",
+                "host": "api.example.com",
                 "roles": []
-                
             },
             {
                 "username": "XXXXXXXXXXXXXXXXXXXXX",
                 "password": "XXXXXXXXXXXXXXXXXXXXX",
-                "domain": "XXXXXXXXXXXXXXXXXXXXX",
+                "host": "XXXXXXXXXXXXXXXXXXXXX",
                 "roles": [
                     "XXXXXXXXXXXXXXXXXXXXX"
                 ],
-                "enabled" : false,
-                "expected_results" : {
+                "enabled": false,
+                "expected_results": {
                     "exception": "InvalidCredentialsException"
                 }
             }
-        ]    
+        ]
     },
     "file_upload_test": {
         "purpose": "Tests the file upload endpoints.",
@@ -49,7 +48,7 @@
             "purpose": "optional: if present this login is used, unless a specific login is defined for the test",
             "username": "foo",
             "password": "bar",
-            "domain": "api.example.com"          
+            "host": "api.example.com"
         },
         "files": [
             {
@@ -57,11 +56,11 @@
             },
             {
                 "file": "XXXXXXXXXXXXXXXXXXXXX",
-                "login" : {
+                "login": {
                     "purpose": "optional: if present tests an upload for a specific user",
                     "username": "XXXXXXXXXXXXXXXXXXXXX",
                     "password": "XXXXXXXXXXXXXXXXXXXXX",
-                    "domain": "XXXXXXXXXXXXXXXXXXXXX" 
+                    "host": "XXXXXXXXXXXXXXXXXXXXX"
                 }
             }
         ]
@@ -71,14 +70,29 @@
         "login": {
             "username": "XXXXXXXXXXXXXXXXXXXXX",
             "password": "XXXXXXXXXXXXXXXXXXXXX",
-            "domain": "XXXXXXXXXXXXXXXXXXXXX"          
+            "host": "XXXXXXXXXXXXXXXXXXXXX"
         },
+        "output_dir": "XXXXXXXXXXXXXXXXXXXXX",
         "analyses": [
-            {                
+            {
+                "file": "XXXXXXXXXXXXXXXXXXXXX",
+                "meta": {},
+                "config": {},
+                "expected_results": {
+                    "status_code": 200
+                },
+                "output_dir": "XXXXXXXXXXXXXXXXXXXXX"
+            },
+            {
                 "file": "XXXXXXXXXXXXXXXXXXXXX",
                 "meta": {},
                 "config": {},
-                "expected_results" : {
+                "login": {
+                    "username": "XXXXXXXXXXXXXXXXXXXXX",
+                    "password": "XXXXXXXXXXXXXXXXXXXXX",
+                    "host": "XXXXXXXXXXXXXXXXXXXXX"
+                },
+                "expected_results": {
                     "status_code": 200
                 }
             }
@@ -89,11 +103,10 @@
         "login": {
             "username": "XXXXXXXXXXXXXXXXXXXXX",
             "password": "XXXXXXXXXXXXXXXXXXXXX",
-            "domain": "XXXXXXXXXXXXXXXXXXXXX"          
+            "host": "XXXXXXXXXXXXXXXXXXXXX"
         },
         "expected_results": {
             "status_code": 200
         }
     }
-    
 }

aplos_nca_saas_sdk-0.0.13/src/aplos_nca_saas_sdk/integration_testing/configs/file_upload_config.py

@@ -0,0 +1,94 @@
+"""
+Copyright 2024-2025 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_config import (
+    LoginConfig,
+    LoginConfigs,
+)
+from aplos_nca_saas_sdk.utilities.environment_services import EnvironmentServices
+from aplos_nca_saas_sdk.utilities.file_utility import FileUtility
+
+
+class FileUploadConfig(ConfigBase):
+    """
+    File Upload: Defines the login that the application configuration tests will check against
+
+    """
+
+    def __init__(self, login: LoginConfig, file_path: str):
+        super().__init__()
+        if login is None:
+            raise RuntimeError("Login is required")
+        self.__login = login
+        if file_path is None:
+            raise RuntimeError("file_path is required")
+        self.__filepath = file_path
+
+    @property
+    def login(self) -> LoginConfig:
+        """The users login"""
+        return self.__login
+
+    @property
+    def file_path(self) -> str:
+        """The file path to file being uploaded"""
+        path = FileUtility.load_filepath(self.__filepath)
+
+        if not os.path.exists(path):
+            raise RuntimeError(f"The Upload File was not found: {path}")
+
+        return path
+
+
+class FileUploadConfigs(ConfigBase):
+    """
+    File Uploads: Defines the files that the application file upload tests will check against
+
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.__fileuploads: List[FileUploadConfig] = []
+
+    @property
+    def list(self) -> List[FileUploadConfig]:
+        """List the file uploads"""
+        return list(filter(lambda x: x.enabled, self.__fileuploads))
+
+    def add(self, *, file_path: str, login: LoginConfig, enabled: bool = True):
+        """Add a file upload"""
+        file_upload = FileUploadConfig(login, file_path)
+        file_upload.enabled = enabled
+        self.__fileuploads.append(file_upload)
+
+    def load(self, test_config: Dict[str, Any]):
+        """Load the file uploads from a list of dictionaries"""
+
+        super().load(test_config)
+        test_config_login: LoginConfig | None = LoginConfigs.try_load_login(
+            test_config.get("login", None)
+        )
+        file_uploads: List[Dict[str, Any]] = test_config.get("files", [])
+        login: LoginConfig | None = None
+        for file_upload in file_uploads:
+            enabled = bool(file_upload.get("enabled", True))
+            if "login" in file_upload:
+                login = LoginConfigs.try_load_login(file_upload["login"])
+            else:
+                login = test_config_login
+
+            file_path = file_upload.get("file", None)
+
+            if not file_path:
+                raise RuntimeError("file_path is required")
+
+            if not login:
+                raise RuntimeError("login configuration is required")
+
+            self.add(file_path=file_path, login=login, enabled=enabled)

aplos_nca_saas_sdk-0.0.11/src/aplos_nca_saas_sdk/integration_testing/configs/login.py → aplos_nca_saas_sdk-0.0.13/src/aplos_nca_saas_sdk/integration_testing/configs/login_config.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,7 +8,7 @@ from typing import List, Optional, Dict, Any
 from aplos_nca_saas_sdk.integration_testing.configs._config_base import ConfigBase
 
 
-class Login(ConfigBase):
+class LoginConfig(ConfigBase):
     """
     Application Login: Defines the login that the application configuration tests will check against
 
@@ -18,13 +18,13 @@ class Login(ConfigBase):
         self,
         username: Optional[str] = None,
         passord: Optional[str] = None,
-        domain: Optional[str] = None,
+        host: Optional[str] = None,
         roles: Optional[List[str]] = None,
     ):
         super().__init__()
         self.__username: Optional[str] = username
         self.__password: Optional[str] = passord
-        self.__domain: Optional[str] = domain
+        self.__host: Optional[str] = host
         self.__roles: List[str] = roles if roles is not None else []
 
     @property
@@ -48,14 +48,15 @@ class Login(ConfigBase):
         self.__password = value
 
     @property
-    def domain(self) -> str:
-        if self.__domain is None:
-            raise RuntimeError("Domain is not set")
-        return self.__domain
+    def host(self) -> str:
+        """API Host"""
+        if self.__host is None:
+            raise RuntimeError("Host is not set")
+        return self.__host
 
-    @domain.setter
-    def domain(self, value: str):
-        self.__domain = value
+    @host.setter
+    def host(self, value: str):
+        self.__host = value
 
     @property
     def roles(self) -> List[str]:
@@ -69,7 +70,7 @@ class Login(ConfigBase):
         self.__roles = value
 
 
-class Logins(ConfigBase):
+class LoginConfigs(ConfigBase):
     """
     Application Logins: Defines the logins that the application configuration tests will check against
 
@@ -77,30 +78,42 @@ class Logins(ConfigBase):
 
     def __init__(self):
         super().__init__()
-        self.__logins: List[Login] = []
+        self.__logins: List[LoginConfig] = []
 
     @property
-    def list(self) -> List[Login]:
+    def list(self) -> List[LoginConfig]:
         """List the logins"""
         return self.__logins
 
-    def add(self, *, username: str, password: str, domain: str, enabled: bool = True):
+    def add(self, *, username: str, password: str, host: str, enabled: bool = True):
         """Add a loging"""
-        login = Login()
+        login = LoginConfig()
         login.username = username
         login.password = password
-        login.domain = domain
+        login.host = host
         login.enabled = enabled
         self.__logins.append(login)
 
     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)
         logins: List[Dict[str, str]] = test_config.get("logins", [])
         for login in logins:
-            self.add(
-                username=login["username"],
-                password=login["password"],
-                domain=login["domain"],
-            )
+            login_config = LoginConfigs.try_load_login(login)
+            if login_config is None:
+                continue
+            self.__logins.append(login_config)
+
+    @staticmethod
+    def try_load_login(login_config: Dict[str, Any]) -> LoginConfig | None:
+        """Attempts to intialize a Login from a configuration object"""
+        login: LoginConfig | None = None
+        if login_config is not None:
+            username = login_config.get("username", None)
+            password = login_config.get("password", None)
+            host = login_config.get("host", None)
+            enabled = login_config.get("enabled", True)
+            login = LoginConfig(username, password, host)
+            login.enabled = enabled
+        return login

aplos_nca_saas_sdk-0.0.13/src/aplos_nca_saas_sdk/integration_testing/configs/nca_execution_config.py

@@ -0,0 +1,186 @@
+"""
+Copyright 2024-2025 Aplos Analytics
+All Rights Reserved.   www.aplosanalytics.com   LICENSED MATERIALS
+Property of Aplos Analytics, Utah, USA
+"""
+
+import os
+import json
+from typing import Any, Dict, List
+from aplos_nca_saas_sdk.integration_testing.configs._config_base import ConfigBase
+from aplos_nca_saas_sdk.integration_testing.configs.login_config import (
+    LoginConfig,
+    LoginConfigs,
+)
+from aplos_nca_saas_sdk.utilities.file_utility import FileUtility
+from aws_lambda_powertools import Logger
+
+logger = Logger(service="NCAExecutionConfig")
+
+
+class NCAExecutionConfig(ConfigBase):
+    """
+    NCA Execution Config: Defines an NCA Execution configuration that the application execution tests will check against
+
+    """
+
+    def __init__(
+        self,
+        login: LoginConfig,
+        input_file_path: str,
+        config_data: dict,
+        meta_data: str | dict | None = None,
+        output_dir: str | None = None,
+        unzip_after_download: bool = False,
+    ):
+        super().__init__()
+
+        if login is None:
+            raise RuntimeError("login is required")
+        self.__login = login
+
+        if input_file_path is None:
+            raise RuntimeError("input_file_path is required")
+        self.__input_file_path = input_file_path
+
+        if config_data is None:
+            raise RuntimeError("config_data is required")
+        self.__config_data = config_data
+
+        self.__meta_data = meta_data
+        self.__output_dir = output_dir
+        self.__unzip_after_download = unzip_after_download
+
+    @property
+    def login(self) -> LoginConfig:
+        """Login Configuration"""
+        return self.__login
+
+    @property
+    def input_file_path(self) -> str:
+        """Input File Path"""
+        return self.__input_file_path
+
+    @property
+    def config_data(self) -> Dict[str, Any]:
+        """Config Data"""
+        return self.__config_data
+
+    @property
+    def meta_data(self) -> str | Dict[str, Any] | None:
+        """Optional Meta Data"""
+        return self.__meta_data
+
+    @property
+    def output_dir(self) -> str | None:
+        """Local Output Directory"""
+        return self.__output_dir
+
+    @property
+    def unzip_after_download(self) -> bool:
+        """Indicates if the download should be unzipped"""
+        return self.__unzip_after_download
+
+
+class NCAExecutionConfigs(ConfigBase):
+    """
+    NCA Execution Configs: Defines the configurations that the application NCA Engine tests will check against
+
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.__nca_executions: List[NCAExecutionConfig] = []
+
+    @property
+    def list(self) -> List[NCAExecutionConfig]:
+        """List the nca execution configurations"""
+        return list(filter(lambda x: x.enabled, self.__nca_executions))
+
+    def add(
+        self,
+        *,
+        login: LoginConfig,
+        input_file_path: str,
+        config_data: dict,
+        meta_data: str | dict | None = None,
+        output_dir: str | None = None,
+        unzip_after_download: bool = False,
+        enabled: bool = True,
+    ):
+        """Add an NCA Execution Config"""
+        nca_excution_config = NCAExecutionConfig(
+            login,
+            input_file_path,
+            config_data,
+            meta_data,
+            output_dir,
+            unzip_after_download,
+        )
+        nca_excution_config.enabled = enabled
+        self.__nca_executions.append(nca_excution_config)
+
+    def load(self, test_config: Dict[str, Any]):
+        """Loads the NCA Execution configs from a list of dictionaries"""
+
+        super().load(test_config)
+
+        base_login: LoginConfig | None = LoginConfigs.try_load_login(
+            test_config.get("login", None)
+        )
+        base_output_dir: str = test_config.get("output_dir", None)
+        analyses: List[Dict[str, Any]] = test_config.get("analyses", [])
+        for analysis in analyses:
+            enabled = bool(analysis.get("enabled", True))
+            login: LoginConfig | None = None
+            if "login" in analysis:
+                login = LoginConfigs.try_load_login(analysis["login"])
+            else:
+                login = base_login
+
+            if "output_dir" in analysis:
+                output_dir = analysis["output_dir"]
+            else:
+                output_dir = base_output_dir
+
+            if not login:
+                raise RuntimeError("Failed to load the login configuration")
+
+            self.add(
+                login=login,
+                input_file_path=analysis["file"],
+                config_data=self.__load_config_data(analysis=analysis),
+                meta_data=self.__load_meta_data(analysis=analysis),
+                output_dir=output_dir,
+                unzip_after_download=True,
+                enabled=enabled,
+            )
+
+    def __load_meta_data(self, analysis: Dict[str, Any]) -> Dict[str, Any]:
+        data: Dict[str, Any] = {}
+        data = analysis.get("meta", {}).get("data", {})
+
+        return data
+
+    def __load_config_data(self, analysis: Dict[str, Any]) -> Dict[str, Any]:
+        config_data: Dict[str, Any] = {}
+        config_data = analysis.get("config", {}).get("data")
+
+        if config_data:
+            return config_data
+
+        config_file_path: str = analysis.get("config", {}).get("file")
+
+        logger.info(
+            {
+                "message": "Initializing config_data from file",
+                "config_data": config_file_path,
+            }
+        )
+        config_path = FileUtility.load_filepath(config_file_path)
+        if os.path.exists(config_path) is False:
+            raise RuntimeError(f"Config file not found: {config_path}")
+        with open(config_path, "r", encoding="utf-8") as f:
+            config_data = json.load(f)
+
+        return config_data