def __init__(self, device_path, device_type): ''' Initial constructor. :param device_path: file descriptor device path. :type device_path: <str> :param device_type: file descriptor device type. :type device_type: <int> :param verbose: enable/disable verbose option. :type verbose: <bool> :exceptions: ATSTypeError | ATSBadCallError ''' checker, error, status = ATSChecker(), None, False error, status = checker.check_params([ ('str:device_path', device_path), ('int:device_type', device_type) ]) if status == ATSChecker.TYPE_ERROR: raise ATSTypeError(error) if status == ATSChecker.VALUE_ERROR: raise ATSBadCallError(error) supported_device_types = [ FileDescriptor.STDIN, FileDescriptor.STDOUT, FileDescriptor.STDERR ] if device_type in supported_device_types: self.__device_path = device_path self.__device_type = device_type self.__device_file = None else: error = 'file descriptor type can be <STDIN | STDOUT | STDERR>' error_message(FileDescriptor.PKG_VERBOSE, error)
def check_module(self, module, verbose=False): ''' Check project module. :param module: module name. :type module: <str> :param verbose: enable/disable verbose option. :type verbose: <bool> :return: 'build' | 'source'| None (wrong module name). :rtype: <str> | <NoneType> :exceptions: ATSTypeError | ATSBadCallError ''' checker, error, status = ATSChecker(), None, False error, status = checker.check_params([('str:module', module)]) if status == ATSChecker.TYPE_ERROR: raise ATSTypeError(error) if status == ATSChecker.VALUE_ERROR: raise ATSBadCallError(error) is_source, is_build, module_type = False, False, None is_source = ModuleType.is_source_module(module) is_build = ModuleType.is_build_module(module) if is_source and not is_build: module_type = 'source' if not is_source and is_build: module_type = 'build' verbose_message(WriteTemplate.GEN_VERBOSE, verbose, 'module type', module_type) return module_type
def center(self, columns, additional_shifter, text, verbose=False): ''' Center console line. :param columns: colums for open console session. :type columns: <int> :param additional_shifter: additional shifters. :type additional_shifter: <int> :param text: text for console session. :type text: <str> :param verbose: enable/disable verbose option. :type verbose: <bool> :exceptions: ATSTypeError | ATSBadCallError ''' checker, error, status = ATSChecker(), None, False error, status = checker.check_params([('int:columns', columns), ('int:additional_shifter', additional_shifter), ('str:text', text)]) if status == ATSChecker.TYPE_ERROR: raise ATSTypeError(error) if status == ATSChecker.VALUE_ERROR: raise ATSBadCallError(error) verbose_message(Splash.VERBOSE, self.__verbose or verbose, columns, additional_shifter, text) start_position = (columns / 2) - 21 number_of_tabs = int((start_position / 8) - 1 + additional_shifter) print('{0}{1}'.format('\011' * number_of_tabs, text))
def read(self, config, verbose=False): ''' Read a templates and return a content. :param config: parameter file name. :type config: <dict> :param verbose: enable/disable verbose option. :type verbose: <bool> :return: template content list | empty list. :rtype: <list> :exceptions: ATSTypeError | ATSBadCallError ''' checker, error, status = ATSChecker(), None, False error, status = checker.check_params([('dict:config', config)]) if status == ATSChecker.TYPE_ERROR: raise ATSTypeError(error) if status == ATSChecker.VALUE_ERROR: raise ATSBadCallError(error) templates = config[ProConfig.TEMPLATES] modules = config[ProConfig.MODULES] loaded_templates = [] for template_file, module_file in zip(templates, modules): template_content, template_file_path = None, None template_file_path = '{0}{1}'.format(self.template_dir, template_file) self.check_path(file_path=template_file_path, verbose=verbose) self.check_mode(file_mode='r', verbose=verbose) self.check_format(file_path=template_file_path, file_format=ProConfig.FORMAT, verbose=verbose) if self.is_file_ok(): with open(template_file_path, 'r') as template_module: template_content = template_module.read() loaded_templates.append({module_file: template_content}) return loaded_templates
def read(self, template_module, verbose=False): ''' Read template structure. :param template_module: template module name. :type template_module: <str> :param verbose: enable/disable verbose option. :type verbose: <bool> :return: template content for setup module | None. :rtype: <str> | <NoneType> :exceptions: ATSTypeError | ATSBadCallError ''' checker, error, status = ATSChecker(), None, False error, status = checker.check_params([('str:template_module', template_module)]) if status == ATSChecker.TYPE_ERROR: raise ATSTypeError(error) if status == ATSChecker.VALUE_ERROR: raise ATSBadCallError(error) setup_content, template_file = None, None verbose_message(ReadTemplate.GEN_VERBOSE, verbose, 'load template') template_file = '{0}{1}'.format(self.__template_dir, template_module) self.check_path(template_file, verbose=verbose) self.check_mode('r', verbose=verbose) self.check_format(template_file, 'template', verbose=verbose) if self.is_file_ok(): with open(template_file, 'r') as setup_template: setup_content = setup_template.read() return setup_content
def __init__(self, project_name, verbose=False): ''' Initial constructor. :param project_name: project name. :type project_name: <str> :param verbose: enable/disable verbose option. :type verbose: <bool> :exceptions: None ''' checker, error, status = ATSChecker(), None, False error, status = checker.check_params([('str:project_name', project_name)]) if status == ATSChecker.TYPE_ERROR: raise ATSTypeError(error) if status == ATSChecker.VALUE_ERROR: raise ATSBadCallError(error) FileChecking.__init__(self, verbose=verbose) ProConfig.__init__(self, verbose=verbose) ProName.__init__(self, verbose=verbose) verbose_message(STM8Setup.GEN_VERBOSE, verbose, 'init generator') self.__reader = ReadTemplate(verbose=verbose) self.__writer = WriteTemplate(verbose=verbose) project_structure = '{0}{1}'.format(dirname(realpath(__file__)), STM8Setup.PRO_STRUCTURE) self.check_path(file_path=project_structure, verbose=verbose) self.check_mode(file_mode='r', verbose=verbose) self.check_format(file_path=project_structure, file_format='yaml', verbose=verbose) if self.is_file_ok(): yml2obj = Yaml2Object(project_structure) self.config = yml2obj.read_configuration() self.pro_name = project_name
def usage(self, operation, verbose=False): ''' Create daemon process. :param operation: daemon operation. :type operation: <str> :param verbose: enable/disable verbose option. :type verbose: <bool> :exceptions: ATSTypeError | ATSBadCallError ''' checker, error, status = ATSChecker(), None, False error, status = checker.check_params([('str:operation', operation)]) if status == ATSChecker.TYPE_ERROR: raise ATSTypeError(error) if status == ATSChecker.VALUE_ERROR: raise ATSBadCallError(error) verbose_message(Daemon.PKG_VERBOSE, verbose, 'daemon operation', operation) if self.unix_status: self.__daemon_usage.check(operation, verbose=verbose) if self.__daemon_usage.usage_status == 127: sys.exit(127) elif self.__daemon_usage.usage_status == 0: self.start(verbose=verbose) elif self.__daemon_usage.usage_status == 1: self.stop(verbose=verbose) elif self.__daemon_usage.usage_status == 2: self.restart(verbose=verbose) else: error_message(Daemon.PKG_VERBOSE, 'wrong option code') sys.exit(128)
def __init__(self, file_process_id_path, file_process_id_mode): ''' Initial constructor. :param file_process_id_path: file process id path. :type file_process_id_path: <str> :param file_process_id_mode: file process id mode. :type file_process_id_mode: <str> :exceptions: ATSTypeError | ATSBadCallError ''' checker, error, status = ATSChecker(), None, False error, status = checker.check_params([ ('str:file_process_id_path', file_process_id_path), ('str:file_process_id_mode', file_process_id_mode) ]) if status == ATSChecker.TYPE_ERROR: raise ATSTypeError(error) if status == ATSChecker.VALUE_ERROR: raise ATSBadCallError(error) if file_process_id_mode in FileProcessId.MODE: self.__file_process_id_path = file_process_id_path self.__file_process_id_mode = file_process_id_mode self.__file_process_id = None else: error = 'PID file mode can be <w+ | r>' error_message(FileProcessId.PKG_VERBOSE, error)
def __init__(self, informations_file, verbose=False): ''' Initial constructor. :param informations_file: informations file path. :type informations_file: <str> :param verbose: enable/disable verbose option. :type verbose: <bool> :exceptions: ATSTypeError | ATSBadCallError ''' checker, error, status = ATSChecker(), None, False error, status = checker.check_params([('str:informations_file', informations_file)]) if status == ATSChecker.TYPE_ERROR: raise ATSTypeError(error) if status == ATSChecker.VALUE_ERROR: raise ATSBadCallError(error) self.__verbose = verbose informations = None self.tool_operational = False self.yaml2obj = Yaml2Object(informations_file, verbose=verbose) self.obj2yaml = Object2Yaml(informations_file, verbose=verbose) if all([self.yaml2obj, self.obj2yaml]): informations = self.yaml2obj.read_configuration(verbose=verbose) if informations: info = ATSInfo(informations, verbose=verbose) if info.ats_info_ok: self.option_parser = ATSOptionParser('{0} {1}'.format( info.name, info.build_date), info.version, info.licence, verbose=verbose) self.tool_operational = True verbose_message(YamlBase.VERBOSE, verbose, 'loaded ATS YAML base info')
def gen_project(self, project_name, verbose=False): ''' Generate project_structure structure. :param project_name: parameter tool name. :type project_name: <str> :param verbose: enable/disable verbose option. :type verbose: <bool> :return: boolean status, True (success) | False. :rtype: <bool> :exceptions: None ''' checker, error, status = ATSChecker(), None, False error, status = checker.check_params([ ('str:project_name', project_name) ]) if status == ATSChecker.TYPE_ERROR: raise ATSTypeError(error) if status == ATSChecker.VALUE_ERROR: raise ATSBadCallError(error) status = False if bool(self.config): templates = self.__reader.read(self.config, verbose=verbose) if bool(templates): status = self.__writer.write( templates, project_name, verbose=verbose ) return status
def __ioctl_get_window_size(self, file_descriptor, verbose=False): ''' Check window size for descriptor. :param file_descriptor: file descriptor. :type file_descriptor: <int> :param verbose: enable/disable verbose option. :type verbose: <bool> :return: window size of terminal. :rtype: <tupple> :exceptions: ATSTypeError | ATSBadCallError ''' checker, error, status = ATSChecker(), None, False error, status = checker.check_params([('int:file_descriptor', file_descriptor)]) if status == ATSChecker.TYPE_ERROR: raise ATSTypeError(error) if status == ATSChecker.VALUE_ERROR: raise ATSBadCallError(error) try: self.__window_size = unpack( 'hh', ioctl(file_descriptor, TIOCGWINSZ, '1234')) except: pass verbose_message(TerminalProperties.VERBOSE, self.__verbose or verbose, 'terminal window size', self.__window_size) return self.__window_size
def gen_setup(self, pro_name, verbose=False): ''' Generate module generator_test.py. :param pro_name: project name. :type pro_name: <str> :param verbose: enable/disable verbose option. :type verbose: <bool> :return: boolean status, True (success) | False. :rtype: <bool> :exceptions: ATSTypeError | ATSBadCallError ''' checker, error, status = ATSChecker(), None, False error, status = checker.check_params([('str:pro_name', pro_name)]) if status == ATSChecker.TYPE_ERROR: raise ATSTypeError(error) if status == ATSChecker.VALUE_ERROR: raise ATSBadCallError(error) status = False verbose_message(MessageQueue.GEN_VERBOSE, verbose, 'prepare setup for', pro_name) if bool(self.config): mq_type = self.select_pro_type(verbose=verbose) if mq_type != 'cancel': templates = self.__reader.read(self.config, mq_type, verbose=verbose) if bool(templates): status = self.__writer.write(templates, pro_name, verbose=verbose) else: status = True return status
def gen_module(self, module_name, verbose=False): ''' Generate file python module. :param module_name: parameter module name. :type module_name: <str> :param verbose: enable/disable verbose option. :type verbose: <bool> :return: boolean status, True (success) | False. :rtype: <bool> :exceptions: ATSTypeError | ATSBadCallError ''' checker, error, status = ATSChecker(), None, False error, status = checker.check_params([('str:module_name', module_name) ]) if status == ATSChecker.TYPE_ERROR: raise ATSTypeError(error) if status == ATSChecker.VALUE_ERROR: raise ATSBadCallError(error) verbose_message(GenModule.GEN_VERBOSE, verbose, 'generating module', module_name) template_name = ModuleSelector.choose_module(self.__config, verbose=verbose) if template_name != 'cancel': module_content = self.__reader.read(template_name, verbose=verbose) if module_content: status = self.__writer.write(module_content, module_name, verbose=verbose) elif template_name == 'cancel': status = True return status
def read(self, template_file, verbose=False): ''' Read template file. :param template_file: template file path. :type template_file: <str> :param verbose: enable/disable verbose option. :type verbose: <bool> :return: template content for module | None. :rtype: <str> | <NoneType> :exceptions: ATSTypeError | ATSBadCallError ''' checker, error, status = ATSChecker(), None, False error, status = checker.check_params([('str:template_file', template_file)]) if status == ATSChecker.TYPE_ERROR: raise ATSTypeError(error) if status == ATSChecker.VALUE_ERROR: raise ATSBadCallError(error) setup_content = None self.check_path(file_path=template_file, verbose=verbose) self.check_mode(file_mode='r', verbose=verbose) self.check_format(file_path=template_file, file_format=ReadTemplate.FORMAT, verbose=verbose) if self.is_file_ok(): verbose_message(ReadTemplate.GEN_VERBOSE, verbose, 'load template') with open(template_file, 'r') as template: if bool(template): setup_content = template.read() return setup_content
def gen_module(self, module_name, verbose=False): ''' Generate kernel module. :param module_name: parameter package name. :type module_name: <str> :param verbose: enable/disable verbose option. :type verbose: <bool> :return: True (success) | False :rtype: <bool> :exceptions: ATSTypeError | ATSBadCallError ''' checker, error, status = ATSChecker(), None, False error, status = checker.check_params([('str:module_name', module_name) ]) if status == ATSChecker.TYPE_ERROR: raise ATSTypeError(error) if status == ATSChecker.VALUE_ERROR: raise ATSBadCallError(error) self.pro_name, status = module_name, False module_type, module_id = self.choose_module(verbose=verbose) if module_id != GenLKM.CANCEL: templates, status = self.__reader.read(module_type, module_name, verbose=verbose) if all([bool(templates), status]): status = self.__writer.write(templates, module_name, verbose=verbose) else: status = True return status
def check_config_keys(cls, config, verbose=False): ''' Checking configuration keys. :param config: dictionary with configuration. :type config: <dict> :param verbose: enable/disable verbose option. :type verbose: <bool> :return: boolean status, True (all ok) | False. :rtype: <bool> :exceptions: ATSTypeError | ATSBadCallError ''' checker, error, status = ATSChecker(), None, False error, status = checker.check_params([('dict:config', config)]) if status == ATSChecker.TYPE_ERROR: raise ATSTypeError(error) if status == ATSChecker.VALUE_ERROR: raise ATSBadCallError(error) status, expected_keys, statuses = False, [ cls.TYPE_KEY, cls.SCHEMA_KEY, cls.ELEMENT_KEY, cls.TEMPLATE_KEY ], [] for config_key in config.keys(): if config_key in expected_keys: statuses.append(True) else: statuses.append(False) if all(statuses): status = True return status
def __init__(self, template_file, verbose=False): ''' Initial constructor. :param template_file: template file. :type template_file: <str> :param verbose: enable/disable verbose option. :type verbose: <bool> :exceptions: ATSTypeError | ATSBadCallError ''' checker, error, status = ATSChecker(), None, False error, status = checker.check_params([('str:template_file', template_file)]) if status == ATSChecker.TYPE_ERROR: raise ATSTypeError(error) if status == ATSChecker.VALUE_ERROR: raise ATSBadCallError(error) FileChecking.__init__(self, verbose=verbose) TemplateContainer.__init__(self, verbose=verbose) verbose_message(TemplateLoader.GEN_VERBOSE, verbose, 'init template loader') template_path = '{0}{1}{2}'.format(dirname(realpath(__file__)), TemplateLoader.CONF_DIR, template_file) self.check_path(file_path=template_path, verbose=verbose) self.check_mode(file_mode='r', verbose=verbose) self.check_format(file_path=template_path, file_format='yaml', verbose=verbose) if self.is_file_ok(): yml2obj = Yaml2Object(template_path) self.template = yml2obj.read_configuration(verbose=verbose)
def read(self, template_modules, verbose=False): ''' Read template structure. :param template_modules: template module name. :type template_modules: <str> :param verbose: enable/disable verbose option. :type verbose: <bool> :return: template content for setup module | None. :rtype: <str> | <NoneType> :exceptions: ATSTypeError | ATSBadCallError ''' checker, error, status = ATSChecker(), None, False error, status = checker.check_params([('str:template_modules', template_modules)]) if status == ATSChecker.TYPE_ERROR: raise ATSTypeError(error) if status == ATSChecker.VALUE_ERROR: raise ATSBadCallError(error) setup_content, template_file = [], None verbose_message(ReadTemplate.GEN_VERBOSE, verbose, 'load templates') template_file = '{0}{1}'.format(self.__template_dir, template_modules) self.check_path(template_file, verbose=verbose) self.check_mode('r', verbose=verbose) self.check_format(template_file, 'yaml', verbose=verbose) if self.is_file_ok(): yml2obj = Yaml2Object(template_file) configuration = yml2obj.read_configuration() templates = configuration['templates'] modules = configuration['modules'] for template, module in zip(templates, modules): template_path = '{0}{1}'.format(self.__template_dir, template) with open(template_path, 'r') as setup_template: setup_content.append({module: setup_template.read()}) return setup_content
def read(self, template_name, verbose=False): ''' Read a template and return a content or None. :param template_name: template file name. :type template_name: <str> :param verbose: enable/disable verbose option. :type verbose: <bool> :return: template module content | None. :rtype: <str> | <NoneType> :exceptions: ATSTypeError | ATSBadCallError ''' checker, error, status = ATSChecker(), None, False error, status = checker.check_params([('str:template_name', template_name)]) if status == ATSChecker.TYPE_ERROR: raise ATSTypeError(error) if status == ATSChecker.VALUE_ERROR: raise ATSBadCallError(error) module_content, status, file_path = None, False, None file_path = '{0}{1}'.format(self.__template_dir, template_name) self.check_path(file_path, verbose=verbose) self.check_mode('r', verbose=verbose) self.check_format(file_path, 'template', verbose=verbose) if self.is_file_ok(): with open(file_path, 'r') as template_file: module_content = template_file.read() return module_content
def __init__(self, pro_property, template, schema, verbose=False): ''' Initial constructor. :param pro_property: project property. :type pro_property: <dict> :param template: project tool/generator template. :type template: <dict> :param schema: project tool/generator schema. :type schema: <dict> :param verbose: enable/disable verbose option. :type verbose: <bool> :exceptions: ATSTypeError | ATSBadCallError ''' checker, error, status = ATSChecker(), None, False error, status = checker.check_params([('dict:pro_property', pro_property), ('dict:template', template), ('dict:schema', schema)]) if status == ATSChecker.TYPE_ERROR: raise ATSTypeError(error) if status == ATSChecker.VALUE_ERROR: raise ATSBadCallError(error) ProCollectiner.__init__(self) self.pro_name = pro_property['name'] self.pro_type = pro_property['type'] self.template = template self.schema = schema verbose_message(PrepareGen.GEN_VERBOSE, verbose, 'init prepare generator')
def check(self, daemon_operation, verbose=False): ''' Checking usage of Daemon process. :param daemon_operation: daemon operation. :type daemon_operation: <str> :param verbose: enable/disable verbose option. :type verbose: <bool> :exceptions: ATSTypeError | ATSBadCallError ''' checker, error, status = ATSChecker(), None, False error, status = checker.check_params([('str:daemon_operation', daemon_operation)]) if status == ATSChecker.TYPE_ERROR: raise ATSTypeError(error) if status == ATSChecker.VALUE_ERROR: raise ATSBadCallError(error) verbose_message(DaemonUsage.PKG_VERBOSE, verbose, 'checking usage') for index, option in enumerate(DaemonUsage.DAEMON_OPERATIONS): if option == daemon_operation: self.__usage_status = index if daemon_operation not in DaemonUsage.DAEMON_OPERATIONS: self.__usage_status = 127 error_message( DaemonUsage.PKG_VERBOSE, 'usage: {0}'.format('|'.join(DaemonUsage.DAEMON_OPERATIONS))) verbose_message(DaemonUsage.PKG_VERBOSE, verbose, 'usage status', self.__usage_status)
def gen_setup(self, pro_name, verbose=False): ''' Generate module generator_test.py. :param pro_name: project name. :type pro_name: <str> :param verbose: enable/disable verbose option. :type verbose: <bool> :return: boolean status, True (success) | False. :rtype: <bool> :exceptions: ATSTypeError | ATSBadCallError ''' checker, error, status = ATSChecker(), None, False error, status = checker.check_params([ ('str:pro_name', pro_name) ]) if status == ATSChecker.TYPE_ERROR: raise ATSTypeError(error) if status == ATSChecker.VALUE_ERROR: raise ATSBadCallError(error) status, setup_content = False, None verbose_message( GenReadmeModule.GEN_VERBOSE, verbose, 'generating module', pro_name ) template_file = self.select_pro_type(verbose=verbose) module = self.__config['module'] if bool(template_file): setup_content = self.__reader.read( template_file, verbose=verbose ) if setup_content: status = self.__writer.write( setup_content, pro_name, module, verbose=verbose ) return status
def __init__(self, pid_file_path, verbose=False): ''' Initial constructor. :param pid_file_path: PID file path. :type pid_file_path: <str> :param verbose: enable/disable verbose option. :type verbose: <bool> :exceptions: ATSTypeError | ATSBadCallError ''' checker, error, status = ATSChecker(), None, False error, status = checker.check_params([('str:pid_file_path', pid_file_path)]) if status == ATSChecker.TYPE_ERROR: raise ATSTypeError(error) if status == ATSChecker.VALUE_ERROR: raise ATSBadCallError(error) UnixOperations.__init__(self) verbose_message(Daemon.PKG_VERBOSE, verbose, 'init daemon process') if self.unix_status: self.__daemon_usage = DaemonUsage() self.__pid_file_path = pid_file_path else: self.__daemon_usage = None self.__pid_file_path = None
def __init__(self, version, epilog, description, verbose=False): ''' Initial constructor. :param version: ATS version and build date. :type version: <str> :param epilog: ATS long description. :type epilog: <str> :param description: ATS author and license. :type description: <str> :param verbose: enable/disable verbose option. :type verbose: <bool> :exceptions: ATSTypeError | ATSBadCallError ''' checker, error, status = ATSChecker(), None, False error, status = checker.check_params([('str:version', version), ('str:epilog', epilog), ('str:description', description) ]) if status == ATSChecker.TYPE_ERROR: raise ATSTypeError(error) if status == ATSChecker.VALUE_ERROR: raise ATSBadCallError(error) self.__verbose = verbose self.__opt_parser = ArgumentParser(version, epilog, description) verbose_message(ATSOptionParser.VERBOSE, self.__verbose or verbose, version, epilog, description)
def verbose_message(verbose_path, verbose=False, *message): ''' Show verbose message. :param verbose_path: verbose prefix message. :type verbose_path: <str> :param verbose: enable/disable verbose option. :type verbose: <bool> :param message: message parts. :type message: <tuple> :exceptions: ATSTypeError | ATSBadCallError ''' if verbose: checker, error, status = ATSChecker(), None, False error, status = checker.check_params([('str:verbose_path', verbose_path), ('tuple:message', message)]) if status == ATSChecker.TYPE_ERROR: raise ATSTypeError(error) if status == ATSChecker.VALUE_ERROR: raise ATSBadCallError(error) message, ver = tuple([str(item) for item in message]), ATSVerbose() ver.message = ' '.join(message) verbose_message_log = '[{0}] {1}'.format(verbose_path.lower(), ver.message) print(verbose_message_log)
def __init__(self, pro_property, schema, template, element, verbose=False): ''' Initial constructor. :param pro_property: project property. :type pro_property: <dict> :param schema: project tool/generator schema. :type schema: <dict> :param template: project tool/generator template. :type template: <dict> :param element: project tool/generator element. :type element: <dict> :param verbose: enable/disable verbose option. :type verbose: <bool> :exceptions: ATSTypeError | ATSBadCallError ''' checker, error, status = ATSChecker(), None, False error, status = checker.check_params([ ('dict:pro_property', pro_property), ('dict:schema', schema), ('dict:template', template), ('dict:element', element), ]) if status == ATSChecker.TYPE_ERROR: raise ATSTypeError(error) if status == ATSChecker.VALUE_ERROR: raise ATSBadCallError(error) self.prepare_tool = PrepareTool( pro_property, template, schema, verbose=verbose ) self.deploy_tool = DeployTool(element, schema, verbose=verbose) verbose_message(ToolFactory.GEN_VERBOSE, verbose, 'init prepare tool')
def write(self, templates, project_name, verbose=False): ''' Write setup content to file. :param templates: project templates. :type templates: <list> :param project_name: project name. :type project_name: <str> :param verbose: enable/disable verbose option. :type verbose: <bool> :return: boolean status, True (success) | False. :rtype: <bool> :exception: ATSBadCallError | ATSTypeError ''' checker, error, status = ATSChecker(), None, False error, status = checker.check_params([('list:templates', templates), ('str:project_name', project_name)]) if status == ATSChecker.TYPE_ERROR: raise ATSTypeError(error) if status == ATSChecker.VALUE_ERROR: raise ATSBadCallError(error) pro_dir, statuses = '{0}/{1}'.format(getcwd(), project_name), [] build_dir = '{0}/{1}'.format(pro_dir, 'build') project, status = {'PRO': '{0}'.format(project_name)}, False expected_num_of_modules = len(templates) if not exists(pro_dir): mkdir(pro_dir) mkdir(build_dir) for pro_item in templates: module_name = pro_item.keys()[0] if 'makefile'.capitalize() in module_name: module_path = '{0}/{1}'.format(build_dir, module_name) else: module_path = '{0}/{1}'.format(pro_dir, module_name) template = Template(pro_item[module_name]) if bool(template): with open(module_path, 'w') as module_file: module_content = template.substitute( {'PRO': '{0}'.format(project_name)}) module_file.write(module_content) chmod(module_path, 0o666) self.check_path(module_path, verbose=verbose) self.check_mode('w', verbose=verbose) if 'makefile'.capitalize() in module_path: self.check_format(module_path, 'makefile', verbose=verbose) else: self.check_format(module_path, module_path.split('.')[1], verbose=verbose) if self.is_file_ok(): statuses.append(True) else: statuses.append(False) if all(statuses) and len(statuses) == expected_num_of_modules: status = True return status
def write(self, project_data, verbose=False): ''' Write a template content to a project module. :param project_data: project data. :type project_data: <dict> :param verbose: enable/disable verbose option. :type verbose: <bool> :return: boolean status, True (success) | False. :rtype: <bool> :exception: ATSTypeError | ATSBadCallError ''' checker, error, status = ATSChecker(), None, False error, status = checker.check_params([('dict:project_data', project_data)]) if status == ATSChecker.TYPE_ERROR: raise ATSTypeError(error) if status == ATSChecker.VALUE_ERROR: raise ATSBadCallError(error) status = False module_type = self.check_module(project_data['module']) if bool(module_type): project = { 'PRO': '{0}'.format(project_data['name']), 'MCU': '{0}'.format(project_data['mcu']), 'OSC': '{0}'.format(project_data['osc']) } template = Template(project_data['template']) if template: module = None if module_type == 'source': module = '{0}/{1}'.format(self.__pro_dir, project_data['module']) if module_type == 'build': module = '{0}/{1}/{2}'.format(self.__pro_dir, 'build', project_data['module']) if module: with open(module, 'w') as module_file: if bool(module_file): verbose_message(WriteTemplate.GEN_VERBOSE, verbose, 'write project module file', module) module_file.write(template.substitute(project)) chmod(module, 0o666) file_extension = None if '.' in module: file_extension = module.split('.')[1] self.check_format(module, file_extension, verbose=verbose) self.check_path(module, verbose=verbose) self.check_mode('w', verbose=verbose) if self.is_file_ok(): status = True else: file_extension = module status = True return status
def write(self, element, modules, verbose=False): ''' Write templates content with parameters to modules. :param element: processes element. :type element: <dict> :param modules: modules for tool/generator. :type modules: <list> :param verbose: enable/disable verbose option. :type verbose: <bool> :return: boolean status, True (success) | False. :rtype: <bool> :exceptions: ATSTypeError | ATSBadCallError ''' checker, error, status = ATSChecker(), None, False error, status = checker.check_params([('dict:element', element), ('list:modules', modules)]) if status == ATSChecker.TYPE_ERROR: raise ATSTypeError(error) if status == ATSChecker.VALUE_ERROR: raise ATSBadCallError(error) status, statuses, expected_num_modules = False, [], len(modules[1:]) for template_content in modules[1:]: template = Template(template_content[0]) module_content = template.substitute({ ElementKeys.TOOL_NAME_KEY: '{0}'.format(element[ElementKeys.ROOT_KEY][0][ ElementKeys.TOOL_NAME_KEY]), ElementKeys.TOOL_UPPER_KEY: '{0}'.format(element[ElementKeys.ROOT_KEY][1][ ElementKeys.TOOL_UPPER_KEY]), ElementKeys.TOOL_CLASS_KEY: '{0}'.format(element[ElementKeys.ROOT_KEY][2][ ElementKeys.TOOL_CLASS_KEY]), ElementKeys.TOOL_YEAR_KEY: '{0}'.format(element[ElementKeys.ROOT_KEY][3][ ElementKeys.TOOL_YEAR_KEY]) }) module_path = '{0}/{1}'.format(getcwd(), template_content[1]) module_extension = module_path.split('.')[1] with open(module_path, 'w') as module_file: module_file.write(module_content) chmod(module_path, 0o666) self.check_path(file_path=module_path, verbose=verbose) self.check_mode(file_mode='w', verbose=verbose) self.check_format(file_path=module_path, file_format=module_extension, verbose=verbose) if self.is_file_ok(): statuses.append(True) else: statuses.append(False) if all([statuses, len(statuses) == expected_num_modules]): status = True else: error_message(WriteTemplate.GEN_VERBOSE, 'failed to generate all modules') return status
def write(self, templates, project_name, verbose=False): ''' Write a templates with parameters. :param templates: parameter templates. :type templates: <list> :param project_name: parameter project name. :type project_name: <str> :param verbose: enable/disable verbose option. :type verbose: <bool> :return: boolean status, True (success) | False. :rtype: <bool> :exceptions: ATSTypeError | ATSBadCallError ''' checker, error, status = ATSChecker(), None, False error, status = checker.check_params([ ('list:templates', templates), ('str:project_name', project_name) ]) if status == ATSChecker.TYPE_ERROR: raise ATSTypeError(error) if status == ATSChecker.VALUE_ERROR: raise ATSBadCallError(error) statuses = [] pro_dir = '{0}/{1}/'.format(getcwd(), project_name) status, expected_num_of_modules = False, len(templates) if not exists(pro_dir): mkdir(pro_dir) for template_content in templates: module_name = template_content.keys()[0] template = Template(template_content[module_name]) module_path = '{0}{1}'.format(pro_dir, module_name) module_dict = { 'PRO': '{0}'.format(project_name), 'YEAR': '{0}'.format(date.today().year) } with open(module_path, 'w') as module_file: module_content = template.substitute(module_dict) module_file.write(module_content) chmod(module_path, 0o666) self.check_path(module_path, verbose=verbose) self.check_mode('w', verbose=verbose) if 'makefile'.capitalize() in module_path: self.check_format( module_path, 'makefile', verbose=verbose ) else: self.check_format( module_path, module_path.split('.')[1], verbose=verbose ) if self.is_file_ok(): statuses.append(True) else: statuses.append(False) if all(statuses) and len(statuses) == expected_num_of_modules: status = True return status