def test_full_path():
"""Test full path paths method."""
element_arg = 'catalog.groups.*.controls.*.controls.*'
p1 = ElementPath('catalog.groups.*')
p2 = ElementPath('group.controls.*', parent_path=p1)
p3 = ElementPath('control.controls.*', parent_path=p2)
full_path_parts = p3.get_full_path_parts()
full_path = ElementPath.PATH_SEPARATOR.join(full_path_parts)
assert element_arg == full_path
def parse_element_arg(element_arg: str, contextual_mode: bool = True) -> List[ElementPath]:
"""Parse an element arg string into a list of ElementPath.
contextual_mode specifies if the path is a valid project model path or not. For example,
if we are processing a metadata.parties.*, we need to know which metadata we are processing. If we pass
contextual_mode=True, we can infer the root model by inspecting the file directory
If contextual_mode=False, then the path must include the full path, e.g. catalog.metadata.parties.* instead of just
metadata.parties.*
One option for caller to utilize this utility function: fs.is_valid_project_model_path(pathlib.Path.cwd())
"""
element_paths: List[ElementPath] = []
element_arg = element_arg.strip()
# search for wildcards and create paths with its parent path
path_parts = element_arg.split(ElementPath.PATH_SEPARATOR)
if len(path_parts) <= 0:
raise TrestleError(f'Invalid element path "{element_arg}" without any path separator')
prev_element_path = None
parent_model = path_parts[0]
i = 1
while i < len(path_parts):
p = path_parts[i]
if p == ElementPath.WILDCARD and len(element_paths) > 0:
# append wildcard to the latest element path
latest_path = element_paths.pop()
if latest_path.get_last() == ElementPath.WILDCARD:
raise TrestleError(f'Invalid element path with consecutive {ElementPath.WILDCARD}')
latest_path_str = ElementPath.PATH_SEPARATOR.join([latest_path.to_string(), p])
element_path = ElementPath(latest_path_str, latest_path.get_parent())
else:
# create and append elment_path
p = ElementPath.PATH_SEPARATOR.join([parent_model, p])
element_path = ElementPath(p, parent_path=prev_element_path)
# if the path has wildcard and there is more parts later,
# get the parent model for the alias path
if element_path.get_last() == ElementPath.WILDCARD:
full_path_str = ElementPath.PATH_SEPARATOR.join(element_path.get_full_path_parts()[:-1])
parent_model = fs.get_singular_alias(full_path_str, contextual_mode)
else:
parent_model = element_path.get_element_name()
# store values for next cycle
prev_element_path = element_path
element_paths.append(element_path)
i += 1
if len(element_paths) <= 0:
raise TrestleError(f'Invalid element path "{element_arg}" without any path separator')
return element_paths
def add(element_path: ElementPath, parent_element: Element, include_optional: bool) -> None:
"""For a element_path, add a child model to the parent_element of a given parent_model.
Args:
element_path: element path of the item to create within the model
parent_element: the parent element that will host the created element
include_optional: whether to create optional attributes in the created element
Notes:
First we find the child model at the specified element path and instantiate it with default values.
Then we check if there's already existing element at that path, in which case we append the child model
to the existing list of dict.
Then we set up an action plan to update the model (specified by file_path) in memory, create a file
at the same location and write the file.
We update the parent_element to prepare for next adds in the chain
"""
if '*' in element_path.get_full_path_parts():
raise err.TrestleError('trestle add does not support Wildcard element path.')
# Get child model
try:
child_model = element_path.get_type(type(parent_element.get()))
# Create child element with sample values
child_object = gens.generate_sample_model(child_model, include_optional=include_optional)
if parent_element.get_at(element_path) is not None:
# The element already exists
if type(parent_element.get_at(element_path)) is list:
child_object = parent_element.get_at(element_path) + child_object
elif type(parent_element.get_at(element_path)) is dict:
child_object = {**parent_element.get_at(element_path), **child_object}
else:
raise err.TrestleError('Already exists and is not a list or dictionary.')
except Exception as e:
raise err.TrestleError(f'Bad element path. {str(e)}')
update_action = UpdateAction(
sub_element=child_object, dest_element=parent_element, sub_element_path=element_path
)
parent_element = parent_element.set_at(element_path, child_object)
return update_action, parent_element
def remove(cls, element_path: ElementPath, parent_model: Type[OscalBaseModel],
parent_element: Element) -> Tuple[RemoveAction, Element]:
"""For the element_path, remove a model from the parent_element of a given parent_model.
First we check if there is an existing element at that path
If not, we complain.
Then we set up an action plan to update the model (specified by file_path) in memory,
return the action and return the parent_element.
LIMITATIONS:
1. This does not remove elements of a list or dict. Instead, the entire list or dict is removed.
2. This cannot remove arbitrarily named elements that are not specified in the schema.
For example, "responsible-parties" contains named elements, e.g., "organisation". The tool will not
remove the "organisation" as it is not in the schema, but one can remove its elements, e.g., "party-uuids".
"""
element_path_list = element_path.get_full_path_parts()
if '*' in element_path_list:
raise err.TrestleError('trestle remove does not support Wildcard element path.')
deleting_element = parent_element.get_at(element_path)
if deleting_element is not None:
# The element already exists
if type(deleting_element) is list:
logger.warning(
'Warning: trestle remove does not support removing elements of a list: '
'this removes the entire list'
)
elif type(deleting_element) is dict:
logger.warning(
'Warning: trestle remove does not support removing dict elements: '
'this removes the entire dict element'
)
else:
raise err.TrestleError(f'Bad element path: {str(element_path)}')
remove_action = RemoveAction(parent_element, element_path)
return remove_action, parent_element
def merge(cls, element_path: ElementPath) -> Plan:
"""Merge operations.
It returns a plan for the operation
"""
element_path_list = element_path.get_full_path_parts()
target_model_alias = element_path_list[-1]
"""1. Load desination model into a stripped model"""
# Load destination model
destination_model_alias = element_path_list[-2]
# Destination model filetype
try:
file_type = fs.get_contextual_file_type(Path(os.getcwd()))
except Exception as e:
raise TrestleError(str(e))
file_ext = FileContentType.to_file_extension(file_type)
# Destination model filename
destination_model_filename = Path(
f'{utils.classname_to_alias(destination_model_alias, "json")}{file_ext}'
)
destination_model_type, _ = fs.get_stripped_contextual_model(
destination_model_filename.absolute())
destination_model_object = destination_model_type.oscal_read(
destination_model_filename)
"""1.5. If target is wildcard, load distributed destrination model and replace destination model."""
# Handle WILDCARD '*' match. Return plan to load the destination model, with it's distributed attributes
if target_model_alias == '*':
merged_model_type, merged_model_alias, merged_model_instance = load_distributed.load_distributed(
destination_model_filename)
plan = Plan()
reset_destination_action = CreatePathAction(
destination_model_filename.absolute(), clear_content=True)
write_destination_action = WriteFileAction(
destination_model_filename,
Element(merged_model_instance),
content_type=file_type)
delete_target_action = RemovePathAction(
Path(merged_model_alias).absolute())
plan: Plan = Plan()
plan.add_action(reset_destination_action)
plan.add_action(write_destination_action)
plan.add_action(delete_target_action)
return plan
# Get destination model without the target field stripped
merged_model_type, merged_model_alias = fs.get_stripped_contextual_model(
destination_model_filename.absolute(),
aliases_not_to_be_stripped=[target_model_alias])
"""2. Load Target model. Target model could be stripped"""
try:
target_model_type = utils.get_target_model(element_path_list,
merged_model_type)
except Exception as e:
raise TrestleError(
f'Target model not found. Possibly merge of the elements not allowed at this point. {str(e)}'
)
# target_model filename - depends whether destination model is decomposed or not
if (Path(os.getcwd()) / destination_model_alias).exists():
target_model_path = f'{os.getcwd()}/{destination_model_alias}/{target_model_alias}'
else:
target_model_path = target_model_alias
# if target model is a file then handle file. If file doesn't exist, handle the directory,
# but in this case it's a list or a dict collection type
if (Path(f'{target_model_path}{file_ext}')).exists():
target_model_filename = Path(f'{target_model_path}{file_ext}')
_, _, target_model_object = load_distributed.load_distributed(
target_model_filename)
else:
target_model_filename = Path(target_model_path)
collection_type = utils.get_origin(target_model_type)
_, _, target_model_object = load_distributed.load_distributed(
target_model_filename, collection_type)
if hasattr(target_model_object,
'__dict__') and '__root__' in target_model_object.__dict__:
target_model_object = target_model_object.__dict__['__root__']
"""3. Insert target model into destination model."""
merged_dict = destination_model_object.__dict__
merged_dict[target_model_alias] = target_model_object
merged_model_object = merged_model_type(**merged_dict) # type: ignore
merged_destination_element = Element(merged_model_object)
"""4. Create action plan"""
reset_destination_action = CreatePathAction(
destination_model_filename.absolute(), clear_content=True)
write_destination_action = WriteFileAction(destination_model_filename,
merged_destination_element,
content_type=file_type)
delete_target_action = RemovePathAction(target_model_filename)
plan: Plan = Plan()
plan.add_action(reset_destination_action)
plan.add_action(write_destination_action)
plan.add_action(delete_target_action)
# TODO: Destination model directory is empty or already merged? Then clean up.
return plan
def parse_chain(
model_obj: Union[OscalBaseModel, None],
path_parts: List[str],
relative_path: Optional[pathlib.Path] = None
) -> List[ElementPath]:
"""Parse the model chain starting from the beginning.
Args:
model_obj: Model to use for inspecting available elements, if available or none
path_parts: list of string paths to parse including wildcards
relative_path: Optional relative path (w.r.t trestle project root directory)
Returns:
List of ElementPath
"""
element_paths: List[ElementPath] = []
sub_model = model_obj
have_model_to_parse = model_obj is not None
prev_element_path = None
latest_path = None
parent_model = path_parts[0]
i = 1
while i < len(path_parts):
p = path_parts[i]
# if hit wildcard create element path up to this point
if p == ElementPath.WILDCARD and len(element_paths) > 0:
# append wildcard to the latest element path
latest_path = element_paths.pop()
if latest_path.get_last() == ElementPath.WILDCARD:
raise TrestleError(f'Invalid element path with consecutive {ElementPath.WILDCARD}')
latest_path_str = ElementPath.PATH_SEPARATOR.join([latest_path.to_string(), p])
element_path = ElementPath(latest_path_str, latest_path.get_parent())
else:
# create and append element_path
# at this point sub_model may be a list of items
# new element path is needed only if any of the items contains the desired part
if p != ElementPath.WILDCARD:
new_attrib = str_utils.dash_to_underscore(p)
if isinstance(sub_model, list):
for item in sub_model:
# go into the list and find one with requested part
sub_item = getattr(item, new_attrib, None)
if sub_item is not None:
sub_model = sub_item
break
else:
sub_model = getattr(sub_model, new_attrib, None)
if have_model_to_parse and sub_model is None:
return element_paths
p = ElementPath.PATH_SEPARATOR.join([parent_model, p])
element_path = ElementPath(p, parent_path=prev_element_path)
# If the path has wildcard and there are more parts later,
# get the parent model for the alias path
# If path has wildcard and it does not refer to a list, then there can be nothing after *
if element_path.get_last() == ElementPath.WILDCARD:
full_path_str = ElementPath.PATH_SEPARATOR.join(element_path.get_full_path_parts()[:-1])
parent_model = ModelUtils.get_singular_alias(full_path_str, relative_path)
# Does wildcard mean we need to inspect the sub_model to determine what can be split off from it?
# If it has __root__ it may mean it contains a list of objects and should be split as a list
if isinstance(sub_model, OscalBaseModel):
root = getattr(sub_model, '__root__', None)
if root is None or not isinstance(root, list):
# Cannot have parts beyond * if it isn't a list
if i < len(path_parts) - 1:
raise TrestleError(
f'Cannot split beyond * when the wildcard does not refer to a list. Path: {path_parts}'
)
for key in sub_model.__fields__.keys():
# only create element path is item is present in the sub_model
if getattr(sub_model, key, None) is None:
continue
new_alias = str_utils.underscore_to_dash(key)
new_path = full_path_str + '.' + new_alias
if not split_is_too_fine(new_path, model_obj):
# to add parts of an element, need to add two links
# prev_element_path may be None, for example catalog.*
if prev_element_path is not None:
element_paths.append(prev_element_path)
element_paths.append(ElementPath(parent_model + '.' + new_alias, latest_path))
# Since wildcard is last in the chain when splitting an oscal model we are done
return element_paths
else:
parent_model = element_path.get_element_name()
# store values for next cycle
prev_element_path = element_path
element_paths.append(element_path)
i += 1
return element_paths