def format_name(cls, module_name, module_type): """ Formatting name for file module :param module_name: Module name (translate to lower case) :type module_name: <str> :param module_type: Type of module (empty/class/main/NotImpl/ABC) :type module_type: <str> :return: File name with extension :rtype: <str> :exceptions: ATSBadCallError | ATSTypeError """ func = stack()[0][3] module_name_txt = 'Argument: expected module_name <str> object' module_name_msg = "{0} {1} {2}".format('def', func, module_name_txt) module_type_txt = 'Argument: expected module_name <str> object' module_type_msg = "{0} {1} {2}".format('def', func, module_type_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) if module_type is None or not module_type: raise ATSBadCallError(module_type_msg) if not isinstance(module_type, int): raise ATSTypeError(module_type_msg) if module_type == ModuleSelector.__MODULES[ModuleSelector.Main]: return "{0}_run{1}".format(module_name.lower(), ".py") return "{0}{1}".format(module_name.lower(), ".py")
def write(self, module_content, module_name, module_type, verbose=False): """ Write a template content with parameters to a file :param module_content: Template content :type module_content: <str> :param module_name: File name :type module_name: <str> :param module_type: Type of module :type module_type: <str> :param verbose: Enable/disable verbose option :type verbose: <bool> :return: Boolean status :rtype: <bool> :exceptions: ATSBadCallError | ATSTypeError """ status = False verbose_message(WriteTemplate.VERBOSE, verbose, 'Write template') module_content_txt = 'Argument: expected module_content <str> object' module_content_msg = "{0} {1} {2}".format('def', stack()[0][3], module_content_txt) module_name_txt = 'Argument: expected module_name <str> object' module_name_msg = "{0} {1} {2}".format('def', stack()[0][3], module_name_txt) module_type_txt = 'Argument: expected module_type <str> object' module_type_msg = "{0} {1} {2}".format('def', stack()[0][3], module_type_txt) if module_content is None or not module_content: raise ATSBadCallError(module_content_msg) if not isinstance(module_content, str): raise ATSTypeError(module_content_msg) 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) if module_type is None or not module_type: raise ATSBadCallError(module_type_msg) if not isinstance(module_type, int): raise ATSTypeError(module_type_msg) self.__check_setup = True module_file_name = "{0}/{1}".format( getcwd(), ModuleSelector.format_name(module_name, module_type)) template = Template(module_content) if template: with open(module_file_name, 'w') as module_file: module_file.write( template.substitute({ "mod": "{0}".format(module_name), "modlc": "{0}".format(module_name.lower()), "date": "{0}".format(date.today()), "year": "{0}".format(date.today().year) })) chmod(module_file_name, 0o666) status = True return True if status else False
def write(self, model_content, model_name, verbose=False): """ :param model_content: Template content for model. :type model_content: <str> :param model_name: Parameter model name :type model_name: <str> :param verbose: Enable/disable verbose option :type verbose: <bool> :return: Boolean status :rtype: <bool> :excptions: ATSBadCallError | ATSTypeError """ func, status, file_name = stack()[0][3], False, None model_cont_txt = 'Argument: expected model_content <str> object' model_cont_msg = "{0} {1} {2}".format('def', func, model_cont_txt) model_name_txt = 'Argument: expected model_content <str> object' model_name_msg = "{0} {1} {2}".format('def', func, model_name_txt) if model_content is None or not model_content: raise ATSBadCallError(model_cont_msg) if not isinstance(model_content, str): raise ATSTypeError(model_cont_msg) if model_name is None or not model_name: raise ATSBadCallError(model_name_msg) if not isinstance(model_name, str): raise ATSTypeError(model_name_msg) verbose_message(WriteTemplate.VERBOSE, verbose, 'Writer template') self.__check_status = True file_name = ModelSelector.format_name(model_name) if file_name: current_dir = getcwd() module_file = "{0}/{1}".format(current_dir, file_name) model_params = { 'mod': "{0}".format(model_name), 'modlc': "{0}".format(model_name.lower()), 'date': "{0}".format(date.today()), 'year': "{0}".format(date.today().year) } template = Template(model_content) verbose_message( WriteTemplate.VERBOSE, verbose, 'Write data model', module_file ) if template: with open(module_file, 'w') as model_file: model_file.write(template.substitute(model_params)) chmod(module_file, 0o666) status = True return True if status else False
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 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 read(self, module_type, verbose=False): """ Read a template and return a content or None :param module_type: File name :type module_type: <str> :param verbose: Enable/disable verbose option :type verbose: <bool> :return: Template module content | None :rtype: <str> | <NoneType> :exceptions: ATSBadCallError | ATSTypeError """ func, module_content = stack()[0][3], None verbose_message(ReadTemplate.VERBOSE, verbose, 'Loading template') module_type_txt = 'Argument: expected module_type <str> object' module_type_msg = "{0} {1} {2}".format('def', func, module_type_txt) if module_type is None or not module_type: raise ATSBadCallError(module_type_msg) if not isinstance(module_type, int): raise ATSTypeError(module_type_msg) file_path = "{0}{1}".format( self.__template, ReadTemplate.__TEMPLATES[module_type] ) with open(file_path, 'r') as template_file: module_content = template_file.read() return module_content
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 __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 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_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 __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 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 read(self, template, verbose=False): """ Read a template and return a content. :param template: File name :type template: <str> :param verbose: Enable/disable verbose option :type verbose: <bool> :return: Template content | None :rtype: <str> | <NoneType> :exceptions: ATSBadCallError | ATSTypeError """ func, template_file_exists = stack()[0][3], None module_content, template_file = False, None template_txt = 'Argument: expected module_type <int> object' template_msg = "{0} {1} {2}".format('def', func, template_txt) if template is None: raise ATSBadCallError(template_msg) if not isinstance(template, str): raise ATSTypeError(template_msg) template_file = "{0}/{1}".format(self.__template_dir, template) template_file_exists = self.check_file(file_path=template_file, verbose=verbose) if template_file_exists: with open(template_file, 'r') as template: module_content = template.read() return module_content
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 __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_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 __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 __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 __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 __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_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 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, 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 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 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 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_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_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 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