def check_format(self, file_path, file_format, verbose=False):
'''
Check file format by extension.
:param file_path: file path.
:type file_path: <str>
:param file_format: file format (file extension).
:type file_format: <str>
:param verbose: enable/disable verbose option.
:type verbose: <bool>
:exceptions: None
'''
if file_format != 'makefile':
file_name_path, extension = splitext(file_path)
extension = extension.replace('.', '')
if extension == '':
extension = file_format
else:
if file_format.capitalize() in file_path:
extension = 'makefile'
else:
extension = 'wrong_format'
if not extension == file_format or extension == 'wrong_format':
error_message(
FileChecking.VERBOSE,
'{0} [{1}] {2}'.format('not matched file extension',
file_format, file_path))
self.__file_format_ok = False
else:
self.__file_format_ok = True
verbose_message(FileChecking.VERBOSE, self.__verbose or verbose,
file_path)
def __init__(self, verbose=False):
'''
Initial constructor.
:param verbose: enable/disable verbose option.
:type verbose: <bool>
:exceptions: ATSTypeError | ATSBadCallError
'''
FileChecking.__init__(self, verbose=verbose)
ProConfig.__init__(self, verbose=verbose)
ProName.__init__(self, verbose=verbose)
verbose_message(GenPro.GEN_VERBOSE, verbose, 'init generator')
self.__reader = ReadTemplate(verbose=verbose)
self.__writer = WriteTemplate(verbose=verbose)
project_structure = '{0}{1}'.format(
dirname(realpath(__file__)), GenPro.PRO_STRUCTURE
)
self.check_path(file_path=project_structure, verbose=verbose)
self.check_mode(file_mode='r', verbose=verbose)
self.check_format(
file_path=project_structure, file_format='yaml', verbose=verbose
)
if self.is_file_ok():
yml2obj = Yaml2Object(project_structure)
self.config = yml2obj.read_configuration()
def __init__(self, verbose=False):
'''
Initial constructor.
:param verbose: enable/disable verbose option.
:type verbose: <bool>
:exceptions: None
'''
FileChecking.__init__(self, verbose=verbose)
verbose_message(GenReadmeModule.GEN_VERBOSE, verbose, 'init generator')
self.__reader = ReadTemplate(verbose=verbose)
self.__writer = WriteTemplate(verbose=verbose)
project = '{0}{1}'.format(
Path(__file__).parent, GenReadmeModule.PRO_STRUCTURE
)
self.check_path(file_path=project, verbose=verbose)
self.check_mode(file_mode='r', verbose=verbose)
self.check_format(
file_path=project, file_format='yaml', verbose=verbose
)
if self.is_file_ok():
yml2obj = Yaml2Object(project)
self.__config = yml2obj.read_configuration()
else:
self.__config = None
def read(self, template_file, verbose=False):
'''
Read template file.
:param template_file: template file path.
:type template_file: <str>
:param verbose: enable/disable verbose option.
:type verbose: <bool>
:return: template content for module | None.
:rtype: <str> | <NoneType>
:exceptions: ATSTypeError | ATSBadCallError
'''
checker, error, status = ATSChecker(), None, False
error, status = checker.check_params([('str:template_file',
template_file)])
if status == ATSChecker.TYPE_ERROR:
raise ATSTypeError(error)
if status == ATSChecker.VALUE_ERROR:
raise ATSBadCallError(error)
setup_content = None
self.check_path(file_path=template_file, verbose=verbose)
self.check_mode(file_mode='r', verbose=verbose)
self.check_format(file_path=template_file,
file_format=ReadTemplate.FORMAT,
verbose=verbose)
if self.is_file_ok():
verbose_message(ReadTemplate.GEN_VERBOSE, verbose, 'load template')
with open(template_file, 'r') as template:
if bool(template):
setup_content = template.read()
return setup_content
def gen_setup(self, pro_name, verbose=False):
'''
Generate module generator_test.py.
:param pro_name: project name.
:type pro_name: <str>
:param verbose: enable/disable verbose option.
:type verbose: <bool>
:return: boolean status, True (success) | False.
:rtype: <bool>
:exceptions: ATSTypeError | ATSBadCallError
'''
checker, error, status = ATSChecker(), None, False
error, status = checker.check_params([('str:pro_name', pro_name)])
if status == ATSChecker.TYPE_ERROR:
raise ATSTypeError(error)
if status == ATSChecker.VALUE_ERROR:
raise ATSBadCallError(error)
status = False
verbose_message(MessageQueue.GEN_VERBOSE, verbose, 'prepare setup for',
pro_name)
if bool(self.config):
mq_type = self.select_pro_type(verbose=verbose)
if mq_type != 'cancel':
templates = self.__reader.read(self.config,
mq_type,
verbose=verbose)
if bool(templates):
status = self.__writer.write(templates,
pro_name,
verbose=verbose)
else:
status = True
return status
def start(self, verbose=False):
'''
Start daemon process.
:param verbose: enable/disable verbose option.
:type verbose: <bool>
:return: start daemon process status (True) | False.
:rtype: <bool>
:exceptions: None
'''
pid, status = None, False
verbose_message(Daemon.PKG_VERBOSE, verbose, 'start daemon process')
if self.unix_status:
with FileProcessId(self.__pid_file_path, 'w+') as pid_file_path:
pid = pid_file_path.read().strip()
if bool(pid):
error_message(
Daemon.PKG_VERBOSE,
'file {0} already exist'.format(self.__pid_file_path),
'daemon already running?')
else:
self.daemonize(verbose=verbose)
self.run()
status = True
return status
def usage(self, operation, verbose=False):
'''
Create daemon process.
:param operation: daemon operation.
:type operation: <str>
:param verbose: enable/disable verbose option.
:type verbose: <bool>
:exceptions: ATSTypeError | ATSBadCallError
'''
checker, error, status = ATSChecker(), None, False
error, status = checker.check_params([('str:operation', operation)])
if status == ATSChecker.TYPE_ERROR:
raise ATSTypeError(error)
if status == ATSChecker.VALUE_ERROR:
raise ATSBadCallError(error)
verbose_message(Daemon.PKG_VERBOSE, verbose, 'daemon operation',
operation)
if self.unix_status:
self.__daemon_usage.check(operation, verbose=verbose)
if self.__daemon_usage.usage_status == 127:
sys.exit(127)
elif self.__daemon_usage.usage_status == 0:
self.start(verbose=verbose)
elif self.__daemon_usage.usage_status == 1:
self.stop(verbose=verbose)
elif self.__daemon_usage.usage_status == 2:
self.restart(verbose=verbose)
else:
error_message(Daemon.PKG_VERBOSE, 'wrong option code')
sys.exit(128)
def __ioctl_get_window_size(self, file_descriptor, verbose=False):
'''
Check window size for descriptor.
:param file_descriptor: file descriptor.
:type file_descriptor: <int>
:param verbose: enable/disable verbose option.
:type verbose: <bool>
:return: window size of terminal.
:rtype: <tupple>
:exceptions: ATSTypeError | ATSBadCallError
'''
checker, error, status = ATSChecker(), None, False
error, status = checker.check_params([('int:file_descriptor',
file_descriptor)])
if status == ATSChecker.TYPE_ERROR:
raise ATSTypeError(error)
if status == ATSChecker.VALUE_ERROR:
raise ATSBadCallError(error)
try:
self.__window_size = unpack(
'hh', ioctl(file_descriptor, TIOCGWINSZ, '1234'))
except:
pass
verbose_message(TerminalProperties.VERBOSE, self.__verbose or verbose,
'terminal window size', self.__window_size)
return self.__window_size
def check(self, daemon_operation, verbose=False):
'''
Checking usage of Daemon process.
:param daemon_operation: daemon operation.
:type daemon_operation: <str>
:param verbose: enable/disable verbose option.
:type verbose: <bool>
:exceptions: ATSTypeError | ATSBadCallError
'''
checker, error, status = ATSChecker(), None, False
error, status = checker.check_params([('str:daemon_operation',
daemon_operation)])
if status == ATSChecker.TYPE_ERROR:
raise ATSTypeError(error)
if status == ATSChecker.VALUE_ERROR:
raise ATSBadCallError(error)
verbose_message(DaemonUsage.PKG_VERBOSE, verbose, 'checking usage')
for index, option in enumerate(DaemonUsage.DAEMON_OPERATIONS):
if option == daemon_operation:
self.__usage_status = index
if daemon_operation not in DaemonUsage.DAEMON_OPERATIONS:
self.__usage_status = 127
error_message(
DaemonUsage.PKG_VERBOSE,
'usage: {0}'.format('|'.join(DaemonUsage.DAEMON_OPERATIONS)))
verbose_message(DaemonUsage.PKG_VERBOSE, verbose, 'usage status',
self.__usage_status)
def __init__(self, project_name, verbose=False):
'''
Initial constructor.
:param project_name: project name.
:type project_name: <str>
:param verbose: enable/disable verbose option.
:type verbose: <bool>
:exceptions: None
'''
checker, error, status = ATSChecker(), None, False
error, status = checker.check_params([('str:project_name',
project_name)])
if status == ATSChecker.TYPE_ERROR:
raise ATSTypeError(error)
if status == ATSChecker.VALUE_ERROR:
raise ATSBadCallError(error)
FileChecking.__init__(self, verbose=verbose)
ProConfig.__init__(self, verbose=verbose)
ProName.__init__(self, verbose=verbose)
verbose_message(STM8Setup.GEN_VERBOSE, verbose, 'init generator')
self.__reader = ReadTemplate(verbose=verbose)
self.__writer = WriteTemplate(verbose=verbose)
project_structure = '{0}{1}'.format(dirname(realpath(__file__)),
STM8Setup.PRO_STRUCTURE)
self.check_path(file_path=project_structure, verbose=verbose)
self.check_mode(file_mode='r', verbose=verbose)
self.check_format(file_path=project_structure,
file_format='yaml',
verbose=verbose)
if self.is_file_ok():
yml2obj = Yaml2Object(project_structure)
self.config = yml2obj.read_configuration()
self.pro_name = project_name
def choose_osc(self, verbose=False):
'''
Select FOSC for target.
:param verbose: enable/disable verbose option.
:type verbose: <bool>
:return: FOSC | None.
:rtype: <str> | <NoneType>
:exceptions: None
'''
verbose_message(OSCSelector.GEN_VERBOSE, verbose, 'select FOSC')
fosc_name_index, fosc_name = -1, None
if bool(self.__fosc_list):
while True:
print('{0}\n'.format('#' * 30))
for index in range(len(self.__fosc_list)):
print('\t{0}: {1}'.format(index, self.__fosc_list[index]))
print('{0}\n'.format('#' * 30))
fosc_name_index = int(input(' select FOSC: '))
if fosc_name_index not in range(len(self.__fosc_list)):
error_message(OSCSelector.GEN_VERBOSE,
'not an appropriate choice')
else:
fosc_name = self.__fosc_list[fosc_name_index]
break
return fosc_name
def gen_setup(self, verbose=False):
'''
Generate module generator_test.py.
:param verbose: enable/disable verbose option.
:type verbose: <bool>
:return: boolean status, True (success) | False.
:rtype: <bool>
:exceptions: ATSTypeError | ATSBadCallError
'''
status = False
verbose_message(MQTTService.GEN_VERBOSE, verbose,
'generating MQTT service')
if all([bool(self.pro_name), bool(self.config)]):
mqtt_type = self.select_mqtt_type(verbose=verbose)
if mqtt_type == 'cancel':
status = True
else:
setup_content = None
setup_content = self.__reader.read(mqtt_type, verbose=verbose)
if setup_content:
status = self.__writer.write(setup_content,
self.pro_name,
verbose=verbose)
return status
def check_module(self, module, verbose=False):
'''
Check project module.
:param module: module name.
:type module: <str>
:param verbose: enable/disable verbose option.
:type verbose: <bool>
:return: 'build' | 'source'| None (wrong module name).
:rtype: <str> | <NoneType>
:exceptions: ATSTypeError | ATSBadCallError
'''
checker, error, status = ATSChecker(), None, False
error, status = checker.check_params([('str:module', module)])
if status == ATSChecker.TYPE_ERROR:
raise ATSTypeError(error)
if status == ATSChecker.VALUE_ERROR:
raise ATSBadCallError(error)
is_source, is_build, module_type = False, False, None
is_source = ModuleType.is_source_module(module)
is_build = ModuleType.is_build_module(module)
if is_source and not is_build:
module_type = 'source'
if not is_source and is_build:
module_type = 'build'
verbose_message(WriteTemplate.GEN_VERBOSE, verbose, 'module type',
module_type)
return module_type
def check_mode(self, file_mode, verbose=False):
'''
Check operation mode for file.
:param file_mode: file mode ('r', 'w', 'a', 'b', 'x', 't', '+').
:type file_mode: <str>
:param verbose: enable/disable verbose option.
:type verbose: <bool>
:return: True (regular file mode) | False.
:rtype: <bool>
:exceptions: None
'''
modes, mode_checks = list(file_mode), []
for mode in modes:
if mode not in FileChecking.MODES:
mode_checks.append(False)
else:
mode_checks.append(True)
if all(mode_checks):
self.__file_mode_ok = True
verbose_message(FileChecking.VERBOSE, self.__verbose or verbose,
file_mode)
else:
self.__file_mode_ok = False
error_message(FileChecking.VERBOSE,
'{0} [{1}]'.format('not supported mode', file_mode))
def read(self, template_modules, verbose=False):
'''
Read template structure.
:param template_modules: template module name.
:type template_modules: <str>
:param verbose: enable/disable verbose option.
:type verbose: <bool>
:return: template content for setup module | None.
:rtype: <str> | <NoneType>
:exceptions: ATSTypeError | ATSBadCallError
'''
checker, error, status = ATSChecker(), None, False
error, status = checker.check_params([('str:template_modules',
template_modules)])
if status == ATSChecker.TYPE_ERROR:
raise ATSTypeError(error)
if status == ATSChecker.VALUE_ERROR:
raise ATSBadCallError(error)
setup_content, template_file = [], None
verbose_message(ReadTemplate.GEN_VERBOSE, verbose, 'load templates')
template_file = '{0}{1}'.format(self.__template_dir, template_modules)
self.check_path(template_file, verbose=verbose)
self.check_mode('r', verbose=verbose)
self.check_format(template_file, 'yaml', verbose=verbose)
if self.is_file_ok():
yml2obj = Yaml2Object(template_file)
configuration = yml2obj.read_configuration()
templates = configuration['templates']
modules = configuration['modules']
for template, module in zip(templates, modules):
template_path = '{0}{1}'.format(self.__template_dir, template)
with open(template_path, 'r') as setup_template:
setup_content.append({module: setup_template.read()})
return setup_content
def choose_model(cls, verbose=False):
"""
Choose type of data model.
:param verbose: Enable/disable verbose option
:type verbose: <bool>
:return: Type of data model (0, 1, 2)
:rtype: <int>
:exceptions: None
"""
verbose_message(cls.VERBOSE, verbose, 'Loading options')
print("\n {0}".format('model option list:'))
for key in sorted(cls.__MODELS):
print(" {0} {1}".format(key, cls.__MODELS[key]))
while True:
try:
model_type = int(raw_input(' Select model: '))
except NameError:
model_type = input(' Select model: ')
if model_type not in cls.__MODELS.keys():
error_message(cls.VERBOSE, 'Not an appropriate choice.')
else:
break
verbose_message(cls.VERBOSE, verbose, 'Selected option', model_type)
return model_type
def daemonize(self, verbose=False):
'''
Create daemon process.
:param verbose: enable/disable verbose option.
:type verbose: <bool>
:exceptions: None
'''
null = '/dev/null'
verbose_message(Daemon.PKG_VERBOSE, verbose, 'create daemon process')
if self.unix_status:
self.first_fork()
chdir('/')
setsid()
umask(0)
self.second_fork()
sys.stdout.flush()
sys.stderr.flush()
with FileDescriptor(null, FileDescriptor.STDIN) as in_file:
dup2(in_file.fileno(), sys.stdin.fileno())
with FileDescriptor(null, FileDescriptor.STDOUT) as out_file:
dup2(out_file.fileno(), sys.stdout.fileno())
with FileDescriptor(null, FileDescriptor.STDERR) as err_file:
dup2(err_file.fileno(), sys.stderr.fileno())
register(self.exit_handler)
pid = str(getpid())
with FileProcessId(self.__pid_file_path, 'w+') as pid_file_path:
pid_file_path.write('{0}\n'.format(pid))
def __init__(self, project_name, verbose=False):
"""
Initial constructor.
:param project_name: Project name
:type project_name: <str>
:param verbose: Enable/disable verbose option
:type verbose: <bool>
:exceptions: ATSBadCallError | ATSTypeError
"""
func = stack()[0][3]
pro_name_txt = 'Argument: expected project_name <str> object'
pro_name_msg = "{0} {1} {2}".format('def', func, pro_name_txt)
verbose_message(WriteTemplate.VERBOSE, verbose, 'Initial writer')
if project_name is None or not project_name:
raise ATSBadCallError(pro_name_msg)
if not isinstance(project_name, str):
raise ATSTypeError(pro_name_msg)
self.__pro_dir = "{0}/{1}".format(getcwd(), project_name)
self.__src_dir = "{0}/{1}".format(self.__pro_dir, 'src')
self.__pro_name = project_name
if not exists(self.__pro_dir):
mkdir(self.__pro_dir)
if not exists(self.__src_dir):
mkdir(self.__src_dir)
def __init__(self, pid_file_path, verbose=False):
'''
Initial constructor.
:param pid_file_path: PID file path.
:type pid_file_path: <str>
:param verbose: enable/disable verbose option.
:type verbose: <bool>
:exceptions: ATSTypeError | ATSBadCallError
'''
checker, error, status = ATSChecker(), None, False
error, status = checker.check_params([('str:pid_file_path',
pid_file_path)])
if status == ATSChecker.TYPE_ERROR:
raise ATSTypeError(error)
if status == ATSChecker.VALUE_ERROR:
raise ATSBadCallError(error)
UnixOperations.__init__(self)
verbose_message(Daemon.PKG_VERBOSE, verbose, 'init daemon process')
if self.unix_status:
self.__daemon_usage = DaemonUsage()
self.__pid_file_path = pid_file_path
else:
self.__daemon_usage = None
self.__pid_file_path = None
def __init__(self, pro_property, template, schema, verbose=False):
'''
Initial constructor.
:param pro_property: project property.
:type pro_property: <dict>
:param template: project tool/generator template.
:type template: <dict>
:param schema: project tool/generator schema.
:type schema: <dict>
:param verbose: enable/disable verbose option.
:type verbose: <bool>
:exceptions: ATSTypeError | ATSBadCallError
'''
checker, error, status = ATSChecker(), None, False
error, status = checker.check_params([('dict:pro_property',
pro_property),
('dict:template', template),
('dict:schema', schema)])
if status == ATSChecker.TYPE_ERROR:
raise ATSTypeError(error)
if status == ATSChecker.VALUE_ERROR:
raise ATSBadCallError(error)
ProCollectiner.__init__(self)
self.pro_name = pro_property['name']
self.pro_type = pro_property['type']
self.template = template
self.schema = schema
verbose_message(PrepareGen.GEN_VERBOSE, verbose,
'init prepare generator')
def choose_mcu(self, verbose=False):
'''
Select MCU target.
:param verbose: enable/disable verbose option.
:type verbose: <bool>
:return: MCU name | None.
:rtype: <str> | <NoneType>
:exceptions: None
'''
verbose_message(MCUSelector.GEN_VERBOSE, verbose, 'select MCU')
mcu_name_index, mcu_name = -1, None
if bool(self.__mcu_list):
while True:
print('{0}\n'.format('#' * 30))
for index in range(len(self.__mcu_list)):
print('\t{0}: {1}'.format(index, self.__mcu_list[index]))
print('{0}\n'.format('#' * 30))
mcu_name_index = int(input(' select MCU: '))
if mcu_name_index not in range(len(self.__mcu_list)):
error_message(MCUSelector.GEN_VERBOSE,
'not an appropriate choice')
else:
mcu_name = self.__mcu_list[mcu_name_index]
break
return mcu_name
def __init__(self, template_file, verbose=False):
'''
Initial constructor.
:param template_file: template file.
:type template_file: <str>
:param verbose: enable/disable verbose option.
:type verbose: <bool>
:exceptions: ATSTypeError | ATSBadCallError
'''
checker, error, status = ATSChecker(), None, False
error, status = checker.check_params([('str:template_file',
template_file)])
if status == ATSChecker.TYPE_ERROR:
raise ATSTypeError(error)
if status == ATSChecker.VALUE_ERROR:
raise ATSBadCallError(error)
FileChecking.__init__(self, verbose=verbose)
TemplateContainer.__init__(self, verbose=verbose)
verbose_message(TemplateLoader.GEN_VERBOSE, verbose,
'init template loader')
template_path = '{0}{1}{2}'.format(dirname(realpath(__file__)),
TemplateLoader.CONF_DIR,
template_file)
self.check_path(file_path=template_path, verbose=verbose)
self.check_mode(file_mode='r', verbose=verbose)
self.check_format(file_path=template_path,
file_format='yaml',
verbose=verbose)
if self.is_file_ok():
yml2obj = Yaml2Object(template_path)
self.template = yml2obj.read_configuration(verbose=verbose)
def __init__(self, pro_property, schema, template, element, verbose=False):
'''
Initial constructor.
:param pro_property: project property.
:type pro_property: <dict>
:param schema: project tool/generator schema.
:type schema: <dict>
:param template: project tool/generator template.
:type template: <dict>
:param element: project tool/generator element.
:type element: <dict>
:param verbose: enable/disable verbose option.
:type verbose: <bool>
:exceptions: ATSTypeError | ATSBadCallError
'''
checker, error, status = ATSChecker(), None, False
error, status = checker.check_params([
('dict:pro_property', pro_property),
('dict:schema', schema),
('dict:template', template),
('dict:element', element),
])
if status == ATSChecker.TYPE_ERROR:
raise ATSTypeError(error)
if status == ATSChecker.VALUE_ERROR:
raise ATSBadCallError(error)
self.prepare_tool = PrepareTool(
pro_property, template, schema, verbose=verbose
)
self.deploy_tool = DeployTool(element, schema, verbose=verbose)
verbose_message(ToolFactory.GEN_VERBOSE, verbose, 'init prepare tool')
def gen_module(self, module_name, verbose=False):
"""
Generate file python module
:param module_name: Parameter module name
:type module_name: <str>
:param verbose: Enable/disable verbose option
:type verbose: <bool>
:return: Boolean status True (success), else False
:rtype: <bool>
:exceptions: ATSBadCallError | ATSTypeError
"""
func, status = stack()[0][3], False
module_name_txt = 'Argument: expected module_name <str> object'
module_name_msg = "{0} {1} {2}".format('def', func, module_name_txt)
if module_name is None or not module_name:
raise ATSBadCallError(module_name_msg)
if not isinstance(module_name, str):
raise ATSTypeError(module_name_msg)
verbose_message(GenModule.VERBOSE, verbose, 'Generating module',
module_name)
module_type = ModuleSelector.choose_module()
if module_type != ModuleSelector.Cancel:
module_content = self.__reader.read(module_type, verbose=verbose)
if module_content:
status = self.__writer.write(module_content,
module_name,
module_type,
verbose=verbose)
return True if status else False
def __init__(self, informations_file, verbose=False):
'''
Initial constructor.
:param informations_file: informations file path.
:type informations_file: <str>
:param verbose: enable/disable verbose option.
:type verbose: <bool>
:exceptions: ATSTypeError | ATSBadCallError
'''
checker, error, status = ATSChecker(), None, False
error, status = checker.check_params([('str:informations_file',
informations_file)])
if status == ATSChecker.TYPE_ERROR:
raise ATSTypeError(error)
if status == ATSChecker.VALUE_ERROR:
raise ATSBadCallError(error)
self.__verbose = verbose
informations = None
self.tool_operational = False
self.yaml2obj = Yaml2Object(informations_file, verbose=verbose)
self.obj2yaml = Object2Yaml(informations_file, verbose=verbose)
if all([self.yaml2obj, self.obj2yaml]):
informations = self.yaml2obj.read_configuration(verbose=verbose)
if informations:
info = ATSInfo(informations, verbose=verbose)
if info.ats_info_ok:
self.option_parser = ATSOptionParser('{0} {1}'.format(
info.name, info.build_date),
info.version,
info.licence,
verbose=verbose)
self.tool_operational = True
verbose_message(YamlBase.VERBOSE, verbose,
'loaded ATS YAML base info')
def read(self, template_module, verbose=False):
'''
Read template structure.
:param template_module: template module name.
:type template_module: <str>
:param verbose: enable/disable verbose option.
:type verbose: <bool>
:return: template content for setup module | None.
:rtype: <str> | <NoneType>
:exceptions: ATSTypeError | ATSBadCallError
'''
checker, error, status = ATSChecker(), None, False
error, status = checker.check_params([('str:template_module',
template_module)])
if status == ATSChecker.TYPE_ERROR:
raise ATSTypeError(error)
if status == ATSChecker.VALUE_ERROR:
raise ATSBadCallError(error)
setup_content, template_file = None, None
verbose_message(ReadTemplate.GEN_VERBOSE, verbose, 'load template')
template_file = '{0}{1}'.format(self.__template_dir, template_module)
self.check_path(template_file, verbose=verbose)
self.check_mode('r', verbose=verbose)
self.check_format(template_file, 'template', verbose=verbose)
if self.is_file_ok():
with open(template_file, 'r') as setup_template:
setup_content = setup_template.read()
return setup_content
def gen_setup(self, pro_name, verbose=False):
'''
Generate module generator_test.py.
:param pro_name: project name.
:type pro_name: <str>
:param verbose: enable/disable verbose option.
:type verbose: <bool>
:return: boolean status, True (success) | False.
:rtype: <bool>
:exceptions: ATSTypeError | ATSBadCallError
'''
checker, error, status = ATSChecker(), None, False
error, status = checker.check_params([
('str:pro_name', pro_name)
])
if status == ATSChecker.TYPE_ERROR:
raise ATSTypeError(error)
if status == ATSChecker.VALUE_ERROR:
raise ATSBadCallError(error)
status, setup_content = False, None
verbose_message(
GenReadmeModule.GEN_VERBOSE, verbose, 'generating module', pro_name
)
template_file = self.select_pro_type(verbose=verbose)
module = self.__config['module']
if bool(template_file):
setup_content = self.__reader.read(
template_file, verbose=verbose
)
if setup_content:
status = self.__writer.write(
setup_content, pro_name, module, verbose=verbose
)
return status
def __init__(self, verbose=False):
'''
Initial constructor.
:param verbose: enable/disable verbose option.
:type verbose: <bool>
:exceptions: None
'''
current_dir = Path(__file__).resolve().parent
base_info = '{0}{1}'.format(current_dir, GenReadme.CONFIG)
CfgCLI.__init__(self, base_info, verbose=verbose)
verbose_message(GenReadme.GEN_VERBOSE, verbose, 'init tool info')
self.logger = ATSLogger(GenReadme.GEN_VERBOSE.lower(),
'{0}{1}'.format(current_dir, GenReadme.LOG),
verbose=verbose)
if self.tool_operational:
self.add_new_option(GenReadme.OPS[0],
GenReadme.OPS[1],
dest='gen',
help='generate README.md')
self.add_new_option(GenReadme.OPS[2],
GenReadme.OPS[3],
action='store_true',
default=False,
help='activate verbose mode for generation')
self.add_new_option(GenReadme.OPS[4],
action='version',
version=__version__)
def __init__(self, version, epilog, description, verbose=False):
'''
Initial constructor.
:param version: ATS version and build date.
:type version: <str>
:param epilog: ATS long description.
:type epilog: <str>
:param description: ATS author and license.
:type description: <str>
:param verbose: enable/disable verbose option.
:type verbose: <bool>
:exceptions: ATSTypeError | ATSBadCallError
'''
checker, error, status = ATSChecker(), None, False
error, status = checker.check_params([('str:version', version),
('str:epilog', epilog),
('str:description', description)
])
if status == ATSChecker.TYPE_ERROR:
raise ATSTypeError(error)
if status == ATSChecker.VALUE_ERROR:
raise ATSBadCallError(error)
self.__verbose = verbose
self.__opt_parser = ArgumentParser(version, epilog, description)
verbose_message(ATSOptionParser.VERBOSE, self.__verbose or verbose,
version, epilog, description)
def center(self, columns, additional_shifter, text, verbose=False):
'''
Center console line.
:param columns: colums for open console session.
:type columns: <int>
:param additional_shifter: additional shifters.
:type additional_shifter: <int>
:param text: text for console session.
:type text: <str>
:param verbose: enable/disable verbose option.
:type verbose: <bool>
:exceptions: ATSTypeError | ATSBadCallError
'''
checker, error, status = ATSChecker(), None, False
error, status = checker.check_params([('int:columns', columns),
('int:additional_shifter',
additional_shifter),
('str:text', text)])
if status == ATSChecker.TYPE_ERROR:
raise ATSTypeError(error)
if status == ATSChecker.VALUE_ERROR:
raise ATSBadCallError(error)
verbose_message(Splash.VERBOSE, self.__verbose or verbose, columns,
additional_shifter, text)
start_position = (columns / 2) - 21
number_of_tabs = int((start_position / 8) - 1 + additional_shifter)
print('{0}{1}'.format('\011' * number_of_tabs, text))
