def test_model(tmp_path):
epc = os.path.join(tmp_path, 'model.epc')
model = rq.new_model(epc)
assert model is not None
crs = rqc.Crs(model)
crs_root = crs.create_xml()
model.store_epc()
assert os.path.exists(epc)
md_datum_1 = rqw.MdDatum(model,
location=(0.0, 0.0, -50.0),
crs_uuid=crs.uuid)
md_datum_1.create_xml(title='Datum & 1')
md_datum_2 = rqw.MdDatum(model,
location=(3.0, 0.0, -50.0),
crs_uuid=crs.uuid)
md_datum_2.create_xml(title='Datum < 2')
assert len(model.uuids(obj_type='MdDatum')) == 2
model.store_epc()
model = rq.Model(epc)
assert model is not None
assert len(model.uuids(obj_type='MdDatum')) == 2
datum_part_1 = model.part(obj_type='MdDatum', title='1', title_mode='ends')
datum_part_2 = model.part(obj_type='MdDatum', title='2', title_mode='ends')
assert datum_part_1 is not None and datum_part_2 is not None and datum_part_1 != datum_part_2
datum_uuid_1 = rqet.uuid_in_part_name(datum_part_1)
datum_uuid_2 = rqet.uuid_in_part_name(datum_part_2)
assert not bu.matching_uuids(datum_uuid_1, datum_uuid_2)
p1 = model.uuid_part_dict[bu.uuid_as_int(datum_uuid_1)]
p2 = model.uuid_part_dict[bu.uuid_as_int(datum_uuid_2)]
assert p1 == datum_part_1 and p2 == datum_part_2
def _parts(model,
parts_list=None,
obj_type=None,
uuid=None,
title=None,
title_mode='is',
title_case_sensitive=False,
extra={},
related_uuid=None,
epc_subdir=None,
sort_by=None):
"""Returns a list of parts matching all of the arguments passed."""
if not parts_list:
parts_list = _list_of_parts(model)
if uuid is not None:
part_name = model.uuid_part_dict.get(bu.uuid_as_int(uuid))
if part_name is None or part_name not in parts_list:
return []
parts_list = [part_name]
if epc_subdir:
parts_list = _filtered_by_epc_subdir(model, parts_list, epc_subdir)
if obj_type:
if obj_type[0].isupper():
obj_type = 'obj_' + obj_type
filtered_list = []
for part in parts_list:
if model.parts_forest[part][0] == obj_type:
filtered_list.append(part)
if len(filtered_list) == 0:
return []
parts_list = filtered_list
if title:
parts_list = _filtered_by_title(model, parts_list, title, title_mode,
title_case_sensitive)
if extra:
parts_list = _filtered_by_extra(model, parts_list, extra)
if related_uuid is not None:
parts_list = _parts_list_filtered_by_related_uuid(
model, parts_list, related_uuid)
if sort_by and len(parts_list):
parts_list = _sorted_parts_list(model, parts_list, sort_by)
return parts_list
def _parts_list_of_type(model, type_of_interest=None, uuid=None):
"""Returns a list of part names for parts of type of interest, optionally matching a uuid."""
if type_of_interest and type_of_interest[0].isupper():
type_of_interest = 'obj_' + type_of_interest
if uuid is not None:
part_name = model.uuid_part_dict.get(bu.uuid_as_int(uuid))
if part_name is None or (
type_of_interest is not None and
(model.parts_forest[part_name][0] != type_of_interest)):
return []
return [part_name]
parts_list = []
for part_name in model.parts_forest:
if type_of_interest is None or model.parts_forest[part_name][
0] == type_of_interest:
parts_list.append(part_name)
return parts_list
def _type_of_uuid(model, uuid, strip_obj=False):
"""Returns content type for the uuid."""
part_name = model.uuid_part_dict.get(bu.uuid_as_int(uuid))
return _type_of_part(model, part_name, strip_obj=strip_obj)
def _part_for_uuid(model, uuid):
"""Returns the part name which has the given uuid."""
return model.uuid_part_dict.get(bu.uuid_as_int(uuid))
def test_catalogue_functions(example_model_and_crs):
model, crs = example_model_and_crs
# create some grid objects with some boring properties
grid_a, grid_b, grid_c = add_grids(model, crs, True)
# test parts() method with various options
all_parts = model.parts()
assert isinstance(all_parts, list)
assert len(all_parts) >= 13
assert all([isinstance(p, str) for p in all_parts])
# test obj_type filtering
grid_parts = model.parts(obj_type='IjkGridRepresentation')
assert len(grid_parts) == 3
pcbt = model.parts_count_by_type('obj_IjkGridRepresentation')
assert isinstance(
pcbt,
list) and len(pcbt) == 1 and pcbt[0] == ('IjkGridRepresentation', 3)
# test single part selection with multiple handling options
oldest_grid_part = model.part(obj_type='IjkGridRepresentation',
multiple_handling='oldest')
assert oldest_grid_part is not None and isinstance(oldest_grid_part, str)
none_part = model.part(obj_type='IjkGridRepresentation',
multiple_handling='none')
assert none_part is None
# test type_of_part()
assert all([(model.type_of_part(p,
strip_obj=True) == 'IjkGridRepresentation')
for p in grid_parts])
# test filtering with title mode and case sensitivity options
grid_b_part = model.part(parts_list=grid_parts,
title='b',
title_mode='ends')
assert grid_b_part is not None
assert model.citation_title_for_part(grid_b_part).endswith('B')
no_grid_b_part = model.part(parts_list=grid_parts,
title='b',
title_mode='ends',
title_case_sensitive=True)
assert no_grid_b_part is None
grid_not_b_titles = model.parts(parts_list=grid_parts,
title='grid b',
title_mode='is not')
assert len(grid_not_b_titles) == 2 and 'GRID B' not in grid_not_b_titles
none_root = model.root(parts_list=grid_parts,
title='GRID',
title_mode='does not start',
title_case_sensitive=True)
assert none_root is None
all_grid_uuids = model.uuids(parts_list=grid_parts,
title='QWERTY',
title_mode='does not contain')
assert len(all_grid_uuids) == 3
two_parts = model.parts(parts_list=grid_parts,
title='A',
title_mode='does not end')
assert len(two_parts) == 2
# test uuids() with relationship filtering
grid_b_rels_uuids = model.uuids(
related_uuid=model.uuid_for_part(grid_b_part), sort_by='uuid')
assert grid_b_rels_uuids is not None and len(grid_b_rels_uuids) >= 4
assert uuid_in_list(crs.uuid, grid_b_rels_uuids)
# test parts_list_related_to_uuid_of_type()
grid_b_rels_crs_part = model.parts_list_related_to_uuid_of_type(
model.uuid_for_part(grid_b_part), 'obj_LocalDepth3dCrs')
assert isinstance(grid_b_rels_crs_part,
list) and len(grid_b_rels_crs_part) == 1
assert grid_b_rels_crs_part[0] == crs.part
grid_b_rels_uuids_ints = [bu.uuid_as_int(u) for u in grid_b_rels_uuids]
assert all(a < b for a, b in zip(grid_b_rels_uuids_ints[:-1],
grid_b_rels_uuids_ints[1:]))
# test parts_list_of_type() with uuid specified
singleton_list = model.parts_list_of_type(
'obj_IjkGridRepresentation', uuid=model.uuid_for_part(grid_b_part))
assert isinstance(singleton_list, list) and len(singleton_list) == 1
assert singleton_list[0] == grid_b_part
empty_list = model.parts_list_of_type('obj_IjkGridRepresentation',
uuid=crs.uuid)
assert isinstance(empty_list, list) and len(empty_list) == 0
empty_list = model.parts_list_of_type('obj_IjkGridRepresentation',
uuid=bu.new_uuid())
assert isinstance(empty_list, list) and len(empty_list) == 0
# test sorting
grid_b_props_titles = model.titles(
obj_type='ContinuousProperty',
parts_list=[model.part_for_uuid(uuid) for uuid in grid_b_rels_uuids],
sort_by='title')
assert len(grid_b_props_titles) == 3
assert all([
a < b
for (a, b) in zip(grid_b_props_titles[:-1], grid_b_props_titles[1:])
])
# test filtering by extra metadata
set_extra_metadata(grid_b, 'em_test', 'chai')
grid_b.create_xml()
set_extra_metadata(grid_c, 'em_test', 'oolong')
grid_c.create_xml()
assert model.root(extra={'em_test': 'espresso'}) is None
assert bu.matching_uuids(grid_c.uuid,
model.uuid(extra={'em_test': 'oolong'}))
# test list_of_parts()
obj_parts = model.list_of_parts()
all_parts = model.list_of_parts(only_objects=False)
assert len(all_parts) > len(obj_parts)
assert all([p in all_parts for p in obj_parts])
assert not all([p in obj_parts for p in all_parts])
# check exception is raised when multiple parts match criteria
with pytest.raises(ValueError) as excinfo:
part = model.part(obj_type='IjkGridRepresentation')