regscale-cli 6.16.0.0__py3-none-any.whl

regscale/core/app/utils/variables.py

@@ -0,0 +1,226 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Utility functions and classes for handling application variables"""
+
+import logging
+import os
+import re
+import sys
+from typing import Any, Callable, Dict, Optional, Tuple, Type
+
+logger = logging.getLogger(__name__)
+
+
+class RsVariableType:
+    """
+    Configuration variable type
+
+    :param Type var_type: The data type of the configuration variable
+    :param str example: An example value for the configuration variable
+    :param Optional[bool] required: A flag indicating if the configuration variable is required, defaults to True
+    :param Optional[bool] sensitive: A flag indicating if the configuration variable is sensitive, defaults to False
+    :param Optional[Any] default: A default value for the configuration variable, defaults to None
+    """
+
+    def __init__(
+        self,
+        var_type: Type,
+        example: str,
+        required: Optional[bool] = True,
+        sensitive: Optional[bool] = False,
+        default: Optional[Any] = None,
+    ) -> None:
+        self.type = var_type
+        self.example = example
+        self.required = required
+        self.sensitive = sensitive
+        self.default = default
+
+
+class RsVariableClassProperty:
+    """
+    Class property for retrieving configuration variables
+
+    :param Callable getter: The getter function for the property
+    """
+
+    def __init__(self, getter: Callable):
+        self.getter = getter
+        self.name = None  # Will store the attribute name
+
+    def __set_name__(self, owner: Any, name: str) -> None:
+        """
+        Sets the name of the property when it's assigned to a class
+
+        :param Any owner: The class that owns this property
+        :param str name: The name of the property
+        """
+        self.name = name
+
+    def __get__(self, obj: Any, cls: Optional[type] = None) -> Any:
+        """
+        Retrieves the value using the getter when the property is accessed
+
+        :param Any obj: The object instance
+        :param Optional[type] cls: The class instance, defaults to None
+        :return: The value of the property
+        :rtype: Any
+        """
+        if obj is None:
+            # Class-level access
+            return self.getter(cls)
+
+        # Instance-level access
+        if not hasattr(obj, f"_{self.name}"):
+            # Initialize the instance-specific value
+            value = self.getter(cls)
+            setattr(obj, f"_{self.name}", value)
+        return getattr(obj, f"_{self.name}")
+
+    def __set__(self, obj: Any, value: Any) -> None:
+        """
+        Sets the value for an instance
+
+        :param Any obj: The object instance
+        :param Any value: The value to set
+        """
+        setattr(obj, f"_{self.name}", value)
+
+
+class RsVariablesMeta(type):
+    """
+    Metaclass for creating RsVariables classes with properties for each configuration variable.
+
+    Example::
+
+        .. code-block:: python
+
+            >>>class GcpVariables(metaclass=RsVariablesMeta):
+            >>>    # Define class-level attributes with type annotations and examples
+            >>>    gcpProjectId: RsVariableType(str, "000000000000")
+            >>>    gcpCredentials: RsVariableType(str, "path/to/credentials.json", sensitive=True)
+    """
+
+    def __new__(cls, name: str, bases: Tuple[type, ...], attrs: Dict[str, Any]):
+        """
+        Creates new RsVariables class with properties for each configuration variable
+
+        :param str name: The name of the class
+        :param Tuple[type, ...] bases: The base classes of the class
+        :param Dict[str, Any] attrs: The attributes of the class
+        :return: The new RsVariables class
+        """
+        for attr, config_type in attrs.get("__annotations__", {}).items():
+            if isinstance(config_type, RsVariableType):
+                # Create a property for each configuration attribute
+                getter = cls.create_getter(attr, config_type)
+                attrs[attr] = RsVariableClassProperty(getter)
+
+        # Add an __init__ method to initialize instance attributes
+        def __init__(self):
+            # Initialize all properties to trigger the getters
+            for attr in self.__class__.__annotations__:
+                if isinstance(self.__class__.__annotations__[attr], RsVariableType):
+                    getattr(self, attr)
+
+        attrs["__init__"] = __init__
+        return super(RsVariablesMeta, cls).__new__(cls, name, bases, attrs)
+
+    @staticmethod
+    def create_getter(attr: str, config_type: RsVariableType) -> Callable:
+        """
+        Creates a getter function for each property
+
+        :param str attr: The name of the attribute
+        :param RsVariableType config_type: The type of the attribute
+        :return: The getter function for the attribute
+        :rtype: Callable
+        """
+
+        def getter(cls: type) -> Any:
+            return RsVariablesMeta.fetch_config_value(attr, config_type)
+
+        return getter
+
+    @classmethod
+    def fetch_config_value(cls, attr_name: str, config_type: RsVariableType) -> Any:
+        """
+        Fetches, processes, and returns the configuration value for a given attribute
+
+        :param str attr_name: The name of the attribute
+        :param RsVariableType config_type: The type of the attribute
+        :raises ValueError: If a required configuration is missing and the script is not running interactively
+        :return: The processed configuration value
+        :rtype: Any
+        """
+        from regscale.core.app.application import Application
+
+        app = Application()
+        # Check Environment variable first (case-insensitive), then init.yaml
+        config_value = next((os.environ[key] for key in os.environ if key.lower() == attr_name.lower()), None)
+        if config_value is None:
+            config_value = next((value for key, value in app.config.items() if key.lower() == attr_name.lower()), "")
+        processed_value = cls.replace_text_inside_brackets(config_value)
+        if config_type.sensitive:
+            logger.debug(f"Configuration for '{attr_name}' set to: ******")
+        else:
+            logger.debug(f"Configuration for '{attr_name}' set to: {processed_value}")
+
+        if processed_value == "":
+            if config_type.required and config_type.default is None:
+                if sys.stdin.isatty():
+                    prompt_message = (
+                        f"\033[91mREQUIRED: {attr_name} not set in init.yaml or environment variable.\033[0m \n"
+                        f"Enter value for {attr_name} (e.g., {config_type.example}):"
+                    )
+                    processed_value = input(prompt_message)
+                else:
+                    error_message = (
+                        f"Required configuration '{attr_name}' is missing and script is not running interactively."
+                    )
+                    logger.error(error_message)
+                    raise ValueError(error_message)
+
+                if config_type.sensitive:
+                    logger.info(f"Configuration for '{attr_name}' saved to init.yaml: ******")
+                else:
+                    logger.info(f"Configuration for '{attr_name}' saved to init.yaml: {processed_value}")
+                # Save the config value
+                app.config[attr_name] = processed_value
+                app.save_config(app.config)
+            elif config_type.default is not None:
+                processed_value = config_type.default
+                logger.debug(f"Using default value for '{attr_name}': {processed_value}")
+        try:
+            if config_type.type == dict:
+                # Handle dictionary values - assume the input is a string representation of a dict
+                import ast
+
+                typed_value = ast.literal_eval(processed_value) if processed_value else {}
+            elif config_type.type == bool:
+                if isinstance(processed_value, str):
+                    typed_value = processed_value.lower() in ["true", "1", "yes"]
+                elif isinstance(processed_value, bool):
+                    typed_value = processed_value
+            else:
+                typed_value = config_type.type(processed_value)
+        except (ValueError, SyntaxError):
+            logger.error(f"Failed to cast '{attr_name}' to {config_type.type.__name__}. Using original value.")
+            typed_value = processed_value
+        return typed_value
+
+    @staticmethod
+    def replace_text_inside_brackets(text: str, replacement: str = "") -> str:
+        """
+        Removes text inside brackets from a given string
+
+        :param str text: The string to remove text from
+        :param str replacement: The replacement text
+        :return: The string with text inside brackets removed
+        :rtype: str
+        """
+        # if string
+        if not isinstance(text, str):
+            return text
+        pattern = "<[^>]*>"
+        return re.sub(pattern, replacement, text)

regscale/core/decorators.py

@@ -0,0 +1,31 @@
+"""
+Decorators for the regscale package
+"""
+
+from typing import Any, Type, Dict
+
+
+def singleton(cls: Type[Any]) -> Type[Any]:
+    """
+    Singleton decorator to ensure a class only has one instance.
+
+    :param Type[Any] cls: The class to be decorated as a singleton.
+    :return: The singleton instance of the class.
+    :rtype: Type[Any]
+    """
+    instances: Dict[Type[Any], Any] = {}
+
+    def get_instance(*args: Any, **kwargs: Any) -> Any:
+        """
+        Get the singleton instance of the class.
+
+        :param Any *args: Positional arguments to instantiate the class.
+        :param Any **kwargs: Keyword arguments to instantiate the class.
+        :return: The singleton instance of the class.
+        :rtype: Any
+        """
+        if cls not in instances:
+            instances[cls] = cls(*args, **kwargs)
+        return instances[cls]
+
+    return get_instance  # type: ignore

regscale/core/lazy_group.py

@@ -0,0 +1,65 @@
+"""
+Class to allow lazy loading of click commands
+"""
+
+import importlib
+import click
+
+
+class LazyGroup(click.Group):
+    """
+    Class to allow lazy loading of click commands
+    """
+
+    def __init__(self, *args, lazy_subcommands=None, **kwargs):
+        super().__init__(*args, **kwargs)
+        # lazy_subcommands is a map of the form:
+        #
+        #   {command-name} -> {module-name}.{command-object-name}
+        #
+        self.lazy_subcommands = lazy_subcommands or {}
+
+    def list_commands(self, ctx) -> list:
+        """
+        Return the list of commands
+
+        :param ctx: The click context
+        :return: The list of commands
+        :rtype: list
+        """
+        base = super().list_commands(ctx)
+        lazy = sorted(self.lazy_subcommands.keys())
+        return base + lazy
+
+    def get_command(self, ctx, cmd_name) -> click.BaseCommand:
+        """
+        Get the command from the context
+
+        :param ctx: The click context
+        :param cmd_name: The command name
+        :return: The command
+        :rtype: click.BaseCommand
+        """
+        if cmd_name in self.lazy_subcommands:
+            return self._lazy_load(cmd_name)
+        return super().get_command(ctx, cmd_name)
+
+    def _lazy_load(self, cmd_name) -> click.BaseCommand:
+        """
+        Lazy load the command
+
+        :param cmd_name: The command name
+        :return: The command
+        :rtype: click.BaseCommand
+        """
+        # lazily loading a command, first get the module name and attribute name
+        import_path = self.lazy_subcommands[cmd_name]
+        modname, cmd_object_name = import_path.rsplit(".", 1)
+        # do the import
+        mod = importlib.import_module(modname)
+        # get the Command object from that module
+        cmd_object = getattr(mod, cmd_object_name)
+        # check the result to make debugging easier
+        if not isinstance(cmd_object, click.BaseCommand):
+            raise ValueError(f"Lazy loading of {import_path} failed by returning " "a non-command object")
+        return cmd_object

regscale/core/login.py

@@ -0,0 +1,63 @@
+"""Provide low-level, basic login."""
+
+import json
+import logging
+from os import getenv
+from typing import Optional, Tuple
+from urllib.parse import urljoin
+
+from regscale.core.app.api import Api
+from regscale.core.app.utils.app_utils import error_and_exit
+
+logger = logging.getLogger("regscale")
+
+
+def get_regscale_token(
+    api: Api,
+    username: str = getenv("REGSCALE_USER"),
+    password: str = getenv("REGSCALE_PASSWORD"),
+    domain: str = getenv("REGSCALE_DOMAIN"),
+    mfa_token: Optional[str] = "",
+) -> Tuple[str, str]:
+    """
+    Authenticate with RegScale and return a token
+
+    :param Api api: API Object to use for authentication
+    :param str username: a string defaulting to the envar REGSCALE_USERNAME
+    :param str password: a string defaulting to the envar REGSCALE_PASSWORD
+    :param str domain: a string representing the RegScale domain, checks environment REGSCALE_DOMAIN
+    :param Optional[str] mfa_token: MFA token to login with
+    :raises EnvironmentError: if domain is not passed or retrieved
+    :return: a tuple of user_id and auth_token
+    :rtype: Tuple[str, str]
+    """
+    if domain is None:
+        raise EnvironmentError("REGSCALE_DOMAIN must be set if not passed as parameter.")
+    if username is None:
+        raise EnvironmentError("REGSCALE_USERNAME must be set if not passed as parameter.")
+    if password is None:
+        raise EnvironmentError("REGSCALE_PASSWORD must be set if not passed as parameter.")
+
+    auth = {  # TODO - HTTP Basic Auth an minimum
+        "userName": username,
+        "password": password,
+        "oldPassword": "",
+        "mfaToken": mfa_token,
+    }
+    logger.info("Logging into: %s", domain)
+    # suggest structuring the login paths so that they all exist in one place
+    url = urljoin(domain, "/api/authentication/login")
+    response = api.post(url=url, json=auth, headers={})
+    error_msg = "Unable to authenticate with RegScale. Please check your credentials."
+    logger.info(response.url)
+    if response.status_code == 200:
+        response_dict = response.json()
+    elif response.status_code == 403:
+        error_and_exit(error_msg)
+    elif response.status_code == 400 and mfa_token == "":
+        error_and_exit(error_msg[:-1] + " and/or if an MFA token is required.")
+    else:
+        error_and_exit(f"{error_msg}\n{response.status_code}: {response.text}")
+    if isinstance(response_dict, str):
+        response_dict = json.loads(response_dict)
+    return response_dict["id"], response_dict["auth_token"]