regscale-cli 6.25.1.0__py3-none-any.whl → 6.27.0.0__py3-none-any.whl

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

@@ -61,7 +61,28 @@ class Vulnerabilities(SynqlyModel):
         self.can_fetch_vulns = "query_findings" in self.capabilities
 
     @staticmethod
-    def _handle_scan_date_options(regscale_ssp_id: int, **kwargs) -> list[str]:
+    def _build_severity_filter(severity: Optional[str] = None) -> str:
+        """
+        Build severity filter string for Synqly queries
+
+        :param Optional[str] severity: Minimum severity level, if None, defaults to 'low'
+        :return: Comma-separated severity filter string
+        :rtype: str
+        """
+        if not severity:
+            severity = "low"
+        severity_map = {
+            "critical": ["critical"],
+            "high": ["high", "critical"],
+            "medium": ["medium", "high", "critical"],
+            "low": ["low", "medium", "high", "critical"],
+            "info": ["info", "low", "medium", "high", "critical"],
+        }
+        mapped_severities = severity_map.get(severity.lower(), severity)
+        severity_filter = f"severity[in]{','.join(mapped_severities)}"
+        return severity_filter
+
+    def _handle_scan_date_options(self, regscale_ssp_id: int, **kwargs) -> list[str]:
         """
         Handle scan date options for the integration sync process
 
@@ -71,12 +92,8 @@ class Vulnerabilities(SynqlyModel):
         """
         from regscale.integrations.commercial.tenablev2.utils import get_last_pull_epoch
 
-        if vuln_filter := kwargs.get("vuln_filter"):
-            kwargs.pop("vuln_filter")
-            if isinstance(vuln_filter, str):
-                vuln_filter = [f"severity[in]{vuln_filter}"]
-        else:
-            vuln_filter = ["severity[in]critical,high,medium,low"]
+        vuln_filter = [self._build_severity_filter(kwargs.get("minimum_severity_filter"))]
+
         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"):

regscale/models/integration_models/synqly_models/synqly_model.py

@@ -243,7 +243,14 @@ class SynqlyModel(BaseModel, ABC):
                 config[f"{self._connector_type}_{self.integration}_{key}"] = attribute[key].default
             elif not skip_prompts:
                 self.logger.info(f"Enter the {key} for {self.integration}. Description: {attribute[key].description}")
-                provided_secret = input(f"{key}: ")
+                if key.lower() in ["secret", "password"] or "token" in key.lower():
+                    from getpass import getpass
+
+                    print(f"{attribute[key].description} (input will be hidden)")
+                    provided_secret = getpass(f"{key}: ")
+                else:
+                    print(f"{attribute[key].description} (input will be visible)")
+                    provided_secret = input(f"{key}: ")
                 kwargs[key] = provided_secret
                 config[f"{self._connector_type}_{self.integration}_{key}"] = provided_secret
             else:

regscale/models/locking.py

@@ -90,11 +90,15 @@ class FileLock:
 
         :rtype: None
         """
-        if os.path.isfile(self.lock_file):
-            with open(self.lock_file, "r") as lockfile:
-                scope = str(lockfile.read().strip())
-
-            if scope == str(self.lock_scope):
-                os.remove(self.lock_file)  # Lock released
-            else:
-                pass  # Lock can only be released by {self.lock_scope}
+        try:
+            if os.path.isfile(self.lock_file):
+                with open(self.lock_file, "r") as lockfile:
+                    scope = str(lockfile.read().strip())
+
+                if scope == str(self.lock_scope):
+                    os.remove(self.lock_file)  # Lock released
+                else:
+                    pass  # Lock can only be released by {self.lock_scope}
+        except FileNotFoundError:
+            # Lock file was already removed by another process, this is acceptable in parallel execution
+            pass

regscale/models/platform.py

@@ -5,10 +5,9 @@ from typing import Optional, Union
 
 from pydantic import BaseModel, SecretStr
 
+from regscale.core.app.api import Api
 from regscale.core.login import get_regscale_token
 from regscale.core.utils.urls import generate_regscale_domain_url
-from regscale.core.app.api import Api
-from regscale.core.app.application import Application
 
 
 class RegScaleAuth(BaseModel):

regscale/models/regscale_models/control_implementation.py

@@ -10,7 +10,7 @@ from urllib.parse import urljoin
 
 import requests
 from lxml.etree import Element
-from pydantic import ConfigDict, Field
+from pydantic import ConfigDict, Field, field_validator
 
 from regscale.core.app.api import Api
 from regscale.core.app.application import Application
@@ -41,6 +41,8 @@ class ControlImplementationStatus(str, Enum):
 
 
 class ImplementationControlOrigin(str, Enum):
+    """Control Implementation Origination"""
+
     SERVICE_PROVIDER_CORPORATE = "Service Provider Corporate"
     SERVICE_PROVIDER_SYSTEM = "Service Provider System Specific"
     SERVICE_PROVIDER_HYBRID = "Service Provider Hybrid (Corporate and System Specific)"
@@ -63,6 +65,7 @@ class ControlImplementationOrigin(str, Enum):
     CustomerConfigured = "Customer Configured"
     CustomerProvided = "Customer"
     Inherited = "Inherited"
+    NotApplicable = "Not Applicable"
 
 
 class ControlImplementation(RegScaleModel):
@@ -77,7 +80,7 @@ class ControlImplementation(RegScaleModel):
     controlOwnersIds: Optional[List[str]] = Field(default=None)
     status: str  # Required
     controlID: int  # Required foreign key to Security Control
-    status_lst: List[ControlImplementationStatus] = []
+    status_lst: List[ControlImplementationStatus] = Field(default=[], exclude=True)
     id: int = 0
     parentId: Optional[int] = None
     parentModule: Optional[str] = None
@@ -85,7 +88,7 @@ class ControlImplementation(RegScaleModel):
     createdById: Optional[str] = Field(default_factory=RegScaleModel.get_user_id)
     uuid: Optional[str] = None
     policy: Optional[str] = None
-    implementation: Optional[str] = None
+    implementation: Optional[str] = Field(default="N/A")
     dateLastAssessed: Optional[str] = None
     lastAssessmentResult: Optional[str] = None
     practiceLevel: Optional[str] = None
@@ -115,7 +118,7 @@ class ControlImplementation(RegScaleModel):
     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)
-    weight: Optional[int] = None
+    weight: Optional[float] = None
     isPublic: Optional[bool] = True
     inheritable: Optional[bool] = False
     systemRoleId: Optional[int] = None
@@ -144,6 +147,20 @@ class ControlImplementation(RegScaleModel):
     maturityLevel: Optional[str] = None
     assessmentFrequency: int = 0
 
+    @field_validator("implementation", mode="before")
+    @classmethod
+    def validate_implementation(cls, v: Optional[str]) -> str:
+        """
+        Validate implementation field - convert empty strings to 'N/A'.
+
+        :param Optional[str] v: The implementation value
+        :return: The validated implementation value
+        :rtype: str
+        """
+        if v is None or (isinstance(v, str) and v.strip() == ""):
+            return "N/A"
+        return v
+
     def __str__(self):
         return f"Control Implementation {self.id}: {self.controlID}"
 
@@ -160,16 +177,21 @@ class ControlImplementation(RegScaleModel):
         if self.controlOwnersIds is None and self.controlOwnerId:
             self.controlOwnersIds = [self.controlOwnerId]
 
-        # Set intelligent default responsibility if not explicitly set and we have parent info
-        if (
-            self.responsibility == self.get_default_responsibility()
-            and self.parentId
-            and self.parentModule == "securityplans"
-        ):
-            # Try to get a more specific default based on the actual security plan's compliance settings
-            better_default = self.get_default_responsibility(parent_id=self.parentId)
-            if better_default != self.responsibility:
-                self.responsibility = better_default
+        # Check if responsibility needs to be set (empty string, None, or default value)
+        should_update_responsibility = (
+            not self.responsibility  # Handles empty string or None
+            or self.responsibility == self.get_default_responsibility()
+        )
+
+        if should_update_responsibility:
+            if self.parentId and self.parentModule == "securityplans":
+                # Try to get a more specific default based on the actual security plan's compliance settings
+                better_default = self.get_default_responsibility(parent_id=self.parentId)
+                if better_default and better_default != self.responsibility:
+                    self.responsibility = better_default
+            elif not self.responsibility:
+                # If still empty/None and no parent info, set to generic default
+                self.responsibility = self.get_default_responsibility()
 
     def __setattr__(self, name: str, value: Any) -> None:
         """
@@ -207,8 +229,7 @@ class ControlImplementation(RegScaleModel):
         actual_compliance_setting_id = compliance_setting_id or cls._get_compliance_setting_id_from_parent(parent_id)
 
         if actual_compliance_setting_id:
-            responsibility = cls._get_responsibility_from_compliance_settings(actual_compliance_setting_id)
-            if responsibility:
+            if responsibility := cls._get_responsibility_from_compliance_settings(actual_compliance_setting_id):
                 return responsibility
 
         return cls._get_fallback_responsibility(actual_compliance_setting_id)
@@ -227,7 +248,7 @@ class ControlImplementation(RegScaleModel):
         try:
             from regscale.models.regscale_models.security_plan import SecurityPlan
 
-            security_plan = SecurityPlan.get_object(parent_id)
+            security_plan: SecurityPlan = SecurityPlan.get_object(parent_id)
             return security_plan.complianceSettingsId if security_plan else None
         except Exception:
             return None
@@ -240,14 +261,18 @@ class ControlImplementation(RegScaleModel):
 
         Cached to avoid repeated API calls for the same compliance setting.
         """
+        responsibility = ControlImplementationOrigin.NotApplicable.value
         try:
             from regscale.models.regscale_models.compliance_settings import ComplianceSettings
 
-            return ComplianceSettings.get_default_responsibility_for_compliance_setting(compliance_setting_id)
+            if cs_responsibility := ComplianceSettings.get_default_responsibility_for_compliance_setting(
+                compliance_setting_id
+            ):
+                responsibility = cs_responsibility
         except Exception:
-            pass
+            return responsibility
 
-        return None
+        return responsibility
 
     @classmethod
     def _get_fallback_responsibility(cls, compliance_setting_id: Optional[int] = None) -> str:
@@ -262,7 +287,7 @@ class ControlImplementation(RegScaleModel):
             return cls._get_framework_default_responsibility(compliance_setting_id)
 
         # Ultimate fallback for unknown compliance settings
-        return ControlImplementationOrigin.ProviderSS.value
+        return ControlImplementationOrigin.NotApplicable.value
 
     @classmethod
     def _get_framework_default_responsibility(cls, compliance_setting_id: int) -> str:
@@ -1146,7 +1171,7 @@ class ControlImplementation(RegScaleModel):
         if field_name == "status":
             return [imp_status.value for imp_status in ControlImplementationStatus]
         if field_name == "responsibility":
-            return ["Provider", "Customer", "Shared", "Not Applicable"]
+            return [origin.value for origin in ControlImplementationOrigin]
         return cls.get_bool_enums(field_name)
 
     @classmethod