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

contentctl/output/conf_writer.py

@@ -1,16 +1,17 @@
-from typing import Any
+import configparser
 import datetime
-import re
-import os
 import json
-import configparser
-from xmlrpc.client import APPLICATION_ERROR
-from jinja2 import Environment, FileSystemLoader, StrictUndefined
+import os
 import pathlib
-from contentctl.objects.security_content_object import SecurityContentObject
-from contentctl.objects.dashboard import Dashboard
-from contentctl.objects.config import build
+import re
 import xml.etree.ElementTree as ET
+from typing import Any, Sequence
+
+from jinja2 import Environment, FileSystemLoader, StrictUndefined
+
+from contentctl.objects.config import CustomApp, build
+from contentctl.objects.dashboard import Dashboard
+from contentctl.objects.security_content_object import SecurityContentObject
 
 # This list is not exhaustive of all default conf files, but should be
 # sufficient for our purposes.
@@ -82,59 +83,68 @@ DEFAULT_CONF_FILES = [
     "workload_rules.conf",
 ]
 
-class ConfWriter():
 
+class ConfWriter:
     @staticmethod
-    def custom_jinja2_enrichment_filter(string:str, object:SecurityContentObject):    
+    def custom_jinja2_enrichment_filter(string: str, object: SecurityContentObject):
         substitutions = re.findall(r"%[^%]*%", string)
         updated_string = string
         for sub in substitutions:
-            sub_without_percents = sub.replace("%","")
+            sub_without_percents = sub.replace("%", "")
             if hasattr(object, sub_without_percents):
-                updated_string = updated_string.replace(sub, str(getattr(object, sub_without_percents)))
-            elif hasattr(object,'tags') and hasattr(object.tags, sub_without_percents):
-                    updated_string = updated_string.replace(sub, str(getattr(object.tags, sub_without_percents)))
+                updated_string = updated_string.replace(
+                    sub, str(getattr(object, sub_without_percents))
+                )
+            elif hasattr(object, "tags") and hasattr(object.tags, sub_without_percents):
+                updated_string = updated_string.replace(
+                    sub, str(getattr(object.tags, sub_without_percents))
+                )
             else:
                 raise Exception(f"Unable to find field {sub} in object {object.name}")
-        
+
         return updated_string
-    
+
     @staticmethod
-    def escapeNewlines(obj:Any):
+    def escapeNewlines(obj: Any):
         # Ensure that any newlines that occur in a string are escaped with a \.
         # Failing to do so will result in an improperly formatted conf files that
         # cannot be parsed
-        if isinstance(obj,str):
-            # Remove leading and trailing characters. Conf parsers may erroneously 
-            # Parse fields if they have leading or trailing newlines/whitespace and we 
+        if isinstance(obj, str):
+            # Remove leading and trailing characters. Conf parsers may erroneously
+            # Parse fields if they have leading or trailing newlines/whitespace and we
             # probably don't want that anyway as it doesn't look good in output
-            return obj.strip().replace(f"\n"," \\\n")
+            return obj.strip().replace("\n", " \\\n")
         else:
             return obj
 
-
     @staticmethod
-    def writeConfFileHeader(app_output_path:pathlib.Path, config: build) -> pathlib.Path:
-        output = ConfWriter.writeFileHeader(app_output_path, config)    
-        
-        output_path = config.getPackageDirectoryPath()/app_output_path
+    def writeConfFileHeader(
+        app_output_path: pathlib.Path, config: build
+    ) -> pathlib.Path:
+        output = ConfWriter.writeFileHeader(app_output_path, config)
+
+        output_path = config.getPackageDirectoryPath() / app_output_path
         output_path.parent.mkdir(parents=True, exist_ok=True)
-        with open(output_path, 'w') as f:
-            output = output.encode('utf-8', 'ignore').decode('utf-8')
+        with open(output_path, "w") as f:
+            output = output.encode("utf-8", "ignore").decode("utf-8")
             f.write(output)
 
-        #Ensure that the conf file we just generated/update is syntactically valid
-        ConfWriter.validateConfFile(output_path)        
+        # Ensure that the conf file we just generated/update is syntactically valid
+        ConfWriter.validateConfFile(output_path)
         return output_path
 
     @staticmethod
-    def getCustomConfFileStems(config:build)->list[str]:
+    def getCustomConfFileStems(config: build) -> list[str]:
         # Get all the conf files in the default directory. We must make a reload.conf_file = simple key/value for them if
         # they are custom conf files
-        default_path = config.getPackageDirectoryPath()/"default"
+        default_path = config.getPackageDirectoryPath() / "default"
         conf_files = default_path.glob("*.conf")
-        
-        custom_conf_file_stems = [conf_file.stem for conf_file in conf_files if conf_file.name not in DEFAULT_CONF_FILES]
+
+        custom_conf_file_stems = [
+            conf_file.stem
+            for conf_file in conf_files
+            if conf_file.name not in DEFAULT_CONF_FILES
+        ]
         return sorted(custom_conf_file_stems)
 
     @staticmethod
@@ -145,16 +155,17 @@ class ConfWriter():
         j2_env = ConfWriter.getJ2Environment()
         template = j2_env.get_template(template_name)
 
-        output = template.render(custom_conf_files=ConfWriter.getCustomConfFileStems(config))
-        
-        output_path = config.getPackageDirectoryPath()/app_output_path
+        output = template.render(
+            custom_conf_files=ConfWriter.getCustomConfFileStems(config)
+        )
+
+        output_path = config.getPackageDirectoryPath() / app_output_path
         output_path.parent.mkdir(parents=True, exist_ok=True)
-        with open(output_path, 'a') as f:
-            output = output.encode('utf-8', 'ignore').decode('utf-8')
+        with open(output_path, "a") as f:
+            output = output.encode("utf-8", "ignore").decode("utf-8")
             f.write(output)
         return output_path
 
-
     @staticmethod
     def writeAppConf(config: build) -> pathlib.Path:
         app_output_path = pathlib.Path("default/app.conf")
@@ -163,135 +174,195 @@ class ConfWriter():
         j2_env = ConfWriter.getJ2Environment()
         template = j2_env.get_template(template_name)
 
-        output = template.render(custom_conf_files=ConfWriter.getCustomConfFileStems(config), 
-                                 app=config.app)
-        
-        output_path = config.getPackageDirectoryPath()/app_output_path
+        output = template.render(
+            custom_conf_files=ConfWriter.getCustomConfFileStems(config), app=config.app
+        )
+
+        output_path = config.getPackageDirectoryPath() / app_output_path
         output_path.parent.mkdir(parents=True, exist_ok=True)
-        with open(output_path, 'a') as f:
-            output = output.encode('utf-8', 'ignore').decode('utf-8')
+        with open(output_path, "a") as f:
+            output = output.encode("utf-8", "ignore").decode("utf-8")
             f.write(output)
         return output_path
 
     @staticmethod
-    def writeManifestFile(app_output_path:pathlib.Path, template_name : str, config: build, objects : list) -> pathlib.Path:
+    def writeManifestFile(
+        app_output_path: pathlib.Path,
+        template_name: str,
+        config: build,
+        objects: list[CustomApp],
+    ) -> pathlib.Path:
         j2_env = ConfWriter.getJ2Environment()
         template = j2_env.get_template(template_name)
-        
-        output = template.render(objects=objects, app=config.app, currentDate=datetime.datetime.now(datetime.UTC).date().isoformat())
-        
-        output_path = config.getPackageDirectoryPath()/app_output_path
+
+        output = template.render(
+            objects=objects,
+            app=config.app,
+            currentDate=datetime.datetime.now(datetime.UTC).date().isoformat(),
+        )
+
+        output_path = config.getPackageDirectoryPath() / app_output_path
         output_path.parent.mkdir(parents=True, exist_ok=True)
-        with open(output_path, 'w') as f:
-            output = output.encode('utf-8', 'ignore').decode('utf-8')
+        with open(output_path, "w") as f:
+            output = output.encode("utf-8", "ignore").decode("utf-8")
             f.write(output)
         return output_path
-    
-
 
     @staticmethod
-    def writeFileHeader(app_output_path:pathlib.Path, config: build) -> str:
-        #Do not output microseconds or +00:000 at the end of the datetime string
-        utc_time = datetime.datetime.now(datetime.UTC).replace(microsecond=0,tzinfo=None).isoformat()
-    
-        j2_env = Environment(
-            loader=FileSystemLoader(os.path.join(os.path.dirname(__file__), 'templates')), 
-            trim_blocks=True)
+    def writeFileHeader(app_output_path: pathlib.Path, config: build) -> str:
+        # Do not output microseconds or +00:000 at the end of the datetime string
+        utc_time = (
+            datetime.datetime.now(datetime.UTC)
+            .replace(microsecond=0, tzinfo=None)
+            .isoformat()
+        )
 
-        template = j2_env.get_template('header.j2')
-        output = template.render(time=utc_time, author=' - '.join([config.app.author_name,config.app.author_company]), author_email=config.app.author_email)
-        
-        return output
+        j2_env = Environment(
+            loader=FileSystemLoader(
+                os.path.join(os.path.dirname(__file__), "templates")
+            ),
+            trim_blocks=True,
+        )
 
+        template = j2_env.get_template("header.j2")
+        output = template.render(
+            time=utc_time,
+            author=" - ".join([config.app.author_name, config.app.author_company]),
+            author_email=config.app.author_email,
+        )
 
+        return output
 
     @staticmethod
-    def writeXmlFile(app_output_path:pathlib.Path, template_name : str, config: build, objects : list) -> None:
-        
-        
+    def writeXmlFile(
+        app_output_path: pathlib.Path,
+        template_name: str,
+        config: build,
+        objects: list[str],
+    ) -> None:
         j2_env = ConfWriter.getJ2Environment()
         template = j2_env.get_template(template_name)
-        
+
         output = template.render(objects=objects, app=config.app)
-        
-        output_path = config.getPackageDirectoryPath()/app_output_path
+
+        output_path = config.getPackageDirectoryPath() / app_output_path
         output_path.parent.mkdir(parents=True, exist_ok=True)
-        with open(output_path, 'a') as f:
-            output = output.encode('utf-8', 'ignore').decode('utf-8')
+        with open(output_path, "a") as f:
+            output = output.encode("utf-8", "ignore").decode("utf-8")
             f.write(output)
-        
-        #Ensure that the conf file we just generated/update is syntactically valid
-        ConfWriter.validateXmlFile(output_path) 
 
-    
+        # Ensure that the conf file we just generated/update is syntactically valid
+        ConfWriter.validateXmlFile(output_path)
 
     @staticmethod
-    def writeDashboardFiles(config:build, dashboards:list[Dashboard])->set[pathlib.Path]:
-        written_files:set[pathlib.Path] = set()
+    def writeDashboardFiles(
+        config: build, dashboards: list[Dashboard]
+    ) -> set[pathlib.Path]:
+        written_files: set[pathlib.Path] = set()
         for dashboard in dashboards:
             output_file_path = dashboard.getOutputFilepathRelativeToAppRoot(config)
             # Check that the full output path does not exist so that we are not having an
             # name collision with a file in app_template
-            if (config.getPackageDirectoryPath()/output_file_path).exists():
-                raise FileExistsError(f"ERROR: Overwriting Dashboard File {output_file_path}. Does this file exist in {config.getAppTemplatePath()} AND {config.path/'dashboards'}?")
-                
+            if (config.getPackageDirectoryPath() / output_file_path).exists():
+                raise FileExistsError(
+                    f"ERROR: Overwriting Dashboard File {output_file_path}. Does this file exist in {config.getAppTemplatePath()} AND {config.path / 'dashboards'}?"
+                )
+
             ConfWriter.writeXmlFileHeader(output_file_path, config)
             dashboard.writeDashboardFile(ConfWriter.getJ2Environment(), config)
-            ConfWriter.validateXmlFile(config.getPackageDirectoryPath()/output_file_path)
+            ConfWriter.validateXmlFile(
+                config.getPackageDirectoryPath() / output_file_path
+            )
             written_files.add(output_file_path)
         return written_files
 
-
     @staticmethod
-    def writeXmlFileHeader(app_output_path:pathlib.Path, config: build) -> None:
-        output = ConfWriter.writeFileHeader(app_output_path, config)    
+    def writeXmlFileHeader(app_output_path: pathlib.Path, config: build) -> None:
+        output = ConfWriter.writeFileHeader(app_output_path, config)
         output_with_xml_comment = f"<!--\n{output}-->\n"
 
-        output_path = config.getPackageDirectoryPath()/app_output_path
+        output_path = config.getPackageDirectoryPath() / app_output_path
         output_path.parent.mkdir(parents=True, exist_ok=True)
-        with open(output_path, 'w') as f:
-            output_with_xml_comment = output_with_xml_comment.encode('utf-8', 'ignore').decode('utf-8')
+        with open(output_path, "w") as f:
+            output_with_xml_comment = output_with_xml_comment.encode(
+                "utf-8", "ignore"
+            ).decode("utf-8")
             f.write(output_with_xml_comment)
-        
-        # We INTENTIONALLY do not validate the comment we wrote to the header.  This is because right now,
-        # the file is an empty XML document (besides the commented header). This means that it will FAIL validation 
 
+        # We INTENTIONALLY do not validate the comment we wrote to the header.  This is because right now,
+        # the file is an empty XML document (besides the commented header). This means that it will FAIL validation
 
     @staticmethod
-    def getJ2Environment()->Environment:
+    def getJ2Environment() -> Environment:
         j2_env = Environment(
-            loader=FileSystemLoader(os.path.join(os.path.dirname(__file__), 'templates')), 
+            loader=FileSystemLoader(
+                os.path.join(os.path.dirname(__file__), "templates")
+            ),
             trim_blocks=True,
-            undefined=StrictUndefined)
-        j2_env.globals.update(objectListToNameList=SecurityContentObject.objectListToNameList)
-
-
-        j2_env.filters['custom_jinja2_enrichment_filter'] = ConfWriter.custom_jinja2_enrichment_filter
-        j2_env.filters['escapeNewlines'] = ConfWriter.escapeNewlines
+            undefined=StrictUndefined,
+        )
+        j2_env.globals.update(
+            objectListToNameList=SecurityContentObject.objectListToNameList
+        )
+
+        j2_env.filters["custom_jinja2_enrichment_filter"] = (
+            ConfWriter.custom_jinja2_enrichment_filter
+        )
+        j2_env.filters["escapeNewlines"] = ConfWriter.escapeNewlines
         return j2_env
 
     @staticmethod
-    def writeConfFile(app_output_path:pathlib.Path, template_name : str, config: build, objects : list) -> pathlib.Path:
-        output_path = config.getPackageDirectoryPath()/app_output_path
+    def writeConfFile(
+        app_output_path: pathlib.Path,
+        template_name: str,
+        config: build,
+        objects: Sequence[SecurityContentObject] | list[CustomApp],
+    ) -> pathlib.Path:
+        output_path = config.getPackageDirectoryPath() / app_output_path
         j2_env = ConfWriter.getJ2Environment()
-        
+
         template = j2_env.get_template(template_name)
-        output = template.render(objects=objects, app=config.app)
-        
-        output_path.parent.mkdir(parents=True, exist_ok=True)
-        with open(output_path, 'a') as f:
-            output = output.encode('utf-8', 'ignore').decode('utf-8')
-            f.write(output)
+
+        # The following code, which is commented out, serializes one object at a time.
+        # This is extremely useful from a debugging perspective, because sometimes when
+        # serializing a large number of objects, exceptions throw in Jinja2 templates can
+        # be quite hard to diagnose.  We leave this code in for use in debugging workflows:
+        SERIALIZE_ONE_AT_A_TIME = False
+        if SERIALIZE_ONE_AT_A_TIME:
+            outputs: list[str] = []
+            for obj in objects:
+                try:
+                    outputs.append(template.render(objects=[obj], app=config.app))
+                except Exception as e:
+                    raise Exception(
+                        f"Failed writing the following object to file:\n"
+                        f"Name:{obj.name if not isinstance(obj, CustomApp) else obj.title}\n"
+                        f"Type {type(obj)}: \n"
+                        f"Output File: {app_output_path}\n"
+                        f"Error: {str(e)}\n"
+                    )
+
+            output_path.parent.mkdir(parents=True, exist_ok=True)
+            with open(output_path, "a") as f:
+                output = "".join(outputs).encode("utf-8", "ignore").decode("utf-8")
+                f.write(output)
+        else:
+            output = template.render(objects=objects, app=config.app)
+
+            output_path.parent.mkdir(parents=True, exist_ok=True)
+            with open(output_path, "a") as f:
+                output = output.encode("utf-8", "ignore").decode("utf-8")
+                f.write(output)
+
         return output_path
-        
-        
+
     @staticmethod
-    def validateConfFile(path:pathlib.Path):
+    def validateConfFile(path: pathlib.Path):
         """Ensure that the conf file is valid.  We will do this by reading back
         the conf using RawConfigParser to ensure that it does not throw any parsing errors.
         This is particularly relevant because newlines contained in string fields may
         break the formatting of the conf file if they have been incorrectly escaped with
-        the 'ConfWriter.escapeNewlines()' function. 
+        the 'ConfWriter.escapeNewlines()' function.
 
         If a conf file failes validation, we will throw an exception
 
@@ -300,7 +371,7 @@ class ConfWriter():
         """
         return
         if path.suffix != ".conf":
-            #there may be some other files built, so just ignore them
+            # there may be some other files built, so just ignore them
             return
         try:
             _ = configparser.RawConfigParser().read(path)
@@ -308,30 +379,35 @@ class ConfWriter():
             raise Exception(f"Failed to validate .conf file {str(path)}: {str(e)}")
 
     @staticmethod
-    def validateXmlFile(path:pathlib.Path):
+    def validateXmlFile(path: pathlib.Path):
         """Ensure that the XML file is valid XML.
 
         Args:
             path (pathlib.Path): path to the xml file to validate
-        """        
-        
+        """
+
         try:
-            with open(path, 'r') as xmlFile:
+            with open(path, "r") as xmlFile:
                 _ = ET.fromstring(xmlFile.read())
         except Exception as e:
             raise Exception(f"Failed to validate .xml file {str(path)}: {str(e)}")
-    
 
     @staticmethod
-    def validateManifestFile(path:pathlib.Path):
+    def validateManifestFile(path: pathlib.Path):
         """Ensure that the Manifest file is valid JSON.
 
         Args:
             path (pathlib.Path): path to the manifest JSON file to validate
-        """        
+        """
         return
         try:
-            with open(path, 'r') as manifestFile:
+            with open(path, "r") as manifestFile:
                 _ = json.load(manifestFile)
         except Exception as e:
-            raise Exception(f"Failed to validate .manifest file {str(path)} (Note that .manifest files should contain only valid JSON-formatted data): {str(e)}")
+            raise Exception(
+                f"Failed to validate .manifest file {str(path)} (Note that .manifest files should contain only valid JSON-formatted data): {str(e)}"
+            )
+        except Exception as e:
+            raise Exception(
+                f"Failed to validate .manifest file {str(path)} (Note that .manifest files should contain only valid JSON-formatted data): {str(e)}"
+            )

contentctl/output/data_source_writer.py

@@ -1,6 +1,5 @@
 import csv
 from contentctl.objects.data_source import DataSource
-from contentctl.objects.event_source import EventSource
 from typing import List
 import pathlib
 

contentctl/output/json_writer.py

@@ -1,11 +1,9 @@
 import json
-from contentctl.objects.abstract_security_content_objects.security_content_object_abstract import SecurityContentObject_Abstract
-from typing import List
-from io import TextIOWrapper
+from typing import Any
 class JsonWriter():
 
     @staticmethod
-    def writeJsonObject(file_path : str, object_name: str, objs: List[dict],readable_output=False) -> None:
+    def writeJsonObject(file_path : str, object_name: str, objs: list[dict[str,Any]],readable_output:bool=True) -> None:
         try:
             with open(file_path, 'w') as outfile:
                 if readable_output:

contentctl/output/svg_output.py

@@ -35,7 +35,7 @@ class SvgOutput():
         
 
         total_dict:dict[str,Any] = self.get_badge_dict("Detections", detections, detections)
-        production_dict:dict[str,Any] = self.get_badge_dict("% Production", detections, [detection for detection in detections if detection.status == DetectionStatus.production.value])
+        production_dict:dict[str,Any] = self.get_badge_dict("% Production", detections, [detection for detection in detections if detection.status == DetectionStatus.production])
         #deprecated_dict = self.get_badge_dict("Deprecated", detections, [detection for detection in detections if detection.status == DetectionStatus.deprecated])
         #experimental_dict = self.get_badge_dict("Experimental", detections, [detection for detection in detections if detection.status == DetectionStatus.experimental])
         

contentctl/output/templates/analyticstories_detections.j2

@@ -5,7 +5,7 @@
 {% if (detection.type == 'TTP' or detection.type == 'Anomaly' or detection.type == 'Hunting' or detection.type == 'Correlation') %}
 [savedsearch://{{ detection.get_conf_stanza_name(app) }}]
 type = detection
-asset_type = {{ detection.tags.asset_type.value }}
+asset_type = {{ detection.tags.asset_type }}
 confidence = medium
 explanation = {{ (detection.explanation if detection.explanation else detection.description) | escapeNewlines() }}
 {% if detection.how_to_implement is defined %}

contentctl/output/templates/collections.j2

@@ -1,6 +1,6 @@
 
 {% for lookup in objects %}
-{% if lookup.collection is defined and lookup.collection != None %}
+{% if lookup.collection is defined %}
 [{{ lookup.name }}]
 enforceTypes = false
 replicate = false

contentctl/output/templates/doc_detections.j2

@@ -162,11 +162,6 @@ The SPL above uses the following Lookups:
 {% endfor %}
 {% endif -%}
 
-#### Required field
-{% for field in object.tags.required_fields -%}
-* {{ field }}
-{% endfor %}
-
 #### How To Implement
 {{ object.how_to_implement}}
 

contentctl/output/templates/savedsearches_detections.j2

@@ -44,7 +44,7 @@ action.escu.providing_technologies = null
 action.escu.analytic_story = {{ objectListToNameList(detection.tags.analytic_story) | tojson }}
 {% if detection.deployment.alert_action.rba.enabled%}
 action.risk = 1
-action.risk.param._risk_message = {{ detection.tags.message | escapeNewlines() }}
+action.risk.param._risk_message = {{ detection.rba.message | escapeNewlines() }}
 action.risk.param._risk = {{ detection.risk | tojson }}
 action.risk.param._risk_score = 0
 action.risk.param.verbose = 0
@@ -70,8 +70,13 @@ action.notable.param.nes_fields = {{ detection.nes_fields }}
 {% endif %}
 action.notable.param.rule_description = {{ detection.deployment.alert_action.notable.rule_description | custom_jinja2_enrichment_filter(detection) | escapeNewlines()}}
 action.notable.param.rule_title = {% if detection.type | lower == "correlation" %}RBA: {{ detection.deployment.alert_action.notable.rule_title | custom_jinja2_enrichment_filter(detection) }}{% else %}{{ detection.deployment.alert_action.notable.rule_title | custom_jinja2_enrichment_filter(detection) }}{% endif +%}
-action.notable.param.security_domain = {{ detection.tags.security_domain.value }}
-action.notable.param.severity = {{ detection.tags.severity.value }}
+action.notable.param.security_domain = {{ detection.tags.security_domain }}
+{% if detection.rba %}
+action.notable.param.severity = {{ detection.rba.severity }}
+{% else %}
+{# Correlations do not have detection.rba defined, but should get a default severity #} 
+action.notable.param.severity = high 
+{% endif %}
 {% endif %}
 {% if detection.deployment.alert_action.email %}
 action.email.subject.alert = {{ detection.deployment.alert_action.email.subject | custom_jinja2_enrichment_filter(detection) | escapeNewlines() }}

contentctl/output/templates/transforms.j2

@@ -1,8 +1,8 @@
 
 {% for lookup in objects %}
 [{{ lookup.name }}]
-{% if lookup.filename is defined and lookup.filename != None %}
-filename = {{ lookup.filename.name  }}
+{% if lookup.app_filename is defined and lookup.app_filename != None %}
+filename = {{ lookup.app_filename.name  }}
 {% else %}
 collection = {{ lookup.collection }}
 external_type = kvstore
@@ -25,8 +25,8 @@ max_matches = {{ lookup.max_matches }}
 {% if lookup.min_matches is defined and lookup.min_matches != None %}
 min_matches = {{ lookup.min_matches }}
 {% endif %}
-{% if lookup.fields_list is defined and lookup.fields_list != None %}
-fields_list = {{ lookup.fields_list }}
+{% if lookup.fields_to_fields_list_conf_format is defined %}
+fields_list = {{ lookup.fields_to_fields_list_conf_format }}
 {% endif %}
 {% if lookup.filter is defined and lookup.filter != None %}
 filter = {{ lookup.filter }}

contentctl/output/yml_writer.py

@@ -1,6 +1,21 @@
 
 import yaml
 from typing import Any
+from enum import StrEnum, IntEnum
+
+# Set the following so that we can write StrEnum and IntEnum
+# to files. Otherwise, we will get the following errors when trying
+# to write to files:
+# yaml.representer.RepresenterError: ('cannot represent an object',.....
+yaml.SafeDumper.add_multi_representer(
+    StrEnum,
+    yaml.representer.SafeRepresenter.represent_str
+)
+
+yaml.SafeDumper.add_multi_representer(
+    IntEnum,
+    yaml.representer.SafeRepresenter.represent_int
+)
 
 class YmlWriter: