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

regscale/models/regscale_models/__init__.py

@@ -1,6 +1,7 @@
 """RegScale models."""
 
 from .assessment_plan import *
+from .assessment_result import *
 from .assessment import *
 from .asset import *
 from .asset_mapping import *
@@ -10,6 +11,7 @@ from .case import *
 from .cci import *
 from .change import *
 from .checklist import *
+from .classification import *
 from .comment import *
 from .compliance_settings import *
 from .component import *
@@ -21,23 +23,32 @@ from .control_parameter import *
 from .control_test import *
 from .control_test_plan import *
 from .control_test_result import *
+from .cryptography import *
 from .custom_field import *
 from .data import *
 from .data_center import *
+from .deviation import *
 from .email import *
 from .evidence import *
 from .evidence_mapping import *
 from .facility import *
 from .file import *
+from .filetag import *
+from .form_field_value import *
+from .functional_roles import *
+from .group import *
 from .implementation_objective import *
 from .implementation_option import *
+from .implementation_role import *
 from .incident import *
 from .inherited_control import *
 from .interconnection import *
 from .issue import *
 from .leveraged_authorization import *
+from .line_of_inquiry import *
 from .link import *
 from .master_assessment import *
+from .milestone import *
 from .meta_data import *
 from .objective import *
 from .parameter import *
@@ -52,6 +63,7 @@ from .property import *
 from .question import *
 from .questionnaire import *
 from .questionnaire_instance import *
+from .rbac import *
 from .reference import *
 from .requirement import *
 from .risk import *
@@ -69,6 +81,7 @@ from .system_role import *
 from .system_role_external_assignment import *
 from .task import *
 from .threat import *
+from .team import *
 from .user import *
 from .vulnerability import *
 from .vulnerability_mapping import *

regscale/models/regscale_models/classification.py

@@ -0,0 +1,23 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Model for Classification Records in the application"""
+
+from typing import Optional, Union
+
+from pydantic import ConfigDict
+from regscale.models.regscale_models.regscale_model import RegScaleModel
+
+
+class ClassifiedRecord(RegScaleModel):
+    _module_slug = "classifiedRecords"
+
+    id: Optional[int] = None
+    parentRecordId: Optional[int] = 0
+    parentModule: Optional[str] = None
+    classificationTypeId: Optional[int] = 0
+    adjustedConfidentiality: Optional[str] = None
+    confidentialityJustification: Optional[str] = None
+    adjustedAvailability: Optional[str] = None
+    availabilityJustification: Optional[str] = None
+    adjustedIntegrity: Optional[str] = None
+    integrityJustification: Optional[str] = None

regscale/models/regscale_models/cryptography.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Model for Cryptography in the application"""
+
+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 Cryptography(RegScaleModel):
+    _module_slug = "cryptography"
+
+    id: Optional[int] = None
+    cryptographyType: str
+    sourceArea: Optional[str] = None
+    sourceVendorName: Optional[str] = None
+    sourceModule: Optional[str] = None
+    fipsNumber: Optional[str] = None
+    bSourceEmbedded: Optional[bool] = False
+    bSourceThirdParty: Optional[bool] = False
+    bSourceOS: Optional[bool] = False
+    bSourceFIPS: Optional[bool] = False
+    bSourceOther: Optional[bool] = False
+    sourceExplanationOther: Optional[str] = None
+    destinationArea: Optional[str] = None
+    destinationVendorName: Optional[str] = None
+    destinationModule: Optional[str] = None
+    bDestinationEmbedded: Optional[bool] = False
+    bDestinationThirdParty: Optional[bool] = False
+    bDestinationOS: Optional[bool] = False
+    bDestinationFIPS: Optional[bool] = False
+    bDestinationOther: Optional[bool] = False
+    destinationExplanationOther: Optional[str] = None
+    bUsageTLS11: Optional[bool] = False
+    bUsageTLS12: Optional[bool] = False
+    bUsageTLS13: Optional[bool] = False
+    bUsageOther: Optional[bool] = False
+    usageExplanationOther: Optional[str] = None
+    usage: str
+    bRestFullDisk: Optional[bool] = False
+    bRestFile: Optional[bool] = False
+    bRestRecord: Optional[bool] = False
+    bRestNone: Optional[bool] = False
+    encryptionExplanationOther: Optional[str] = None
+    encryptionType: Optional[str] = None
+    notes: Optional[str] = None
+    referenceUrl: Optional[str] = None
+    isPublic: Optional[bool] = False
+    parentId: Optional[int] = 0
+    parentModule: 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)
+    tenantsId: int = 1

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[str] = 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/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.20.10.0.dist-info}/METADATA

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