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
