def versions_compatibility_validating(self): """version of generator script requires the same or lesser version of parser script. if the parser script needs to fix a bug (and becomes, e.g. 1.0.1) and the generator script stays at 1.0.0. As long as the generator script is the same or greater major version, it should be parsable. This requires some level of backward compatibility. E.g. they have to be the same major version. """ regex = r'(\d+\.\d+).(\d)' parser_origin = Parser().get_version parser_split = re.findall(regex, parser_origin).pop() generator_split = re.findall(regex, self.get_version).pop() parser_major = float(parser_split[0]) generator_major = float(generator_split[0]) if parser_major > generator_major: self.logger.critical( 'Generator (%s) requires the same or lesser version of Parser (%s)', self.get_version, parser_origin) sys.exit(1) self.logger.info('Parser type: %s, version %s,\tGenerator version %s', basename(getfile(Parser().__class__)), parser_origin, self.get_version)
def main(source_xml='../MOBILE_API.xml'): parser = Parser() version = parser.get_version print(version) try: interface = parser.parse(source_xml) print(vars(interface)) return interface except ParseError as error: print(error)
def main(self): """ Main functions calls """ args = self.get_parser() self.config_logging(args.verbose) try: interface = Parser().parse(args.source_xml, args.source_xsd) except (ModelParseError, XmlParseError) as error1: self.logger.error(error1) sys.exit(1) filtered = self.filter_pattern(interface, args.regex_pattern) if not args.enums: del filtered['enums'] if not args.structs: del filtered['structs'] if not args.functions: del filtered['functions'] if args.output_directory.is_file(): if args.skip: self.logger.info('Skipping %s', args.output_directory.as_posix()) return if args.overwrite: self.logger.info('Overriding %s', args.output_directory.as_posix()) self.process(args.output_directory, filtered) else: while True: try: confirm = input( 'File already exists {}. Overwrite? Y/Enter = yes, N = no\n' .format(args.output_directory.as_posix())) if confirm.lower() == 'y' or not confirm: self.logger.info('Overriding %s', args.output_directory.as_posix()) self.process(args.output_directory, filtered) break if confirm.lower() == 'n': self.logger.info('Skipping %s', args.output_directory.as_posix()) break except KeyboardInterrupt: self.logger.info( '\nThe user interrupted the execution of the program' ) sys.exit(1) else: self.logger.info('Writing new %s', args.output_directory.as_posix()) self.process(args.output_directory, filtered)
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 main(self): """ Entry point for parser and generator :return: None """ args = self.get_parser() self.config_logging(args.verbose) self.logger.debug('parsed arguments:\n%s', pformat((vars(args)))) self.env = args.templates_directory self.versions_compatibility_validating() paths = self.get_paths() try: interface = Parser().parse(args.source_xml, args.source_xsd) except ParseError as error1: self.logger.error(error1) sys.exit(1) filtered, names = self.filter_pattern(interface, args.regex_pattern) key_words = self.get_key_words() mappings = self.get_mappings() functions_transformer = FunctionsProducer(paths, names, mappings, key_words) if args.enums and filtered.enums: directory = args.output_directory.joinpath( self.evaluate_instance_directory(paths.enums_dir_name)) self.process(directory, args.skip, args.overwrite, filtered.enums, EnumsProducer(paths, mappings, key_words)) if args.structs and filtered.structs: directory = args.output_directory.joinpath( self.evaluate_instance_directory(paths.structs_dir_name)) self.process(directory, args.skip, args.overwrite, filtered.structs, StructsProducer(paths, names, mappings, key_words)) if args.functions and filtered.functions: directory = args.output_directory.joinpath( self.evaluate_instance_directory(paths.functions_dir_name)) self.process(directory, args.skip, args.overwrite, filtered.functions, functions_transformer) self.process_function_name( args.output_directory.joinpath(paths.rpc_creator), paths.functions_dir_name, args.skip, args.overwrite, interface.functions, functions_transformer, mappings.get('functions', OrderedDict()))
async def parser(self, source_xml, source_xsd): """ Getting Model from source_xml, parsed and validated by module 'rpc_spec/InterfaceParser' :param source_xml: path to xml file :param source_xsd: path to xsd file :return: Model, obtained from module 'rpc_spec/InterfaceParser' """ try: start = datetime.now() model = self.loop.run_in_executor(None, Parser().parse, source_xml, source_xsd) model = await model self.logger.debug('finish getting model in %s milisec,', (datetime.now() - start).microseconds / 1000.0) return model except ParseError as error1: self.logger.error(error1) sys.exit(1)
def setUp(self): """Test initialization.""" valid_xml_name = Path(__file__).parents[0].joinpath( 'valid_SDLRPCV2.xml').as_posix() self.interface = Parser().parse(valid_xml_name) self.assertIsNotNone(self.interface)