trestle.core.parser

def parse_dict(data: Dict[str, Any], model_name: str) -> OscalBaseModel:
    """Load a model from the data dict.

    This functionality is provided for situations when the OSCAL data type is not known ahead of time. Here the model
    has been loaded into memory using json loads or similar and passed as a dict.

    Args:
        data: Oscal data loaded into memory as a dictionary with the `root key` removed.
        model_name: should be of the form 'module.class' from trestle.oscal.* modules

    Returns:
        The oscal model of the desired model.
    """
    if data is None:
        raise TrestleError('data name is required')

    if model_name is None:
        raise TrestleError('model_name is required')

    parts = model_name.split('.')
    class_name = parts.pop()
    module_name = '.'.join(parts)

    logger.debug(f'Loading class "{class_name}" from "{module_name}"')
    module = importlib.import_module(module_name)
    mclass: OscalBaseModel = getattr(module, class_name)
    if mclass is None:
        raise TrestleError(f'class "{class_name}" could not be found in "{module_name}"')

    instance = mclass.parse_obj(data)
    return instance

def root_key(data: Dict[str, Any]) -> str:
    """Find root model name in the data."""
    if len(data.items()) == 1:
        return next(iter(data))

    raise TrestleError('data does not contain a root key')

def to_full_model_name(root_key: str) -> str:
    """
    Find model name from the root_key in the file.

    Args:
        root_key: root key such as 'system-security-plan' from a top level OSCAL model.
    """
    if root_key not in const.MODEL_TYPE_LIST:
        raise TrestleError(f'{root_key} is not a top level model name.')

    module = const.MODEL_TYPE_TO_MODEL_MODULE[root_key]
    class_name = alias_to_classname(root_key, AliasMode.JSON)
    return f'{module}.{class_name}'