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

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

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

{aplos_nca_saas_sdk-0.0.11 → aplos_nca_saas_sdk-0.0.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aplos_nca_saas_sdk
-Version: 0.0.11
+Version: 0.0.12
 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.12}/pyproject.toml

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

{aplos_nca_saas_sdk-0.0.11 → aplos_nca_saas_sdk-0.0.12}/src/aplos_nca_saas_sdk/aws_resources/aws_cognito.py

@@ -14,10 +14,9 @@ from aplos_nca_saas_sdk.nca_resources.nca_app_configuration import (
 )
 
 
-class CognitoAuthenication:
+class CognitoAuthentication:
     """
     Cognito Authentication
-
     """
 
     def __init__(
@@ -73,6 +72,12 @@ class CognitoAuthenication:
         return self.__region
 
     def __validate_parameters(self) -> None:
+        """
+        Validate the required parameters.
+        We need either:
+          - the Cognito ClientId and Cognito Region
+          - or the Aplos Domain (which can get the clientId and region)
+        """
         if self.__client_id is None and self.__aplos_domain is not None:
             self.__config = NCAAppConfiguration(aplos_saas_domain=self.__aplos_domain)
             self.__client_id = self.__config.cognito_client_id
@@ -81,14 +86,12 @@ class CognitoAuthenication:
         if self.__client_id is None:
             raise RuntimeError(
                 "Missing Cognito Client Id. "
-                "Pass in a client_id as a command arg or set the COGNITO_CLIENT_ID enviornment var. "
                 "Alternatively, set the aplos_domain to automatically get the client_id and region."
             )
 
         if self.__region is None:
             raise RuntimeError(
                 "Missing Cognito Region"
-                "Pass in a region as a command arg or set the COGNITO_REGION enviornment var. "
                 "Alternatively, set the aplos_domain to automatically get the client_id and region."
             )
 
@@ -139,13 +142,16 @@ class CognitoAuthenication:
             self.__parse_jwt(self.__jwt)
             return self.__jwt
 
-        raise RuntimeError("Failed to get a JWT token")
+        raise RuntimeError(
+            "Failed to get a JWT token.  Check the error logs for more information."
+        )
 
     def __parse_jwt(self, encoded_jwt: str) -> None:
         # Decode the payload (second part) from Base64
         decoded_jwt: dict = jwt_lib.decode(
             encoded_jwt, options={"verify_signature": False}
         )
+        # custom fields contain information we'll need for later requests
         self.__user_id = decoded_jwt.get("custom:aplos_user_id")
         self.__tenant_id = decoded_jwt.get("custom:aplos_user_tenant_id")
 

aplos_nca_saas_sdk-0.0.11/src/aplos_nca_saas_sdk/integration_testing/configs/app_settings.py → aplos_nca_saas_sdk-0.0.12/src/aplos_nca_saas_sdk/integration_testing/configs/app_settings_config.py

@@ -8,7 +8,7 @@ from typing import List, Dict, Any
 from aplos_nca_saas_sdk.integration_testing.configs._config_base import ConfigBase
 
 
-class ApplicationDomain(ConfigBase):
+class ApplicationDomainConfig(ConfigBase):
     """
     Application Domain: Defines the domains that the application configuration tests will check against
 
@@ -30,7 +30,7 @@ class ApplicationDomain(ConfigBase):
         self.__domain = value
 
 
-class ApplicationDomains(ConfigBase):
+class ApplicationDomainConfigs(ConfigBase):
     """
     Application ApplicationDomain: Defines the Domains that the application configuration tests will check against
 
@@ -38,16 +38,16 @@ class ApplicationDomains(ConfigBase):
 
     def __init__(self):
         super().__init__()
-        self.__domains: List[ApplicationDomain] = []
+        self.__domains: List[ApplicationDomainConfig] = []
 
     @property
-    def list(self) -> List[ApplicationDomain]:
+    def list(self) -> List[ApplicationDomainConfig]:
         """List the logins"""
         return self.__domains
 
     def add(self, *, domain: str, enabled: bool = True):
         """Add a loging"""
-        app_domain = ApplicationDomain()
+        app_domain = ApplicationDomainConfig()
         app_domain.domain = domain
         app_domain.enabled = enabled
         self.__domains.append(app_domain)
@@ -60,7 +60,7 @@ class ApplicationDomains(ConfigBase):
 
         domain: Dict[str, Any]
         for domain in domains:
-            app_domain = ApplicationDomain()
+            app_domain = ApplicationDomainConfig()
             app_domain.domain = domain.get("domain", None)
             app_domain.enabled = bool(domain.get("enabled", True))
 
@@ -75,10 +75,10 @@ class ApplicationSettings(ConfigBase):
 
     def __init__(self):
         super().__init__()
-        self.__domains: ApplicationDomains = ApplicationDomains()
+        self.__domains: ApplicationDomainConfigs = ApplicationDomainConfigs()
 
     @property
-    def domains(self) -> ApplicationDomains:
+    def domains(self) -> ApplicationDomainConfigs:
         """List of the domain"""
         return self.__domains
 

{aplos_nca_saas_sdk-0.0.11 → aplos_nca_saas_sdk-0.0.12}/src/aplos_nca_saas_sdk/integration_testing/configs/config_sample.json

@@ -4,14 +4,14 @@
         "domains": [
             {
                 "domain": "api.example.com",
-                "expected_results" : {
+                "expected_results": {
                     "status_code": 200
                 },
                 "enabled": true
             },
             {
                 "domain": "XXXXXXXXXXXXXXXXXXXXX",
-                "expected_results" : {
+                "expected_results": {
                     "status_code": 403
                 },
                 "enabled": false
@@ -26,7 +26,6 @@
                 "password": "barr",
                 "domain": "api.example.com",
                 "roles": []
-                
             },
             {
                 "username": "XXXXXXXXXXXXXXXXXXXXX",
@@ -35,12 +34,12 @@
                 "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"          
+            "domain": "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" 
+                    "domain": "XXXXXXXXXXXXXXXXXXXXX"
                 }
             }
         ]
@@ -71,14 +70,29 @@
         "login": {
             "username": "XXXXXXXXXXXXXXXXXXXXX",
             "password": "XXXXXXXXXXXXXXXXXXXXX",
-            "domain": "XXXXXXXXXXXXXXXXXXXXX"          
+            "domain": "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",
+                    "domain": "XXXXXXXXXXXXXXXXXXXXX"
+                },
+                "expected_results": {
                     "status_code": 200
                 }
             }
@@ -89,11 +103,10 @@
         "login": {
             "username": "XXXXXXXXXXXXXXXXXXXXX",
             "password": "XXXXXXXXXXXXXXXXXXXXX",
-            "domain": "XXXXXXXXXXXXXXXXXXXXX"          
+            "domain": "XXXXXXXXXXXXXXXXXXXXX"
         },
         "expected_results": {
             "status_code": 200
         }
     }
-    
 }

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

@@ -0,0 +1,94 @@
+"""
+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_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.12/src/aplos_nca_saas_sdk/integration_testing/configs/login_config.py

@@ -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
 
@@ -69,7 +69,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,16 +77,16 @@ 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):
         """Add a loging"""
-        login = Login()
+        login = LoginConfig()
         login.username = username
         login.password = password
         login.domain = domain
@@ -95,12 +95,24 @@ class Logins(ConfigBase):
 
     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)
+            domain = login_config.get("domain", None)
+            enabled = login_config.get("enabled", True)
+            login = LoginConfig(username, password, domain)
+            login.enabled = enabled
+        return login

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

@@ -0,0 +1,186 @@
+"""
+Copyright 2024 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

aplos_nca_saas_sdk-0.0.12/src/aplos_nca_saas_sdk/integration_testing/files/executions/config1.json

@@ -0,0 +1,46 @@
+{
+    "version": "2024-02-22",
+    "designations": {
+      "blq": "BLQ",
+      "missing": "NS",
+      "concentration_unit": "ng/mL"
+    },
+    "columns": {
+      "time": "time",
+      "unique_id": "subject",
+      "concentration": {
+        "observed": "conc_obs",
+        "analyzed": "conc"
+      },
+      "sorting": [
+        "subject",
+        "time"
+      ],
+      "grouping": [
+        "subject"
+      ]
+    },
+    "dosing": {
+      "amount": 10000,
+      "unit": "mg",
+      "frequency": "single",
+      "type": "ev"
+    },
+    "time": {
+      "unit": "hr",
+      "time_of_administration": 0      
+    },
+    "kel_rules": {
+      "regression_statistic": "adj_r2",
+      "minimum_statistic": 0,
+      "maximum_extrapolation_linear": 0,
+      "maximum_extrapolation_logarithmic": 0,
+      "maximum_time_points": 0,
+      "minimum_span": 0,
+      "earliest_time_point": 0,
+      "tie": [
+        "kel_n",
+        "kel_lower"
+      ]
+    }
+  }

{aplos_nca_saas_sdk-0.0.11 → aplos_nca_saas_sdk-0.0.12}/src/aplos_nca_saas_sdk/integration_testing/integration_test_base.py

@@ -21,11 +21,18 @@ class IntegrationTestBase(ABC):
     """
 
     def __init__(self, name: str | None = None, index: int = 0):
-        self.name = name
+        self.__name = name
         self.index = index
         self.__config: TestConfiguration = TestConfiguration()
         self.__results: List[IntegrationTestResponse] = []
 
+    @property
+    def name(self) -> str:
+        """
+        Get the name of the test
+        """
+        return self.__name if self.__name is not None else self.__class__.__name__
+
     @property
     def config(self) -> TestConfiguration:
         """