def test_map_attribute_to_seq(class_node: yatiml.Node) -> None: assert class_node.has_attribute_type('dict1', dict) class_node.map_attribute_to_seq('dict1', 'item_id', 'price') assert class_node.has_attribute_type('dict1', list) attr_node = class_node.get_attribute('dict1') assert len(attr_node.seq_items()) == 3 first_item_node = attr_node.seq_items()[0] assert first_item_node.has_attribute('item_id') assert first_item_node.has_attribute('price') first_item_id = first_item_node.get_attribute('item_id').get_value() second_item_node = attr_node.seq_items()[1] assert second_item_node.has_attribute('item_id') assert second_item_node.has_attribute('price') second_item_id = second_item_node.get_attribute('item_id').get_value() third_item_node = attr_node.seq_items()[2] assert third_item_node.has_attribute('item_id') assert third_item_node.has_attribute('price') third_item_id = third_item_node.get_attribute('item_id').get_value() assert first_item_id == 'item1' assert second_item_id == 'item2' assert third_item_id == 'item3' assert ((first_item_id == 'item1' and second_item_id == 'item2') or (first_item_id == 'item2' and second_item_id == 'item1'))
def _yatiml_sweeten(cls, node: yatiml.Node) -> None: multiplicity = node.get_attribute('multiplicity') items = multiplicity.seq_items() if len(items) == 0: node.remove_attribute('multiplicity') elif len(items) == 1: node.set_attribute('multiplicity', items[0].get_value())
def yatiml_sweeten(self, node: yatiml.Node) -> None: namespace_nodes = node.get_attribute('namespaces').seq_items() namespaces = list(map(yatiml.Node.get_value, namespace_nodes)) namespace_str = '.'.join(namespaces) name = node.get_attribute('name').get_value() node.set_value('{}.{}'.format(namespace_str, name))
def test_map_attribute_to_index(class_node: yatiml.Node) -> None: class_node.map_attribute_to_index('dict1', 'item_id', 'price') assert class_node.has_attribute_type('dict1', dict) attr_node = class_node.get_attribute('dict1') assert attr_node.is_mapping() assert attr_node.has_attribute('item1') item1_node = attr_node.get_attribute('item1') assert len(item1_node.yaml_node.value) == 2 assert item1_node.has_attribute('item_id') assert item1_node.get_attribute('item_id').get_value() == 'item1' assert item1_node.has_attribute('price') assert item1_node.get_attribute('price').get_value() == 100.0 assert attr_node.has_attribute('item2') item2_node = attr_node.get_attribute('item2') assert len(item2_node.yaml_node.value) == 2 assert item2_node.has_attribute('item_id') assert item2_node.get_attribute('item_id').get_value() == 'item2' assert item2_node.has_attribute('price') assert item2_node.get_attribute('price').get_value() == 200.0 assert attr_node.has_attribute('item3') item3_node = attr_node.get_attribute('item3') assert len(item3_node.yaml_node.value) == 2 assert item3_node.has_attribute('item_id') assert item3_node.get_attribute('item_id').get_value() == 'item3' assert item3_node.has_attribute('price') assert item3_node.get_attribute('price').get_value() == 150.0
def _yatiml_sweeten(cls, node: yatiml.Node) -> None: int_to_str = { 5: 'five', 6: 'six', 7: 'seven' } int_val = int(node.get_attribute('age').get_value()) if int_val in int_to_str: node.set_attribute('age', int_to_str[int_val])
def _yatiml_savorize(cls, node: yatiml.Node) -> None: if node.has_attribute('multiplicity'): if node.has_attribute_type('multiplicity', int): attr = node.get_attribute('multiplicity') start_mark = attr.yaml_node.start_mark end_mark = attr.yaml_node.end_mark new_seq = yaml.nodes.SequenceNode( 'tag:yaml.org,2002:seq', [attr.yaml_node], start_mark, end_mark) node.set_attribute('multiplicity', new_seq)
def test_rename_attribute(class_node: yatiml.Node) -> None: assert class_node.has_attribute('attr1') assert not class_node.has_attribute('attr2') attr1_value = class_node.get_attribute('attr1').get_value() class_node.rename_attribute('attr1', 'attr2') assert not class_node.has_attribute('attr1') assert class_node.has_attribute('attr2') assert class_node.get_attribute('attr2').get_value() == attr1_value # make sure that this does not raise class_node.rename_attribute('non_existent_attribute', 'attr3')
def _yatiml_savorize(cls, node: yatiml.Node) -> None: str_to_int = { 'five': 5, 'six': 6, 'seven': 7, } if node.has_attribute_type('age', str): str_val = node.get_attribute('age').get_value() if str_val in str_to_int: node.set_attribute('age', str_to_int[str_val]) else: raise yatiml.SeasoningError('Invalid age string')
def _yatiml_savorize(cls, node: yatiml.Node) -> None: # enum.Enum has a __members__ attribute which contains its # members, which we reverse here to make a look-up table that # converts values in the YAML file to names expected by YAtiML. yaml_to_python = { v.value: v.name for v in cls.__members__.values()} # Remember that the node can be anything here. We only convert # if it's a string with an expected value, otherwise we leave # it alone so that a useful error message can be generated. if node.is_scalar(str): if node.get_value() in yaml_to_python: node.set_value(yaml_to_python[node.get_value()])
def test_index_attribute_to_map1(class_node: yatiml.Node) -> None: class_node.index_attribute_to_map('index1', 'item_id') assert class_node.has_attribute('index1') new_mapping = class_node.get_attribute('index1') assert new_mapping.is_mapping() assert new_mapping.has_attribute('item1') item1_mapping = new_mapping.get_attribute('item1') assert item1_mapping.is_mapping() assert not item1_mapping.has_attribute('item_id') assert item1_mapping.has_attribute('price') assert new_mapping.has_attribute('item2') item2_mapping = new_mapping.get_attribute('item2') assert item2_mapping.is_mapping() assert not item2_mapping.has_attribute('item_id') assert item2_mapping.has_attribute('price') assert new_mapping.has_attribute('item3') item3_mapping = new_mapping.get_attribute('item3') assert item3_mapping.is_mapping() assert not item3_mapping.has_attribute('item_id') assert item3_mapping.has_attribute('price') assert item3_mapping.has_attribute('on_sale') # check that it fails silently if the attribute is missing or not a mapping class_node.index_attribute_to_map('non_existent_attribute', 'item_id') class_node.index_attribute_to_map('attr1', 'item_id')
def _yatiml_sweeten(cls, node: yatiml.Node) -> None: script_node = node.get_attribute('script') if script_node.is_scalar(str): text = cast(str, script_node.get_value()) if '\n' in text: # make a sequence of lines lines = text.split('\n') start_mark = node.yaml_node.start_mark end_mark = node.yaml_node.end_mark lines_nodes = [ yaml.ScalarNode( 'tag:yaml.org,2002:str', line, start_mark, end_mark) for line in lines] seq_node = yaml.SequenceNode( 'tag:yaml.org,2002:seq', lines_nodes, start_mark, end_mark) node.set_attribute('script', seq_node)
def test_set_value(class_node: yatiml.Node) -> None: assert class_node.is_mapping() class_node.set_value(42) assert class_node.is_scalar(int) assert class_node.yaml_node.value == '42' class_node.set_value(True) assert class_node.is_scalar(bool) assert class_node.yaml_node.value == 'true'
def test_is_scalar(class_node: yatiml.Node) -> None: assert class_node.get_attribute('attr1').is_scalar() assert class_node.get_attribute('attr1').is_scalar(int) assert class_node.get_attribute('null_attr').is_scalar(None) assert not class_node.is_scalar() with pytest.raises(ValueError): class_node.get_attribute('attr1').is_scalar(dict)
def test_index_attribute_to_map2(class_node: yatiml.Node) -> None: class_node.index_attribute_to_map('index1', 'item_id', 'price') assert class_node.has_attribute('index1') new_mapping = class_node.get_attribute('index1') assert new_mapping.is_mapping() assert new_mapping.has_attribute('item1') item1 = new_mapping.get_attribute('item1') print(item1.yaml_node) assert item1.is_scalar(float) assert item1.get_value() == 100.0 assert new_mapping.has_attribute('item2') item2 = new_mapping.get_attribute('item2') assert item2.is_scalar(float) assert item2.get_value() == 200.0 assert new_mapping.has_attribute('item3') item3_mapping = new_mapping.get_attribute('item3') assert item3_mapping.is_mapping() assert not item3_mapping.has_attribute('item_id') assert item3_mapping.has_attribute('price') assert item3_mapping.has_attribute('on_sale')
def yatiml_savorize(cls, node: yatiml.Node) -> None: text = str(node.get_value()) parts = text.split('.') node.make_mapping() # We need to make a yaml.SequenceNode by hand here, since # set_attribute doesn't take lists as an argument. start_mark = yaml.error.StreamMark('generated node', 0, 0, 0) end_mark = yaml.error.StreamMark('generated node', 0, 0, 0) item_nodes = list() for part in parts[:-1]: item_nodes.append( yaml.ScalarNode('tag:yaml.org,2002:str', part, start_mark, end_mark)) ynode = yaml.SequenceNode('tag:yaml.org,2002:seq', item_nodes, start_mark, end_mark) node.set_attribute('namespaces', ynode) node.set_attribute('name', parts[-1])
def _yatiml_sweeten(cls, node: yatiml.Node) -> None: node.rename_attribute('typ', 'type') node.unders_to_dashes_in_keys()
def _yatiml_savorize(cls, node: yatiml.Node) -> None: node.dashes_to_unders_in_keys() node.rename_attribute('type', 'typ')
def _yatiml_sweeten(cls, node: yatiml.Node) -> None: # Here we just use cls.__members__ directly to convert. node.set_value(cls.__members__[node.get_value()].value)
def test_is_sequence(class_node: yatiml.Node) -> None: assert not class_node.is_sequence() assert class_node.get_attribute('list1').is_sequence() assert not class_node.get_attribute('attr1').is_sequence()
def _yatiml_savorize(cls, node: yatiml.Node) -> None: yaml_to_py = {v._value_: v._name_ for v in cls.__members__.values()} if node.is_scalar(str): node.set_value(yaml_to_py.get(node.get_value()))
def test_set_attribute(class_node: yatiml.Node) -> None: assert class_node.get_attribute('attr1').get_value() == 42 class_node.set_attribute('attr1', 43) attr1 = class_node.get_attribute('attr1') assert attr1.yaml_node.tag == 'tag:yaml.org,2002:int' assert attr1.yaml_node.value == '43' assert attr1.yaml_node.start_mark is not None assert attr1.yaml_node.end_mark is not None class_node.set_attribute('attr1', 'test') attr1 = class_node.get_attribute('attr1') assert attr1.yaml_node.tag == 'tag:yaml.org,2002:str' assert attr1.yaml_node.value == 'test' assert attr1.yaml_node.start_mark is not None assert attr1.yaml_node.end_mark is not None class_node.set_attribute('attr1', 3.14) attr1 = class_node.get_attribute('attr1') assert attr1.yaml_node.tag == 'tag:yaml.org,2002:float' assert attr1.yaml_node.value == '3.14' assert attr1.yaml_node.start_mark is not None assert attr1.yaml_node.end_mark is not None class_node.set_attribute('attr1', True) attr1 = class_node.get_attribute('attr1') assert attr1.yaml_node.tag == 'tag:yaml.org,2002:bool' assert attr1.yaml_node.value == 'true' assert attr1.yaml_node.start_mark is not None assert attr1.yaml_node.end_mark is not None class_node.set_attribute('attr1', None) attr1 = class_node.get_attribute('attr1') assert attr1.yaml_node.tag == 'tag:yaml.org,2002:null' assert attr1.yaml_node.value == '' assert attr1.yaml_node.start_mark is not None assert attr1.yaml_node.end_mark is not None assert not class_node.has_attribute('attr2') class_node.set_attribute('attr2', 'testing') attr2 = class_node.get_attribute('attr2') assert attr2.yaml_node.value == 'testing' assert attr2.yaml_node.start_mark is not None assert attr2.yaml_node.end_mark is not None node = yaml.ScalarNode('tag:yaml.org,2002:str', 'testnode') class_node.set_attribute('attr3', node) assert class_node.get_attribute('attr3').yaml_node == node with pytest.raises(TypeError): class_node.set_attribute('attr4', class_node) # type: ignore
def test_get_attribute(class_node: yatiml.Node) -> None: assert class_node.get_attribute('attr1').yaml_node.value == '42' with pytest.raises(yatiml.SeasoningError): class_node.get_attribute('non_existent_attribute')
def test_has_attribute_type(class_node: yatiml.Node) -> None: assert class_node.has_attribute_type('attr1', int) assert not class_node.has_attribute_type('attr1', float) assert class_node.has_attribute_type('list1', list) with pytest.raises(ValueError): class_node.has_attribute_type('attr1', yaml.Node)
def test_has_attribute(class_node: yatiml.Node) -> None: assert class_node.has_attribute('attr1') assert class_node.has_attribute('list1') assert not class_node.has_attribute('non_existent_attribute')
def test_make_mapping(scalar_node: yatiml.Node) -> None: assert scalar_node.is_scalar(int) scalar_node.make_mapping() assert isinstance(scalar_node.yaml_node, yaml.MappingNode) assert scalar_node.yaml_node.tag == 'tag:yaml.org,2002:map' assert scalar_node.yaml_node.value == []
def _yatiml_savorize(cls, node: yatiml.Node) -> None: node.dashes_to_unders_in_keys()
def test_unders_to_dashes_in_keys(class_node: yatiml.Node) -> None: assert class_node.has_attribute('undered_attr') assert class_node.has_attribute('attr1') class_node.unders_to_dashes_in_keys() assert class_node.has_attribute('undered-attr') assert class_node.has_attribute('attr1')
def test_get_value(class_node: yatiml.Node) -> None: assert class_node.get_attribute('attr1').get_value() == 42
def _yatiml_sweeten(cls, node: yatiml.Node) -> None: node.unders_to_dashes_in_keys()
def test_dashes_to_unders_in_keys(class_node: yatiml.Node) -> None: assert class_node.has_attribute('dashed-attr') assert class_node.has_attribute('list1') class_node.dashes_to_unders_in_keys() assert class_node.has_attribute('dashed_attr') assert class_node.has_attribute('list1')