regscale-cli 6.20.9.1__py3-none-any.whl → 6.21.0.0__py3-none-any.whl

regscale/models/regscale_models/deviation.py

@@ -5,9 +5,7 @@ from typing import List, Optional
 from pydantic import ConfigDict, Field
 
 from regscale.core.app.utils.app_utils import get_current_datetime
-
-from .. import Property
-from .regscale_model import RegScaleModel
+from regscale.models.regscale_models.regscale_model import RegScaleModel
 
 logger = logging.getLogger("regscale")
 
@@ -143,7 +141,7 @@ class Deviation(RegScaleModel):
         return []
 
     @classmethod
-    def get_dr_ids(cls, issue_id: int) -> Optional[Property]:
+    def get_dr_ids(cls, issue_id: int) -> Optional["Property"]:
         """
         Get a list of control implementations by plan ID.
 
@@ -151,6 +149,8 @@ class Deviation(RegScaleModel):
         :return: A single Property object with the DR number if it exists or None
         :rtype: Optional[Property]
         """
+        from regscale.models import Property
+
         properties = [
             prop
             for prop in Property.get_all_by_parent(parent_id=issue_id, parent_module="issues")

regscale/models/regscale_models/group.py

@@ -8,11 +8,12 @@ from typing import Optional, List, Tuple, cast
 from pydantic import ConfigDict, Field
 
 from regscale.core.app.utils.app_utils import get_current_datetime
-from regscale.models import User, deprecated
+from regscale.utils.decorators import deprecated
 from regscale.models.regscale_models.regscale_model import RegScaleModel, T
+from regscale.models.regscale_models.user import User
 from regscale.models.regscale_models.user_group import UserGroup
 
-logger = logging.getLogger(__name__)
+logger = logging.getLogger("regscale")
 
 
 class Group(RegScaleModel):

regscale/models/regscale_models/interconnection.py

@@ -19,7 +19,7 @@ class InterConnection(RegScaleModel):
     name: str
     organization: str
     status: str
-    aOId: str
+    aoId: str
     interconnectOwnerId: str
     parentId: int = 0
     parentModule: Optional[str] = None

regscale/models/regscale_models/issue.py

@@ -2,6 +2,7 @@
 # -*- coding: utf-8 -*-
 """Model for a RegScale Issue"""
 import datetime
+import time
 from collections import defaultdict
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from enum import Enum
@@ -25,6 +26,11 @@ from regscale.models.regscale_models.regscale_model import RegScaleModel
 from regscale.utils.version import RegscaleVersion
 
 
+# Module-level cache for open issues - avoids Pydantic conflicts
+_OPEN_ISSUES_CACHE: Dict[int, Tuple[float, Dict[int, List["OpenIssueDict"]]]] = {}
+_CACHE_TTL: float = 300.0  # 5 minutes TTL in seconds
+
+
 class OpenIssueDict(TypedDict):
     """TypedDict for open issues"""
 
@@ -280,6 +286,59 @@ class Issue(RegScaleModel):
             "find_by_integration_finding_id": "/api/{model_slug}/findByIntegrationFindingId/{id}",
         }
 
+    @classmethod
+    def _is_cache_valid(cls, plan_id: int) -> bool:
+        """
+        Check if cached data for a plan_id is still valid
+
+        :param int plan_id: The plan ID to check cache validity for
+        :return: True if cache is valid, False otherwise
+        :rtype: bool
+        """
+        if plan_id not in _OPEN_ISSUES_CACHE:
+            return False
+
+        cached_time, _ = _OPEN_ISSUES_CACHE[plan_id]
+        return (time.time() - cached_time) < _CACHE_TTL
+
+    @classmethod
+    def _get_from_cache(cls, plan_id: int) -> Optional[Dict[int, List[OpenIssueDict]]]:
+        """
+        Get cached data for a plan_id if it exists and is valid
+
+        :param int plan_id: The plan ID to get cached data for
+        :return: Cached data if valid, None otherwise
+        :rtype: Optional[Dict[int, List[OpenIssueDict]]]
+        """
+        if cls._is_cache_valid(plan_id):
+            _, cached_data = _OPEN_ISSUES_CACHE[plan_id]
+            return cached_data
+        return None
+
+    @classmethod
+    def _cache_data(cls, plan_id: int, data: Dict[int, List[OpenIssueDict]]) -> None:
+        """
+        Cache data for a plan_id
+
+        :param int plan_id: The plan ID to cache data for
+        :param Dict[int, List[OpenIssueDict]] data: The data to cache
+        :rtype: None
+        """
+        _OPEN_ISSUES_CACHE[plan_id] = (time.time(), data)
+
+    @classmethod
+    def clear_cache(cls, plan_id: Optional[int] = None) -> None:
+        """
+        Clear cache for a specific plan_id or all cached data
+
+        :param Optional[int] plan_id: The plan ID to clear cache for, or None to clear all cache
+        :rtype: None
+        """
+        if plan_id is not None:
+            _OPEN_ISSUES_CACHE.pop(plan_id, None)
+        else:
+            _OPEN_ISSUES_CACHE.clear()
+
     @classmethod
     def find_by_other_identifier(cls, other_identifier: str) -> List["Issue"]:
         """
@@ -826,70 +885,110 @@ class Issue(RegScaleModel):
         cls, plan_id: int, is_component: Optional[bool] = False
     ) -> Dict[int, List[OpenIssueDict]]:
         """
-        Get all open issues by implementation id for a given security plan
+        Get all open issues by implementation id for a given security plan with optimized performance and caching
 
         :param int plan_id: The ID of the parent
+        :param bool is_component: Optional[bool] Defaults to False
         :return: A dictionary of control ids and their associated issue ids
         :rtype: Dict[int, List[OpenIssueDict]]
         """
         import logging
 
+        cache_disabled = cls._is_cache_disabled()
+        use_cache: bool = not cache_disabled
+
         logger = logging.getLogger("regscale")
-        take = 50
+        # 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)
+
+        start_time = time.time()
+        logger.info(f"Fetching open issues for controls and for security plan {plan_id}...")
+
         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()
 
-        # Define fields based on version
-        fields = """
-            id,
-            controlId
-            otherIdentifier
-            {extra_fields}
-        """.format(
-            extra_fields="controlImplementations { id }" if supports_multiple_controls else ""
-        )
+        # Optimize field selection - only get what we need
+        if supports_multiple_controls:
+            fields = "id, otherIdentifier, integrationFindingId, controlImplementations { id }"
+        else:
+            fields = "id, controlId, otherIdentifier, integrationFindingId"
+
+        total_fetched = 0
 
-        while True:
-            query = f"""
-                query MyQuery() {{
-                    {cls.get_module_string()}(
-                        skip: {skip},
-                        take: {take},
-                        where: {{
-                            {"componentId" if is_component else "securityPlanId"}: {{eq: {plan_id}}},
-                            status: {{eq: "Open"}}
+        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
                         }}
-                    ) {{
-                        items {{ {fields} }}
-                        pageInfo {{ hasNextPage }}
-                        totalCount
                     }}
-                }}
-            """
+                """
 
-            response = cls._get_api_handler().graph(query)
-            items = response.get(cls.get_module_string(), {}).get("items", [])
+                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)
 
-            for item in items:
-                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"])
-                        )
-                else:
-                    control_issues[item["controlId"]].append(
-                        OpenIssueDict(id=item["id"], otherIdentifier=item["otherIdentifier"])
+                # 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})"
+                    )
+
+                for item in items:
+                    issue_dict = OpenIssueDict(
+                        id=item["id"],
+                        otherIdentifier=item.get("otherIdentifier", ""),
+                        integrationFindingId=item.get("integrationFindingId", ""),
                     )
 
-            if not response.get(cls.get_module_string(), {}).get("pageInfo", {}).get("hasNextPage", False):
-                break
-            skip += take
-        logger.info("Finished fetching %i open control issue(s) for %s %i", len(control_issues), module_str, plan_id)
+                    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)
+
+                total_fetched += len(items)
+                if not response.get(cls.get_module_string(), {}).get("pageInfo", {}).get("hasNextPage", False):
+                    break
+                skip += take
+
+        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)
+
+        elapsed_time = time.time() - start_time
+        logger.info(
+            f"Finished fetching {total_fetched} open issue(s) for {len(control_issues)} 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

regscale/models/regscale_models/milestone.py

@@ -0,0 +1,40 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Class for milestone model in RegScale platform"""
+
+from typing import Optional
+from pydantic import ConfigDict, Field
+
+from regscale.core.app.utils.app_utils import get_current_datetime
+from regscale.models.regscale_models.regscale_model import RegScaleModel
+
+
+class Milestone(RegScaleModel):
+    """Milestone Model"""
+
+    _module_slug = "milestones"
+    _module_string = "milestones"
+
+    title: str
+    id: int = 0
+    isPublic: Optional[bool] = True
+    milestoneDate: Optional[str] = Field(default_factory=get_current_datetime)
+    responsiblePersonId: Optional[str] = None
+    predecessorStepId: Optional[int] = 0
+    completed: Optional[bool] = False
+    dateCompleted: Optional[str] = Field(default_factory=get_current_datetime)
+    notes: Optional[str] = ""
+    parentID: Optional[int] = None
+    parentModule: str = ""
+
+    @staticmethod
+    def _get_additional_endpoints() -> ConfigDict:
+        """
+        Get additional endpoints for the Milestone model
+
+        :return: A dictionary of additional endpoints
+        :rtype: ConfigDict
+        """
+        return ConfigDict(
+            get_all_by_parent="/api/{model_slug}/getAllByParent/{intParentID}",
+        )

regscale/models/regscale_models/property.py

@@ -10,7 +10,6 @@ from pydantic import ConfigDict, Field, field_validator
 
 from regscale.core.app.api import Api
 from regscale.core.app.application import Application
-from regscale.core.app.internal.model_editor import get_all_by_parent
 from regscale.core.app.utils.app_utils import get_current_datetime, recursive_items
 from regscale.models.regscale_models.regscale_model import RegScaleModel
 from regscale.utils import flatten_dict

regscale/models/regscale_models/rbac.py

@@ -28,6 +28,7 @@ class RBAC(RegScaleModel):
             add="/api/{model_slug}/add/{moduleId}/{parentId}/{groupId}/{permissionType}",
             public="/api/{model_slug}/public/{moduleId}/{parentId}/{public}",
             none_standard_delete="/api/{model_slug}/{moduleId}/{parentId}/{rbacId}",
+            reset="/api/{model_slug}/reset/{moduleId}/{parentId}",
         )
 
     @classmethod
@@ -129,3 +130,24 @@ class RBAC(RegScaleModel):
         else:
             cls.log_response_error(response=response)
             return False
+
+    @classmethod
+    def reset(cls, module_id: int, parent_id: int) -> bool:
+        """
+        Proliferates the RBAC entry to all its children
+
+        :param int module_id: The ID of the module
+        :param int parent_id: The ID of the parent
+        :return: True if the RBAC entry was added, False otherwise
+        :rtype: bool
+        """
+        response = cls._get_api_handler().get(
+            endpoint=cls.get_endpoint("reset").format(
+                model_slug=cls._module_slug, moduleId=module_id, parentId=parent_id
+            )
+        )
+        if response and response.ok:
+            return True
+        else:
+            cls.log_response_error(response=response)
+            return False

regscale/models/regscale_models/regscale_model.py

@@ -32,8 +32,6 @@ T = TypeVar("T", bound="RegScaleModel")
 
 logger = logging.getLogger("regscale")
 
-IS_DISABLE_CACHE = False  # flag to disable caching
-
 
 class RegScaleModel(BaseModel, ABC):
     """Mixin class for RegScale Models to add functionality to interact with RegScale API"""
@@ -58,6 +56,7 @@ class RegScaleModel(BaseModel, ABC):
     _parent_cache: ClassVar[Cache] = Cache(maxsize=50000)
     _lock_registry: ClassVar[ThreadSafeDict] = ThreadSafeDict()
     _global_lock: ClassVar[threading.Lock] = threading.Lock()  # Class-level lock
+    _is_disable_cache: ClassVar[Optional[bool]] = None  # Class-level cache setting
 
     _pending_updates: ClassVar[Dict[str, Set[int]]] = {}
     _pending_creations: ClassVar[Dict[str, Set[str]]] = {}
@@ -78,17 +77,19 @@ class RegScaleModel(BaseModel, ABC):
         :rtype: None
         """
         try:
-            global IS_DISABLE_CACHE
             super().__init__(*args, **data)
             # Capture initial state after initialization
             self._original_data = self.dict(exclude_unset=True)
-            IS_DISABLE_CACHE = self._fetch_disabled_cache_setting()
-            if IS_DISABLE_CACHE:
+            # Initialize cache setting if not already set
+            if self.__class__._is_disable_cache is None:
+                self.__class__._is_disable_cache = self.__class__._fetch_disabled_cache_setting()
+            if self.__class__._is_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:
+    @classmethod
+    def _fetch_disabled_cache_setting(cls) -> bool:
         """
         Check if caching is disabled based on the application config.
 
@@ -96,10 +97,22 @@ class RegScaleModel(BaseModel, ABC):
         :rtype: bool
         """
         is_disabled = False
-        if config := self._get_api_handler().config:
+        if config := cls._get_api_handler().config:
             is_disabled = config.get("disableCache", False)
         return is_disabled
 
+    @classmethod
+    def _is_cache_disabled(cls) -> bool:
+        """
+        Check if caching is disabled for this class.
+
+        :return: True if caching is disabled, False otherwise
+        :rtype: bool
+        """
+        if cls._is_disable_cache is None:
+            cls._is_disable_cache = cls._fetch_disabled_cache_setting()
+        return cls._is_disable_cache
+
     @classmethod
     def disable_cache(cls) -> bool:
         """
@@ -108,9 +121,8 @@ class RegScaleModel(BaseModel, ABC):
         :return: True if caching is disabled, False otherwise
         :rtype: bool
         """
-        global IS_DISABLE_CACHE
-        IS_DISABLE_CACHE = True
-        return IS_DISABLE_CACHE
+        cls._is_disable_cache = True
+        return cls._is_disable_cache
 
     @classmethod
     def enable_cache(cls) -> bool:
@@ -120,9 +132,8 @@ class RegScaleModel(BaseModel, ABC):
         :return: True if caching is enabled, False otherwise
         :rtype: bool
         """
-        global IS_DISABLE_CACHE
-        IS_DISABLE_CACHE = False
-        return IS_DISABLE_CACHE
+        cls._is_disable_cache = False
+        return cls._is_disable_cache
 
     @classmethod
     def _get_api_handler(cls) -> APIHandler:
@@ -210,7 +221,7 @@ class RegScaleModel(BaseModel, ABC):
         :return: The cached object if found, None otherwise
         :rtype: Optional[T]
         """
-        if IS_DISABLE_CACHE:
+        if cls._is_cache_disabled():
             return None
         with cls._get_lock(cache_key):
             return cls._object_cache.get(cache_key)
@@ -224,7 +235,7 @@ class RegScaleModel(BaseModel, ABC):
         :return: None
         :rtype: None
         """
-        if IS_DISABLE_CACHE:
+        if cls._is_cache_disabled():
             return
         try:
             if not obj:
@@ -274,7 +285,7 @@ class RegScaleModel(BaseModel, ABC):
         :return: None
         :rtype: None
         """
-        if IS_DISABLE_CACHE:
+        if cls._is_cache_disabled():
             return
         parent_id = getattr(obj, cls._parent_id_field, None)
         parent_module = getattr(obj, "parentModule", getattr(obj, "parent_module", ""))
@@ -299,7 +310,7 @@ class RegScaleModel(BaseModel, ABC):
         :return: None
         :rtype: None
         """
-        if IS_DISABLE_CACHE:
+        if cls._is_cache_disabled():
             return
         with cls._get_lock(cache_key):
             for obj in objects:
@@ -325,7 +336,7 @@ class RegScaleModel(BaseModel, ABC):
         :return: None
         :rtype: None
         """
-        if IS_DISABLE_CACHE:
+        if cls._is_cache_disabled():
             return
         cache_key = cls._get_cache_key(obj)
         with cls._get_lock(cache_key):

regscale/models/regscale_models/team.py

@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Model for Teams in the application"""
+
+from typing import Optional, Union
+
+from pydantic import ConfigDict
+
+from regscale.core.app.api import Api
+from regscale.models.regscale_models.regscale_model import RegScaleModel
+
+
+class Team(RegScaleModel):
+    _module_slug = "teams"
+
+    id: Optional[int] = None
+    member: Optional[str] = None
+    memberId: Optional[str] = None
+    memberType: Optional[str] = None
+    bExecutive: Optional[bool] = False
+    bOversight: Optional[bool] = False
+    bCommunications: Optional[bool] = False
+    bEngineer: Optional[bool] = False
+    bAssessor: Optional[bool] = False
+    bQuality: Optional[bool] = False
+    bSafety: Optional[bool] = False
+    bSecurity: Optional[bool] = False
+    bAnalyst: Optional[bool] = False
+    bScheduler: Optional[bool] = False
+    bAdministrative: Optional[bool] = False
+    bProjectManager: Optional[bool] = False
+    bFinance: Optional[bool] = False
+    bHumanResources: Optional[bool] = False
+    bOperations: Optional[bool] = False
+    bISSO: Optional[bool] = False
+    bISSM: Optional[bool] = False
+    bAO: Optional[bool] = False
+    bCISO: Optional[bool] = False
+    bSCA: Optional[bool] = False
+    bDevOps: Optional[bool] = False
+    bProgrammer: Optional[bool] = False
+    bSystemOwner: Optional[bool] = False
+    bRiskAnalyst: Optional[bool] = False
+    bInternalAudit: Optional[bool] = False
+    bExternalAudit: Optional[bool] = False
+    bInformationOwner: Optional[bool] = False
+    bAODR: Optional[bool] = False
+    bContingencyCoordinator: Optional[bool] = False
+    bContingencyDirector: Optional[bool] = False
+    bResponsible: Optional[bool] = False
+    bAccountable: Optional[bool] = False
+    bConsulted: Optional[bool] = False
+    bInformed: Optional[bool] = False
+    parentId: Optional[int] = None
+    parentModule: Optional[str] = None

{regscale_cli-6.20.9.1.dist-info → regscale_cli-6.21.0.0.dist-info}/METADATA

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