def parse(self, filename): """Parse XML. Returns an instance of model.Interface containing parsed interface or raises ParseError if input XML contains errors and can't be parsed. :param filename: name of input XML file. :return: Interface object """ tree = ElementTree.parse(filename) root = tree.getroot() self._enums = self._initialize_enums() self._structs = OrderedDict() self._functions = OrderedDict() self._params = {} self._types = dict(self._enums.items()) self._parse_root(root) return Interface(enums=self._enums, structs=self._structs, functions=self._functions, params=self._params)
def filter_pattern(self, interface, pattern): """ :param interface: initial Model :param pattern: regex-pattern from command-line arguments to filter element from initial Model :return: initial Model """ names = tuple(interface.enums.keys()) + tuple(interface.structs.keys()) if pattern: match = {i: OrderedDict() for i in vars(interface).keys()} match['params'] = interface.params empty = True for key, value in vars(interface).items(): if key == 'params': continue for name, item in value.items(): if re.match(pattern, item.name): if hasattr(item, 'message_type'): log = '{}/{} {} match with {}'.format( key, item.name, item.message_type.name.title(), pattern) else: log = '{}/{} match with {}'.format( key, item.name, pattern) self.logger.info(log) if key in match: match[key][name] = item empty = False if empty: self.logger.warning('no one match with %s', pattern) sys.exit(0) return Interface(**match), names return interface, names
def get_interfaces(*conditions): interfaces = list() response = super(InterfaceOperations, InterfaceOperations).get( constants.OVSDBTables.interface.value, *conditions) for record in response: interfaces.append( Interface( record['name'], admin_state=record['admin_state'], bfd={key: value for key, value in record['bfd'][1]}, bfd_status={ key: value for key, value in record['bfd_status'][1] }, cfm_fault=record['cfm_fault'][1], cfm_fault_status=record['cfm_fault_status'][1], cfm_flap_count=record['cfm_flap_count'][1], cfm_health=record['cfm_health'][1], cfm_mpid=record['cfm_mpid'][1], cfm_remote_mpids=record['cfm_remote_mpids'][1], cfm_remote_opstate=record['cfm_remote_opstate'][1], duplex=record['duplex'][1], error=record['error'][1], external_ids={ key: value for key, value in record['external_ids'][1] }, ifindex=record['ifindex'], ingress_policing_burst=record['ingress_policing_burst'], ingress_policing_rate=record['ingress_policing_rate'], lacp_current=record['lacp_current'][1], link_resets=record['link_resets'], link_speed=record['link_speed'][1], link_state=record['link_state'], lldp={key: value for key, value in record['lldp'][1]}, mac=record['mac'][1], mac_in_use=record['mac_in_use'], mtu=record['mtu'], mtu_request=record['mtu_request'][1], ofport=record['ofport'], ofport_request=record['ofport_request'][1], options={ key: value for key, value in record['options'][1] }, other_config={ key: value for key, value in record['other_config'][1] }, statistics={ key: value for key, value in record['statistics'][1] }, status={key: value for key, value in record['status'][1]}, type=record['type'], uuid=record['_uuid'][1])) return interfaces
def parser(self, xml, xsd, pattern=None): """ Validate xml to match with xsd. Calling parsers to get Model from xml. If provided pattern, filtering Model. :param xml: path to MOBILE_API.xml :param xsd: path to MOBILE_API.xsd :param pattern: regex-pattern from command-line arguments to filter element from initial Model :return: initial Model """ self.logger.info( '''Validating XML and generating model with following parameters: Source xml : %s Source xsd : %s''', xml, xsd) try: schema = XMLSchema(xsd) if not schema.is_valid(xml): raise GenerateError(schema.validate(xml)) interface = Parser().parse(xml) except (InterfaceError, XMLSchemaError, GenerateError) as message1: self.logger.critical('Invalid XML file content: %s, %s', xml, message1) sys.exit(1) enum_names = tuple(interface.enums.keys()) struct_names = tuple(interface.structs.keys()) if pattern: intermediate = OrderedDict() intermediate.update({'params': interface.params}) for kind, content in vars(interface).items(): if kind == 'params': continue for name, item in content.items(): if re.match(pattern, item.name): self.logger.info('%s/%s match with %s', kind, item.name, pattern) if kind in intermediate: intermediate[kind].update({name: item}) else: intermediate.update({kind: {name: item}}) interface = Interface(**intermediate) self.logger.debug({ 'enums': tuple(interface.enums.keys()), 'structs': tuple(interface.structs.keys()), 'functions': tuple( map(lambda i: i.function_id.name, interface.functions.values())), 'params': interface.params }) return enum_names, struct_names, interface
def filter_pattern(interface, pattern): """ Filtering Model to match with regex pattern :param interface: Initial (original) Model, obtained from module 'rpc_spec/InterfaceParser' :param pattern: regex pattern (string) :return: Model with items which match with regex pattern """ enum_names = tuple(interface.enums.keys()) struct_names = tuple(interface.structs.keys()) if pattern: match = {key: OrderedDict() for key in vars(interface).keys()} match['params'] = interface.params for key, value in vars(interface).items(): if key == 'params': continue match[key].update({name: item for name, item in value.items() if re.match(pattern, item.name)}) return Interface(**match), enum_names, struct_names return interface, enum_names, struct_names
def filter_pattern(interface, pattern): """ Filtring model according to regex pattern :param interface: Interface model :param pattern: regex pattern :return: """ match = {i: {} for i in vars(interface).keys()} match['params'] = interface.params if pattern: for key, value in vars(interface).items(): if key == 'params': continue for name, item in value.items(): if re.match(pattern, item.name): if key in match: match[key].update({name: item}) else: return interface return Interface(**match)
def from_tree(cls, ctx: VhdlParser.Port_clauseContext): port_list = cls() interface_port_list = ctx.port_list().interface_port_list() for declaration in interface_port_list.interface_port_declaration(): direction = declaration.signal_mode().getText() data_type = declaration.subtype_indication() data_type = DataType.from_tree(data_type) value = declaration.expression() if value is not None: value = value.getText() for identifier in declaration.identifier_list().identifier(): name = identifier.getText() interface = Interface(name, data_type, value) port = Port(direction, interface) port_list.append(port) return port_list
def test_full_generation(self): """Test full generation using SDLPRC SmartSchema generator. Creates output files which is captured by the mock and compare them with sample files with correct code. This test requires valid test_expected_sdlrpc.h and test_expected_sdlrpc.cc in the same as this module. """ self.maxDiff = None expected_h_file_content = Path(__file__).parents[0].joinpath('test_expected_sdlrpc.h').read_text() expected_cc_file_content = Path(__file__).parents[0].joinpath('test_expected_sdlrpc.cc').read_text() generator = SmartFactorySDLRPC.CodeGenerator() message_type_elements = collections.OrderedDict() message_type_elements[u"request"] = EnumElement(name=u"request") message_type_elements[u"response"] = EnumElement( name=u"response") message_type_elements[u"notification"] = EnumElement( name=u"notification") message_type = Enum(name=u"messageType", elements=message_type_elements) elements1 = collections.OrderedDict() elements1[u"name1"] = EnumElement( name=u"name1", design_description=DESIGN_DESCRIPTION, todos=TODOS, value=u"1") elements1[u"name2"] = EnumElement( name="name2", description=DESCRIPTION, issues=ISSUES, internal_name=u"internal_name2") enum1 = Enum(name=u"Enum1", todos=TODOS, elements=elements1) elements2 = collections.OrderedDict() elements2[u"xxx"] = EnumElement(name=u"xxx", internal_name=u"val_1") elements2[u"yyy"] = EnumElement(name=u"yyy", internal_name=u"val_2", value=u"100") elements2[u"zzz"] = EnumElement(name=u"val_3") enum2 = Enum(name=u"E2", elements=elements2) elements3 = collections.OrderedDict() elements3["1"] = EnumElement(name="xxx", internal_name="_1") elements3["2"] = EnumElement(name="xxx", internal_name="_2") elements3["3"] = EnumElement(name="xxx", internal_name="_3") enum3 = Enum(name="Enum_new2", elements=elements3) elements4 = collections.OrderedDict() elements4["name1"] = EnumElement(name="xxx", internal_name="_11") elements4["name2"] = EnumElement(name="xxx", internal_name="_22") enum4 = Enum(name="Enum_new4", elements=elements4) enums = collections.OrderedDict() enums["Enum1"] = enum1 enums["Enum2"] = enum2 enums["Enum3"] = enum3 enums["Enum4"] = enum4 enums["messageType"] = message_type params1 = collections.OrderedDict() params1["1"] = Param( name="param1", design_description=DESIGN_DESCRIPTION, description=DESCRIPTION, issues=ISSUES, todos=TODOS, param_type=enum4, default_value=elements4["name1"]) params1["2"] = Param( name="param2", param_type=EnumSubset( name="sub1", enum=enum1, allowed_elements={"e1": elements1["name1"]}), default_value=elements1["name1"]) functions = collections.OrderedDict() functions["Function1"] = Function( name="Function1", function_id=elements1["name1"], message_type=message_type_elements["request"], params=params1) functions["Function2"] = Function( name="Function2", function_id=elements2["xxx"], message_type=message_type_elements["response"]) functions["Function3"] = Function( name="Function2", function_id=elements2["yyy"], message_type=message_type_elements["notification"]) members1 = collections.OrderedDict() members1["m1"] = Param(name="intParam", param_type=Integer(max_value=2)) members1["m11"] = Param(name="doubleParam", param_type=Float(min_value=0.333), is_mandatory=False) members1["m222"] = Param(name="boolParam", param_type=Boolean()) members1["m2"] = Param(name="structParam", param_type=Struct(name="Struct2")) members1["aaa"] = Param(name="enumParam", param_type=enum1) members1["bbb"] = Param(name="enumParam1", param_type=enum1) members1["xxx"] = Param( name="enumSubset1", param_type=EnumSubset( name="sub", enum=enum1, allowed_elements={"e1": elements1["name1"]}), is_mandatory=False) members1["1"] = Param( name="arrayOfInt", param_type=Array(min_size=0, max_size=20, element_type=Boolean()), is_mandatory=False) members1["2"] = Param( name="arrayOfEnum1", param_type=Array(min_size=0, max_size=20, element_type=enum1), is_mandatory=False) members1["3"] = Param( name="arrayOfEnum3", param_type=Array(min_size=10, max_size=40, element_type=enum3), is_mandatory=True) members1["4"] = Param( name="arrayOfEnum4", param_type=Array( min_size=10, max_size=41, element_type=EnumSubset( name="sub1", enum=enum1, allowed_elements={"e1": elements1["name1"]}))) members1["5"] = Param( name="arrayOfEnum5", param_type=Array( min_size=10, max_size=42, element_type=EnumSubset( name="sub2", enum=enum1, allowed_elements={"e1": elements1["name2"]}))) members1["6"] = Param( name="arrayOfEnum6", param_type=Array( min_size=10, max_size=43, element_type=EnumSubset( name="sub3", enum=enum4, allowed_elements={"e1": elements4["name2"]}))) structs = collections.OrderedDict() structs["Struct1"] = Struct( name="Struct1", design_description=DESIGN_DESCRIPTION, issues=ISSUES, members=members1) structs["Struct2"] = Struct(name="Struct2", issues=ISSUES) interface = Interface(enums=enums, structs=structs, functions=functions, params={"param1": "value1", "param2": "value2"}) os.path.exists = MagicMock(return_value=True) uuid.uuid1 = MagicMock( return_value=uuid.UUID("12345678123456781234567812345678")) codecs.open = MagicMock() generator.generate(interface=interface, filename="Test.xml", namespace="XXX::YYY::ZZZ", destination_dir="/some/test/dir") os.path.exists.assert_has_calls([call('/some/test/dir')]) open_result = codecs.open mock_calls = open_result.mock_calls self.assertEqual(mock_calls[0], call('/some/test/dir/Test.h', mode='w', encoding='utf-8'), "Invalid header file creation") self.assertEqual(mock_calls[4], call('/some/test/dir/Test_schema.h', mode='w', encoding='utf-8'), "Invalid source file creation") try: self.assertSequenceEqual(str(mock_calls[2])[27:-2].replace("\\n", "\n"), expected_h_file_content, "Invalid header file content") self.assertSequenceEqual(str(mock_calls[6])[27:-2].replace("\\n", "\n"), expected_cc_file_content, "Invalid source file content") except AssertionError as message: print(message)