def _set_transformation_values(self):
     if isinstance(self.values, StreamModule):
         nx_log = Group(name=self.name, parent_node=self)  # type: ignore
         nx_log.nx_class = LOG_CLASS_NAME
         self.values.parent_node = nx_log
         nx_log.children.append(self.values)
         self.values = nx_log
    def get_transforms_group(self) -> Group:
        if self[TRANSFORMS_GROUP_NAME] is not None:
            return self[TRANSFORMS_GROUP_NAME]

        self[TRANSFORMS_GROUP_NAME] = Group(TRANSFORMS_GROUP_NAME,
                                            parent_node=self)
        self[TRANSFORMS_GROUP_NAME].nx_class = "NXtransformations"
        return self[TRANSFORMS_GROUP_NAME]
Exemple #3
0
def test_get_flags_transformation_list():
    test_component_tree_model, test_instrument = create_component_tree_model(
        [get_component()])

    transformation_group = Group(name="transformations")
    transformation_group.nx_class = NX_TRANSFORMATIONS
    index = test_component_tree_model.createIndex(0, 0, transformation_group)

    assert (test_component_tree_model.flags(index) == Qt.ItemIsEnabled
            | Qt.ItemIsSelectable)
Exemple #4
0
 def _create_user(self, group: Group, user_data: Dict[str, str]) -> Group:
     group.name = f"user_{user_data['name'].replace(' ', '')}"
     group.nx_class = NX_USER
     for name, value in user_data.items():
         group.children.append(
             Dataset(
                 name=name, parent_node=group, type=ValueTypes.STRING, values=value
             )
         )
     return group
Exemple #5
0
def test_group_as_dict_contains_expected_keys():
    input_name = "test_group"
    test_group = Group("test_group")
    dictionary_output = test_group.as_dict([])
    for expected_key in (
            "name",
            "type",
            "children",
    ):  # Attributes should not be included by default if there are none, unlike children
        assert expected_key in dictionary_output.keys()

    assert dictionary_output["name"] == input_name
Exemple #6
0
 def __init__(
     self,
     length: float,
     width: float,
     height: float,
     name: str = "",
     units: str = "m",
 ):
     Group.__init__(self, name)
     self._size = [length, width, height]
     self._units = units
     self.nx_class = GEOMETRY_NX_CLASS
     self._create_datasets_and_add_to_shape_group()
Exemple #7
0
 def __init__(
     self,
     vertices: List[QVector3D] = None,
     faces: List[List[int]] = None,
     name: str = "",
     colors: List[List[int]] = [],
 ):
     """
     :param vertices: list of Vector objects used as corners of polygons in the geometry
     :param faces: list of integer lists. Each sublist is a winding path around the corners of a polygon.
         Each sublist item is an index into the vertices list to identify a specific point in 3D space
     """
     Group.__init__(self, name)
     OFFGeometry.__init__(self)
     self.name = name
     self._vertices = vertices
     self._faces = faces
     self._colors = colors
Exemple #8
0
def test_GIVEN_dataset_with_string_value_WHEN_adding_dataset_THEN_dataset_object_is_created_with_correct_dtype():
    name = "description"
    values = "a description"
    parent = Group(name="test")
    ds = Dataset(parent_node=parent, type=ValueTypes.STRING, values=values, name=name)
    assert ds.name == name
    assert ds.values == values
    assert ds.parent_node == parent
    assert ds.type == ValueTypes.STRING
Exemple #9
0
 def _create_datasets_and_add_to_shape_group(self):
     group = Group(name=SHAPE_GROUP_NAME)
     group.nx_class = SHAPE_NX_CLASS
     group.parent_node = self
     new_child = create_fw_module_object(
         WriterModules.DATASET.value,
         self._get_dataset_config(self._size, SIZE),
         group,
     )
     new_child.type = ValueTypes.DOUBLE
     attributes = Attributes()
     attributes.set_attribute_value(CommonAttrs.UNITS, self._units)
     new_child.attributes = attributes
     new_child.parent_node = group
     group.children.append(new_child)
     group[SHAPE_GROUP_NAME] = create_fw_module_object(
         WriterModules.DATASET.value,
         self._get_dataset_config(NX_BOX, SHAPE_GROUP_NAME),
         group,
     )
     self[SHAPE_GROUP_NAME] = group
Exemple #10
0
def test_GIVEN_dataset_with_array_value_WHEN_adding_dataset_THEN_dataset_object_is_created_with_numpy_array_as_value():
    name = "an_array"
    values = [1.1, 2.2, 3.3, 4.4]
    dtype = ValueTypes.FLOAT

    np_array = np.array(values, dtype=VALUE_TYPE_TO_NP[dtype])
    parent = Group(name="test")
    ds = Dataset(parent_node=parent, type=dtype, values=np_array, name=name)

    assert ds.name == name
    assert np.array_equal(ds.values, np_array)
    assert ds.parent_node == parent
    assert ds.type == dtype
def test_get_absolute_path_works_if_component_with_parents():
    name1 = "thing1"
    node1 = Group(name=name1, parent_node=None)
    name2 = "thing2"
    node2 = Group(name=name2, parent_node=node1)
    assert node2.absolute_path == f"/{name1}/{name2}"
def test_get_absolute_path_works_with_no_parent():
    name = "test"
    node = Group(name=name, parent_node=None)

    assert node.absolute_path == f"/{name}"
Exemple #13
0
def create_tree_structure():
    entry = Group("entry")
    sample = Component("sample", parent_node=entry)
    instrument = Group("instrument", parent_node=entry)
    g1 = Group("g1", parent_node=instrument)
    g2 = Group("g2", parent_node=instrument)
    g21 = Group("g21", parent_node=g2)

    c1 = Component("c1", parent_node=instrument)
    c2 = Group("c2", parent_node=instrument)

    dataset = Dataset(name="dataset", values=0, parent_node=sample)
    entry.children = [sample, instrument]
    sample.children = [g1, g2, dataset]
    g2.children = [g21]
    instrument.children = [c1, c2]

    return entry, sample, instrument
Exemple #14
0
def test_get_field_value_throws_if_field_does_not_exist():
    group = Group("test_group")

    with pytest.raises(AttributeError):
        group.get_field_value("nonexistentfield")
    def _read_json_object(self, json_object: Dict, parent_node: Group = None):
        """
        Tries to create a component based on the contents of the JSON file.
        :param json_object: A component from the JSON dictionary.
        :param parent_name: The name of the parent object. Used for warning messages if something goes wrong.
        """
        nexus_object: Union[Group, FileWriterModule] = None
        use_placeholder = False
        if isinstance(json_object,
                      str) and json_object in PLACEHOLDER_WITH_NX_CLASSES:
            json_object = self._replace_placeholder(json_object)
            if not json_object:
                return
            use_placeholder = True
        if (CommonKeys.TYPE in json_object
                and json_object[CommonKeys.TYPE] == NodeType.GROUP):
            try:
                name = json_object[CommonKeys.NAME]
            except KeyError:
                self._add_object_warning(CommonKeys.NAME, parent_node)
                return None
            nx_class = _find_nx_class(json_object.get(CommonKeys.ATTRIBUTES))
            if nx_class == SAMPLE_CLASS_NAME:
                self.sample_name = name
            if not self._validate_nx_class(name, nx_class):
                self._add_object_warning(f"valid Nexus class {nx_class}",
                                         parent_node)
            if nx_class in COMPONENT_TYPES:
                nexus_object = Component(name=name, parent_node=parent_node)
                children_dict = json_object[CommonKeys.CHILDREN]
                self._add_transform_and_shape_to_component(
                    nexus_object, children_dict)
                self.model.append_component(nexus_object)
            else:
                nexus_object = Group(name=name, parent_node=parent_node)
            nexus_object.nx_class = nx_class
            if CommonKeys.CHILDREN in json_object:
                for child in json_object[CommonKeys.CHILDREN]:
                    node = self._read_json_object(child, nexus_object)
                    if node and isinstance(node, StreamModule):
                        nexus_object.children.append(node)
                    elif node and node.name not in nexus_object:
                        nexus_object[node.name] = node
        elif CommonKeys.MODULE in json_object and NodeType.CONFIG in json_object:
            module_type = json_object[CommonKeys.MODULE]
            if (module_type == WriterModules.DATASET.value
                    and json_object[NodeType.CONFIG][CommonKeys.NAME]
                    == CommonAttrs.DEPENDS_ON):
                nexus_object = None
            elif module_type in [x.value for x in WriterModules]:
                nexus_object = create_fw_module_object(
                    module_type, json_object[NodeType.CONFIG], parent_node)
                nexus_object.parent_node = parent_node
            else:
                self._add_object_warning("valid module type", parent_node)
                return None
        elif json_object == USERS_PLACEHOLDER:
            self.model.entry.users_placeholder = True
            return None
        else:
            self._add_object_warning(
                f"valid {CommonKeys.TYPE} or {CommonKeys.MODULE}", parent_node)

        # Add attributes to nexus_object.
        if nexus_object:
            json_attrs = json_object.get(CommonKeys.ATTRIBUTES)
            if json_attrs:
                attributes = Attributes()
                for json_attr in json_attrs:
                    if not json_attr[CommonKeys.VALUES]:
                        self._add_object_warning(
                            f"values in attribute {json_attr[CommonKeys.NAME]}",
                            parent_node,
                        )
                    elif CommonKeys.DATA_TYPE in json_attr:
                        attributes.set_attribute_value(
                            json_attr[CommonKeys.NAME],
                            json_attr[CommonKeys.VALUES],
                            json_attr[CommonKeys.DATA_TYPE],
                        )
                    elif CommonKeys.NAME in json_attr:
                        attributes.set_attribute_value(
                            json_attr[CommonKeys.NAME],
                            json_attr[CommonKeys.VALUES])
                nexus_object.attributes = attributes
            if (parent_node and isinstance(nexus_object, Dataset)
                    and parent_node.nx_class == ENTRY_CLASS_NAME):
                self.model.entry[nexus_object.name] = nexus_object
            if isinstance(nexus_object, Group) and not nexus_object.nx_class:
                self._add_object_warning(
                    f"valid {CommonAttrs.NX_CLASS}",
                    parent_node,
                )
            elif isinstance(nexus_object,
                            Group) and nexus_object.nx_class == "NXuser":
                self.model.entry[nexus_object.name] = nexus_object
            if isinstance(nexus_object, Group):
                nexus_object.group_placeholder = use_placeholder

        return nexus_object
Exemple #16
0
 def users(self, users: List[Dict[str, str]]):
     self._clear_all_users()
     for user in users:
         group = Group(name="temporary name", parent_node=self)
         group = self._create_user(group, user)
         self[group.name] = group