def load_top_level_model(
trestle_root: pathlib.Path,
model_name: str,
model_class: Type[TopLevelOscalModel],
file_content_type: Optional[FileContentType] = None
) -> Tuple[Union[OscalBaseModel, List[OscalBaseModel], Dict[
str, OscalBaseModel]], pathlib.Path]:
"""Load a model by name and model class and infer file content type if not specified.
If you need to load an existing model but its content type may not be known, use this method.
But the file content type should be specified if it is somehow known.
"""
root_model_path = ModelUtils._root_path_for_top_level_model(
trestle_root, model_name, model_class)
if file_content_type is None:
file_content_type = FileContentType.path_to_content_type(
root_model_path)
if not FileContentType.is_readable_file(file_content_type):
raise TrestleError(
f'Unable to load model {model_name} without specifying json or yaml.'
)
full_model_path = root_model_path.with_suffix(
FileContentType.to_file_extension(file_content_type))
_, _, model = ModelUtils.load_distributed(full_model_path,
trestle_root)
return model, full_model_path
def full_path_for_top_level_model(
trestle_root: pathlib.Path,
model_name: str,
model_class: Type[TopLevelOscalModel],
) -> pathlib.Path:
"""
Find the full path of an existing model given its name and model type but no file content type.
Use this method when you need the path of a model but you don't know the file content type.
This method should only be called if the model needs to exist already in the trestle directory.
If you do know the file content type, use path_for_top_level_model instead.
"""
root_model_path = ModelUtils._root_path_for_top_level_model(
trestle_root, model_name, model_class)
file_content_type = FileContentType.path_to_content_type(
root_model_path)
if not FileContentType.is_readable_file(file_content_type):
raise TrestleError(
f'Unable to load model {model_name} as json or yaml.')
return root_model_path.with_suffix(
FileContentType.to_file_extension(file_content_type))
def load_distributed(
abs_path: Path,
abs_trestle_root: Path,
collection_type: Optional[Type[Any]] = None
) -> Tuple[Type[OscalBaseModel], str, Union[
OscalBaseModel, List[OscalBaseModel], Dict[str, OscalBaseModel]]]:
"""
Given path to a model, load the model.
If the model is decomposed/split/distributed,the decomposed models are loaded recursively.
Args:
abs_path: The path to the file/directory to be loaded.
abs_trestle_root: The trestle project root directory.
collection_type: The type of collection model, if it is a collection model.
typing.List is the only collection type handled or expected.
Defaults to None.
Returns:
Return a tuple of Model Type (e.g. class 'trestle.oscal.catalog.Catalog'),
Model Alias (e.g. 'catalog.metadata') and Instance of the Model.
If the model is decomposed/split/distributed, the instance of the model contains
the decomposed models loaded recursively.
"""
# if trying to load file that does not exist, load path instead
if not abs_path.exists():
abs_path = abs_path.with_name(abs_path.stem)
if not abs_path.exists():
raise TrestleNotFoundError(f'File {abs_path} not found for load.')
if collection_type:
# If the path contains a list type model
if collection_type is list:
return ModelUtils._load_list(abs_path, abs_trestle_root)
# the only other collection type in OSCAL is dict, and it only applies to include_all,
# which is too granular ever to be loaded by this routine
else:
raise TrestleError(
f'Collection type {collection_type} not recognized for distributed load.'
)
# Get current model
primary_model_type, primary_model_alias = ModelUtils.get_stripped_model_type(
abs_path, abs_trestle_root)
primary_model_instance: Optional[OscalBaseModel] = None
# is this an attempt to load an actual json or yaml file?
content_type = FileContentType.path_to_content_type(abs_path)
# if file is sought but it doesn't exist, ignore and load as decomposed model
if FileContentType.is_readable_file(
content_type) and abs_path.exists():
primary_model_instance = primary_model_type.oscal_read(abs_path)
# Is model decomposed?
decomposed_dir = abs_path.with_name(abs_path.stem)
if decomposed_dir.exists():
aliases_not_to_be_stripped = []
instances_to_be_merged: List[OscalBaseModel] = []
for local_path in sorted(
trestle.common.file_utils.iterdir_without_hidden_files(
decomposed_dir)):
if local_path.is_file():
model_type, model_alias, model_instance = ModelUtils.load_distributed(
local_path, abs_trestle_root)
aliases_not_to_be_stripped.append(
model_alias.split('.')[-1])
instances_to_be_merged.append(model_instance)
elif local_path.is_dir():
model_type, model_alias = ModelUtils.get_stripped_model_type(
local_path, abs_trestle_root)
# Only load the directory if it is a collection model. Otherwise do nothing - it gets loaded when
# iterating over the model file
# If a model is just a container for a list e.g.
# class Foo(OscalBaseModel): noqa: E800
# __root__: List[Bar] noqa: E800
# You need to test whether first a root key exists
# then whether the outer_type of root is a collection.
# Alternative is to do a try except to avoid the error for an unknown key.
if model_type.is_collection_container():
# This directory is a decomposed List or Dict
collection_type = model_type.get_collection_type()
model_type, model_alias, model_instance = ModelUtils.load_distributed(
local_path, abs_trestle_root, collection_type)
aliases_not_to_be_stripped.append(
model_alias.split('.')[-1])
instances_to_be_merged.append(model_instance)
primary_model_dict = {}
if primary_model_instance is not None:
primary_model_dict = primary_model_instance.__dict__
merged_model_type, merged_model_alias = ModelUtils.get_stripped_model_type(
abs_path, abs_trestle_root, aliases_not_to_be_stripped)
# The following use of top_level is to allow loading of a top level model by name only, e.g. MyCatalog
# There may be a better overall way to approach this.
top_level = len(merged_model_alias.split('.')) == 1
for i in range(len(aliases_not_to_be_stripped)):
alias = aliases_not_to_be_stripped[i]
instance = instances_to_be_merged[i]
if hasattr(
instance, '__dict__'
) and '__root__' in instance.__dict__ and isinstance(
instance, OscalBaseModel):
instance = instance.__dict__['__root__']
if top_level and not primary_model_dict:
primary_model_dict = instance.__dict__
else:
primary_model_dict[alias] = instance
merged_model_instance = merged_model_type(
**primary_model_dict) # type: ignore
return merged_model_type, merged_model_alias, merged_model_instance
return primary_model_type, primary_model_alias, primary_model_instance
