regscale-cli 6.16.0.0__py3-none-any.whl

regscale/utils/threading/threadsafe_dict.py

@@ -0,0 +1,242 @@
+"""
+This module contains the ThreadSafeDict class, which is a thread-safe dictionary.
+"""
+
+from threading import RLock
+from typing import Optional, List, Callable, Iterator, TypeVar, Generic, Dict
+
+KT = TypeVar("KT")  # Key Type
+VT = TypeVar("VT")  # Value Type
+
+
+class ThreadSafeDict(Generic[KT, VT]):
+    """
+    ThreadSafeDict class to create a thread-safe dictionary.
+    """
+
+    def __init__(self):
+        self._dict: Dict[KT, VT] = {}
+        self._lock = RLock()
+
+    def __getitem__(self, key: KT) -> VT:
+        """
+        Get a value from the thread-safe dictionary
+
+        :param KT key: Key to get the value for
+        :return: The value from the dictionary
+        :rtype: VT
+        """
+        with self._lock:
+            return self._dict[key]
+
+    def __setitem__(self, key: KT, value: VT) -> None:
+        """
+        Set a value in the thread-safe dictionary
+
+        :param KT key: Key to set the value for
+        :param VT value: Value to set
+        :rtype: None
+        """
+        with self._lock:
+            self._dict[key] = value
+
+    def __delitem__(self, key: KT) -> None:
+        """
+        Delete a key from the thread-safe dictionary
+
+        :param Any key: Key to delete
+        :rtype: None
+        """
+        with self._lock:
+            del self._dict[key]
+
+    def get(self, key: KT, default: Optional[VT] = None) -> Optional[VT]:
+        """
+        Get a value from the thread-safe dictionary
+
+        :param Any key: Key to get the value for
+        :param Optional[Any] default: Default value to return if the key is not in the dictionary, defaults to None
+        :return: The value from the dictionary, if found or the default value
+        :rtype: Optional[Any]
+        """
+        with self._lock:
+            return self._dict.get(key, default)
+
+    def pop(self, key: KT, default: Optional[VT] = None) -> Optional[VT]:
+        """
+        Pop a value from the thread-safe dictionary
+
+        :param Any key: Key to pop the value for
+        :param Optional[Any] default: Default value to return if the key is not in the dictionary, defaults to None
+        :return: The value from the dictionary, if found or the default value
+        :rtype: Optional[Any]
+        """
+        with self._lock:
+            return self._dict.pop(key, default)
+
+    def __contains__(self, key: KT) -> bool:
+        """
+        Check if a key is in the thread-safe dictionary
+
+        :param Any key: Key to check in the dictionary
+        :return: Whether the key is in the dictionary
+        :rtype: bool
+        """
+        with self._lock:
+            return key in self._dict
+
+    def keys(self) -> List[KT]:
+        """
+        Get a list of keys from the thread-safe dictionary
+
+        :return: A list of keys
+        :rtype: List[Any]
+        """
+        with self._lock:
+            return list(self._dict.keys())
+
+    def values(self) -> List[VT]:
+        """
+        Get a list of values from the thread-safe dictionary
+
+        :return: A list of values
+        :rtype: List[Any]
+        """
+        with self._lock:
+            return list(self._dict.values())
+
+    def items(self) -> List[tuple]:
+        """
+        Get a list of items from the thread-safe dictionary
+
+        :return: A list of items
+        :rtype: List[Any]
+        """
+        with self._lock:
+            return list(self._dict.items())
+
+    def clear(self) -> None:
+        """
+        Clear the thread-safe dictionary
+
+        :rtype: None
+        """
+        with self._lock:
+            self._dict.clear()
+
+    def update(self, other_dict: Dict[KT, VT]) -> None:
+        """
+        Update the thread-safe dictionary with another dictionary
+
+        :param dict other_dict: Dictionary to update the thread-safe dictionary with
+        :rtype: None
+        """
+        with self._lock:
+            self._dict.update(other_dict)
+
+    def __len__(self) -> int:
+        """
+        Get the length of the thread-safe dictionary
+
+        :return: The length of the dictionary
+        :rtype: int
+        """
+        with self._lock:
+            return len(self._dict)
+
+    def __iter__(self) -> Iterator[KT]:
+        """
+        Return an iterator over the keys of the dictionary.
+
+        :return: An iterator over the keys of the dictionary
+        :rtype: Iterator[Any]
+        """
+        with self._lock:
+            # Create a copy of the keys to prevent issues during iteration
+            return iter(self._dict.copy())
+
+    def setdefault(self, key: KT, default: VT = None) -> VT:
+        with self._lock:
+            return self._dict.setdefault(key, default)
+
+
+class ThreadSafeDefaultDict(ThreadSafeDict):
+    """
+    ThreadSafeDefaultDict class to create a thread-safe defaultdict.
+    """
+
+    def __init__(self, default_factory: Optional[Callable[[], VT]] = None):
+        """
+        Initialize a ThreadSafeDefaultDict.
+
+        :param Optional[Callable[[], Any]] default_factory: A callable that returns the default value for missing keys
+        """
+        super().__init__()
+        if default_factory is not None and not callable(default_factory):
+            raise TypeError("default_factory must be callable")
+        self.default_factory: Optional[Callable[[], VT]] = default_factory
+
+    def __getitem__(self, key: KT) -> VT:
+        """
+        Get an item from the dictionary, using the default_factory if the key is missing.
+
+        :param Any key: The key to look up
+        :return: The value associated with the key or the default value
+        :rtype: Any
+        """
+        with self._lock:
+            try:
+                return self._dict[key]
+            except KeyError:
+                if self.default_factory is None:
+                    raise
+                else:
+                    value = self.default_factory()
+                    self._dict[key] = value
+                    return value
+
+    def get(self, key: KT, default: Optional[VT] = None) -> Optional[VT]:
+        """
+        Get an item from the dictionary, using the default_factory or provided default if the key is missing.
+
+        :param Any key: The key to look up
+        :param Optional[Any] default: The default value to return if the key is not found and default_factory is None
+        :return: The value associated with the key or the default value
+        :rtype: Optional[Any]
+        """
+        with self._lock:
+            if key in self._dict:
+                return self._dict[key]
+            elif self.default_factory is not None:
+                value = self.default_factory()
+                self._dict[key] = value
+                return value
+            else:
+                return default
+
+    def setdefault(self, key: KT, default: Optional[VT] = None) -> VT:
+        """
+        Insert key with a value of default if key is not in the dictionary.
+
+        :param Any key: The key to insert if it doesn't exist
+        :param Optional[Any] default: The value to set if the key doesn't exist
+        :return: The value for key if key is in the dictionary, else default
+        :rtype: Any
+        """
+        with self._lock:
+            if key in self._dict:
+                return self._dict[key]
+            else:
+                if default is None and self.default_factory is not None:
+                    default = self.default_factory()
+                self._dict[key] = default
+                return default
+
+    def __repr__(self) -> str:
+        """
+        Return a string representation of the ThreadSafeDefaultDict.
+
+        :return: A string representation of the object
+        :rtype: str
+        """
+        return f"{self.__class__.__name__}({self.default_factory}, {self._dict})"

regscale/utils/threading/threadsafe_list.py

@@ -0,0 +1,83 @@
+"""
+This module contains the ThreadSafeList class, which is a thread-safe list.
+"""
+
+from threading import RLock
+from typing import Generic, List, Optional, TypeVar
+
+T = TypeVar("T")  # Declare type variable
+
+
+class ThreadSafeList(Generic[T]):
+    """
+    ThreadSafeList class to create a thread-safe list.
+    """
+
+    def __init__(self, initial_list: Optional[List[T]] = None):
+        """
+        Initialize a new ThreadSafeList
+
+        :param List[T]|None initial_list: Optional initial list to populate the ThreadSafeList
+        """
+        self._list: List[T] = list(initial_list) if initial_list is not None else []
+        self._lock = RLock()
+
+    def append(self, item: T) -> None:
+        """
+        Append an item to the list
+
+        :param T item: Item to append to the list
+        :rtype: None
+        """
+        with self._lock:
+            self._list.append(item)
+
+    def __getitem__(self, index: int) -> T:
+        """
+        Get an item from the list by index
+
+        :param int index: Index of the item to get
+        :return: The item at the specified index
+        :rtype: T
+        """
+        with self._lock:
+            return self._list[index]
+
+    def __len__(self) -> int:
+        """
+        Get the length of the list
+
+        :return: The length of the list
+        :rtype: int
+        """
+        with self._lock:
+            return len(self._list)
+
+    def __iter__(self):
+        """
+        Return an iterator over the list
+
+        :return: An iterator over the list
+        :rtype: Iterator[T]
+        """
+        with self._lock:
+            return iter(self._list.copy())
+
+    def remove(self, item: T) -> None:
+        """
+        Remove an item from the list
+
+        :param T item: Item to remove from the list
+        :rtype: None
+        """
+        with self._lock:
+            self._list.remove(item)
+
+    def clear(self) -> None:
+        """
+        Clear the list
+
+        :rtype: None
+        """
+        with self._lock:
+            self._list.clear()

regscale/utils/version.py

@@ -0,0 +1,104 @@
+"""Version utility functions"""
+
+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__)
+
+
+class RegscaleVersion:
+    """Utility class for managing and comparing Rescale platform versions"""
+
+    def __init__(self):
+        """Initialize RegscaleVersion with current platform version"""
+        self.current_version = self.get_platform_version()
+
+    @staticmethod
+    @lru_cache(maxsize=1)
+    def get_platform_version() -> str:
+        """Fetch the current platform version from the API. Result is cached.
+
+        :return: Platform version string (e.g. "1.2.3") or special version ("dev", "localdev", "Unknown")
+        :rtype: str
+        """
+        logger.debug("Fetching platform version using API handler")
+        try:
+            api_handler = APIHandler()
+            response = api_handler.get("/assets/json/version.json")
+            if 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"
+        except Exception as e:
+            logger.error(f"Error fetching version: {e}", exc_info=True)
+            return "dev"
+
+    @staticmethod
+    def is_valid_version(version: str) -> bool:
+        """Check if a version string matches semantic versioning format (X.Y.Z or X.Y.Z.W).
+
+        :param str version: Version string to validate
+        :return: True if version matches semantic versioning format
+        :rtype: bool
+
+        Examples:
+            >>> RegscaleVersion.is_valid_version("1.2.3")     # Returns True
+            >>> RegscaleVersion.is_valid_version("1.2.3.4")   # Returns True
+            >>> RegscaleVersion.is_valid_version("1.2")       # Returns True
+            >>> RegscaleVersion.is_valid_version("1.2.3.4.5") # Returns False
+            >>> RegscaleVersion.is_valid_version("1.2.a")     # Returns False
+        """
+        return bool(re.match(r"^\d+\.\d+(\.\d+)?(\.\d+)?$", version))
+
+    @staticmethod
+    def meets_minimum_version(minimum_version: str, dev_is_latest: bool = True) -> bool:
+        """Check if the given platform version meets or exceeds a minimum version requirement.
+
+        :param str minimum_version: The minimum version required (e.g. "1.2.3")
+        :param bool dev_is_latest: When True, dev is treated as newest version. When False, as oldest.
+        :return: True if current platform version is new enough
+        :rtype: bool
+
+        Examples:
+            >>> RegscaleVersion.meets_minimum_version("1.0.0")  # Returns True if platform version >= 1.0.0
+            >>> RegscaleVersion.meets_minimum_version("2.0.0", dev_is_latest=False)  # Dev version treated as oldest
+        """
+        current_version = RegscaleVersion.get_platform_version()
+        return RegscaleVersion.compare_versions(current_version, minimum_version, dev_is_latest)
+
+    @staticmethod
+    def compare_versions(version1: str, version2: str, dev_is_latest: bool = True) -> bool:
+        """Compare two version strings.
+
+        :param str version1: First version to compare
+        :param str version2: Second version to compare
+        :param bool dev_is_latest: When True, dev is treated as newest version. When False, as oldest.
+        :return: True if version1 >= version2
+        :rtype: bool
+        """
+        special_value = "9999.9999.9999.9999" if dev_is_latest else "0.0.0.0"
+        special_versions = dict.fromkeys(["dev", "localdev", "Unknown"], special_value)
+
+        # This handles if it is an epic/dev versions as they are normally in the format `BUILDNUMBER-YYYY-MM-DD`
+        if "-" in version1:
+            version1 = version1.split("-")[0]
+        if "-" in version2:
+            version2 = version2.split("-")[0]
+
+        v1 = special_versions.get(version1, version1)
+        v2 = special_versions.get(version2, version2)
+
+        if not RegscaleVersion.is_valid_version(v2):
+            logger.info(f"Invalid version {v2}, assuming dev")
+            return True
+
+        return Version(v1) >= Version(v2)

regscale/validation/address.py

@@ -0,0 +1,37 @@
+import ipaddress
+import re
+
+
+def validate_ip_address(ip_str: str) -> bool:
+    """Validate IPv4 or IPv6 address
+
+    :param str ip_str: String to validate
+    :return: bool
+    :rtype: bool
+    """
+    try:
+        ipaddress.IPv4Address(ip_str)
+        return True
+    except ipaddress.AddressValueError:
+        try:
+            ipaddress.IPv6Address(ip_str)
+            return True
+        except ipaddress.AddressValueError:
+            return False
+
+
+def validate_mac_address(mac_address: str) -> bool:
+    """
+    Simple validation of a mac address input
+    :param str mac_address: mac address
+    :return: Whether mac address is valid or not
+    :rtype: bool
+    """
+    if not mac_address:
+        return False
+    return bool(
+        re.match(
+            "[0-9a-f]{2}(:?)[0-9a-f]{2}(\\1[0-9a-f]{2}){4}$",
+            mac_address.lower(),
+        )
+    )

regscale/validation/record.py

@@ -0,0 +1,48 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Rich Logging"""
+
+
+from regscale.core.app.api import Api
+
+# standard python imports
+from regscale.core.utils.graphql import GraphQLQuery
+from regscale.models.regscale_models.modules import Modules
+
+
+def validate_regscale_object(parent_id: int, parent_module: str) -> bool:
+    """
+    Query regscale to confirm the object in question exists.
+
+    :param int parent_id: The RegScale id to query
+    :param str parent_module: The RegScale module to query
+    :return: Whether the object exists or not
+    :rtype: bool
+    """
+    import inflect  # Optimize import performance
+
+    api = Api()
+    query = GraphQLQuery()
+    query.start_query()
+    result = False
+    mods = Modules()
+    p = inflect.engine()
+    for (
+        key,
+        val,
+    ) in mods.dict().items():  # for name, age in dictionary.iteritems():  (for Python 2.x)
+        if val.lower() == parent_module.lower():
+            mod_lookup = p.plural(key)
+    query.add_query(
+        entity=mod_lookup,
+        items=[
+            "id",
+        ],
+        where={"id": {"eq": parent_id}},
+    )
+    query.end_query()
+
+    dat = api.graph(query=query.build())
+    if mod_lookup.lower() in [k.lower() for k in dat.keys()] and dat[list(dat.keys())[0]]["totalCount"] > 0:
+        result = True
+    return result

regscale/visualization/__init__.py

@@ -0,0 +1,5 @@
+try:
+    import matplotlib.pyplot as plt
+    import networkx as nx
+except ImportError as exc:
+    raise ImportError("Install regscale[viz] to visualize regscale.") from exc

regscale/visualization/click.py

@@ -0,0 +1,34 @@
+"""Generate a click group object."""
+
+import matplotlib.pyplot as plt
+import networkx as nx
+
+from regscale.models.click_models import ClickGroup, ClickCommand
+
+
+def plot_click_group(group: ClickGroup):
+    G = nx.DiGraph()
+
+    def add_node(cmd, parent=None):
+        G.add_node(cmd.name)
+        if parent is not None:
+            G.add_edge(parent.name, cmd.name)
+        if isinstance(cmd, ClickCommand):
+            for param in cmd.params:
+                G.add_node(param.name)
+                G.add_edge(cmd.name, param.name)
+        elif isinstance(cmd, ClickGroup):
+            for subcmd in cmd.commands:
+                add_node(subcmd, cmd)
+
+    add_node(group)
+    nx.draw(G, with_labels=True)
+    plt.show()
+
+
+if __name__ == "__main__":
+    from regscale.regscale import cli
+
+    click_group = ClickGroup.from_group(cli, include_callback=True)
+    print(click_group.json())
+    plot_click_group(click_group)

regscale_cli-6.16.0.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 RegScale Corporation
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.