regscale-cli 6.27.2.0__py3-none-any.whl → 6.28.0.0__py3-none-any.whl

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

@@ -78,10 +78,44 @@ class Vulnerabilities(SynqlyModel):
             "low": ["low", "medium", "high", "critical"],
             "info": ["info", "low", "medium", "high", "critical"],
         }
-        mapped_severities = severity_map.get(severity.lower(), severity)
+        if severity[0].lower() == "a":
+            mapped_severities = list(severity_map.keys())
+        else:
+            mapped_severities = severity_map.get(severity.lower(), severity)
         severity_filter = f"severity[in]{','.join(mapped_severities)}"
         return severity_filter
 
+    def _translate_asset_filter(self, replace: str, replace_with: str, asset_filters: Optional[list[str]]) -> list[str]:
+        """
+        Translate asset filters to the correct format for the integration
+
+        :param str replace: The string to replace
+        :param str replace_with: The string to replace with
+        :param list[str] asset_filters: The asset filters to translate
+        :return: The translated asset filters
+        :rtype: list[str]
+        """
+        translated_asset_filters = []
+        for asset_filter in asset_filters:
+            # Remove outer double quotes if present
+            cleaned_filter = asset_filter
+            if cleaned_filter.startswith('"') and cleaned_filter.endswith('"') and len(cleaned_filter) > 1:
+                cleaned_filter = cleaned_filter[1:-1]
+            if cleaned_filter.startswith("'") and cleaned_filter.endswith("'") and len(cleaned_filter) > 1:
+                cleaned_filter = cleaned_filter[1:-1]
+
+            if replace_with in cleaned_filter:
+                possible_filter = cleaned_filter
+            elif replace in cleaned_filter:
+                possible_filter = cleaned_filter.replace(replace, replace_with)
+                self.logger.debug(f"Translated filter: from {cleaned_filter} to {possible_filter}")
+            else:
+                continue
+            valid_filter, _ = self.filter_parser.validate_filter(self.integration_id, possible_filter)
+            if valid_filter:
+                translated_asset_filters.append(possible_filter)
+        return translated_asset_filters
+
     def _handle_scan_date_options(self, regscale_ssp_id: int, **kwargs) -> list[str]:
         """
         Handle scan date options for the integration sync process
@@ -94,6 +128,11 @@ class Vulnerabilities(SynqlyModel):
 
         vuln_filter = [self._build_severity_filter(kwargs.get("minimum_severity_filter"))]
 
+        if asset_filters := kwargs.get("filter", []):
+            vuln_filter.extend(
+                self._translate_asset_filter(replace="device.", replace_with="resources.", asset_filters=asset_filters)
+            )
+
         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"):
@@ -118,8 +157,10 @@ class Vulnerabilities(SynqlyModel):
         self.logger.debug(f"Vulnerability filter: {vuln_filter}")
 
         # Pop the filter from kwargs so it doesn't get passed to query_findings
-        asset_filter = kwargs.pop("filter", [])
-        if asset_filter:
+        if asset_filter := kwargs.pop("filter", []):
+            asset_filter = self._translate_asset_filter(
+                replace="resources.", replace_with="device.", asset_filters=asset_filter
+            )
             self.logger.debug(f"Asset filter: {asset_filter}")
 
         self.logger.info(f"Fetching asset data from {self.integration_name}...")

regscale/models/integration_models/synqly_models/ocsf_mapper.py

@@ -106,9 +106,8 @@ class Mapper:
             regscale_issue.manualDetectionId = ticket.id
         return regscale_issue
 
-    @staticmethod
     def _ocsf_asset_to_regscale(
-        connector: Union["Edr", "Vulnerabilities"], asset: Union[InventoryInfo, OCSFAsset, SoftwareInfo], **kwargs
+        self, connector: Union["Edr", "Vulnerabilities"], asset: Union[InventoryInfo, OCSFAsset, SoftwareInfo], **kwargs
     ) -> IntegrationAsset:
         """
         Convert OCSF Asset to RegScale Asset
@@ -134,6 +133,9 @@ class Mapper:
         else:
             name = device_data.name or device_data.hostname or f"{connector.provider} Asset: {device_data.uid}"
             category = AssetCategory.Software
+        ip_v4s, ip_v6s = self._determine_ip_addresses(
+            device_data.ip_addresses if device_data.ip_addresses else [device_data.ip]
+        )
         return IntegrationAsset(
             name=name,
             identifier=device_data.uid,
@@ -143,7 +145,8 @@ class Mapper:
             parent_module=SecurityPlan.get_module_string(),
             mac_address=device_data.mac,
             fqdn=device_data.hostname,
-            ip_address=", ".join(device_data.ip_addresses) if device_data.ip_addresses else device_data.ip,
+            ip_address=", ".join(ip_v4s),
+            ipv6_address=", ".join(ip_v6s),
             location=device_data.location or device_data.zone,
             vlan_id=device_data.vlan_uid,
             other_tracking_number=device_data.uid,
@@ -155,6 +158,31 @@ class Mapper:
             software_inventory=software_inventory,
         )
 
+    @staticmethod
+    def _determine_ip_addresses(ips: list[str]) -> tuple[list[str], list[str]]:
+        """
+        Parse the list of ips and return a tuple of two lists: list of IP v4 and IP v6 addresses
+
+        :param list[str] ips: List of IP addresses
+        :return: Tuple containing two lists, list of IP v4 addresses and list of IP v6 addresses
+        :rtype: tuple[list[str], list[str]]
+        """
+        import ipaddress
+
+        ip_v4s = []
+        ip_v6s = []
+        for ip in ips:
+            try:
+                ipaddress.IPv4Address(ip)
+                ip_v4s.append(ip)
+            except ipaddress.AddressValueError:
+                try:
+                    ipaddress.IPv6Address(ip)
+                    ip_v6s.append(ip)
+                except ipaddress.AddressValueError:
+                    continue
+        return ip_v4s, ip_v6s
+
     @staticmethod
     def _determine_date(
         attribute: str, finding: Optional["Finding"] = None, vuln: Optional["Vulnerability"] = None
@@ -205,6 +233,7 @@ class Mapper:
             "plugin_id": vuln.cve.uid if vuln else finding.finding.product_uid,
             "severity": vuln.severity if vuln and getattr(vuln, "severity") else finding.severity_id,
             "remediation": getattr(vuln, "remediation") if vuln else finding.finding.remediation.desc,
+            "title": getattr(vuln, "title") or finding.finding.title,
         }
         if vuln:
             finding_data["cve"] = vuln.cve.uid
@@ -267,28 +296,28 @@ class Mapper:
             """
             base = vuln if vuln else finding.finding
             finding_data = self._parse_finding_data(finding, vuln)
-            if resource_data := getattr(resource, "data"):
-                dns = resource_data.get("hostname")
-                ip_address = resource_data.get("ipv4")
-            else:
-                dns = resource.uid if vuln else None
-                ip_address = None
+            resource_data = getattr(resource, "data", {})
+            dns = resource_data.get("hostname") or resource.uid if vuln else None
+            ip_v4s, ip_v6s = self._determine_ip_addresses(
+                resource_data["ipAddresses"] if resource_data.get("ipAddresses") else [resource_data.get("ip")]
+            )
+            ips = ip_v4s + ip_v6s
 
             finding_obj = IntegrationFinding(
                 control_labels=[],
                 category=f"{connector.integration_name} Vulnerability",
-                title=base.title,
+                title=finding_data["title"],
                 plugin_name=connector.integration_name,
                 severity=Issue.assign_severity(finding.severity),  # type: ignore
                 description=base.desc,
                 status=finding.status or "Open",
                 first_seen=self._datetime_to_str(finding_data["first_seen"]),
                 last_seen=self._datetime_to_str(finding_data["last_seen"]),
-                ip_address=ip_address,
+                ip_address=", ".join(ips),
                 plugin_id=finding_data["plugin_id"],
                 dns=dns,
                 severity_int=finding_data["severity"],
-                issue_title=base.title,
+                issue_title=finding_data["title"],
                 cve=finding_data["cve"],
                 evidence=finding.evidence,
                 impact=finding.impact,

regscale/models/platform.py

@@ -44,6 +44,7 @@ class RegScaleAuth(BaseModel):
         password: Optional[Union[str, SecretStr]] = None,
         domain: Optional[str] = None,
         mfa_token: Optional[str] = None,
+        app_id: Optional[int] = 1,
     ) -> "RegScaleAuth":
         """
         Authenticate with RegScale and return a token and a user_id
@@ -52,6 +53,7 @@ class RegScaleAuth(BaseModel):
         :param Optional[Union[str, SecretStr]] password: Password to log in with, defaults to None
         :param Optional[str] domain: Domain to log into, defaults to None
         :param Optional[str] mfa_token: mfa_token to verify, defaults to None
+        :param Optional[int] app_id: The app ID to login with
         :return: RegScaleAuth object
         :rtype: RegScaleAuth
         """
@@ -88,6 +90,7 @@ class RegScaleAuth(BaseModel):
             password=password.get_secret_value(),
             domain=domain,
             mfa_token=mfa_token,
+            app_id=app_id,
         )
         return cls(
             user_id=uid,

regscale/models/regscale_models/__init__.py

@@ -51,6 +51,8 @@ from .link import *
 from .master_assessment import *
 from .milestone import *
 from .meta_data import *
+from .module import *
+from .modules import *
 from .objective import *
 from .organization import *
 from .parameter import *
@@ -81,10 +83,13 @@ from .stig import *
 from .supply_chain import *
 from .system_role import *
 from .system_role_external_assignment import *
+from .tag import *
+from .tag_mapping import *
 from .task import *
 from .threat import *
 from .team import *
 from .user import *
+from .user_group import *
 from .vulnerability import *
 from .vulnerability_mapping import *
 from .workflow import *

regscale/models/regscale_models/assessment.py

@@ -5,6 +5,7 @@ from concurrent.futures import ThreadPoolExecutor
 from enum import Enum
 from typing import Any, List, Optional, Union
 
+from pydantic import Field
 from requests import JSONDecodeError
 
 from regscale.core.app.api import Api
@@ -60,7 +61,7 @@ class Assessment(RegScaleModel):
     _module_slug = "assessments"
 
     id: int = 0
-    leadAssessorId: str = ""
+    leadAssessorId: str = Field(default_factory=RegScaleModel.get_user_id)
     title: Optional[str] = None
     assessmentType: Optional[Union[AssessmentType, str]] = None
     plannedStart: Optional[str] = None

regscale/models/regscale_models/component.py

@@ -76,7 +76,7 @@ class Component(RegScaleModel):
     externalId: Optional[str] = None
     isPublic: bool = True
     riskCategorization: Optional[str] = None
-    complianceSettingsId: Optional[int] = None
+    complianceSettingsId: Optional[int] = 1
 
     @staticmethod
     def _get_additional_endpoints() -> ConfigDict:

regscale/models/regscale_models/control_implementation.py

@@ -489,15 +489,15 @@ class ControlImplementation(RegScaleModel):
         :return: A dictionary mapping control IDs to implementation IDs
         :rtype: Dict[str, int]
         """
-        logger.info("Getting control label map by parent...")
+        logger.debug("Getting control label map by parent...")
         response = cls._get_api_handler().get(
             endpoint=cls.get_endpoint("get_all_by_parent").format(intParentID=parent_id, strModule=parent_module)
         )
 
         if response and response.ok:
-            logger.info("Fetched control label map by parent successfully.")
+            logger.debug("Fetched control label map by parent successfully.")
             return {parentheses_to_dot(ci["controlName"]): ci["id"] for ci in response.json()}
-        logger.info("Unable to get control label map by parent.")
+        logger.debug("Unable to get control label map by parent.")
         return {}
 
     @classmethod
@@ -509,14 +509,14 @@ class ControlImplementation(RegScaleModel):
         :return: A dictionary mapping control IDs to implementation IDs
         :rtype: Dict[int, int]
         """
-        logger.info("Getting control id map by parent...")
+        logger.debug("Getting control id map by parent...")
         response = cls._get_api_handler().get(
             endpoint=cls.get_endpoint("get_all_by_parent").format(intParentID=parent_id, strModule=parent_module)
         )
         if response and response.ok:
-            logger.info("Fetched control id map by parent successfully.")
+            logger.debug("Fetched control id map by parent successfully.")
             return {ci["controlID"]: ci["id"] for ci in response.json()}
-        logger.info("Unable to get control id map by parent.")
+        logger.debug("Unable to get control id map by parent.")
         return {}
 
     @classmethod
@@ -1218,6 +1218,8 @@ class ControlImplementation(RegScaleModel):
         :return: list GraphQL response from RegScale
         :rtype: list
         """
+        from regscale.core.app.internal.control_editor import _extract_control_owner_display
+
         body = """
                     query{
                         controlImplementations (skip: 0, take: 50, where: {parentId: {eq: parent_id} parentModule: {eq: "parent_module"}}) {
@@ -1263,22 +1265,25 @@ class ControlImplementation(RegScaleModel):
                 moded_item = {}
                 moded_item["id"] = item["id"]
                 moded_item["controlID"] = item["controlID"]
-                moded_item["controlOwnerId"] = (
-                    str(item["controlOwner"]["lastName"]).strip()
-                    + ", "
-                    + str(item["controlOwner"]["firstName"]).strip()
-                    + " ("
-                    + str(item["controlOwner"]["userName"]).strip()
-                    + ")"
-                )
-                moded_item["controlName"] = item["control"]["controlId"]
-                moded_item["controlTitle"] = item["control"]["title"]
-                moded_item["description"] = item["control"]["description"]
-                moded_item["status"] = item["status"]
-                moded_item["policy"] = item["policy"]
-                moded_item["implementation"] = item["implementation"]
-                moded_item["responsibility"] = item["responsibility"]
-                moded_item["inheritable"] = item["inheritable"]
+
+                # Extract control owner display using centralized method
+                moded_item["controlOwnerId"] = _extract_control_owner_display(item)
+
+                # Handle case where control or its fields might be None
+                if item.get("control") and item["control"] is not None:
+                    moded_item["controlName"] = item["control"].get("controlId", "")
+                    moded_item["controlTitle"] = item["control"].get("title", "")
+                    moded_item["description"] = item["control"].get("description", "")
+                else:
+                    moded_item["controlName"] = ""
+                    moded_item["controlTitle"] = ""
+                    moded_item["description"] = ""
+
+                moded_item["status"] = item.get("status", "")
+                moded_item["policy"] = item.get("policy", "")
+                moded_item["implementation"] = item.get("implementation", "")
+                moded_item["responsibility"] = item.get("responsibility", "")
+                moded_item["inheritable"] = item.get("inheritable", False)
                 moded_data.append(moded_item)
             return moded_data
         return []
@@ -1351,8 +1356,34 @@ class ControlImplementation(RegScaleModel):
         :return: list of control implementations, or None if not found
         :rtype: Optional[list[dict]]
         """
-        endpoint = cls.get_endpoint("get_list_by_parent").format(int_id=regscale_id, str_module=regscale_module)
-        response = cls._get_api_handler().get(endpoint=endpoint)
+        query = {
+            "parentID": 0,
+            "module": "",
+            "friendlyName": "",
+            "workbench": "",
+            "base": "",
+            "sort": "sortId",
+            "direction": "Ascending",
+            "simpleSearch": "",
+            "page": 1,
+            "pageSize": 1000,
+            "query": {
+                "id": 0,
+                "viewName": "",
+                "module": "",
+                "scope": "",
+                "createdById": "",
+                "dateCreated": None,
+                "parameters": [],
+            },
+            "groupBy": "",
+            "intDays": 0,
+            "subTab": True,
+        }
+        query["parentId"] = regscale_id
+        query["module"] = regscale_module
+        endpoint = cls.get_endpoint("filter_control_implementations")
+        response = cls._get_api_handler().post(endpoint=endpoint, data=query)
         if response and response.ok:
             return response.json()
         return None

regscale/models/regscale_models/control_objective.py

@@ -250,13 +250,82 @@ class ControlObjective(RegScaleModel):
         return control_objectives
 
 
+def _process_objective_ccis(objective: ControlObjective, ccis_to_control_ids: dict[str, set[int]]) -> None:
+    """
+    Process CCI IDs from a control objective.
+
+    :param ControlObjective objective: The control objective to process
+    :param dict ccis_to_control_ids: Dictionary to update with CCI mappings
+    :return: None
+    """
+    if not objective.otherId:
+        return
+
+    cci_ids = objective.otherId.split(",")
+    for cci_id in cci_ids:
+        cci_id = cci_id.strip()
+        if cci_id and cci_id.startswith("CCI-"):
+            ccis_to_control_ids[cci_id].add(objective.securityControlId)
+
+
+def _fetch_cci_objectives_batch(parent_id: int, skip: int, take: int) -> list[ControlObjective]:
+    """
+    Fetch a batch of CCI objectives.
+
+    :param int parent_id: The parent ID
+    :param int skip: Number of items to skip
+    :param int take: Number of items to take
+    :return: List of control objectives
+    :rtype: list[ControlObjective]
+    """
+    return ControlObjective.fetch_control_objectives_by_other_id(
+        parent_id=parent_id, other_id_contains="CCI-", skip=skip, take=take
+    )
+
+
 def map_ccis_to_control_ids(parent_id: int) -> dict:
+    """
+    Map CCI IDs to control IDs with pagination support.
+
+    :param int parent_id: The parent ID to fetch objectives for
+    :return: Dictionary mapping CCI IDs to sets of control IDs
+    :rtype: dict
+    """
+    import logging
+
+    logger = logging.getLogger("regscale")
     ccis_to_control_ids: dict[str, set[int]] = defaultdict(set)
-    objectives = ControlObjective.fetch_control_objectives_by_other_id(parent_id=parent_id, other_id_contains="CCI-")
 
-    for objective in objectives:
-        cci_ids = objective.otherId.split(",")
-        for cci_id in cci_ids:
-            ccis_to_control_ids[cci_id.strip()].add(objective.securityControlId)
+    try:
+        skip = 0
+        take = 50  # Use 50 as RegScale API limit
+        total_fetched = 0
+        max_iterations = 100  # Increase safety limit since batch size is smaller
+
+        for _ in range(max_iterations):
+            objectives = _fetch_cci_objectives_batch(parent_id, skip, take)
+            if not objectives:
+                break
+
+            # Process each objective
+            for objective in objectives:
+                _process_objective_ccis(objective, ccis_to_control_ids)
+
+            total_fetched += len(objectives)
+
+            # Check if we've reached the end
+            if len(objectives) < take:
+                break
+
+            skip += take
+        else:
+            logger.warning(f"Reached max iterations ({max_iterations}). Total fetched: {total_fetched}")
+
+    except Exception as e:
+        logger.debug(f"Error fetching CCI to control map: {e}")
+        return {}
+
+    if ccis_to_control_ids:
+        logger.debug(f"Mapped {len(ccis_to_control_ids)} unique CCIs to controls")
 
     return ccis_to_control_ids

regscale/models/regscale_models/file.py

@@ -385,6 +385,8 @@ class File(BaseModel):
                 file_type_header = "application/gzip"
             elif file_type == ".msg":
                 file_type_header = "application/vnd.ms-outlook"
+            elif file_type == ".jsonl":
+                file_type_header = "application/jsonl+json"
             else:
                 logger = logging.getLogger("regscale")
                 logger.warning(f"Unacceptable file type for upload: {file_type}")

regscale/models/regscale_models/issue.py

@@ -1025,7 +1025,6 @@ class Issue(RegScaleModel):
         """
         take = 50
         skip = 0
-        total_fetched = 0
         supports_multiple_controls = cls.is_multiple_controls_supported()
         fields = cls._get_query_fields(supports_multiple_controls)
 
@@ -1039,14 +1038,12 @@ class Issue(RegScaleModel):
             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
+        # return total count here as counting the items yields the wrong value.
+        return total_count
 
     @classmethod
     def _get_query_fields(cls, supports_multiple_controls: bool) -> str:

regscale/models/regscale_models/organization.py

@@ -15,7 +15,10 @@ class Organization(RegScaleModel):
     id: int = 0
     name: Optional[str] = ""
     description: Optional[str] = ""
+    orgCode: Optional[str] = ""
+    orgUrl: Optional[str] = ""
     status: Optional[str] = "Active"
+    externalId: Optional[str] = ""
 
     @staticmethod
     def _get_additional_endpoints() -> dict:

regscale/models/regscale_models/regscale_model.py

@@ -1258,17 +1258,18 @@ class RegScaleModel(BaseModel, ABC):
         return ConfigDict()
 
     @classmethod
-    def get_endpoint(cls, endpoint_type: str) -> str:
+    def get_endpoint(cls, endpoint_type: str, suppress_error: bool = False) -> str:
         """
         Get the endpoint for a specific type.
 
         :param str endpoint_type: The type of endpoint
+        :param bool suppress_error: Whether to suppress the error if the endpoint is not found, defaults to False
         :raises ValueError: If the endpoint type is not found
         :return: The endpoint
         :rtype: str
         """
         endpoint = cls._get_endpoints().get(endpoint_type, "na")  # noqa
-        if not endpoint or endpoint == "na":
+        if not endpoint or endpoint == "na" and not suppress_error:
             logger.error(f"{cls.__name__} does not have endpoint {endpoint_type}")
             raise ValueError(f"Endpoint {endpoint_type} not found")
         endpoint = str(endpoint).replace("{model_slug}", cls.get_module_slug())
@@ -1566,11 +1567,22 @@ class RegScaleModel(BaseModel, ABC):
                     f"[#f68d1f]Updating {total_items} RegScale {cls.__name__}s...",
                     total=total_items,
                 )
+            endpoint = cls.get_endpoint("batch_update", suppress_error=True)
+            if not endpoint or endpoint == "na":
+                logger.debug(f"No batch_update endpoint found for {cls.__name__}, using save method instead")
+                for item in items:
+                    updated_item = item.save()
+                    cls.cache_object(updated_item)
+                    results.append(updated_item)
+                    if progress and update_job is not None:
+                        progress.advance(update_job, advance=1)
+                cls._check_and_remove_progress_object(progress_context, remove_progress_bar, update_job)
+                return results
             for i in range(0, total_items, batch_size):
                 batch = items[i : i + batch_size]
                 batch_results = cls._handle_list_response(
                     cls._get_api_handler().put(
-                        endpoint=cls.get_endpoint("batch_update"),
+                        endpoint=endpoint,
                         data=[item.model_dump() for item in batch if item],
                     )
                 )
@@ -1583,10 +1595,10 @@ class RegScaleModel(BaseModel, ABC):
             cls._check_and_remove_progress_object(progress_context, remove_progress_bar, update_job)
 
         if progress_context:
-            process_batch(progress_context)
+            process_batch(progress=progress_context, remove_progress_bar=remove_progress)
         else:
             with create_progress_object() as create_progress:
-                process_batch(create_progress)
+                process_batch(progress=create_progress, remove_progress_bar=remove_progress)
 
         return results
 

regscale/models/regscale_models/security_plan.py

@@ -43,6 +43,7 @@ class SecurityPlan(RegScaleModel):
     environment: Optional[str] = ""
     lawsAndRegulations: Optional[str] = ""
     authorizationBoundary: Optional[str] = ""
+    authorizationTerminationDate: Optional[str] = ""
     networkArchitecture: Optional[str] = ""
     dataFlow: Optional[str] = ""
     overallCategorization: Optional[str] = ""

regscale/regscale.py

@@ -477,12 +477,21 @@ def validate_token():
     cls=NotRequiredIf,
     not_required_if=["token"],
 )
+@click.option(
+    "--app_id",
+    type=click.INT,
+    help="RegScale App ID to login with.",
+    default=1,
+    prompt=False,
+    required=False,
+)
 def login(
     username: Optional[str],
     password: Optional[str],
     token: Optional[str] = None,
     domain: Optional[str] = None,
     mfa_token: Optional[str] = None,
+    app_id: Optional[int] = 1,
 ):
     """Logs the user into their RegScale instance."""
     from regscale.core.app.application import Application
@@ -502,9 +511,10 @@ def login(
             mfa_token=mfa_token,
             app=app,
             host=domain,
+            app_id=app_id,
         )
     else:
-        lg.login(str_user=username, str_password=password, app=app, host=domain)
+        lg.login(str_user=username, str_password=password, app=app, host=domain, app_id=app_id)
 
 
 # Check the health of the RegScale Application

{regscale_cli-6.27.2.0.dist-info → regscale_cli-6.28.0.0.dist-info}/METADATA

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