regscale-cli 6.16.2.0__py3-none-any.whl → 6.16.4.0__py3-none-any.whl

regscale/models/regscale_models/risk.py

@@ -48,17 +48,18 @@ class Risk(RegScaleModel):
     dateClosed: Optional[str] = None
     facilityId: Optional[int] = None
     orgId: Optional[int] = None
+    scenarioId: Optional[int] = None
     comments: Optional[str] = None
     riskTier: Optional[str] = None
     title: Optional[str] = None
     recommendations: Optional[str] = None
     impactDescription: Optional[str] = None
-    inherentRiskScore: Optional[int] = None
-    residualRiskScore: Optional[int] = None
-    targetRiskScore: Optional[int] = None
-    difference: Optional[int] = None
-    futureCosts: Optional[int] = None
-    costToMitigate: Optional[int] = None
+    inherentRiskScore: Optional[float] = None
+    residualRiskScore: Optional[float] = None
+    targetRiskScore: Optional[float] = None
+    difference: Optional[float] = None
+    futureCosts: Optional[float] = None
+    costToMitigate: Optional[float] = None
     controlId: Optional[int] = None
     assessmentId: Optional[int] = None
     requirementId: Optional[int] = None
@@ -73,6 +74,9 @@ class Risk(RegScaleModel):
     nextAssessmentDueDate: Optional[str] = None
     riskOwnerId: Optional[str] = None
     isPublic: bool = True
+    averageRiskScore: Optional[float] = None
+    weightedRiskScore: Optional[float] = None
+    parentRiskModelId: Optional[int] = None
 
     @staticmethod
     def fetch_all_risks(app: Application) -> list["Risk"]:
@@ -145,31 +149,35 @@ class Risk(RegScaleModel):
             "dateClosed": 26,
             "facilityId": 27,
             "orgId": 28,
-            "comments": 29,
-            "riskTier": 30,
-            "title": 31,
-            "recommendations": 32,
-            "impactDescription": 33,
-            "inherentRiskScore": 34,
-            "residualRiskScore": 35,
-            "targetRiskScore": 36,
-            "difference": 37,
-            "futureCosts": 38,
-            "costToMitigate": 39,
-            "controlId": 40,
-            "assessmentId": 41,
-            "requirementId": 42,
-            "securityPlanId": 43,
-            "projectId": 44,
-            "supplyChainId": 45,
-            "policyId": 46,
-            "componentId": 47,
-            "incidentId": 48,
-            "riskAssessmentFrequency": 49,
-            "dateLastAssessed": 50,
-            "nextAssessmentDueDate": 51,
-            "riskOwnerId": 52,
+            "scenarioId": 29,
+            "comments": 30,
+            "riskTier": 31,
+            "title": 32,
+            "recommendations": 33,
+            "impactDescription": 34,
+            "inherentRiskScore": 35,
+            "residualRiskScore": 36,
+            "targetRiskScore": 37,
+            "difference": 38,
+            "futureCosts": 39,
+            "costToMitigate": 40,
+            "controlId": 41,
+            "assessmentId": 42,
+            "requirementId": 43,
+            "securityPlanId": 44,
+            "projectId": 45,
+            "supplyChainId": 46,
+            "policyId": 47,
+            "componentId": 48,
+            "incidentId": 49,
+            "riskAssessmentFrequency": 50,
+            "dateLastAssessed": 51,
+            "nextAssessmentDueDate": 52,
+            "riskOwnerId": 53,
             "isPublic": -1,
+            "averageRiskScore": 54,
+            "weightedRiskScore": 55,
+            "parentRiskModelId": 56,
         }
 
     # pylint: disable=W0613

regscale/models/regscale_models/security_plan.py

@@ -18,6 +18,7 @@ class SecurityPlan(RegScaleModel):
     """
 
     _module_slug = "securityplans"
+    _unique_fields = ["systemName", "tenantsId"]
 
     id: int = 0
     uuid: str = ""

regscale/models/regscale_models/supply_chain.py

@@ -106,7 +106,7 @@ class SupplyChain(RegScaleModel):
     actualCosts: Optional[int] = 0
     strategicTier: Optional[Union[SupplyChainTier, str]] = None
     contractType: Optional[Union[SupplyChainContractType, str]] = None
-    scope: Optional[str] = (None,)
+    scope: Optional[str] = None
     startDate: Optional[str] = None
     endDate: Optional[str] = None
     violationURL: Optional[str] = None

regscale/models/regscale_models/user.py

@@ -5,11 +5,12 @@
 # standard python imports
 import random
 import string
-from typing import cast, Optional, List
+from typing import List, Optional, cast
 
-from pydantic import Field, ConfigDict, field_validator
+from pydantic import ConfigDict, Field, field_validator
 
 from regscale.core.app.utils.app_utils import get_current_datetime
+
 from .regscale_model import RegScaleModel, T
 
 
@@ -75,11 +76,10 @@ class User(RegScaleModel):
         :param str v: homePageUrl value
         :return: The homePageUrl if the RegScale version is compatible, None otherwise
         """
-        from packaging.version import Version
-
-        regscale_version = cls._get_api_handler().regscale_version
+        from regscale.utils.version import RegscaleVersion
 
-        if len(regscale_version) >= 10 or Version(regscale_version) >= Version("6.14.0.0"):
+        rv = RegscaleVersion()
+        if rv.meets_minimum_version("6.14.0.0"):
             return v
         else:
             return None
@@ -123,6 +123,19 @@ class User(RegScaleModel):
             change_avatar="/api/{model_slug}/changeAvatar/{strUsername}",
         )
 
+    @classmethod
+    def get_roles(cls) -> List[dict]:
+        """
+        Get all roles from RegScale
+
+        :return: List of RegScale roles
+        :rtype: List[dict]
+        """
+        response = cls._get_api_handler().get(endpoint=cls.get_endpoint("get_roles"))
+        if response and response.ok:
+            return response.json()
+        return []
+
     @classmethod
     def get_tenant_id_for_user_id(cls, user_id: str) -> Optional[int]:
         """

regscale/utils/threading/__init__.py

@@ -6,3 +6,4 @@ from .threadhandler import ThreadManager
 from .threadsafe_counter import ThreadSafeCounter
 from .threadsafe_dict import ThreadSafeDict
 from .threadsafe_list import ThreadSafeList
+from .threadsafe_set import ThreadSafeSet

regscale/utils/threading/threadsafe_list.py

@@ -63,6 +63,16 @@ class ThreadSafeList(Generic[T]):
         with self._lock:
             return iter(self._list.copy())
 
+    def __list__(self) -> List[T]:
+        """
+        Convert ThreadSafeList to a regular list when list() is called
+
+        :return: A copy of the internal list
+        :rtype: List[T]
+        """
+        with self._lock:
+            return self._list.copy()
+
     def remove(self, item: T) -> None:
         """
         Remove an item from the list

regscale/utils/threading/threadsafe_set.py

@@ -0,0 +1,116 @@
+"""
+This module contains the ThreadSafeSet class, which is a thread-safe set.
+"""
+
+from threading import RLock
+from typing import Generic, Iterator, Optional, Set, TypeVar
+
+T = TypeVar("T")  # Declare type variable
+
+
+class ThreadSafeSet(Generic[T]):
+    """
+    ThreadSafeSet class to create a thread-safe set.
+    """
+
+    def __init__(self, initial_set: Optional[Set[T]] = None):
+        """
+        Initialize a new ThreadSafeSet
+
+        :param Set[T]|None initial_set: Optional initial set to populate the ThreadSafeSet
+        """
+        self._set: Set[T] = set(initial_set) if initial_set is not None else set()
+        self._lock = RLock()
+
+    def add(self, item: T) -> None:
+        """
+        Add an item to the set
+
+        :param T item: Item to add to the set
+        :rtype: None
+        """
+        with self._lock:
+            self._set.add(item)
+
+    def remove(self, item: T) -> None:
+        """
+        Remove an item from the set
+
+        :param T item: Item to remove from the set
+        :raises KeyError: If the item is not found
+        :rtype: None
+        """
+        with self._lock:
+            self._set.remove(item)
+
+    def discard(self, item: T) -> None:
+        """
+        Remove an item from the set if it exists
+
+        :param T item: Item to remove from the set
+        :rtype: None
+        """
+        with self._lock:
+            self._set.discard(item)
+
+    def __len__(self) -> int:
+        """
+        Get the length of the set
+
+        :return: The length of the set
+        :rtype: int
+        """
+        with self._lock:
+            return len(self._set)
+
+    def __iter__(self) -> Iterator[T]:
+        """
+        Return an iterator over the set
+
+        :return: An iterator over the set
+        :rtype: Iterator[T]
+        """
+        with self._lock:
+            return iter(self._set.copy())
+
+    def __contains__(self, item: T) -> bool:
+        """
+        Check if an item is in the set
+
+        :param T item: Item to check
+        :return: True if the item is in the set, False otherwise
+        :rtype: bool
+        """
+        with self._lock:
+            return item in self._set
+
+    def clear(self) -> None:
+        """
+        Clear the set
+
+        :rtype: None
+        """
+        with self._lock:
+            self._set.clear()
+
+    def union(self, other: Set[T]) -> Set[T]:
+        """
+        Return the union of this set and another
+
+        :param Set[T] other: Other set to union with
+        :return: A new set containing the union
+        :rtype: Set[T]
+        """
+        with self._lock:
+            return self._set.union(other)
+
+    def intersection(self, other: Set[T]) -> Set[T]:
+        """
+        Return the intersection of this set and another
+
+        :param Set[T] other: Other set to intersect with
+        :return: A new set containing the intersection
+        :rtype: Set[T]
+        """
+        with self._lock:
+            return self._set.intersection(other)

regscale/utils/version.py

@@ -2,13 +2,11 @@
 
 import logging
 import re
-from typing import Optional
 from functools import lru_cache
 
 from packaging.version import Version
 
 from regscale.core.app.utils.api_handler import APIHandler
-from regscale.utils.decorators import classproperty
 
 logger = logging.getLogger(__name__)
 
@@ -32,15 +30,15 @@ class RegscaleVersion:
         try:
             api_handler = APIHandler()
             response = api_handler.get("/assets/json/version.json")
-            if response.status_code == 200:
+            if response.ok and response.status_code == 200:
                 version_data = response.json()
                 return version_data.get("version", "Unknown")
             else:
                 logger.error(f"Failed to fetch version. Status code: {response.status_code}")
-                return "dev"
+                return "Unknown"
         except Exception as e:
             logger.error(f"Error fetching version: {e}", exc_info=True)
-            return "dev"
+            return "Unknown"
 
     @staticmethod
     def is_valid_version(version: str) -> bool:

{regscale_cli-6.16.2.0.dist-info → regscale_cli-6.16.4.0.dist-info}/METADATA

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