contentctl 4.4.7__py3-none-any.whl → 5.0.0__py3-none-any.whl

contentctl/helper/splunk_app.py

@@ -39,6 +39,7 @@ class RetryConstant:
 
 class SplunkBaseError(requests.HTTPError):
     """An error raise in communicating with Splunkbase"""
+
     pass
 
 
@@ -50,6 +51,7 @@ class SplunkApp:
 
     class InitializationError(Exception):
         """An initialization error during SplunkApp setup"""
+
         pass
 
     @staticmethod
@@ -68,16 +70,16 @@ class SplunkApp:
             status_forcelist=status_forcelist,
         )
         adapter = HTTPAdapter(max_retries=retry)
-        session.mount('http://', adapter)
-        session.mount('https://', adapter)
+        session.mount("http://", adapter)
+        session.mount("https://", adapter)
         return session
 
     def __init__(
-            self,
-            app_uid: Optional[int] = None,
-            app_name_id: Optional[str] = None,
-            manual_setup: bool = False,
-            ) -> None:
+        self,
+        app_uid: Optional[int] = None,
+        app_name_id: Optional[str] = None,
+        manual_setup: bool = False,
+    ) -> None:
         if app_uid is None and app_name_id is None:
             raise SplunkApp.InitializationError(
                 "Either app_uid (the numeric app UID e.g. 742) or app_name_id (the app name "
@@ -123,18 +125,22 @@ class SplunkApp:
         if self._app_info_cache is not None:
             return self._app_info_cache
         elif self.app_uid is None:
-            raise SplunkApp.InitializationError("app_uid must be set in order to fetch app info")
+            raise SplunkApp.InitializationError(
+                "app_uid must be set in order to fetch app info"
+            )
 
         # NOTE: auth not required
         # Get app info by uid
         try:
             response = self.requests_retry_session().get(
                 APIEndPoint.SPLUNK_BASE_APP_INFO.format(app_uid=self.app_uid),
-                timeout=RetryConstant.RETRY_INTERVAL
+                timeout=RetryConstant.RETRY_INTERVAL,
             )
             response.raise_for_status()
         except requests.exceptions.RequestException as e:
-            raise SplunkBaseError(f"Error fetching app info for app_uid {self.app_uid}: {str(e)}")
+            raise SplunkBaseError(
+                f"Error fetching app info for app_uid {self.app_uid}: {str(e)}"
+            )
 
         # parse JSON and set cache
         self._app_info_cache: dict = json.loads(response.content)
@@ -156,7 +162,9 @@ class SplunkApp:
         if "appid" in app_info:
             self.app_name_id = app_info["appid"]
         else:
-            raise SplunkBaseError(f"Invalid response from Splunkbase; missing key 'appid': {app_info}")
+            raise SplunkBaseError(
+                f"Invalid response from Splunkbase; missing key 'appid': {app_info}"
+            )
 
     def set_app_uid(self) -> None:
         """
@@ -166,19 +174,25 @@ class SplunkApp:
         if self.app_uid is not None:
             return
         elif self.app_name_id is None:
-            raise SplunkApp.InitializationError("app_name_id must be set in order to fetch app_uid")
+            raise SplunkApp.InitializationError(
+                "app_name_id must be set in order to fetch app_uid"
+            )
 
         # NOTE: auth not required
         # Get app_uid by app_name_id via a redirect
         try:
             response = self.requests_retry_session().get(
-                APIEndPoint.SPLUNK_BASE_GET_UID_REDIRECT.format(app_name_id=self.app_name_id),
+                APIEndPoint.SPLUNK_BASE_GET_UID_REDIRECT.format(
+                    app_name_id=self.app_name_id
+                ),
                 allow_redirects=False,
-                timeout=RetryConstant.RETRY_INTERVAL
+                timeout=RetryConstant.RETRY_INTERVAL,
             )
             response.raise_for_status()
         except requests.exceptions.RequestException as e:
-            raise SplunkBaseError(f"Error fetching app_uid for app_name_id '{self.app_name_id}': {str(e)}")
+            raise SplunkBaseError(
+                f"Error fetching app_uid for app_name_id '{self.app_name_id}': {str(e)}"
+            )
 
         # Extract the app_uid from the redirect path
         if "Location" in response.headers:
@@ -199,7 +213,9 @@ class SplunkApp:
         if "title" in app_info:
             self.app_title = app_info["title"]
         else:
-            raise SplunkBaseError(f"Invalid response from Splunkbase; missing key 'title': {app_info}")
+            raise SplunkBaseError(
+                f"Invalid response from Splunkbase; missing key 'title': {app_info}"
+            )
 
     def __fetch_url_latest_version_info(self) -> str:
         """
@@ -209,12 +225,16 @@ class SplunkApp:
         # retrieve app entries using the app_name_id
         try:
             response = self.requests_retry_session().get(
-                APIEndPoint.SPLUNK_BASE_FETCH_APP_BY_ENTRY_ID.format(app_name_id=self.app_name_id),
-                timeout=RetryConstant.RETRY_INTERVAL
+                APIEndPoint.SPLUNK_BASE_FETCH_APP_BY_ENTRY_ID.format(
+                    app_name_id=self.app_name_id
+                ),
+                timeout=RetryConstant.RETRY_INTERVAL,
             )
             response.raise_for_status()
         except requests.exceptions.RequestException as e:
-            raise SplunkBaseError(f"Error fetching app entries for app_name_id '{self.app_name_id}': {str(e)}")
+            raise SplunkBaseError(
+                f"Error fetching app entries for app_name_id '{self.app_name_id}': {str(e)}"
+            )
 
         # parse xml
         app_xml = xmltodict.parse(response.content)
@@ -231,7 +251,9 @@ class SplunkApp:
                     return entry.get("link").get("@href")
 
         # raise if no entry was found
-        raise SplunkBaseError(f"No app entry found with 'islatest' tag set to True: {self.app_name_id}")
+        raise SplunkBaseError(
+            f"No app entry found with 'islatest' tag set to True: {self.app_name_id}"
+        )
 
     def __fetch_url_latest_version_download(self, info_url: str) -> str:
         """
@@ -241,10 +263,14 @@ class SplunkApp:
         """
         # fetch download info
         try:
-            response = self.requests_retry_session().get(info_url, timeout=RetryConstant.RETRY_INTERVAL)
+            response = self.requests_retry_session().get(
+                info_url, timeout=RetryConstant.RETRY_INTERVAL
+            )
             response.raise_for_status()
         except requests.exceptions.RequestException as e:
-            raise SplunkBaseError(f"Error fetching download info for app_name_id '{self.app_name_id}': {str(e)}")
+            raise SplunkBaseError(
+                f"Error fetching download info for app_name_id '{self.app_name_id}': {str(e)}"
+            )
 
         # parse XML and extract download URL
         build_xml = xmltodict.parse(response.content)
@@ -254,14 +280,18 @@ class SplunkApp:
     def set_latest_version_info(self) -> None:
         # raise if app_name_id not set
         if self.app_name_id is None:
-            raise SplunkApp.InitializationError("app_name_id must be set in order to fetch latest version info")
+            raise SplunkApp.InitializationError(
+                "app_name_id must be set in order to fetch latest version info"
+            )
 
         # fetch the info URL
         info_url = self.__fetch_url_latest_version_info()
 
         # parse out the version number and fetch the download URL
         self.latest_version = info_url.split("/")[-1]
-        self.latest_version_download_url = self.__fetch_url_latest_version_download(info_url)
+        self.latest_version_download_url = self.__fetch_url_latest_version_download(
+            info_url
+        )
 
     def __get_splunk_base_session_token(self, username: str, password: str) -> str:
         """
@@ -309,12 +339,12 @@ class SplunkApp:
         return token_value
 
     def download(
-            self,
-            out: Path,
-            username: str,
-            password: str,
-            is_dir: bool = False,
-            overwrite: bool = False
+        self,
+        out: Path,
+        username: str,
+        password: str,
+        is_dir: bool = False,
+        overwrite: bool = False,
     ) -> Path:
         """
         Given an output path, download the app to the specified location
@@ -336,11 +366,7 @@ class SplunkApp:
         # Get the Splunkbase session token
         token = self.__get_splunk_base_session_token(username, password)
         response = requests.request(
-            "GET",
-            self.latest_version_download_url,
-            cookies={
-                "sessionid": token
-            }
+            "GET", self.latest_version_download_url, cookies={"sessionid": token}
         )
 
         # If the provided output path was a directory we need to try and pull the filename from the
@@ -348,17 +374,21 @@ class SplunkApp:
         if is_dir:
             try:
                 # Pull 'Content-Disposition' from the headers
-                content_disposition: str = response.headers['Content-Disposition']
+                content_disposition: str = response.headers["Content-Disposition"]
 
                 # Attempt to parse the filename as a KV
                 key, value = content_disposition.strip().split("=")
                 if key != "attachment;filename":
-                    raise ValueError(f"Unexpected key in 'Content-Disposition' KV pair: {key}")
+                    raise ValueError(
+                        f"Unexpected key in 'Content-Disposition' KV pair: {key}"
+                    )
 
                 # Validate the filename is the expected .tgz file
                 filename = Path(value.strip().strip('"'))
                 if filename.suffixes != [".tgz"]:
-                    raise ValueError(f"Filename has unexpected extension(s): {filename.suffixes}")
+                    raise ValueError(
+                        f"Filename has unexpected extension(s): {filename.suffixes}"
+                    )
                 out = Path(out, filename)
             except KeyError as e:
                 raise KeyError(
@@ -371,9 +401,7 @@ class SplunkApp:
 
         # Ensure the output path is not already occupied
         if out.exists() and not overwrite:
-            msg = (
-                f"File already exists at {out}, cannot download the app."
-            )
+            msg = f"File already exists at {out}, cannot download the app."
             raise Exception(msg)
 
         # Make any parent directories as needed

contentctl/helper/utils.py

@@ -12,6 +12,7 @@ import tqdm
 from math import ceil
 
 from typing import TYPE_CHECKING
+
 if TYPE_CHECKING:
     from contentctl.objects.security_content_object import SecurityContentObject
 from contentctl.objects.security_content_object import SecurityContentObject
@@ -24,26 +25,29 @@ ALWAYS_PULL = True
 class Utils:
     @staticmethod
     def get_all_yml_files_from_directory(path: str) -> list[pathlib.Path]:
-        listOfFiles:list[pathlib.Path] = []
+        listOfFiles: list[pathlib.Path] = []
         base_path = pathlib.Path(path)
         if not base_path.exists():
             return listOfFiles
-        for (dirpath, dirnames, filenames) in os.walk(path):
+        for dirpath, dirnames, filenames in os.walk(path):
             for file in filenames:
                 if file.endswith(".yml"):
                     listOfFiles.append(pathlib.Path(os.path.join(dirpath, file)))
-    
+
         return sorted(listOfFiles)
-    
+
     @staticmethod
-    def get_security_content_files_from_directory(path: pathlib.Path, allowedFileExtensions:list[str]=[".yml"], fileExtensionsToReturn:list[str]=[".yml"]) -> list[pathlib.Path]:
-    
+    def get_security_content_files_from_directory(
+        path: pathlib.Path,
+        allowedFileExtensions: list[str] = [".yml"],
+        fileExtensionsToReturn: list[str] = [".yml"],
+    ) -> list[pathlib.Path]:
         """
         Get all of the Security Content Object Files rooted in a given directory.  These will almost
         certain be YML files, but could be other file types as specified by the user
 
         Args:
-            path (pathlib.Path): The root path at which to enumerate all Security Content Files. All directories will be traversed. 
+            path (pathlib.Path): The root path at which to enumerate all Security Content Files. All directories will be traversed.
             allowedFileExtensions (set[str], optional): File extensions which are allowed to be  present in this directory.  In most cases, we do not want to allow the presence of non-YML files. Defaults to [".yml"].
             fileExtensionsToReturn (set[str], optional): Filenames with extensions that should be returned from this function. For example, the lookups/ directory contains YML, CSV, and MLMODEL directories, but only the YMLs are Security Content Objects for constructing Lookyps. Defaults to[".yml"].
 
@@ -56,14 +60,18 @@ class Utils:
             list[pathlib.Path]: list of files with an extension in fileExtensionsToReturn found in path
         """
         if not set(fileExtensionsToReturn).issubset(set(allowedFileExtensions)):
-            raise Exception(f"allowedFileExtensions {allowedFileExtensions} MUST be a subset of fileExtensionsToReturn {fileExtensionsToReturn}, but it is not")
-        
+            raise Exception(
+                f"allowedFileExtensions {allowedFileExtensions} MUST be a subset of fileExtensionsToReturn {fileExtensionsToReturn}, but it is not"
+            )
+
         if not path.exists() or not path.is_dir():
-            raise Exception(f"Unable to get security_content files, required directory '{str(path)}' does not exist or is not a directory")
-        
-        allowedFiles:list[pathlib.Path] = []
-        erroneousFiles:list[pathlib.Path] = []
-        #Get every single file extension 
+            raise Exception(
+                f"Unable to get security_content files, required directory '{str(path)}' does not exist or is not a directory"
+            )
+
+        allowedFiles: list[pathlib.Path] = []
+        erroneousFiles: list[pathlib.Path] = []
+        # Get every single file extension
         for filePath in path.glob("**/*.*"):
             if filePath.suffix in allowedFileExtensions:
                 # Yes these are allowed
@@ -73,58 +81,75 @@ class Utils:
                 erroneousFiles.append(filePath)
 
         if len(erroneousFiles):
-            raise Exception(f"The following files are not allowed in the directory '{path}'. Only files with the extensions {allowedFileExtensions} are allowed:{[str(filePath) for filePath in erroneousFiles]}")
-        
+            raise Exception(
+                f"The following files are not allowed in the directory '{path}'. Only files with the extensions {allowedFileExtensions} are allowed:{[str(filePath) for filePath in erroneousFiles]}"
+            )
+
         # There were no errorneous files, so return the requested files
-        return sorted([filePath for filePath in allowedFiles if filePath.suffix in fileExtensionsToReturn])
+        return sorted(
+            [
+                filePath
+                for filePath in allowedFiles
+                if filePath.suffix in fileExtensionsToReturn
+            ]
+        )
 
     @staticmethod
-    def get_all_yml_files_from_directory_one_layer_deep(path: str) -> list[pathlib.Path]:
+    def get_all_yml_files_from_directory_one_layer_deep(
+        path: str,
+    ) -> list[pathlib.Path]:
         listOfFiles: list[pathlib.Path] = []
         base_path = pathlib.Path(path)
         if not base_path.exists():
             return listOfFiles
         # Check the base directory
         for item in base_path.iterdir():
-            if item.is_file() and item.suffix == '.yml':
+            if item.is_file() and item.suffix == ".yml":
                 listOfFiles.append(item)
         # Check one subfolder level deep
         for subfolder in base_path.iterdir():
             if subfolder.is_dir() and subfolder.name != "cim":
                 for item in subfolder.iterdir():
-                    if item.is_file() and item.suffix == '.yml':
+                    if item.is_file() and item.suffix == ".yml":
                         listOfFiles.append(item)
         return sorted(listOfFiles)
 
-
     @staticmethod
-    def add_id(id_dict:dict[str, list[pathlib.Path]], obj:SecurityContentObject, path:pathlib.Path) -> None:     
+    def add_id(
+        id_dict: dict[str, list[pathlib.Path]],
+        obj: SecurityContentObject,
+        path: pathlib.Path,
+    ) -> None:
         if hasattr(obj, "id"):
             obj_id = obj.id
             if obj_id in id_dict:
                 id_dict[obj_id].append(path)
             else:
                 id_dict[obj_id] = [path]
+
     # Otherwise, no ID so nothing to add....
 
     @staticmethod
-    def check_ids_for_duplicates(id_dict:dict[str, list[pathlib.Path]])->list[Tuple[pathlib.Path,  ValueError]]:
-        validation_errors:list[Tuple[pathlib.Path,  ValueError]] = []
-        
+    def check_ids_for_duplicates(
+        id_dict: dict[str, list[pathlib.Path]],
+    ) -> list[Tuple[pathlib.Path, ValueError]]:
+        validation_errors: list[Tuple[pathlib.Path, ValueError]] = []
+
         for key, values in id_dict.items():
             if len(values) > 1:
                 error_file_path = pathlib.Path("MULTIPLE")
-                all_files = '\n\t'.join(str(pathlib.Path(p)) for p in values)
-                exception = ValueError(f"Error validating id [{key}] - duplicate ID was used in the following files: \n\t{all_files}")
+                all_files = "\n\t".join(str(pathlib.Path(p)) for p in values)
+                exception = ValueError(
+                    f"Error validating id [{key}] - duplicate ID was used in the following files: \n\t{all_files}"
+                )
                 validation_errors.append((error_file_path, exception))
-                
+
         return validation_errors
 
     @staticmethod
     def validate_git_hash(
         repo_path: str, repo_url: str, commit_hash: str, branch_name: Union[str, None]
     ) -> bool:
-
         # Get a list of all branches
         repo = git.Repo(repo_path)
         if commit_hash is None:
@@ -141,14 +166,14 @@ class Utils:
             # Note, of course, that a hash can be in 0, 1, more branches!
             for branch_string in all_branches_containing_hash:
                 if branch_string.split(" ")[0] == "*" and (
-                    branch_string.split(" ")[-1] == branch_name or branch_name == None
+                    branch_string.split(" ")[-1] == branch_name or branch_name is None
                 ):
                     # Yes, the hash exists in the branch (or branch_name was None and it existed in at least one branch)!
                     return True
             # If we get here, it does not exist in the given branch
             raise (Exception("Does not exist in branch"))
 
-        except Exception as e:
+        except Exception:
             if branch_name is None:
                 branch_name = "ANY_BRANCH"
             if ALWAYS_PULL:
@@ -247,25 +272,10 @@ class Utils:
 
         return hash
 
-    # @staticmethod
-    # def check_required_fields(
-    #     thisField: str, definedFields: dict, requiredFields: list[str]
-    # ):
-    #     missing_fields = [
-    #         field for field in requiredFields if field not in definedFields
-    #     ]
-    #     if len(missing_fields) > 0:
-    #         raise (
-    #             ValueError(
-    #                 f"Could not validate - please resolve other errors resulting in missing fields {missing_fields}"
-    #             )
-    #         )
-
     @staticmethod
     def verify_file_exists(
         file_path: str, verbose_print=False, timeout_seconds: int = 10
     ) -> None:
-
         try:
             if pathlib.Path(file_path).is_file():
                 # This is a file and we know it exists
@@ -275,18 +285,13 @@ class Utils:
 
         # Try to make a head request to verify existence of the file
         try:
-            
             req = requests.head(
                 file_path, timeout=timeout_seconds, verify=True, allow_redirects=True
             )
             if req.status_code > 400:
                 raise (Exception(f"Return code={req.status_code}"))
         except Exception as e:
-            raise (
-                Exception(
-                    f"HTTP Resolution Failed: {str(e)}"
-                )
-            )
+            raise (Exception(f"HTTP Resolution Failed: {str(e)}"))
 
     @staticmethod
     def copy_local_file(
@@ -390,7 +395,7 @@ class Utils:
             )
 
         try:
-            download_start_time = default_timer()
+            default_timer()
             bytes_written = 0
             file_to_download = requests.get(file_path, stream=True)
             file_to_download.raise_for_status()

contentctl/input/director.py

@@ -14,7 +14,7 @@ from contentctl.objects.investigation import Investigation
 from contentctl.objects.playbook import Playbook
 from contentctl.objects.deployment import Deployment
 from contentctl.objects.macro import Macro
-from contentctl.objects.lookup import Lookup
+from contentctl.objects.lookup import LookupAdapter, Lookup
 from contentctl.objects.atomic import AtomicEnrichment
 from contentctl.objects.security_content_object import SecurityContentObject
 from contentctl.objects.data_source import DataSource
@@ -29,7 +29,7 @@ from contentctl.helper.utils import Utils
 
 @dataclass
 class DirectorOutputDto:
-    # Atomic Tests are first because parsing them 
+    # Atomic Tests are first because parsing them
     # is far quicker than attack_enrichment
     atomic_enrichment: AtomicEnrichment
     attack_enrichment: AttackEnrichment
@@ -50,15 +50,14 @@ class DirectorOutputDto:
 
     def addContentToDictMappings(self, content: SecurityContentObject):
         content_name = content.name
-        
-        
+
         if content_name in self.name_to_content_map:
             raise ValueError(
                 f"Duplicate name '{content_name}' with paths:\n"
                 f" - {content.file_path}\n"
                 f" - {self.name_to_content_map[content_name].file_path}"
             )
-        
+
         if content.id in self.uuid_to_content_map:
             raise ValueError(
                 f"Duplicate id '{content.id}' with paths:\n"
@@ -83,7 +82,7 @@ class DirectorOutputDto:
         elif isinstance(content, Detection):
             self.detections.append(content)
         elif isinstance(content, Dashboard):
-            self.dashboards.append(content)            
+            self.dashboards.append(content)
 
         elif isinstance(content, DataSource):
             self.data_sources.append(content)
@@ -94,7 +93,7 @@ class DirectorOutputDto:
         self.uuid_to_content_map[content.id] = content
 
 
-class Director():
+class Director:
     input_dto: validate
     output_dto: DirectorOutputDto
 
@@ -113,13 +112,18 @@ class Director():
         self.createSecurityContent(SecurityContentType.playbooks)
         self.createSecurityContent(SecurityContentType.detections)
         self.createSecurityContent(SecurityContentType.dashboards)
-        
-        from contentctl.objects.abstract_security_content_objects.detection_abstract import MISSING_SOURCES
+
+        from contentctl.objects.abstract_security_content_objects.detection_abstract import (
+            MISSING_SOURCES,
+        )
+
         if len(MISSING_SOURCES) > 0:
             missing_sources_string = "\n 🟡 ".join(sorted(list(MISSING_SOURCES)))
-            print("WARNING: The following data_sources have been used in detections, but are not yet defined.\n"
-                  "This is not yet an error since not all data_sources have been defined, but will be convered to an error soon:\n 🟡 "
-                  f"{missing_sources_string}")
+            print(
+                "WARNING: The following data_sources have been used in detections, but are not yet defined.\n"
+                "This is not yet an error since not all data_sources have been defined, but will be convered to an error soon:\n 🟡 "
+                f"{missing_sources_string}"
+            )
         else:
             print("No missing data_sources!")
 
@@ -134,18 +138,20 @@ class Director():
             SecurityContentType.playbooks,
             SecurityContentType.detections,
             SecurityContentType.data_sources,
-            SecurityContentType.dashboards
+            SecurityContentType.dashboards,
         ]:
             files = Utils.get_all_yml_files_from_directory(
                 os.path.join(self.input_dto.path, str(contentType.name))
             )
-            security_content_files = [
-                f for f in files 
-            ]
+            security_content_files = [f for f in files]
         else:
-            raise (Exception(f"Cannot createSecurityContent for unknown product {contentType}."))
+            raise (
+                Exception(
+                    f"Cannot createSecurityContent for unknown product {contentType}."
+                )
+            )
 
-        validation_errors:list[tuple[Path,ValueError]] = []
+        validation_errors: list[tuple[Path, ValueError]] = []
 
         already_ran = False
         progress_percent = 0
@@ -157,40 +163,67 @@ class Director():
                 modelDict = YmlReader.load_file(file)
 
                 if contentType == SecurityContentType.lookups:
-                    lookup = Lookup.model_validate(modelDict, context={"output_dto":self.output_dto, "config":self.input_dto})
+                    lookup = LookupAdapter.validate_python(
+                        modelDict,
+                        context={
+                            "output_dto": self.output_dto,
+                            "config": self.input_dto,
+                        },
+                    )
+                    # lookup = Lookup.model_validate(modelDict, context={"output_dto":self.output_dto, "config":self.input_dto})
                     self.output_dto.addContentToDictMappings(lookup)
-                
+
                 elif contentType == SecurityContentType.macros:
-                    macro = Macro.model_validate(modelDict, context={"output_dto":self.output_dto})
+                    macro = Macro.model_validate(
+                        modelDict, context={"output_dto": self.output_dto}
+                    )
                     self.output_dto.addContentToDictMappings(macro)
-                
+
                 elif contentType == SecurityContentType.deployments:
-                    deployment = Deployment.model_validate(modelDict, context={"output_dto":self.output_dto})
+                    deployment = Deployment.model_validate(
+                        modelDict, context={"output_dto": self.output_dto}
+                    )
                     self.output_dto.addContentToDictMappings(deployment)
 
                 elif contentType == SecurityContentType.playbooks:
-                    playbook = Playbook.model_validate(modelDict, context={"output_dto":self.output_dto})
-                    self.output_dto.addContentToDictMappings(playbook)                  
-                
+                    playbook = Playbook.model_validate(
+                        modelDict, context={"output_dto": self.output_dto}
+                    )
+                    self.output_dto.addContentToDictMappings(playbook)
+
                 elif contentType == SecurityContentType.baselines:
-                    baseline = Baseline.model_validate(modelDict, context={"output_dto":self.output_dto})
+                    baseline = Baseline.model_validate(
+                        modelDict, context={"output_dto": self.output_dto}
+                    )
                     self.output_dto.addContentToDictMappings(baseline)
-                
+
                 elif contentType == SecurityContentType.investigations:
-                    investigation = Investigation.model_validate(modelDict, context={"output_dto":self.output_dto})
+                    investigation = Investigation.model_validate(
+                        modelDict, context={"output_dto": self.output_dto}
+                    )
                     self.output_dto.addContentToDictMappings(investigation)
 
                 elif contentType == SecurityContentType.stories:
-                    story = Story.model_validate(modelDict, context={"output_dto":self.output_dto})
+                    story = Story.model_validate(
+                        modelDict, context={"output_dto": self.output_dto}
+                    )
                     self.output_dto.addContentToDictMappings(story)
-            
+
                 elif contentType == SecurityContentType.detections:
-                    detection = Detection.model_validate(modelDict, context={"output_dto":self.output_dto, "app":self.input_dto.app})
+                    detection = Detection.model_validate(
+                        modelDict,
+                        context={
+                            "output_dto": self.output_dto,
+                            "app": self.input_dto.app,
+                        },
+                    )
                     self.output_dto.addContentToDictMappings(detection)
-                
+
                 elif contentType == SecurityContentType.dashboards:
-                        dashboard = Dashboard.model_validate(modelDict,context={"output_dto":self.output_dto})
-                        self.output_dto.addContentToDictMappings(dashboard)
+                    dashboard = Dashboard.model_validate(
+                        modelDict, context={"output_dto": self.output_dto}
+                    )
+                    self.output_dto.addContentToDictMappings(dashboard)
 
                 elif contentType == SecurityContentType.data_sources:
                     data_source = DataSource.model_validate(
@@ -237,4 +270,3 @@ class Director():
             raise Exception(
                 f"The following {len(validation_errors)} error(s) were found during validation:\n\n{errors_string}\n\nVALIDATION FAILED"
             )
-