regscale-cli 6.16.0.0__py3-none-any.whl → 6.16.1.0__py3-none-any.whl

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

@@ -84,6 +84,7 @@ class Assets(SynqlyModel):
                 title=f"{self.integration_name} Assets",
                 plan_id=regscale_ssp_id,
                 integration_assets=integration_assets,
+                asset_count=len(integration_assets),
             )
 
         self.logger.info(f"[green]Sync from {self.integration_name} to RegScale completed.")

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

@@ -133,6 +133,7 @@ class Vulnerabilities(SynqlyModel):
                 title=f"{self.integration_name} Vulnerabilities",
                 plan_id=regscale_ssp_id,
                 integration_assets=integration_assets,
+                asset_count=len(integration_assets),
             )
 
         if findings:
@@ -157,6 +158,7 @@ class Vulnerabilities(SynqlyModel):
                 title=f"{self.integration_name} Vulnerabilities",
                 plan_id=regscale_ssp_id,
                 integration_findings=integration_findings,
+                finding_count=len(integration_findings),
             )
         self.logger.info(f"[green]Sync from {self.integration_name} to RegScale completed.")
 

regscale/models/integration_models/tenable_models/integration.py

@@ -5,7 +5,6 @@ This module contains the Tenable SC Integration class that is responsible for fe
 import logging
 from typing import Any, Iterator, List, Optional, Tuple
 
-from regscale.core.app.application import Application
 from regscale.core.app.utils.app_utils import epoch_to_datetime
 from regscale.integrations.commercial.tenablev2.utils import get_filtered_severities
 from regscale.integrations.integration_override import IntegrationOverride
@@ -13,6 +12,8 @@ from regscale.integrations.scanner_integration import IntegrationAsset, Integrat
 from regscale.models import regscale_models
 from regscale.models.integration_models.tenable_models.models import TenableAsset
 
+logger = logging.getLogger("regscale")
+
 
 class SCIntegration(ScannerIntegration):
     """
@@ -38,7 +39,7 @@ class SCIntegration(ScannerIntegration):
         :param dict kwargs: Additional keyword arguments
         :yields: Iterator[IntegrationAsset]
         """
-        integration_assets = kwargs.get("integration_assets")
+        integration_assets = kwargs.get("integration_assets", [])
         yield from integration_assets
 
     def fetch_findings(self, *args: Tuple, **kwargs: dict) -> Iterator[IntegrationFinding]:
@@ -50,7 +51,7 @@ class SCIntegration(ScannerIntegration):
         :yields: Iterator[IntegrationFinding]
 
         """
-        integration_findings = kwargs.get("integration_findings")
+        integration_findings = kwargs.get("integration_findings", [])
         yield from integration_findings
 
     def parse_findings(self, vuln: TenableAsset, integration_mapping: Any) -> List[IntegrationFinding]:

regscale/models/integration_models/trivy_import.py

@@ -221,7 +221,7 @@ class TrivyImport(FlatFileImporter):
         """
         data = self.validater.data
         assets: List[IntegrationAsset] = []
-        os_data = self.mapping.get_value(data, "Metadata", {}, warnings=False).get("OS", {})
+        os_data = self.mapping.get_value(data, "Metadata", {}).get("OS", {})
         try:
             assets.append(self.parse_asset(asset=data, os_data=os_data))
             return assets

regscale/models/integration_models/xray.py

@@ -123,7 +123,7 @@ class XRay(FlatFileImporter):
                         cve=cve,
                         vprScore=None,
                         tenantsId=0,  # Need a way to figure this out programmatically
-                        title=f"{self.mapping.get_value(dat, 'issue_id', warnings=False) or self.mapping.get_value(dat, 'summary', f'XRay Vulnerability from Import {get_current_datetime()}', warnings=False)} on asset {asset.name}",
+                        title=f"{self.mapping.get_value(dat, 'issue_id') or self.mapping.get_value(dat, 'summary', f'XRay Vulnerability from Import {get_current_datetime()}')} on asset {asset.name}",
                         description=self.mapping.get_value(dat, "summary"),
                         plugInText=vuln.get("cve"),
                         extra_data={

regscale/models/regscale_models/__init__.py

@@ -8,6 +8,7 @@ from .cci import *
 from .change import *
 from .checklist import *
 from .comment import *
+from .compliance_settings import *
 from .component import *
 from .component_mapping import *
 from .control import *
@@ -26,6 +27,7 @@ from .file import *
 from .implementation_objective import *
 from .implementation_option import *
 from .incident import *
+from .inherited_control import *
 from .interconnection import *
 from .issue import *
 from .leveraged_authorization import *

regscale/models/regscale_models/control_implementation.py

@@ -13,7 +13,7 @@ from pydantic import ConfigDict, Field
 
 from regscale.core.app.api import Api
 from regscale.core.app.application import Application
-from regscale.core.app.utils.app_utils import get_current_datetime, remove_keys
+from regscale.core.app.utils.app_utils import get_current_datetime
 from regscale.core.app.utils.catalog_utils.common import parentheses_to_dot
 from regscale.models.regscale_models.implementation_role import ImplementationRole
 from regscale.models.regscale_models.regscale_model import RegScaleModel
@@ -178,7 +178,7 @@ class ControlImplementation(RegScaleModel):
             export="/api/{model_slug}/export/{int_id}",
             wizard="/api/{model_slug}/wizard/{int_id}/{str_module}",
             get_date_last_assessed_by_parent="/api/{model_slug}/getDateLastAssessedByParent/{int_record}",
-            get_date_last_assessed_by_parent_and_module="/api/{model_slug}/getDateLastAssessedByParentAndModule/{str_module}/{int_record}",
+            get_date_last_assessed_by_parent_and_module="/api/{model_slug}/getDateLastAssessedByParentAndModule/{str_module}/{int_record}",  # noqa: E501
             get_date_last_assessed_for_all_assets="/api/{model_slug}/getDateLastAssessedForAllAssets/{int_record}",
             graph_controls_by_date="/api/{model_slug}/graphControlsByDate/{year}",
             get_date_last_assessed_by_control="/api/{model_slug}/getDateLastAssessedByControl/{int_control}",
@@ -203,14 +203,14 @@ class ControlImplementation(RegScaleModel):
             quick_update="/api/{model_slug}/quickUpdate/{id}/{str_status}/{int_weight}/{str_user}",
             dashboard_by_parent="/api/{model_slug}/dashboardByParent/{str_group_by}/{int_id}/{str_module}",
             security_control_dashboard="/api/{model_slug}/securityControlDashboard/{str_group_by}/{int_id}",
-            dashboard_by_parent_and_catalogue="/api/{model_slug}/dashboardByParentAndCatalogue/{str_group_by}/{int_id}/{int_cat_id}",
+            dashboard_by_parent_and_catalogue="/api/{model_slug}/dashboardByParentAndCatalogue/{str_group_by}/{int_id}/{int_cat_id}",  # noqa: E501
             group_by_family="/api/{model_slug}/groupByFamily/{int_security_plan}",
             dashboard_by_sp="/api/{model_slug}/dashboardBySP/{str_group_by}/{int_security_plan}",
             report="/api/{model_slug}/report/{str_report}",
             get_by_parent="/api/{model_slug}/getByParent/{int_id}/{str_module}",
             get_count_by_parent="/api/{model_slug}/getCountByParent/{int_id}/{str_module}",
             get_all_asset_controls_by_component="/api/{model_slug}/getAllAssetControlsByComponent/{int_id}",
-            drilldown_asset_controls_by_component="/api/{model_slug}/drilldownAssetControlsByComponent/{component_id}/{str_field}/{str_value}",
+            drilldown_asset_controls_by_component="/api/{model_slug}/drilldownAssetControlsByComponent/{component_id}/{str_field}/{str_value}",  # noqa: E501
             get_control_context="/api/{model_slug}/getControlContext/{int_control_id}/{int_parent_id}/{str_module}",
         )
 
@@ -662,7 +662,6 @@ class ControlImplementation(RegScaleModel):
         parent_module: str,
         existing_implementation_dict: dict,
         full_controls: dict,
-        partial_controls: dict,
         failing_controls: dict,
         include_not_implemented: Optional[bool] = False,
     ) -> None:
@@ -674,7 +673,6 @@ class ControlImplementation(RegScaleModel):
         :param str parent_module: Name of the parent module
         :param dict existing_implementation_dict: Dictionary of existing implementations
         :param dict full_controls: Dictionary of fully implemented controls
-        :param dict partial_controls: Dictionary of partially implemented controls
         :param dict failing_controls: Dictionary of failing controls
         :param Optional[bool] include_not_implemented: Whether to include not implemented controls, defaults to False
         :rtype: None
@@ -688,7 +686,6 @@ class ControlImplementation(RegScaleModel):
             parent_module,
             existing_implementation_dict,
             full_controls,
-            partial_controls,
             failing_controls,
             user_id,
             include_not_implemented,
@@ -705,7 +702,6 @@ class ControlImplementation(RegScaleModel):
         parent_module: str,
         existing_implementation_dict: dict,
         full_controls: dict,
-        partial_controls: dict,
         failing_controls: dict,
         user_id: Optional[str] = None,
         include_not_implemented: Optional[bool] = False,
@@ -718,7 +714,6 @@ class ControlImplementation(RegScaleModel):
         :param str parent_module: Name of the parent module
         :param dict existing_implementation_dict: Dictionary of existing implementations
         :param dict full_controls: Dictionary of fully implemented controls
-        :param dict partial_controls: Dictionary of partially implemented controls
         :param dict failing_controls: Dictionary of failing controls
         :param Optional[str] user_id: ID of the user performing the operation, defaults to None
         :param Optional[bool] include_not_implemented: Whether to include not implemented controls, defaults to False
@@ -729,21 +724,12 @@ class ControlImplementation(RegScaleModel):
         to_update = []
 
         for control in controls:
-            # if otherid exists in catalog object make sure it has something in it before matching
-            # this case may exist while new catalogs are being migrated to for customers
-            if len(control.get("otherId", [])) > 0:
-                lower_case_control_id = control["otherId"].lower()
-            else:
-                lower_case_control_id = control["controlId"].lower()
-
-            status = cls.check_implementation(full_controls, partial_controls, failing_controls, lower_case_control_id)
+            lower_case_control_id = control["controlId"].lower()
+            status = cls.check_implementation(full_controls, failing_controls, lower_case_control_id)
             if not include_not_implemented and status == ControlImplementationStatus.NotImplemented.value:
                 continue
 
-            if len(control.get("otherId", [])) > 0:
-                controlid = control["otherId"]
-            else:
-                controlid = control["controlId"]
+            controlid = control.get("controlId")
 
             if controlid not in existing_implementation_dict:
                 cim = cls.create_new_control_implementation(control, parent_id, parent_module, status, user_id)
@@ -808,18 +794,11 @@ class ControlImplementation(RegScaleModel):
         :param list to_update: List of controls to update
         :param Optional[str] user_id: ID of the user performing the operation, defaults to None
         """
-        existing_imp = existing_implementation_dict[control["controlId"]]
-        existing_imp.update(
-            {
-                "implementation": control.get("implementation"),
-                "status": status,
-                "dateLastAssessed": get_current_datetime(),
-                "lastUpdatedById": user_id,
-                "dateLastUpdated": get_current_datetime(),
-            }
-        )
-
-        remove_keys(existing_imp, ["createdBy", "systemRole", "controlOwner", "lastUpdatedBy"])
+        existing_imp: ControlImplementation = existing_implementation_dict[control["controlId"]]
+        existing_imp.status = status
+        existing_imp.dateLastAssessed = get_current_datetime()
+        existing_imp.lastUpdatedById = user_id
+        existing_imp.dateLastUpdated = get_current_datetime()
 
         if existing_imp not in to_update:
             to_update.append(existing_imp)
@@ -860,7 +839,6 @@ class ControlImplementation(RegScaleModel):
     @staticmethod
     def check_implementation(
         full_controls: dict,
-        partial_controls: dict,
         failing_controls: dict,
         control_id: str,
     ) -> str:
@@ -874,18 +852,14 @@ class ControlImplementation(RegScaleModel):
         :return: status of control implementation
         :rtype: str
         """
+        status = ControlImplementationStatus.NotImplemented.value
         if control_id in full_controls.keys():
-            logger.debug(f"Found fully implemented control: {control_id}")
-            return ControlImplementationStatus.FullyImplemented.value
-        elif control_id in partial_controls.keys():
-            logger.debug(f"Found partially implemented control: {control_id}")
-            return ControlImplementationStatus.PartiallyImplemented.value
+            logger.debug(f"Found control passing compliance check: {control_id}")
+            status = ControlImplementationStatus.PartiallyImplemented.value
         elif control_id in failing_controls.keys():
-            logger.debug(f"Found failing control: {control_id}")
-            return ControlImplementationStatus.InRemediation.value
-        else:
-            logger.debug(f"Found not implemented control: {control_id}")
-            return ControlImplementationStatus.NotImplemented.value
+            logger.debug(f"Found control failing compliance check: {control_id}")
+            status = ControlImplementationStatus.InRemediation.value
+        return status
 
     @classmethod
     def get_sort_position_dict(cls) -> dict:

regscale/models/regscale_models/inherited_control.py

@@ -0,0 +1,61 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Model for Security Plan in the application"""
+
+from typing import Optional, Union
+
+from pydantic import ConfigDict, Field, field_validator
+
+from regscale.core.app.api import Api
+from regscale.core.app.logz import create_logger
+from regscale.core.app.utils.app_utils import get_current_datetime
+from regscale.models.regscale_models.regscale_model import RegScaleModel
+
+
+class InheritedControl(RegScaleModel):
+    """
+    Inherited Control model
+    """
+
+    _module_slug = "inheritedControls"
+
+    id: int = 0
+    createdBy: Optional[str] = None
+    createdById: Optional[str] = None
+    dateCreated: Optional[str] = Field(default_factory=get_current_datetime)
+    lastUpdatedById: Optional[str] = Field(default_factory=RegScaleModel.get_user_id)
+    dateLastUpdated: Optional[str] = Field(default_factory=get_current_datetime)
+    isPublic: bool = True
+    parentId: int = 0
+    parentModule: str = ""
+    baseControlId: int = 0
+    inheritedControlId: int = 0
+
+    @staticmethod
+    def _get_additional_endpoints() -> ConfigDict:
+        """
+        Get additional endpoints for the Inherited Controls model.
+
+        :return: A dictionary of additional endpoints
+        :rtype: ConfigDict
+        """
+        return ConfigDict(  # type: ignore
+            get_all_by_parent="/api/{model_slug}/getAllByParent/{intParentID}/{strModule}",
+            get_all_by_control="/api/{model_slug}/getAllByBaseControl/{control_id}",
+        )
+
+    @classmethod
+    def get_all_by_control(cls, control_id: int) -> dict:
+        """
+        Fetch the Mega API data for the given SSP ID
+
+        :param int ssp_id: RegScale SSP ID
+        :return: Mega API data
+        :rtype: dict
+        """
+        response = cls._get_api_handler().get(
+            endpoint=cls.get_endpoint("get_all_by_control").format(module_slug=cls._module_slug, control_id=control_id)
+        )
+        if not response.raise_for_status():
+            return response.json()
+        return {}

regscale/models/regscale_models/issue.py

@@ -789,6 +789,7 @@ class Issue(RegScaleModel):
         skip = 0
         control_issues: Dict[int, List[OpenIssueDict]] = defaultdict(list)
         logger.info("Fetching open issues for controls and for security plan %i...", plan_id)
+        supports_multiple_controls: bool = cls.is_multiple_controls_supported()
 
         # Define fields based on version
         fields = """
@@ -797,7 +798,7 @@ class Issue(RegScaleModel):
             otherIdentifier
             {extra_fields}
         """.format(
-            extra_fields="controlImplementations { id }" if cls.is_multiple_controls_supported() else ""
+            extra_fields="controlImplementations { id }" if supports_multiple_controls else ""
         )
 
         while True:
@@ -822,7 +823,7 @@ class Issue(RegScaleModel):
             items = response.get(cls.get_module_string(), {}).get("items", [])
 
             for item in items:
-                if cls.is_multiple_controls_supported() and item.get("controlImplementations"):
+                if supports_multiple_controls and item.get("controlImplementations"):
                     for control in item.get("controlImplementations", []):
                         control_issues[control["id"]].append(
                             OpenIssueDict(id=item["id"], otherIdentifier=item["otherIdentifier"])

regscale/models/regscale_models/mixins/parent_cache.py

@@ -51,7 +51,7 @@ class PlanCacheMixin(Generic[T]):
         objects = cls.get_plan_objects(plan_id)
         for obj in objects:
             cls.cache_object(obj)
-        logger.info("Cached %s %s objects", len(objects), cls.__name__)
+        logger.debug("Cached %s %s objects.", len(objects), cls.__name__)
 
     @classmethod
     def get_plan_objects(cls: Type[T], plan_id: int) -> List[T]:

regscale/models/regscale_models/regscale_model.py

@@ -53,6 +53,7 @@ class RegScaleModel(BaseModel, ABC):
     _original_data: Optional[Dict[str, Any]] = None
 
     # Caching
+    _disable_cache: bool = False  # flag to disable caching
     _object_cache: ClassVar[Cache] = Cache(maxsize=100000)
     _parent_cache: ClassVar[Cache] = Cache(maxsize=50000)
     _lock_registry: ClassVar[ThreadSafeDict] = ThreadSafeDict()
@@ -80,9 +81,46 @@ class RegScaleModel(BaseModel, ABC):
             super().__init__(*args, **data)
             # Capture initial state after initialization
             self._original_data = self.dict(exclude_unset=True)
+            self._disable_cache = self._fetch_disabled_cache_setting()
+            if self._disable_cache:
+                logger.debug("cache is disabled")
         except Exception as e:
             logger.error(f"Error creating {self.__class__.__name__}: {e} {data}", exc_info=True)
 
+    def _fetch_disabled_cache_setting(self) -> bool:
+        """
+        Check if caching is disabled based on the application config.
+
+        :return: True if caching is disabled, False otherwise
+        :rtype: bool
+        """
+        is_disabled = False
+        if config := self._get_api_handler().config:
+            is_disabled = config.get("disableCache", False)
+        return is_disabled
+
+    @classmethod
+    def disable_cache(cls) -> bool:
+        """
+        Disable caching for the model.
+
+        :return: True if caching is disabled, False otherwise
+        :rtype: bool
+        """
+        cls._disable_cache = True
+        return cls._disable_cache
+
+    @classmethod
+    def enable_cache(cls) -> bool:
+        """
+        Enable caching for the model.
+
+        :return: True if caching is enabled, False otherwise
+        :rtype: bool
+        """
+        cls._disable_cache = False
+        return cls._disable_cache
+
     @classmethod
     def _get_api_handler(cls) -> APIHandler:
         """
@@ -169,6 +207,8 @@ class RegScaleModel(BaseModel, ABC):
         :return: The cached object if found, None otherwise
         :rtype: Optional[T]
         """
+        if cls._disable_cache:
+            return None
         with cls._get_lock(cache_key):
             return cls._object_cache.get(cache_key)
 
@@ -181,6 +221,8 @@ class RegScaleModel(BaseModel, ABC):
         :return: None
         :rtype: None
         """
+        if cls._disable_cache:
+            return
         try:
             if not obj:
                 return
@@ -229,6 +271,8 @@ class RegScaleModel(BaseModel, ABC):
         :return: None
         :rtype: None
         """
+        if cls._disable_cache:
+            return
         parent_id = getattr(obj, cls._parent_id_field, None)
         parent_module = getattr(obj, "parentModule", getattr(obj, "parent_module", ""))
         if parent_id and parent_module:
@@ -252,6 +296,8 @@ class RegScaleModel(BaseModel, ABC):
         :return: None
         :rtype: None
         """
+        if cls._disable_cache:
+            return
         with cls._get_lock(cache_key):
             for obj in objects:
                 cls.cache_object(obj)
@@ -265,6 +311,8 @@ class RegScaleModel(BaseModel, ABC):
         :return: None
         :rtype: None
         """
+        if cls._disable_cache:
+            return
         cls._object_cache.clear()
 
     @classmethod
@@ -276,6 +324,8 @@ class RegScaleModel(BaseModel, ABC):
         :return: None
         :rtype: None
         """
+        if cls._disable_cache:
+            return
         cache_key = cls._get_cache_key(obj)
         with cls._get_lock(cache_key):
             cls._object_cache.delete(cache_key)
@@ -1058,12 +1108,12 @@ class RegScaleModel(BaseModel, ABC):
         return endpoint
 
     @classmethod
-    def _get_pending_updates(cls) -> Set[int]:
+    def _get_pending_updates(cls) -> Set[Union[int, str]]:
         """
         Get the set of pending updates for the class.
 
         :return: Set of pending update IDs
-        :rtype: Set[int]
+        :rtype: Set[Union[int, str]]
         """
         class_name = cls.__name__
         if class_name not in cls._pending_updates:
@@ -1138,18 +1188,34 @@ class RegScaleModel(BaseModel, ABC):
         # Handle updates
         pending_updates = cls._get_pending_updates()
         if pending_updates:
-            logger.info(f"Performing bulk update for {len(pending_updates)} {cls.__name__} objects")
-            objects_to_update = [cls.get_cached_object(cache_key=cache_key) for cache_key in pending_updates]
+            logger.debug(f"Analyzing {len(pending_updates)} {cls.__name__} objects for bulk update...")
+            objects_to_update = [
+                cls.get_cached_object(cache_key=cache_key)
+                for cache_key in pending_updates
+                if cls.get_cached_object(cache_key=cache_key)
+            ]
+            logger.debug(
+                f"{len(objects_to_update)}/{len(pending_updates)} {cls.__name__} objects qualify for bulk update."
+            )
             if objects_to_update:
+                logger.info(f"Performing bulk update for {len(objects_to_update)} {cls.__name__} objects...")
                 result["updated"] = cls.batch_update(items=objects_to_update, progress_context=progress_context)
             pending_updates.clear()
 
         # Handle creations
         pending_creations = cls._get_pending_creations()
         if pending_creations:
-            logger.info(f"Performing bulk creation for {len(pending_creations)} {cls.__name__} objects")
-            objects_to_create = [cls.get_cached_object(cache_key=cache_key) for cache_key in pending_creations]
+            logger.debug(f"Analyzing {len(pending_creations)} {cls.__name__} objects for bulk creation...")
+            objects_to_create = [
+                cls.get_cached_object(cache_key=cache_key)
+                for cache_key in pending_creations
+                if cls.get_cached_object(cache_key=cache_key)
+            ]
+            logger.debug(
+                f"{len(objects_to_create)}/{len(pending_creations)} {cls.__name__} objects qualify for bulk creation."
+            )
             if objects_to_create:
+                logger.info(f"Performing bulk creation for {len(pending_creations)} {cls.__name__} objects...")
                 result["created"] = cls.batch_create(items=objects_to_create, progress_context=progress_context)
             pending_creations.clear()
 

regscale/models/regscale_models/vulnerability.py

@@ -1,12 +1,13 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 """Model for Vulnerability in the application"""
+import logging
 from enum import Enum
 from typing import List, Optional, Union
 from urllib.parse import urljoin
 from warnings import warn
 
-from pydantic import ConfigDict, Field
+from pydantic import ConfigDict, Field, field_validator
 from requests import Response
 
 from regscale.core.app.api import Api
@@ -16,6 +17,9 @@ from regscale.models import regscale_models
 from regscale.models.regscale_models.regscale_model import RegScaleModel
 
 
+logger = logging.getLogger("regscale")
+
+
 def deprecated(message):
     def decorator(func):
         def wrapper(*args, **kwargs):
@@ -48,7 +52,7 @@ class Vulnerability(RegScaleModel):
 
     _module_slug = "vulnerability"
     _unique_fields = [
-        ["plugInName", "parentId", "parentModule"],
+        ["plugInName", "plugInId", "parentId", "parentModule"],
     ]
 
     id: int = 0
@@ -64,14 +68,14 @@ class Vulnerability(RegScaleModel):
     firstSeen: Optional[str] = None
     daysOpen: Optional[int] = None
     dns: Optional[str] = None
-    ipAddress: Optional[str] = Field(default="")
+    ipAddress: Optional[str] = ""
     mitigated: Optional[bool] = None
     operatingSystem: Optional[str] = None
     port: Optional[Union[str, int]] = None
     protocol: Optional[str] = None
     severity: Optional[Union[str, VulnerabilitySeverity]] = None
     plugInName: Optional[str] = None
-    plugInId: Optional[int] = None
+    plugInId: Optional[Union[int, str]] = None
     cve: Optional[str] = None
     vprScore: Optional[Union[int, float]] = None
     exploitAvailable: Optional[bool] = None
@@ -84,10 +88,37 @@ class Vulnerability(RegScaleModel):
     dateClosed: Optional[str] = None
     status: Optional[VulnerabilityStatus] = VulnerabilityStatus.Open
 
-    def __eq__(self, other) -> bool:
+    @field_validator("plugInId")
+    def validate_regscale_version_and_plugin_id_type(cls, v: Union[int, str]) -> Union[int, str, None]:
+        """
+        Validate the RegScale version and if plugInId should be a string or an integer, >= 6.16 is a string
+
+        :param int v: pluginId value
+        :return: The correct type for plugInId depending on the RegScale version, None if unable to determine
+        :rtype: Union[int, str, None]
+        """
+        from packaging.version import Version
+
+        try:
+            regscale_version = cls._get_api_handler().regscale_version
+
+            if len(regscale_version) >= 10 or Version(regscale_version) >= Version("6.16.0.0"):
+                return str(v) if v else None
+            else:
+                if isinstance(v, str):
+                    return int(v) if v.isdigit() else None
+                elif isinstance(v, int):
+                    return v
+                return None
+        except Exception as e:
+            logger.debug("Unable to determine RegScale version or pluginId type: %s", str(e))
+            return None
+
+    def __eq__(self, other: "Vulnerability") -> bool:
         """
         Check if two Vulnerability objects are equal is needed for comparison operations in flat file importer
-        :param other:
+
+        :param Vulnerability other: the other Vulnerability object to compare
         :return: True if the two objects are equal, False otherwise
         :rtype: bool
         """
@@ -95,13 +126,14 @@ class Vulnerability(RegScaleModel):
             return False
         return (
             self.plugInName == other.plugInName
+            and self.plugInId == other.plugInId
             and self.parentId == other.parentId
             and self.parentModule == other.parentModule
             and self.ipAddress == other.ipAddress
             and self.dns == other.dns
         )
 
-    def __init__(self, **data):
+    def __init__(self, *args, **data):
         # Map snake_case to camelCase before initialization
         field_mappings = {
             "scan_id": "scanId",
@@ -128,7 +160,7 @@ class Vulnerability(RegScaleModel):
             if snake_key in data:
                 data[camel_key] = data.pop(snake_key)
 
-        super().__init__(**data)
+        super().__init__(*args, **data)
 
     @staticmethod
     def _get_additional_endpoints() -> ConfigDict:

{regscale_cli-6.16.0.0.dist-info → regscale_cli-6.16.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: regscale-cli
-Version: 6.16.0.0
+Version: 6.16.1.0
 Summary: Command Line Interface (CLI) for bulk processing/loading data into RegScale
 Home-page: https://github.com/RegScale/regscale-cli
 Author: Travis Howerton