def check_format(self, file_path, file_format, verbose=False): ''' Check file format by extension. :param file_path: file path. :type file_path: <str> :param file_format: file format (file extension). :type file_format: <str> :param verbose: enable/disable verbose option. :type verbose: <bool> :exceptions: None ''' if file_format != 'makefile': file_name_path, extension = splitext(file_path) extension = extension.replace('.', '') if extension == '': extension = file_format else: if file_format.capitalize() in file_path: extension = 'makefile' else: extension = 'wrong_format' if not extension == file_format or extension == 'wrong_format': error_message( FileChecking.VERBOSE, '{0} [{1}] {2}'.format('not matched file extension', file_format, file_path)) self.__file_format_ok = False else: self.__file_format_ok = True verbose_message(FileChecking.VERBOSE, self.__verbose or verbose, file_path)
def __init__(self, verbose=False): ''' Initial constructor. :param verbose: enable/disable verbose option. :type verbose: <bool> :exceptions: ATSTypeError | ATSBadCallError ''' FileChecking.__init__(self, verbose=verbose) ProConfig.__init__(self, verbose=verbose) ProName.__init__(self, verbose=verbose) verbose_message(GenPro.GEN_VERBOSE, verbose, 'init generator') self.__reader = ReadTemplate(verbose=verbose) self.__writer = WriteTemplate(verbose=verbose) project_structure = '{0}{1}'.format( dirname(realpath(__file__)), GenPro.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()
def __init__(self, verbose=False): ''' Initial constructor. :param verbose: enable/disable verbose option. :type verbose: <bool> :exceptions: None ''' FileChecking.__init__(self, verbose=verbose) verbose_message(GenReadmeModule.GEN_VERBOSE, verbose, 'init generator') self.__reader = ReadTemplate(verbose=verbose) self.__writer = WriteTemplate(verbose=verbose) project = '{0}{1}'.format( Path(__file__).parent, GenReadmeModule.PRO_STRUCTURE ) self.check_path(file_path=project, verbose=verbose) self.check_mode(file_mode='r', verbose=verbose) self.check_format( file_path=project, file_format='yaml', verbose=verbose ) if self.is_file_ok(): yml2obj = Yaml2Object(project) self.__config = yml2obj.read_configuration() else: self.__config = None
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_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 start(self, verbose=False): ''' Start daemon process. :param verbose: enable/disable verbose option. :type verbose: <bool> :return: start daemon process status (True) | False. :rtype: <bool> :exceptions: None ''' pid, status = None, False verbose_message(Daemon.PKG_VERBOSE, verbose, 'start daemon process') if self.unix_status: with FileProcessId(self.__pid_file_path, 'w+') as pid_file_path: pid = pid_file_path.read().strip() if bool(pid): error_message( Daemon.PKG_VERBOSE, 'file {0} already exist'.format(self.__pid_file_path), 'daemon already running?') else: self.daemonize(verbose=verbose) self.run() status = True return status
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 __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 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 __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 choose_osc(self, verbose=False): ''' Select FOSC for target. :param verbose: enable/disable verbose option. :type verbose: <bool> :return: FOSC | None. :rtype: <str> | <NoneType> :exceptions: None ''' verbose_message(OSCSelector.GEN_VERBOSE, verbose, 'select FOSC') fosc_name_index, fosc_name = -1, None if bool(self.__fosc_list): while True: print('{0}\n'.format('#' * 30)) for index in range(len(self.__fosc_list)): print('\t{0}: {1}'.format(index, self.__fosc_list[index])) print('{0}\n'.format('#' * 30)) fosc_name_index = int(input(' select FOSC: ')) if fosc_name_index not in range(len(self.__fosc_list)): error_message(OSCSelector.GEN_VERBOSE, 'not an appropriate choice') else: fosc_name = self.__fosc_list[fosc_name_index] break return fosc_name
def gen_setup(self, verbose=False): ''' Generate module generator_test.py. :param verbose: enable/disable verbose option. :type verbose: <bool> :return: boolean status, True (success) | False. :rtype: <bool> :exceptions: ATSTypeError | ATSBadCallError ''' status = False verbose_message(MQTTService.GEN_VERBOSE, verbose, 'generating MQTT service') if all([bool(self.pro_name), bool(self.config)]): mqtt_type = self.select_mqtt_type(verbose=verbose) if mqtt_type == 'cancel': status = True else: setup_content = None setup_content = self.__reader.read(mqtt_type, verbose=verbose) if setup_content: status = self.__writer.write(setup_content, self.pro_name, verbose=verbose) return status
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 check_mode(self, file_mode, verbose=False): ''' Check operation mode for file. :param file_mode: file mode ('r', 'w', 'a', 'b', 'x', 't', '+'). :type file_mode: <str> :param verbose: enable/disable verbose option. :type verbose: <bool> :return: True (regular file mode) | False. :rtype: <bool> :exceptions: None ''' modes, mode_checks = list(file_mode), [] for mode in modes: if mode not in FileChecking.MODES: mode_checks.append(False) else: mode_checks.append(True) if all(mode_checks): self.__file_mode_ok = True verbose_message(FileChecking.VERBOSE, self.__verbose or verbose, file_mode) else: self.__file_mode_ok = False error_message(FileChecking.VERBOSE, '{0} [{1}]'.format('not supported mode', file_mode))
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 choose_model(cls, verbose=False): """ Choose type of data model. :param verbose: Enable/disable verbose option :type verbose: <bool> :return: Type of data model (0, 1, 2) :rtype: <int> :exceptions: None """ verbose_message(cls.VERBOSE, verbose, 'Loading options') print("\n {0}".format('model option list:')) for key in sorted(cls.__MODELS): print(" {0} {1}".format(key, cls.__MODELS[key])) while True: try: model_type = int(raw_input(' Select model: ')) except NameError: model_type = input(' Select model: ') if model_type not in cls.__MODELS.keys(): error_message(cls.VERBOSE, 'Not an appropriate choice.') else: break verbose_message(cls.VERBOSE, verbose, 'Selected option', model_type) return model_type
def daemonize(self, verbose=False): ''' Create daemon process. :param verbose: enable/disable verbose option. :type verbose: <bool> :exceptions: None ''' null = '/dev/null' verbose_message(Daemon.PKG_VERBOSE, verbose, 'create daemon process') if self.unix_status: self.first_fork() chdir('/') setsid() umask(0) self.second_fork() sys.stdout.flush() sys.stderr.flush() with FileDescriptor(null, FileDescriptor.STDIN) as in_file: dup2(in_file.fileno(), sys.stdin.fileno()) with FileDescriptor(null, FileDescriptor.STDOUT) as out_file: dup2(out_file.fileno(), sys.stdout.fileno()) with FileDescriptor(null, FileDescriptor.STDERR) as err_file: dup2(err_file.fileno(), sys.stderr.fileno()) register(self.exit_handler) pid = str(getpid()) with FileProcessId(self.__pid_file_path, 'w+') as pid_file_path: pid_file_path.write('{0}\n'.format(pid))
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: ATSBadCallError | ATSTypeError """ func = stack()[0][3] pro_name_txt = 'Argument: expected project_name <str> object' pro_name_msg = "{0} {1} {2}".format('def', func, pro_name_txt) verbose_message(WriteTemplate.VERBOSE, verbose, 'Initial writer') if project_name is None or not project_name: raise ATSBadCallError(pro_name_msg) if not isinstance(project_name, str): raise ATSTypeError(pro_name_msg) self.__pro_dir = "{0}/{1}".format(getcwd(), project_name) self.__src_dir = "{0}/{1}".format(self.__pro_dir, 'src') self.__pro_name = project_name if not exists(self.__pro_dir): mkdir(self.__pro_dir) if not exists(self.__src_dir): mkdir(self.__src_dir)
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, 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 choose_mcu(self, verbose=False): ''' Select MCU target. :param verbose: enable/disable verbose option. :type verbose: <bool> :return: MCU name | None. :rtype: <str> | <NoneType> :exceptions: None ''' verbose_message(MCUSelector.GEN_VERBOSE, verbose, 'select MCU') mcu_name_index, mcu_name = -1, None if bool(self.__mcu_list): while True: print('{0}\n'.format('#' * 30)) for index in range(len(self.__mcu_list)): print('\t{0}: {1}'.format(index, self.__mcu_list[index])) print('{0}\n'.format('#' * 30)) mcu_name_index = int(input(' select MCU: ')) if mcu_name_index not in range(len(self.__mcu_list)): error_message(MCUSelector.GEN_VERBOSE, 'not an appropriate choice') else: mcu_name = self.__mcu_list[mcu_name_index] break return mcu_name
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 __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 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), else False :rtype: <bool> :exceptions: ATSBadCallError | ATSTypeError """ func, status = stack()[0][3], False module_name_txt = 'Argument: expected module_name <str> object' module_name_msg = "{0} {1} {2}".format('def', func, module_name_txt) if module_name is None or not module_name: raise ATSBadCallError(module_name_msg) if not isinstance(module_name, str): raise ATSTypeError(module_name_msg) verbose_message(GenModule.VERBOSE, verbose, 'Generating module', module_name) module_type = ModuleSelector.choose_module() if module_type != ModuleSelector.Cancel: module_content = self.__reader.read(module_type, verbose=verbose) if module_content: status = self.__writer.write(module_content, module_name, module_type, verbose=verbose) return True if status else False
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 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 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, verbose=False): ''' Initial constructor. :param verbose: enable/disable verbose option. :type verbose: <bool> :exceptions: None ''' current_dir = Path(__file__).resolve().parent base_info = '{0}{1}'.format(current_dir, GenReadme.CONFIG) CfgCLI.__init__(self, base_info, verbose=verbose) verbose_message(GenReadme.GEN_VERBOSE, verbose, 'init tool info') self.logger = ATSLogger(GenReadme.GEN_VERBOSE.lower(), '{0}{1}'.format(current_dir, GenReadme.LOG), verbose=verbose) if self.tool_operational: self.add_new_option(GenReadme.OPS[0], GenReadme.OPS[1], dest='gen', help='generate README.md') self.add_new_option(GenReadme.OPS[2], GenReadme.OPS[3], action='store_true', default=False, help='activate verbose mode for generation') self.add_new_option(GenReadme.OPS[4], action='version', version=__version__)
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 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))