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

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):
@@ -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

regscale/models/regscale_models/issue.py

@@ -84,6 +84,35 @@ class IssueStatus(str, Enum):
         return self.value
 
 
+class IssueIdentification(str, Enum):
+    """Issue Identification"""
+
+    A123Review = "A-123 Review"
+    AssessmentAuditInternal = "Assessment/Audit (Internal)"
+    AssessmentAuditExternal = "Assessment/Audit (External)"
+    CriticalControlReview = "Critical Control Review"
+    FDCCUSGCB = "FDCC/USGCB"
+    GAOAudit = "GAO Audit"
+    IGAudit = "IG Audit"
+    IncidentResponseLessonsLearned = "Incident Response Lessons Learned"
+    ITAR = "ITAR"
+    PenetrationTest = "Penetration Test"
+    RiskAssessment = "Risk Assessment"
+    SecurityAuthorization = "Security Authorization"
+    SecurityControlAssessment = "Security Control Assessment"
+    VulnerabilityAssessment = "Vulnerability Assessment"
+    Other = "Other"
+
+    def __str__(self) -> str:
+        """
+        Return the value of the Enum as a string
+
+        :return: The value of the Enum as a string
+        :rtype: str
+        """
+        return self.value
+
+
 class Issue(RegScaleModel):
     """Issue Model"""
 
@@ -917,103 +946,252 @@ class Issue(RegScaleModel):
         """
         import logging
 
-        cache_disabled = cls._is_cache_disabled()
-        use_cache: bool = not cache_disabled
-
         logger = logging.getLogger("regscale")
+
         # Check cache first
-        if use_cache:
-            cached_data = cls._get_from_cache(plan_id)
-            if cached_data is not None:
-                logger.info(f"Using cached open issues data for security plan {plan_id}")
-                return cached_data
-
-        # Performance optimization: Use larger batch size and optimize query
-        take = 50  # Increased from 50 to reduce API roundtrips
-        skip = 0
-        control_issues: Dict[int, List[OpenIssueDict]] = defaultdict(list)
+        cached_data = cls._check_cache(plan_id, logger)
+        if cached_data is not None:
+            return cached_data
 
-        start_time = time.time()
-        logger.info(f"Fetching open issues for controls and for security plan {plan_id}...")
+        # Fetch open issues from API
+        control_issues = cls._fetch_open_issues_from_api(plan_id, is_component, logger)
+
+        # Cache the results if caching is enabled
+        if not cls._is_cache_disabled():
+            cls._cache_data(plan_id, control_issues)
+
+        return control_issues
+
+    @classmethod
+    def _check_cache(cls, plan_id: int, logger) -> Optional[Dict[int, List[OpenIssueDict]]]:
+        """
+        Check cache for open issues data
+
+        :param int plan_id: The ID of the parent
+        :param logger: Logger instance
+        :return: Cached data if available and valid, None otherwise
+        :rtype: Optional[Dict[int, List[OpenIssueDict]]]
+        """
+        if cls._is_cache_disabled():
+            return None
+
+        cached_data = cls._get_from_cache(plan_id)
+        if cached_data is not None:
+            logger.info(f"Using cached open issues data for security plan {plan_id}")
+        return cached_data
+
+    @classmethod
+    def _fetch_open_issues_from_api(cls, plan_id: int, is_component: bool, logger) -> Dict[int, List[OpenIssueDict]]:
+        """
+        Fetch open issues from API with pagination
 
+        :param int plan_id: The ID of the parent
+        :param bool is_component: Whether parent is a component
+        :param logger: Logger instance
+        :return: Dictionary of control IDs to open issues
+        :rtype: Dict[int, List[OpenIssueDict]]
+        """
+        start_time = time.time()
         module_str = "component" if is_component else "security plan"
-        logger.info(
-            f"Fetching open issues for controls and for {module_str} {plan_id}...",
-        )
-        supports_multiple_controls: bool = cls.is_multiple_controls_supported()
+        logger.info(f"Fetching open issues for controls and for {module_str} {plan_id}...")
 
-        # Optimize field selection - only get what we need
-        if supports_multiple_controls:
-            fields = "id, otherIdentifier, integrationFindingId, controlImplementations { id }"
-        else:
-            fields = "id, controlId, otherIdentifier, integrationFindingId"
+        control_issues: Dict[int, List[OpenIssueDict]] = defaultdict(list)
+
+        try:
+            total_fetched = cls._paginate_and_process_issues(plan_id, is_component, control_issues, logger)
+            cls._log_completion(plan_id, total_fetched, len(control_issues), start_time, logger)
+        except Exception as e:
+            logger.error(f"Error fetching open issues for security plan {plan_id}: {e}")
+            return defaultdict(list)
+
+        return control_issues
 
+    @classmethod
+    def _paginate_and_process_issues(
+        cls,
+        plan_id: int,
+        is_component: bool,
+        control_issues: Dict[int, List[OpenIssueDict]],
+        logger,
+    ) -> int:
+        """
+        Paginate through API results and process issues
+
+        :param int plan_id: The ID of the parent
+        :param bool is_component: Whether parent is a component
+        :param Dict[int, List[OpenIssueDict]] control_issues: Dictionary to populate with results
+        :param logger: Logger instance
+        :return: Total number of items fetched
+        :rtype: int
+        """
+        take = 50
+        skip = 0
         total_fetched = 0
+        supports_multiple_controls = cls.is_multiple_controls_supported()
+        fields = cls._get_query_fields(supports_multiple_controls)
 
-        try:
-            while True:
-                query = f"""
-                    query GetOpenIssuesByPlanOrComponent {{
-                        {cls.get_module_string()}(
-                            skip: {skip},
-                            take: {take},
-                            where: {{
-                                {"componentId" if is_component else "securityPlanId"}: {{eq: {plan_id}}},
-                                status: {{eq: "Open"}}
-                            }}
-                        ) {{
-                            items {{ {fields} }}
-                            pageInfo {{ hasNextPage }}
-                            totalCount
-                        }}
+        while True:
+            query = cls._build_query(plan_id, is_component, skip, take, fields)
+            response = cls._get_api_handler().graph(query)
+
+            items = response.get(cls.get_module_string(), {}).get("items", [])
+            total_count = response.get(cls.get_module_string(), {}).get("totalCount", 0)
+
+            cls._log_progress(skip, take, len(items), total_count, logger)
+            cls._process_issue_items(items, supports_multiple_controls, control_issues)
+
+            total_fetched += len(items)
+
+            if not response.get(cls.get_module_string(), {}).get("pageInfo", {}).get("hasNextPage", False):
+                break
+
+            skip += take
+
+        return total_fetched
+
+    @classmethod
+    def _get_query_fields(cls, supports_multiple_controls: bool) -> str:
+        """
+        Get GraphQL query fields based on control support
+
+        :param bool supports_multiple_controls: Whether multiple controls are supported
+        :return: GraphQL field selection string
+        :rtype: str
+        """
+        if supports_multiple_controls:
+            return "id, otherIdentifier, integrationFindingId, controlImplementations { id }"
+        return "id, controlId, otherIdentifier, integrationFindingId"
+
+    @classmethod
+    def _build_query(cls, plan_id: int, is_component: bool, skip: int, take: int, fields: str) -> str:
+        """
+        Build GraphQL query for fetching open issues
+
+        :param int plan_id: The ID of the parent
+        :param bool is_component: Whether parent is a component
+        :param int skip: Number of items to skip
+        :param int take: Number of items to take
+        :param str fields: GraphQL fields to select
+        :return: GraphQL query string
+        :rtype: str
+        """
+        parent_field = "componentId" if is_component else "securityPlanId"
+        return f"""
+            query GetOpenIssuesByPlanOrComponent {{
+                {cls.get_module_string()}(
+                    skip: {skip},
+                    take: {take},
+                    where: {{
+                        {parent_field}: {{eq: {plan_id}}},
+                        status: {{eq: "Open"}}
                     }}
-                """
+                ) {{
+                    items {{ {fields} }}
+                    pageInfo {{ hasNextPage }}
+                    totalCount
+                }}
+            }}
+        """
 
-                response = cls._get_api_handler().graph(query)
-                items = response.get(cls.get_module_string(), {}).get("items", [])
-                total_count = response.get(cls.get_module_string(), {}).get("totalCount", 0)
+    @classmethod
+    def _log_progress(cls, skip: int, take: int, items_count: int, total_count: int, logger) -> None:
+        """
+        Log progress for large datasets
 
-                # Log progress for large datasets
-                if total_count > 1000:
-                    logger.info(
-                        f"Processing batch {skip // take + 1} - fetched {len(items)} items ({skip + len(items)}/{total_count})"
-                    )
+        :param int skip: Number of items skipped
+        :param int take: Batch size
+        :param int items_count: Number of items in current batch
+        :param int total_count: Total count of items
+        :param logger: Logger instance
+        :rtype: None
+        """
+        if total_count > 1000:
+            logger.info(
+                f"Processing batch {skip // take + 1} - fetched {items_count} items ({skip + items_count}/{total_count})"
+            )
 
-                for item in items:
-                    issue_dict = OpenIssueDict(
-                        id=item["id"],
-                        otherIdentifier=item.get("otherIdentifier", ""),
-                        integrationFindingId=item.get("integrationFindingId", ""),
-                    )
+    @classmethod
+    def _process_issue_items(
+        cls,
+        items: List[Dict[str, Any]],
+        supports_multiple_controls: bool,
+        control_issues: Dict[int, List[OpenIssueDict]],
+    ) -> None:
+        """
+        Process issue items and populate control_issues dictionary
 
-                    if supports_multiple_controls and item.get("controlImplementations"):
-                        for control in item.get("controlImplementations", []):
-                            control_issues[control["id"]].append(issue_dict)
-                    elif item.get("controlId"):
-                        control_issues[item["controlId"]].append(issue_dict)
+        :param List[Dict[str, Any]] items: List of issue items from API
+        :param bool supports_multiple_controls: Whether multiple controls are supported
+        :param Dict[int, List[OpenIssueDict]] control_issues: Dictionary to populate
+        :rtype: None
+        """
+        for item in items:
+            issue_dict = OpenIssueDict(
+                id=item["id"],
+                otherIdentifier=item.get("otherIdentifier", ""),
+                integrationFindingId=item.get("integrationFindingId", ""),
+            )
 
-                total_fetched += len(items)
-                if not response.get(cls.get_module_string(), {}).get("pageInfo", {}).get("hasNextPage", False):
-                    break
-                skip += take
+            if supports_multiple_controls:
+                cls._add_issue_to_multiple_controls(item, issue_dict, control_issues)
+            else:
+                cls._add_issue_to_single_control(item, issue_dict, control_issues)
 
-        except Exception as e:
-            logger.error(f"Error fetching open issues for security plan {plan_id}: {e}")
-            # Return empty dict on error to prevent breaking the calling code
-            return defaultdict(list)
+    @classmethod
+    def _add_issue_to_multiple_controls(
+        cls,
+        item: Dict[str, Any],
+        issue_dict: OpenIssueDict,
+        control_issues: Dict[int, List[OpenIssueDict]],
+    ) -> None:
+        """
+        Add issue to multiple control implementations
+
+        :param Dict[str, Any] item: Issue item from API
+        :param OpenIssueDict issue_dict: Issue dictionary
+        :param Dict[int, List[OpenIssueDict]] control_issues: Dictionary to populate
+        :rtype: None
+        """
+        if item.get("controlImplementations"):
+            for control in item.get("controlImplementations", []):
+                control_issues[control["id"]].append(issue_dict)
 
+    @classmethod
+    def _add_issue_to_single_control(
+        cls,
+        item: Dict[str, Any],
+        issue_dict: OpenIssueDict,
+        control_issues: Dict[int, List[OpenIssueDict]],
+    ) -> None:
+        """
+        Add issue to single control
+
+        :param Dict[str, Any] item: Issue item from API
+        :param OpenIssueDict issue_dict: Issue dictionary
+        :param Dict[int, List[OpenIssueDict]] control_issues: Dictionary to populate
+        :rtype: None
+        """
+        if item.get("controlId"):
+            control_issues[item["controlId"]].append(issue_dict)
+
+    @classmethod
+    def _log_completion(cls, plan_id: int, total_fetched: int, control_count: int, start_time: float, logger) -> None:
+        """
+        Log completion statistics
+
+        :param int plan_id: The ID of the parent
+        :param int total_fetched: Total number of items fetched
+        :param int control_count: Number of controls with issues
+        :param float start_time: Start time of the operation
+        :param logger: Logger instance
+        :rtype: None
+        """
         elapsed_time = time.time() - start_time
         logger.info(
-            f"Finished fetching {total_fetched} open issue(s) for {len(control_issues)} control(s) "
+            f"Finished fetching {total_fetched} open issue(s) for {control_count} control(s) "
             f"in security plan {plan_id} - took {elapsed_time:.2f} seconds"
         )
 
-        # Cache the results
-        if use_cache:
-            cls._cache_data(plan_id, control_issues)
-
-        return control_issues
-
     @classmethod
     def get_sort_position_dict(cls) -> Dict[str, int]:
         """
@@ -1103,36 +1281,20 @@ class Issue(RegScaleModel):
         }
 
     @classmethod
-    def get_enum_values(cls, field_name: str) -> List[Union[IssueSeverity, IssueStatus, str]]:
+    def get_enum_values(cls, field_name: str) -> List[Union[IssueSeverity, IssueStatus, IssueIdentification, str]]:
         """
         Overrides the base method.
 
         :param str field_name: The property name to provide enum values for
         :return: List of enum values or strings
-        :rtype: List[Union[IssueSeverity, IssueStatus, str]]
+        :rtype: List[Union[IssueSeverity, IssueStatus, IssueIdentification, str]]
         """
         if field_name == "severityLevel":
             return [severity.__str__() for severity in IssueSeverity]
         if field_name == "status":
             return [status.__str__() for status in IssueStatus]
         if field_name == "identification":
-            return [
-                "A-123 Review",
-                "Assessment/Audit (External)",
-                "Assessment/Audit (Internal)",
-                "Critical Control Review",
-                "FDCC/USGCB",
-                "GAO Audit",
-                "IG Audit",
-                "Incidnet Response Lessons Learned",
-                "ITAR",
-                "Other",
-                "Penetration Test",
-                "Risk Assessment",
-                "Security Authorization",
-                "Security Control Assessment",
-                "Vulnerability Assessment",
-            ]
+            return [identification.__str__() for identification in IssueIdentification]
         return cls.get_bool_enums(field_name)
 
     @classmethod

regscale/models/regscale_models/milestone.py

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

regscale/models/regscale_models/regscale_model.py

@@ -60,6 +60,7 @@ class RegScaleModel(BaseModel, ABC):
 
     _pending_updates: ClassVar[Dict[str, Set[int]]] = {}
     _pending_creations: ClassVar[Dict[str, Set[str]]] = {}
+    _ignore_has_changed: bool = False
 
     id: int = 0
     extra_data: Dict[str, Any] = Field(default={}, exclude=True)
@@ -1309,7 +1310,11 @@ class RegScaleModel(BaseModel, ABC):
         """
         # Check if the model has change tracking and if there are changes
         has_change_tracking = hasattr(self, "has_changed") and callable(getattr(self, "has_changed", None))
-        should_save = not has_change_tracking or self.has_changed()
+
+        if hasattr(self, "_ignore_has_changed") and self._ignore_has_changed:
+            should_save = True
+        else:
+            should_save = not has_change_tracking or self.has_changed()
 
         if should_save:
             if bulk:

{regscale_cli-6.25.1.0.dist-info → regscale_cli-6.26.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: regscale-cli
-Version: 6.25.1.0
+Version: 6.26.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