regscale-cli 6.16.0.0__py3-none-any.whl

regscale/core/app/internal/workflow.py

@@ -0,0 +1,105 @@
+"""Functions for creating, starting, and fetching workflows from RegScale."""
+
+from typing import Optional, Dict
+
+from regscale.core.app.api import Api
+from regscale.core.app.application import Application
+from regscale.core.app.utils.app_utils import (
+    error_and_exit,
+    get_current_datetime,
+)
+from regscale.models.regscale_models.workflow import Workflow
+
+
+def create_regscale_workflow_from_template(new_assessment_id: int, template_id: int) -> int:
+    """Create a RegScale workflow from a template
+
+    :param int new_assessment_id: RegScale assessment ID
+    :param int template_id: RegScale template ID
+    :return: RegScale workflow ID
+    :rtype: int
+    """
+    app = Application()
+    workflow = Workflow(
+        name="Placeholder",  # just a placeholder its overriden below by the template
+        status="Active",
+        startDate=get_current_datetime(),
+        endDate=None,
+        currentStep=0,
+        comments="",
+        createdById=app.config["userId"],
+        dateCreated=get_current_datetime(),
+        lastUpdatedById=app.config["userId"],
+        isPublic=True,
+        dateLastUpdated=get_current_datetime(),
+        ownerId=app.config["userId"],
+        atlasModule="assessments",
+        parentId=new_assessment_id,
+        workflowInstanceSteps=[],
+    )
+
+    if template := get_workflow_template(app, template_id):
+        app.logger.debug(template)
+        workflow.name = template.get("name")
+        workflow.workflowInstanceSteps = template["workflowTemplateSteps"]
+    else:
+        error_and_exit(f"Failed to get workflow template with id #{template_id}.")
+
+    if new_workflow_id := workflow.insert_workflow(app, template_id).id:
+        app.logger.info(f"Workflow created with id {new_workflow_id}")
+        if submit_workflow_instance(app, workflow.dict(), new_workflow_id):
+            return new_workflow_id
+    error_and_exit(f"Failed to create RegScale workflow from template with id #{template_id}.")
+
+
+def create_workflow(app: Application, workflow_data: dict, template_id: int) -> Optional[Dict]:
+    """Create a RegScale workflow from a template
+
+    :param Application app: Regscale application
+    :param dict workflow_data: Workflow data
+    :param int template_id: RegScale template ID
+    :return: RegScale workflow or None
+    :rtype: Optional[Dict]
+    """
+    api = Api()
+    create_workflow_instance_from_template_url = (
+        f"{app.config['domain']}/api/workflowInstances/createFromTemplate/{template_id}"
+    )
+    workflow_res = api.post(url=create_workflow_instance_from_template_url, json=workflow_data)
+    app.logger.debug(workflow_res.status_code)
+    if not workflow_res.ok:
+        app.logger.error(f"Failed to create RegScale workflow from template with id {template_id}.")
+        return None
+    return workflow_res.json()
+
+
+def get_workflow_template(app: Application, template_id: int) -> Optional[Dict]:
+    """Get a RegScale workflow template
+
+    :param Application app: Regscale application
+    :param int template_id: RegScale template ID
+    :return: RegScale workflow template
+    :rtype: Optional[Dict]
+    """
+    api = Api()
+    workflow_template_url = f"{app.config['domain']}/api/workflowTemplates/{template_id}"
+    get_template_rep = api.get(url=workflow_template_url)
+    return get_template_rep.json() if get_template_rep.ok else None
+
+
+def submit_workflow_instance(app: Application, workflow_data: dict, workflow_id: int) -> bool:
+    """Submit a RegScale workflow instance
+
+    :param Application app: Regscale application
+    :param dict workflow_data: Workflow data
+    :param int workflow_id: RegScale workflow ID
+    :return: True if successful else False
+    :rtype: bool
+    """
+    api = Api()
+    submit_workflow_url = f"{app.config['domain']}/api/workflowInstances/submit/{app.config['userId']}"
+    submit_resp = api.put(url=submit_workflow_url, json=workflow_data)
+    if submit_resp.ok:
+        api.logger.info(f"Workflow with id: {workflow_id} started.")
+        return True
+    return False

regscale/core/app/logz.py

@@ -0,0 +1,74 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Rich Logging"""
+
+# standard python imports
+import logging
+import os
+import tempfile
+from logging.handlers import TimedRotatingFileHandler
+from typing import Any, Optional
+
+import click
+from rich.logging import RichHandler
+from rich.traceback import install
+from rich.console import Console
+
+from regscale import exceptions
+
+if not os.getenv("REGSCALE_DEBUG", False):
+    install(suppress=[click, exceptions])
+
+
+def create_logger(propagate: Optional[bool] = None, custom_handler: Optional[Any] = None) -> logging.Logger:
+    """
+    Create a logger for use in all cases
+
+    :param Optional[bool] propagate: Whether to propagate the logger, defaults to None
+    :param Optional[Any] custom_handler: Custom handler to add to the logger, defaults to None
+    :return: logger object
+    :rtype: logging.Logger
+    """
+    loglevel = os.environ.get("LOGLEVEL", "INFO").upper()
+    # Try to get the log width from the environment variable, default to 160 if not set
+    try:
+        width = int(os.environ.get("REGSCALE_LOG_WIDTH"))  # Default to 160 if not set
+        rich_handler = RichHandler(rich_tracebacks=False, markup=True, show_time=False, console=Console(width=width))
+    except (TypeError, ValueError):
+        # If the value is not an integer, set it to None (goes to default to use the full width of the terminal)
+        # Without this except block, the logs do NOT print
+        rich_handler = RichHandler(rich_tracebacks=False, markup=True, show_time=False)
+
+    rich_handler.setLevel(loglevel)
+
+    # Only create file handler if not in container
+    handlers: list[logging.Handler] = [rich_handler]
+    if os.getenv("REGSCALE_ECS", False) != "True":
+        file_handler = TimedRotatingFileHandler(
+            filename=f"{tempfile.gettempdir()}{os.sep}RegScale.log",
+            when="D",
+            interval=3,
+            backupCount=10,
+        )
+        file_handler.setLevel(loglevel)
+        handlers.append(file_handler)
+
+    if custom_handler:
+        handlers.append(custom_handler)
+
+    logging.getLogger("botocore").setLevel(logging.CRITICAL)
+    logging.basicConfig(
+        level=loglevel,
+        format="%(asctime)s [%(levelname)-5.5s]  %(message)s",
+        datefmt="[%Y/%m/%d %H:%M;%S]",
+        handlers=handlers,
+        force=os.getenv("REGSCALE_ECS", False) == "True",
+    )
+
+    logger = logging.getLogger("regscale")
+    logger.handlers = handlers
+    logger.setLevel(loglevel)
+    logger.parent.handlers = []
+    if propagate is not None:
+        logger.propagate = propagate
+    return logger

regscale/core/app/utils/XMLIR.py

@@ -0,0 +1,258 @@
+# Author: Luke Bechtel (Regscale)
+import typing
+from functools import wraps
+from typing import List
+
+from lxml import etree
+from pydantic import BaseModel, ConfigDict
+from typing_extensions import TypedDict
+
+from regscale.integrations.public.fedramp.reporting import log_error, log_event
+
+
+class LogEventArgs(TypedDict):
+    """
+    Args for the log_event function.
+    """
+
+    record_type: str
+    event_msg: str
+    model_layer: str
+    level: str
+
+
+class LogErrorArgs(TypedDict):
+    """
+    Args for the log_error function.
+    """
+
+    record_type: str
+    missing_element: str
+    model_layer: str
+    level: str
+    event_msg: str
+
+
+class XMLIRTraversal(BaseModel):
+    """
+    A traversal through an XML tree to produce an XMLIR object.
+    :param xpathToThis: The XPath to the current element
+    :param el: The current element
+    :param root: The root element
+    :param add_error: A function to add an error
+    :param add_log: A function to add a log
+    """
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    namespaces: dict
+    xpathToThis: str
+    el: etree._Element
+    root: etree._Element
+
+    events: List[LogEventArgs] = []
+    errors: List[LogErrorArgs] = []
+
+    def el_xpath(self, xpath: str):
+        """
+        Helper function to get an element by xpath from the current element, using the correct namespaces.
+        """
+        return self.el.xpath(xpath, namespaces=self.namespaces)
+
+    def root_xpath(self, xpath: str) -> etree._Element:
+        """
+        Helper function to get an element by xpath from the root element, using the correct namespaces.
+
+        :param str xpath: The xpath to the element
+        :return: The element at the provided xpath
+        :rtype: etree._Element
+        """
+        return self.root.xpath(xpath, namespaces=self.namespaces)
+
+    def add_event(self, args: LogEventArgs):
+        """
+        Add an event to this traversal.
+
+        :param LogEventArgs args: The event arguments
+        """
+        self.events.append(
+            log_event(
+                record_type=args["record_type"],
+                event_msg=args["event_msg"],
+                model_layer=args["model_layer"],
+                level=args["level"],
+            )
+        )
+
+    def add_error(self, args: LogErrorArgs):
+        """
+        Add an error to this traversal.
+
+        :param LogErrorArgs args: The event arguments
+        """
+        self.errors.append(
+            log_error(
+                record_type=args["record_type"],
+                missing_element=args["missing_element"],
+                model_layer=args["model_layer"],
+                level=args["level"],
+                event_msg=args["event_msg"],
+            )
+        )
+
+
+class XMLIR:
+    """
+    A class that makes creating intermediate representations of XML objects easier.
+    Calling parse() on an XMLIR-inheriting object will run through all its decorated functions
+    and return a dictionary of the results.
+    """
+
+    __decorated_functions: {} = {}
+
+    @classmethod
+    def from_el(cls, xpath):
+        """
+        A decorator used to decorate functions that will be run on an XML element.
+        The return value of the decorated function will be added to the object returned by 'XMLIR.parse()'
+        """
+
+        def wrapper(func):
+            qualname = func.__qualname__
+            clsname = qualname.rsplit(".", 1)[0] if "." in qualname else None
+
+            @wraps(func)
+            def inner(self, *args, **kwargs):
+                return func(self, *args, **kwargs)
+
+            if clsname not in cls.__decorated_functions:
+                cls.__decorated_functions[clsname] = {}
+
+            if func.__name__ not in cls.__decorated_functions[clsname]:
+                cls.__decorated_functions[clsname][func.__name__] = {}
+
+            cls.__decorated_functions[clsname][func.__name__]["func"] = func
+            cls.__decorated_functions[clsname][func.__name__]["xpath"] = xpath
+            return inner
+
+        return wrapper
+
+    def decorated_functions_for_class(self):
+        """
+        Returns the decorated functions for this class.
+        """
+        return self.__decorated_functions[self.__class__.__name__]
+
+    def parse(self, traversal: XMLIRTraversal):
+        """
+        Will traverse an XML element,
+        and run any functions decorated with @XMLIR.from_el
+        """
+        ret = {}
+
+        # Run through all decorated functions and run them.
+        for func_name, f_desc in self.decorated_functions_for_class().items():
+            xpath = f_desc["xpath"]
+            func = f_desc["func"]
+
+            # Get the relevant element from the xpath
+            xml_els = traversal.el.xpath(xpath, namespaces=traversal.namespaces)
+
+            # Pass the xml_els to the function
+            # And get the result
+            processed_xml_els = func(self, xml_els, traversal)
+
+            # Add the result to the return object
+            ret[func_name] = processed_xml_els
+
+        return ret
+
+
+class XMLIR2:
+    def __init__(self, traversal: XMLIRTraversal) -> None:
+        # Validate that all custom attributes have a getter
+        self.check_get_methods()
+
+        # Get all custom attributes.
+        attributes_to_parse = self.get_custom_attrs()
+
+        # Run through all getters and add the result to the object
+        for attr_name in attributes_to_parse:
+            getter = self.getter_for_attr(attr_name)
+            setattr(self, attr_name, getter(traversal))
+
+    def __repr__(self) -> str:
+        """
+        Print out all normal attributes of the object.
+        """
+        attrs = self.custom_attr_dict()
+
+        return f"{self.__class__.__name__} ({str(attrs)})"
+
+    def custom_attr_dict(self) -> dict:
+        """
+        Return a list of all custom attributes and their values.
+        """
+        custom_attrs = self.get_custom_attrs()
+        return {attr_name: getattr(self, attr_name) for attr_name in custom_attrs}
+
+    def items(self):
+        return self.custom_attr_dict().items()
+
+    def __iter__(self):
+        return iter(self.items())
+
+    def getter_for_attr(self, attr_name: str):
+        return getattr(self, f"get_{attr_name}")
+
+    def check_get_methods(self) -> None:
+        attributes = self.get_custom_attrs()
+
+        for attr in attributes:
+            getter_name = f"get_{attr}"
+            if not hasattr(self, getter_name):
+                raise AttributeError(
+                    f"No 'get_{attr}' method found. "
+                    "All non-callable, non-'__'-prefixed custom attributes must have a getter."
+                )
+
+            # Get the getter method
+            getter_method = getattr(self.__class__, getter_name)
+
+            # Check if the getter has a return type hint
+            getter_hints = typing.get_type_hints(getter_method)
+            if "return" not in getter_hints:
+                raise TypeError(f"Getter '{getter_name}' does not have a return type hint.")
+
+            # Check if the attribute has a type hint
+            attr_hints = typing.get_type_hints(self.__class__)
+            if attr not in attr_hints:
+                raise TypeError(f"Attribute '{attr}' does not have a type hint.")
+
+            # Compare the type hint of the getter and the attribute
+            if getter_hints["return"] != attr_hints[attr]:
+                raise TypeError(
+                    f"Type hint of the attribute '{attr}' does not match the return type hint of its getter method."
+                )
+
+        getters = self.get_custom_attr_getters()
+        for getter in getters:
+            attr_name = getter.replace("get_", "")
+            if not hasattr(self, attr_name):
+                raise AttributeError(f"Getter '{getter}' found, but no attribute '{attr_name}' found.")
+
+    def get_custom_attr_getters(self) -> List[str]:
+        attributes: List[str] = [
+            attr_name
+            for attr_name, attr_value in self.__class__.__dict__.items()
+            if callable(attr_value) and attr_name.startswith("get_")
+        ]
+        return attributes
+
+    def get_custom_attrs(self) -> List[str]:
+        attributes: List[str] = [
+            attr_name
+            for attr_name, attr_value in self.__class__.__dict__.items()
+            if not callable(attr_value) and not attr_name.startswith("__")
+        ]
+        return attributes