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
