regscale-cli 6.23.0.0__py3-none-any.whl → 6.24.0.0__py3-none-any.whl

regscale/models/integration_models/synqly_models/connectors/vulnerabilities.py

@@ -80,10 +80,10 @@ class Vulnerabilities(SynqlyModel):
         if kwargs.get("all_scans"):
             vuln_filter.append("finding.last_seen_time[gte]915148800")  # Friday, January 1, 1999 12:00:00 AM UTC
         elif scan_date := kwargs.get("scan_date"):
-            from regscale.core.utils.date import date_obj
+            from regscale.core.utils.date import datetime_obj
 
-            if scan_date := date_obj(scan_date):
-                vuln_filter.append(f"finding.last_seen_time[gte]{scan_date.isoformat()}")
+            if scan_date := datetime_obj(scan_date):
+                vuln_filter.append(f"finding.last_seen_time[gte]{int(scan_date.timestamp())}")
             else:
                 vuln_filter.append(f"finding.last_seen_time[gte]{get_last_pull_epoch(regscale_ssp_id)}")
         else:

regscale/models/regscale_models/form_field_value.py

@@ -148,7 +148,7 @@ class FormFieldValue(RegScaleModel):
             ]
             if data:
                 FormFieldValue.save_custom_data(
-                    record_id=form_field_value.get["record_id"],
+                    record_id=form_field_value.get("record_id"),
                     module_name=form_field_value.get("record_module", "securityplans"),
                     data=data,
                 )

regscale/models/regscale_models/milestone.py

@@ -16,6 +16,7 @@ class Milestone(RegScaleModel):
     _module_slug = "milestones"
     _module_string = "milestones"
     _unique_fields = ["title", "parentModule"]
+    _parent_id_field = "parentID"
 
     title: str
     id: int = 0

regscale/models/regscale_models/regscale_model.py

@@ -502,31 +502,93 @@ class RegScaleModel(BaseModel, ABC):
         :return: A list of unique fields
         :rtype: List[List[str]]
         """
-        sample_format = {"uniqueOverride": {"asset": ["ipAddress"]}}
         config = Application().config
 
+        # First, ensure _unique_fields is in new format (List[List[str]])
+        cls._ensure_unique_fields_format()
+
         try:
             primary = config.get("uniqueOverride", {}).get(cls.__name__.lower())
             if primary:
-                if not isinstance(primary, list):
-                    raise ValueError(
-                        f"Invalid config format in uniqueOverride.{cls.__name__.lower()}, the configuration must be in a format like so:\n{dump(sample_format, default_flow_style=False)}"
-                    )
-                if primary != cls._unique_fields:
-                    if all(attr in cls.model_fields for attr in primary):
-                        if primary not in cls._unique_fields:
-                            cls._unique_fields.insert(1, primary)
-                        else:
-                            # Move primary to index 1 if it exists
-                            cls._unique_fields.insert(1, cls._unique_fields.pop(cls._unique_fields.index(primary)))
-                    else:
-                        raise ValueError(
-                            f"One or more invalid attribute(s) detected: {primary}, falling back on default unique fields for type: {cls.__name__.lower()}"
-                        )
+                cls._process_primary_override(primary)
         except ValueError as e:
             logger.warning(e)
         return cls._unique_fields
 
+    @classmethod
+    def _ensure_unique_fields_format(cls) -> None:
+        """
+        Ensure _unique_fields is in the new format (List[List[str]]).
+
+        :rtype: None
+        """
+        # Check if it's still in old format (List[str])
+        if cls._unique_fields and isinstance(cls._unique_fields[0], str):
+            # Convert old format to new format
+            cls._unique_fields = [cls._unique_fields]  # type: ignore
+
+    @classmethod
+    def _process_primary_override(cls, primary: List[str]) -> None:
+        """
+        Process the primary override configuration.
+
+        :param List[str] primary: The primary override fields
+        :raises ValueError: If the primary fields are invalid
+        :rtype: None
+        """
+        cls._validate_primary_format(primary)
+
+        # Now cls._unique_fields is guaranteed to be List[List[str]]
+        # Check if primary is different from any existing unique field set
+        if primary not in cls._unique_fields:
+            cls._handle_new_primary_fields(primary)
+
+    @classmethod
+    def _validate_primary_format(cls, primary: List[str]) -> None:
+        """
+        Validate the format of the primary override configuration.
+
+        :param List[str] primary: The primary override fields
+        :raises ValueError: If the primary format is invalid
+        :rtype: None
+        """
+        if not isinstance(primary, list):
+            sample_format = {"uniqueOverride": {"asset": ["ipAddress"]}}
+            raise ValueError(
+                f"Invalid config format in uniqueOverride.{cls.__name__.lower()}, the configuration must be in a format like so:\n{dump(sample_format, default_flow_style=False)}"
+            )
+
+    @classmethod
+    def _handle_new_primary_fields(cls, primary: List[str]) -> None:
+        """
+        Handle new primary fields that are not in existing unique fields.
+
+        :param List[str] primary: The primary override fields
+        :raises ValueError: If any attributes are invalid
+        :rtype: None
+        """
+        if all(attr in cls.model_fields for attr in primary):
+            cls._insert_primary_fields(primary)
+        else:
+            raise ValueError(
+                f"One or more invalid attribute(s) detected: {primary}, falling back on default unique fields for type: {cls.__name__.lower()}"
+            )
+
+    @classmethod
+    def _insert_primary_fields(cls, primary: List[str]) -> None:
+        """
+        Insert primary fields into the unique fields list.
+
+        :param List[str] primary: The primary override fields
+        :rtype: None
+        """
+        # Check if primary already exists in the list
+        if primary not in cls._unique_fields:
+            cls._unique_fields.insert(1, primary)
+        else:
+            # Move primary to index 1 if it exists
+            cls._unique_fields.insert(1, cls._unique_fields.pop(cls._unique_fields.index(primary)))
+
     @classmethod
     def _get_endpoints(cls) -> ConfigDict:
         """
@@ -665,17 +727,45 @@ class RegScaleModel(BaseModel, ABC):
                 self.cache_object(instance)
                 return False, instance
             else:
-                created_instance = self.create(bulk=bulk)
-                self.cache_object(created_instance)
-                return True, created_instance
+                try:
+                    created_instance = self.create(bulk=bulk)
+                    self.cache_object(created_instance)
+                    return True, created_instance
+                except APIInsertionError as e:
+                    # Check if this is a duplicate error (race condition in threading)
+                    error_str = str(e).lower()
+                    if "already exists" in error_str or "mapping already exists" in error_str:
+                        logger.debug(
+                            f"Race condition detected for {self.__class__.__name__}, retrying find_by_unique: {e}"
+                        )
+                        # Clear the cache to force a fresh lookup
+                        self.clear_cache()
+                        # Try to find the instance again - another thread may have created it
+                        instance = self.find_by_unique()
+                        if instance:
+                            self.cache_object(instance)
+                            logger.debug(
+                                f"Successfully found existing {self.__class__.__name__} after duplicate creation error, ID: {instance.id}"
+                            )
+                            return False, instance
+                        else:
+                            # If we still can't find it, log error but don't stop the process
+                            logger.error(
+                                f"Failed to find {self.__class__.__name__} after duplicate creation error: {e}"
+                            )
+                            # Return None to indicate creation failed but don't raise
+                            return False, None
+                    else:
+                        # Not a duplicate error, re-raise
+                        logger.error(f"Failed to create object: {self.__class__.__name__} creation error: {e}")
 
-    def get_or_create(self: T, bulk: bool = False) -> T:
+    def get_or_create(self: T, bulk: bool = False) -> Optional[T]:
         """
         Get or create an instance.
 
         :param bool bulk: Whether to perform a bulk create operation, defaults to False
-        :return: The instance
-        :rtype: T
+        :return: The instance or None if creation failed due to race condition
+        :rtype: Optional[T]
         """
         _, instance = self.get_or_create_with_status(bulk=bulk)
         return instance
@@ -727,44 +817,100 @@ class RegScaleModel(BaseModel, ABC):
             instance = cached_object or self.find_by_unique()
 
             if instance:
-                # An existing instance was found (either in cache or database)
-                logger.debug(f"Found {'cached' if cached_object else 'existing'} instance of {self.__class__.__name__}")
-                # Update the current object's ID with the found instance's ID
-                self.id = instance.id
-                # If the object has a 'dateCreated' attribute, update it
-                if hasattr(self, "dateCreated"):
-                    self.dateCreated = instance.dateCreated  # noqa
-
-                # Update the _original_data attribute with the instance data
-                self._original_data = instance.dict(exclude_unset=True)
-
-                # Check if the current object has any changes compared to the found instance
-                if self.has_changed():
-                    logger.debug(f"Instance of {self.__class__.__name__} has changed, updating")
-                    # Save the changes, potentially in bulk
-                    updated_instance = self.save(bulk=bulk_update)
-                    # Update the cache with the new instance
-                    self.cache_object(updated_instance)
-                    # Return the updated instance, optionally with a flag indicating it wasn't newly created
-                    return False, updated_instance
-
-                # If no changes, return the existing instance
-                return False, instance
+                return self._handle_existing_instance(instance, cached_object, bulk_update)
 
             # No existing instance was found, so create a new one
-            # apply defaults if they are provided
-            if defaults:
-                for key, value in defaults.items():
-                    # Handle callable values by executing them
-                    if callable(value):
-                        value = value()
-                    setattr(self, key, value)
-            logger.debug(f"No existing instance found for {self.__class__.__name__}, creating new")
-            created_instance = self.create(bulk=bulk_create)
-            # Cache the newly created instance
-            self.cache_object(created_instance)
-            # Return the created instance, optionally with a flag indicating it was newly created
-            return True, created_instance
+            return self._handle_new_instance(defaults, bulk_create)
+
+    def _handle_existing_instance(
+        self: T, instance: T, cached_object: Optional[T], bulk_update: bool
+    ) -> Tuple[bool, T]:
+        """
+        Handle processing of an existing instance found in cache or database.
+
+        :param T instance: The found instance
+        :param Optional[T] cached_object: The cached object if found in cache
+        :param bool bulk_update: Whether to perform a bulk update
+        :return: Tuple of (was_created, instance)
+        :rtype: Tuple[bool, T]
+        """
+        # An existing instance was found (either in cache or database)
+        logger.debug(f"Found {'cached' if cached_object else 'existing'} instance of {self.__class__.__name__}")
+
+        # Update current object with instance data
+        self._sync_with_existing_instance(instance)
+
+        # Check if the current object has any changes compared to the found instance
+        if self.has_changed():
+            return self._update_existing_instance(bulk_update)
+
+        # If no changes, return the existing instance
+        return False, instance
+
+    def _sync_with_existing_instance(self: T, instance: T) -> None:
+        """
+        Synchronize current object with existing instance data.
+
+        :param T instance: The existing instance to sync with
+        :rtype: None
+        """
+        # Update the current object's ID with the found instance's ID
+        self.id = instance.id
+        # If the object has a 'dateCreated' attribute, update it
+        if hasattr(self, "dateCreated"):
+            self.dateCreated = instance.dateCreated  # noqa
+
+        # Update the _original_data attribute with the instance data
+        self._original_data = instance.dict(exclude_unset=True)
+
+    def _update_existing_instance(self: T, bulk_update: bool) -> Tuple[bool, T]:
+        """
+        Update an existing instance that has changes.
+
+        :param bool bulk_update: Whether to perform a bulk update
+        :return: Tuple of (was_created, updated_instance)
+        :rtype: Tuple[bool, T]
+        """
+        logger.debug(f"Instance of {self.__class__.__name__} has changed, updating")
+        # Save the changes, potentially in bulk
+        updated_instance = self.save(bulk=bulk_update)
+        # Update the cache with the new instance
+        self.cache_object(updated_instance)
+        # Return the updated instance, optionally with a flag indicating it wasn't newly created
+        return False, updated_instance
+
+    def _handle_new_instance(self: T, defaults: Optional[Dict[str, Any]], bulk_create: bool) -> Tuple[bool, T]:
+        """
+        Handle creation of a new instance when none exists.
+
+        :param Optional[Dict[str, Any]] defaults: Dictionary of default values to apply
+        :param bool bulk_create: Whether to perform a bulk create
+        :return: Tuple of (was_created, created_instance)
+        :rtype: Tuple[bool, T]
+        """
+        # apply defaults if they are provided
+        self._apply_defaults(defaults)
+
+        logger.debug(f"No existing instance found for {self.__class__.__name__}, creating new")
+        created_instance = self.create(bulk=bulk_create)
+        # Cache the newly created instance
+        self.cache_object(created_instance)
+        # Return the created instance, optionally with a flag indicating it was newly created
+        return True, created_instance
+
+    def _apply_defaults(self: T, defaults: Optional[Dict[str, Any]]) -> None:
+        """
+        Apply default values to the instance.
+
+        :param Optional[Dict[str, Any]] defaults: Dictionary of default values to apply
+        :rtype: None
+        """
+        if defaults:
+            for key, value in defaults.items():
+                # Handle callable values by executing them
+                if callable(value):
+                    value = value()
+                setattr(self, key, value)
 
     @classmethod
     def _handle_list_response(
@@ -1269,7 +1415,15 @@ class RegScaleModel(BaseModel, ABC):
         endpoint = self.get_endpoint("insert")
         response = self._get_api_handler().post(endpoint=endpoint, data=self.dict(), headers=self._get_headers())
         if response and response.ok:
-            obj = self.__class__(**response.json())
+            response_data = response.json()
+
+            # Handle special case for ComponentMapping which may have nested response structure
+            if self.__class__.__name__ == "ComponentMapping" and "componentMapping" in response_data:
+                component_mapping_data = response_data["componentMapping"]
+                obj = self.__class__(**component_mapping_data)
+            else:
+                obj = self.__class__(**response_data)
+
             self.cache_object(obj)
             return obj
         else:
@@ -1468,6 +1622,17 @@ class RegScaleModel(BaseModel, ABC):
             logger.warning(f"{cls.__name__}: No matching record found for ID: {cls.__name__} {object_id}")
             return None
 
+    @classmethod
+    def get(cls, id: Union[str, int]) -> Optional[T]:
+        """
+        Get a RegScale object by ID. shortcut for get_object.
+
+        :param Union[str, int] id: The ID of the object
+        :return: The object or None if not found
+        :rtype: Optional[T]
+        """
+        return cls.get_object(object_id=id)
+
     @classmethod
     def get_objects_and_attachments_by_parent(
         cls, parent_id: int, parent_module: str
@@ -1480,7 +1645,7 @@ class RegScaleModel(BaseModel, ABC):
         :return: A tuple of a list of objects and a list of attachments
         :rtype: Tuple[List[T], dict[int, List["File"]]]
         """
-        from regscale.models import File
+        from regscale.models.regscale_models import File
 
         # get the existing issues for the parent record that are already in RegScale
         logger.info("Fetching full %s list from RegScale %s #%i.", cls.__name__, parent_module, parent_id)

regscale/models/regscale_models/security_plan.py

@@ -107,6 +107,7 @@ class SecurityPlan(RegScaleModel):
     fedrampDateSubmitted: Optional[str] = ""
     fedrampDateAuthorized: Optional[str] = ""
     fedrampId: Optional[str] = ""
+    complianceSettings: Optional[str] = None
     complianceSettingsId: Optional[int] = 1
     tenantsId: int = 1
 
@@ -119,11 +120,11 @@ class SecurityPlan(RegScaleModel):
         :return: The ComplianceSettings ID if the RegScale version is compatible, None otherwise
         :rtype: Optional[int]
         """
-        from packaging.version import Version
+        from regscale.utils.version import RegscaleVersion
 
         regscale_version = cls._get_api_handler().regscale_version
 
-        if len(regscale_version) >= 10 or Version(regscale_version) >= Version("6.13.0.0"):
+        if len(regscale_version) >= 10 or RegscaleVersion.compare_versions(regscale_version, "6.13.0.0"):
             return v
         else:
             return None

regscale/regscale.py

@@ -142,6 +142,11 @@ nist = import_command_with_timing(PUBLIC, "nist")
 oscal = import_command_with_timing(PUBLIC, "oscal")
 criticality_updater = import_command_with_timing(PUBLIC, "criticality_updater")
 
+############################################################
+# Utils
+############################################################
+cci_importer = import_command_with_timing("regscale.integrations.public.cci_importer", "cci_importer")
+
 ############################################################
 # Commercial Integrations
 ############################################################
@@ -816,6 +821,8 @@ cli.add_command(emass)  # add eMASS support
 cli.add_command(fedramp)  # add FedRAMP support
 cli.add_command(nist)  # add Nist_Catalog support
 cli.add_command(oscal)  # add OSCAL support
+cli.add_command(criticality_updater)  # add Criticality Updater support
+cli.add_command(cci_importer)  # add CCI Importer support
 
 # start function for the CLI
 if __name__ == "__main__":

{regscale_cli-6.23.0.0.dist-info → regscale_cli-6.24.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: regscale-cli
-Version: 6.23.0.0
+Version: 6.24.0.0
 Summary: Command Line Interface (CLI) for bulk processing/loading data into RegScale
 Home-page: https://github.com/RegScale/regscale-cli
 Author: Travis Howerton
@@ -68,7 +68,7 @@ Requires-Dist: setuptools
 Requires-Dist: simple-salesforce
 Requires-Dist: smart-open ~=7.0
 Requires-Dist: static
-Requires-Dist: synqly >=0.4.56
+Requires-Dist: synqly ==0.4.56
 Requires-Dist: tools
 Requires-Dist: typing-extensions ~=4.12.2
 Requires-Dist: wheel
@@ -150,7 +150,7 @@ Requires-Dist: setuptools >=69.0.0 ; extra == 'airflow'
 Requires-Dist: simple-salesforce ; extra == 'airflow'
 Requires-Dist: smart-open ~=7.0 ; extra == 'airflow'
 Requires-Dist: static ; extra == 'airflow'
-Requires-Dist: synqly >=0.4.56 ; extra == 'airflow'
+Requires-Dist: synqly ==0.4.56 ; extra == 'airflow'
 Requires-Dist: tools ; extra == 'airflow'
 Requires-Dist: typing-extensions ~=4.12.2 ; extra == 'airflow'
 Requires-Dist: wheel ; extra == 'airflow'
@@ -235,7 +235,7 @@ Requires-Dist: setuptools >=69.0.0 ; extra == 'airflow-azure'
 Requires-Dist: simple-salesforce ; extra == 'airflow-azure'
 Requires-Dist: smart-open ~=7.0 ; extra == 'airflow-azure'
 Requires-Dist: static ; extra == 'airflow-azure'
-Requires-Dist: synqly >=0.4.56 ; extra == 'airflow-azure'
+Requires-Dist: synqly ==0.4.56 ; extra == 'airflow-azure'
 Requires-Dist: tools ; extra == 'airflow-azure'
 Requires-Dist: typing-extensions ~=4.12.2 ; extra == 'airflow-azure'
 Requires-Dist: wheel ; extra == 'airflow-azure'
@@ -320,7 +320,7 @@ Requires-Dist: setuptools >=69.0.0 ; extra == 'airflow-sqlserver'
 Requires-Dist: simple-salesforce ; extra == 'airflow-sqlserver'
 Requires-Dist: smart-open ~=7.0 ; extra == 'airflow-sqlserver'
 Requires-Dist: static ; extra == 'airflow-sqlserver'
-Requires-Dist: synqly >=0.4.56 ; extra == 'airflow-sqlserver'
+Requires-Dist: synqly ==0.4.56 ; extra == 'airflow-sqlserver'
 Requires-Dist: tools ; extra == 'airflow-sqlserver'
 Requires-Dist: typing-extensions ~=4.12.2 ; extra == 'airflow-sqlserver'
 Requires-Dist: wheel ; extra == 'airflow-sqlserver'
@@ -410,7 +410,7 @@ Requires-Dist: setuptools >=69.0.0 ; extra == 'all'
 Requires-Dist: simple-salesforce ; extra == 'all'
 Requires-Dist: smart-open ~=7.0 ; extra == 'all'
 Requires-Dist: static ; extra == 'all'
-Requires-Dist: synqly >=0.4.56 ; extra == 'all'
+Requires-Dist: synqly ==0.4.56 ; extra == 'all'
 Requires-Dist: tools ; extra == 'all'
 Requires-Dist: typing-extensions ~=4.12.2 ; extra == 'all'
 Requires-Dist: werkzeug >=2.3.8 ; extra == 'all'
@@ -472,7 +472,7 @@ Requires-Dist: setuptools ; extra == 'ansible'
 Requires-Dist: simple-salesforce ; extra == 'ansible'
 Requires-Dist: smart-open ~=7.0 ; extra == 'ansible'
 Requires-Dist: static ; extra == 'ansible'
-Requires-Dist: synqly >=0.4.56 ; extra == 'ansible'
+Requires-Dist: synqly ==0.4.56 ; extra == 'ansible'
 Requires-Dist: tools ; extra == 'ansible'
 Requires-Dist: typing-extensions ~=4.12.2 ; extra == 'ansible'
 Requires-Dist: wheel ; extra == 'ansible'
@@ -555,7 +555,7 @@ Requires-Dist: sphinx ; extra == 'dev'
 Requires-Dist: sphinx-autodoc-typehints ; extra == 'dev'
 Requires-Dist: sphinx-click ; extra == 'dev'
 Requires-Dist: static ; extra == 'dev'
-Requires-Dist: synqly >=0.4.56 ; extra == 'dev'
+Requires-Dist: synqly ==0.4.56 ; extra == 'dev'
 Requires-Dist: tools ; extra == 'dev'
 Requires-Dist: types-python-dateutil ; extra == 'dev'
 Requires-Dist: types-pyyaml ; extra == 'dev'
@@ -624,7 +624,7 @@ Requires-Dist: setuptools ; extra == 'server'
 Requires-Dist: simple-salesforce ; extra == 'server'
 Requires-Dist: smart-open ~=7.0 ; extra == 'server'
 Requires-Dist: static ; extra == 'server'
-Requires-Dist: synqly >=0.4.56 ; extra == 'server'
+Requires-Dist: synqly ==0.4.56 ; extra == 'server'
 Requires-Dist: tools ; extra == 'server'
 Requires-Dist: typing-extensions ~=4.12.2 ; extra == 'server'
 Requires-Dist: werkzeug >=2.3.8 ; extra == 'server'