text stringlengths 81 112k |
|---|
This function is used for create tab page for notebook.
Input arguments are:
assistant - used for collecting all info about assistants and subassistants
def _create_notebook_page(self, assistant):
"""
This function is used for create tab page for notebook.
Input arguments are:
assistant - used for collecting all info about assistants and subassistants
"""
#frame = self._create_frame()
grid_lang = self.gui_helper.create_gtk_grid()
scrolled_window = self.gui_helper.create_scrolled_window(grid_lang)
row = 0
column = 0
scrolled_window.main_assistant, sub_as = assistant.get_subassistant_tree()
for ass in sorted(sub_as, key=lambda x: x[0].fullname.lower()):
if column > 2:
row += 1
column = 0
if not ass[1]:
# If assistant has not any subassistant then create only button
self.gui_helper.add_button(grid_lang, ass, row, column)
else:
# If assistant has more subassistants then create button with menu
self.gui_helper.add_submenu(grid_lang, ass, row, column)
column += 1
# Install More Assistants button
if column > 2:
row += 1
column = 0
self.gui_helper.add_install_button(grid_lang, row, column)
column += 1
if row == 0 and len(sub_as) < 3:
while column < 3:
btn = self.gui_helper.create_button(style=Gtk.ReliefStyle.NONE)
btn.set_sensitive(False)
btn.hide()
grid_lang.attach(btn, column, row, 1, 1)
column += 1
return scrolled_window |
Hides this window and opens path window.
Passes all needed data and kwargs.
def _open_path_window(self):
"""
Hides this window and opens path window.
Passes all needed data and kwargs.
"""
self.data['top_assistant'] = self.top_assistant
self.data['current_main_assistant'] = self.get_current_main_assistant()
self.data['kwargs'] = self.kwargs
self.path_window.open_window(self.data)
self.main_win.hide() |
Function serves for getting full assistant path and
collects the information from GUI
def sub_menu_pressed(self, widget, event):
"""
Function serves for getting full assistant path and
collects the information from GUI
"""
for index, data in enumerate(self.dev_assistant_path):
index += 1
if settings.SUBASSISTANT_N_STRING.format(index) in self.kwargs:
del self.kwargs[settings.SUBASSISTANT_N_STRING.format(index)]
self.kwargs[settings.SUBASSISTANT_N_STRING.format(index)] = data
self.kwargs['subassistant_0'] = self.get_current_main_assistant().name
self._open_path_window() |
Function return current assistant
def get_current_main_assistant(self):
"""
Function return current assistant
"""
current_page = self.notebook.get_nth_page(self.notebook.get_current_page())
return current_page.main_assistant |
Function is used for case that assistant does not have any
subassistants
def btn_clicked(self, widget, data=None):
"""
Function is used for case that assistant does not have any
subassistants
"""
self.kwargs['subassistant_0'] = self.get_current_main_assistant().name
self.kwargs['subassistant_1'] = data
if 'subassistant_2' in self.kwargs:
del self.kwargs['subassistant_2']
self._open_path_window() |
Function opens Main Window and in case of previously created
project is switches to /home directory
This is fix in case that da creats a project
and project was deleted and GUI was not closed yet
def open_window(self, widget, data=None):
"""
Function opens Main Window and in case of previously created
project is switches to /home directory
This is fix in case that da creats a project
and project was deleted and GUI was not closed yet
"""
if data is not None:
self.data = data
os.chdir(os.path.expanduser('~'))
self.kwargs = dict()
self.main_win.show_all() |
Function is used for showing Popup menu
def btn_press_event(self, widget, event):
"""
Function is used for showing Popup menu
"""
if event.type == Gdk.EventType.BUTTON_PRESS:
if event.button.button == 1:
widget.popup(None, None, None, None,
event.button.button, event.time)
return True
return False |
Function for running DevAssistant GUI
def run_gui():
"""
Function for running DevAssistant GUI
"""
try:
from gi.repository import Gtk
except ImportError as ie:
pass
except RuntimeError as e:
sys.stderr.write(GUI_MESSAGE)
sys.stderr.write("%s: %r" % (e.__class__.__name__, utils.exc_as_decoded_string(e)))
sys.stderr.flush()
sys.exit(1)
if not os.environ.get('DISPLAY'):
sys.stderr.write("%s %s" % (GUI_MESSAGE, GUI_MESSAGE_DISPLAY))
sys.stderr.flush()
sys.exit(1)
# For GNOME 3 icon:
# because this is invoked as da-gui and the desktop file is called devassistant
try:
from gi.repository import GLib
GLib.set_prgname(PRGNAME)
except ImportError:
pass
parser = argparse.ArgumentParser(description='Run DevAssistant GUI.')
utils.add_no_cache_argument(parser)
# now we only have "--no-cache" argument, which we don't actually need to remember,
# see add_no_cache_argument help; so we only run parse_args to determine if
# the invocation was correct
parser.parse_args()
settings.USE_CACHE = False if '--no-cache' in sys.argv else True
from devassistant.gui import main_window
main_window.MainWindow() |
Wraps all publicly callable methods of YamlAssistant. If the assistant was loaded
from cache, this decorator will fully load it first time a publicly callable method
is used.
def needs_fully_loaded(method):
"""Wraps all publicly callable methods of YamlAssistant. If the assistant was loaded
from cache, this decorator will fully load it first time a publicly callable method
is used.
"""
@functools.wraps(method)
def inner(self, *args, **kwargs):
if not self.fully_loaded:
loaded_yaml = yaml_loader.YamlLoader.load_yaml_by_path(self.path)
self.parsed_yaml = loaded_yaml
self.fully_loaded = True
return method(self, *args, **kwargs)
return inner |
Returns default path to icon of this assistant.
Assuming self.path == "/foo/assistants/crt/python/django.yaml"
For image format in [png, svg]:
1) Take the path of this assistant and strip it of load path
(=> "crt/python/django.yaml")
2) Substitute its extension for <image format>
(=> "crt/python/django.<image format>")
3) Prepend self.load_path + 'icons'
(=> "/foo/icons/crt/python/django.<image format>")
4) If file from 3) exists, return it
Return empty string if no icon found.
def default_icon_path(self):
"""Returns default path to icon of this assistant.
Assuming self.path == "/foo/assistants/crt/python/django.yaml"
For image format in [png, svg]:
1) Take the path of this assistant and strip it of load path
(=> "crt/python/django.yaml")
2) Substitute its extension for <image format>
(=> "crt/python/django.<image format>")
3) Prepend self.load_path + 'icons'
(=> "/foo/icons/crt/python/django.<image format>")
4) If file from 3) exists, return it
Return empty string if no icon found.
"""
supported_exts = ['.png', '.svg']
stripped = self.path.replace(os.path.join(self.load_path, 'assistants'), '').strip(os.sep)
for ext in supported_exts:
icon_with_ext = os.path.splitext(stripped)[0] + ext
icon_fullpath = os.path.join(self.load_path, 'icons', icon_with_ext)
if os.path.exists(icon_fullpath):
return icon_fullpath
return '' |
Returns kwargs updated with proper meta variables (like __assistant__).
If this method is run repeatedly with the same section and the same kwargs,
it always modifies kwargs in the same way.
def proper_kwargs(self, section, kwargs):
"""Returns kwargs updated with proper meta variables (like __assistant__).
If this method is run repeatedly with the same section and the same kwargs,
it always modifies kwargs in the same way.
"""
kwargs['__section__'] = section
kwargs['__assistant__'] = self
kwargs['__env__'] = copy.deepcopy(os.environ)
kwargs['__files__'] = [self._files]
kwargs['__files_dir__'] = [self.files_dir]
kwargs['__sourcefiles__'] = [self.path]
# if any of the following fails, DA should keep running
for i in ['system_name', 'system_version', 'distro_name', 'distro_version']:
try:
val = getattr(utils, 'get_' + i)()
except:
val = ''
kwargs['__' + i + '__'] = val |
Returns all dependencies of this assistant with regards to specified kwargs.
If expand_only == False, this method returns list of mappings of dependency types
to actual dependencies (keeps order, types can repeat), e.g.
Example:
[{'rpm', ['rubygems']}, {'gem', ['mygem']}, {'rpm', ['spam']}, ...]
If expand_only == True, this method returns a structure that can be used as
"dependencies" section and has all the "use: foo" commands expanded (but conditions
are left untouched and variables are not substituted).
def dependencies(self, kwargs=None, expand_only=False):
"""Returns all dependencies of this assistant with regards to specified kwargs.
If expand_only == False, this method returns list of mappings of dependency types
to actual dependencies (keeps order, types can repeat), e.g.
Example:
[{'rpm', ['rubygems']}, {'gem', ['mygem']}, {'rpm', ['spam']}, ...]
If expand_only == True, this method returns a structure that can be used as
"dependencies" section and has all the "use: foo" commands expanded (but conditions
are left untouched and variables are not substituted).
"""
# we can't use {} as a default for kwargs, as that initializes the dict only once in Python
# and uses the same dict in all subsequent calls of this method
if not kwargs:
kwargs = {}
self.proper_kwargs('dependencies', kwargs)
sections = self._get_dependency_sections_to_use(kwargs)
deps = []
for sect in sections:
if expand_only:
deps.extend(lang.expand_dependencies_section(sect, kwargs))
else:
deps.extend(lang.dependencies_section(sect, kwargs, runner=self))
return deps |
Return text for prompt (do you want to install...), to install given packages.
def get_perm_prompt(cls, package_list):
"""
Return text for prompt (do you want to install...), to install given packages.
"""
if cls == PackageManager:
raise NotImplementedError()
ln = len(package_list)
plural = 's' if ln > 1 else ''
return cls.permission_prompt.format(num=ln, plural=plural) |
Try to detect a package manager used in a current Gentoo system.
def _try_get_current_manager(cls):
""" Try to detect a package manager used in a current Gentoo system. """
if utils.get_distro_name().find('gentoo') == -1:
return None
if 'PACKAGE_MANAGER' in os.environ:
pm = os.environ['PACKAGE_MANAGER']
if pm == 'paludis':
# Try to import paludis module
try:
import paludis
return GentooPackageManager.PALUDIS
except ImportError:
# TODO Environment tells that paludis must be used, but
# it seems latter was build w/o USE=python...
# Need to report an error!!??
cls._debug_doesnt_work('can\'t import paludis', name='PaludisPackageManager')
return None
elif pm == 'portage':
# Fallback to default: portage
pass
else:
# ATTENTION Some unknown package manager?! Which one?
return None
# Try to import portage module
try:
import portage
return GentooPackageManager.PORTAGE
except ImportError:
cls._debug_doesnt_work('can\'t import portage', name='EmergePackageManager')
return None |
Returns True if this package manager is usable, False otherwise.
def is_current_manager_equals_to(cls, pm):
"""Returns True if this package manager is usable, False otherwise."""
if hasattr(cls, 'works_result'):
return cls.works_result
is_ok = bool(cls._try_get_current_manager() == pm)
setattr(cls, 'works_result', is_ok)
return is_ok |
Choose proper package manager and return it.
def get_package_manager(self, dep_t):
"""Choose proper package manager and return it."""
mgrs = managers.get(dep_t, [])
for manager in mgrs:
if manager.works():
return manager
if not mgrs:
err = 'No package manager for dependency type "{dep_t}"'.format(dep_t=dep_t)
raise exceptions.NoPackageManagerException(err)
else:
mgrs_nice = ', '.join([mgr.__name__ for mgr in mgrs])
err = 'No working package manager for "{dep_t}" in: {mgrs}'.format(dep_t=dep_t,
mgrs=mgrs_nice)
raise exceptions.NoPackageManagerOperationalException(err) |
Add dependencies into self.dependencies, possibly also adding system packages
that contain non-distro package managers (e.g. if someone wants to install
dependencies with pip and pip is not present, it will get installed through
RPM on RPM based systems, etc.
Skips dependencies that are supposed to be installed by system manager that
is not native to this system.
def _process_dependency(self, dep_t, dep_l):
"""Add dependencies into self.dependencies, possibly also adding system packages
that contain non-distro package managers (e.g. if someone wants to install
dependencies with pip and pip is not present, it will get installed through
RPM on RPM based systems, etc.
Skips dependencies that are supposed to be installed by system manager that
is not native to this system.
"""
if dep_t not in managers:
err = 'No package manager for dependency type "{dep_t}"'.format(dep_t=dep_t)
raise exceptions.NoPackageManagerException(err)
# try to get list of distros where the dependency type is system type
distros = settings.SYSTEM_DEPTYPES_SHORTCUTS.get(dep_t, None)
if not distros: # non-distro dependency type
sysdep_t = self.get_system_deptype_shortcut()
# for now, just take the first manager that can install dep_t and install this manager
self._process_dependency(sysdep_t,
managers[dep_t][0].get_distro_dependencies(sysdep_t))
else:
local_distro = utils.get_distro_name()
found = False
for distro in distros:
if distro in local_distro:
found = True
break
if not found: # distro dependency type, but for another distro
return
self.__add_dependencies(dep_t, dep_l) |
Return True if user wants to install packages, False otherwise
def _ask_to_confirm(self, ui, pac_man, *to_install):
""" Return True if user wants to install packages, False otherwise """
ret = DialogHelper.ask_for_package_list_confirm(
ui, prompt=pac_man.get_perm_prompt(to_install),
package_list=to_install,
)
return bool(ret) |
Install missing dependencies
def _install_dependencies(self, ui, debug):
"""Install missing dependencies"""
for dep_t, dep_l in self.dependencies:
if not dep_l:
continue
pkg_mgr = self.get_package_manager(dep_t)
pkg_mgr.works()
to_resolve = []
for dep in dep_l:
if not pkg_mgr.is_pkg_installed(dep):
to_resolve.append(dep)
if not to_resolve:
# nothing to install, let's move on
continue
to_install = pkg_mgr.resolve(*to_resolve)
confirm = self._ask_to_confirm(ui, pkg_mgr, *to_install)
if not confirm:
msg = 'List of packages denied by user, exiting.'
raise exceptions.DependencyException(msg)
type(self).install_lock = True
# TODO: we should do this more systematically (send signal to cl/gui?)
logger.info('Installing dependencies, sit back and relax ...',
extra={'event_type': 'dep_installation_start'})
if ui == 'cli' and not debug: # TODO: maybe let every manager to decide when to start
event = threading.Event()
t = EndlessProgressThread(event)
t.start()
installed = pkg_mgr.install(*to_install)
if ui == 'cli' and not debug:
event.set()
t.join()
if installed:
logger.info(' Done.')
else:
logger.error(' Failed.')
type(self).install_lock = False
log_extra = {'event_type': 'dep_installation_end'}
if not installed:
msg = 'Failed to install dependencies, exiting.'
logger.error(msg, extra=log_extra)
raise exceptions.DependencyException(msg)
else:
logger.info('Successfully installed dependencies!', extra=log_extra) |
This is the only method that should be called from outside. Call it
like:
`DependencyInstaller(struct)` and it will install packages which are
not present on system (it uses package managers specified by `struct`
structure)
def install(self, struct, ui, debug=False):
"""
This is the only method that should be called from outside. Call it
like:
`DependencyInstaller(struct)` and it will install packages which are
not present on system (it uses package managers specified by `struct`
structure)
"""
# the system dependencies should always go first
self.__add_dependencies(self.get_system_deptype_shortcut(), [])
for dep_dict in struct:
for dep_t, dep_l in dep_dict.items():
self._process_dependency(dep_t, dep_l)
if self.dependencies:
self._install_dependencies(ui, debug) |
Checks and refreshes (if needed) all assistants with given role.
Args:
role: role of assistants to refresh
file_hierarchy: hierarchy as returned by devassistant.yaml_assistant_loader.\
YamlAssistantLoader.get_assistants_file_hierarchy
def refresh_role(self, role, file_hierarchy):
"""Checks and refreshes (if needed) all assistants with given role.
Args:
role: role of assistants to refresh
file_hierarchy: hierarchy as returned by devassistant.yaml_assistant_loader.\
YamlAssistantLoader.get_assistants_file_hierarchy
"""
if role not in self.cache:
self.cache[role] = {}
was_change = self._refresh_hierarchy_recursive(self.cache[role], file_hierarchy)
if was_change:
cf = open(self.cache_file, 'w')
yaml.dump(self.cache, cf, Dumper=Dumper)
cf.close() |
Recursively goes through given corresponding hierarchies from cache and filesystem
and adds/refreshes/removes added/changed/removed assistants.
Args:
cached_hierarchy: the respective hierarchy part from current cache
(for format see Cache class docstring)
file_hierarchy: the respective hierarchy part from filesystem
(for format see what refresh_role accepts)
Returns:
True if self.cache has been changed, False otherwise (doesn't write anything
to cache file)
def _refresh_hierarchy_recursive(self, cached_hierarchy, file_hierarchy):
"""Recursively goes through given corresponding hierarchies from cache and filesystem
and adds/refreshes/removes added/changed/removed assistants.
Args:
cached_hierarchy: the respective hierarchy part from current cache
(for format see Cache class docstring)
file_hierarchy: the respective hierarchy part from filesystem
(for format see what refresh_role accepts)
Returns:
True if self.cache has been changed, False otherwise (doesn't write anything
to cache file)
"""
was_change = False
cached_ass = set(cached_hierarchy.keys())
new_ass = set(file_hierarchy.keys())
to_add = new_ass - cached_ass
to_remove = cached_ass - new_ass
to_check = cached_ass - to_remove
if to_add or to_remove:
was_change = True
for ass in to_add:
cached_hierarchy[ass] = self._new_ass_hierarchy(file_hierarchy[ass])
for ass in to_remove:
del cached_hierarchy[ass]
for ass in to_check:
needs_refresh = False
try:
needs_refresh = self._ass_needs_refresh(cached_hierarchy[ass], file_hierarchy[ass])
except:
needs_refresh = True
if needs_refresh:
self._ass_refresh_attrs(cached_hierarchy[ass], file_hierarchy[ass])
was_change = True
was_change |= self._refresh_hierarchy_recursive(
cached_hierarchy[ass]['subhierarchy'],
file_hierarchy[ass]['subhierarchy'])
return was_change |
Checks if assistant needs refresh.
Assistant needs refresh iff any of following conditions is True:
- stored source file is different than given source file
- stored assistant ctime is lower than current source file ctime
- stored list of subassistants is different than given list of subassistants
- stored ctime of any of the snippets that this assistant uses to compose
args is lower than current ctime of that snippet
Args:
cached_ass: an assistant from cache hierarchy
(for format see Cache class docstring)
file_ass: the respective assistant from filesystem hierarchy
(for format see what refresh_role accepts)
def _ass_needs_refresh(self, cached_ass, file_ass):
"""Checks if assistant needs refresh.
Assistant needs refresh iff any of following conditions is True:
- stored source file is different than given source file
- stored assistant ctime is lower than current source file ctime
- stored list of subassistants is different than given list of subassistants
- stored ctime of any of the snippets that this assistant uses to compose
args is lower than current ctime of that snippet
Args:
cached_ass: an assistant from cache hierarchy
(for format see Cache class docstring)
file_ass: the respective assistant from filesystem hierarchy
(for format see what refresh_role accepts)
"""
if cached_ass['source'] != file_ass['source']:
return True
if os.path.getctime(file_ass['source']) > cached_ass.get('ctime', 0.0):
return True
if set(cached_ass['subhierarchy'].keys()) != set(set(file_ass['subhierarchy'].keys())):
return True
for snip_name, snip_ctime in cached_ass['snippets'].items():
if self._get_snippet_ctime(snip_name) > snip_ctime:
return True
return False |
Completely refreshes cached assistant from file.
Args:
cached_ass: an assistant from cache hierarchy
(for format see Cache class docstring)
file_ass: the respective assistant from filesystem hierarchy
(for format see what refresh_role accepts)
def _ass_refresh_attrs(self, cached_ass, file_ass):
"""Completely refreshes cached assistant from file.
Args:
cached_ass: an assistant from cache hierarchy
(for format see Cache class docstring)
file_ass: the respective assistant from filesystem hierarchy
(for format see what refresh_role accepts)
"""
# we need to process assistant in custom way to see unexpanded args, etc.
loaded_ass = yaml_loader.YamlLoader.load_yaml_by_path(file_ass['source'], log_debug=True)
attrs = loaded_ass
yaml_checker.check(file_ass['source'], attrs)
cached_ass['source'] = file_ass['source']
cached_ass['ctime'] = os.path.getctime(file_ass['source'])
cached_ass['attrs'] = {}
cached_ass['snippets'] = {}
# only cache these attributes if they're actually found in assistant
# we do this to specify the default values for them just in one place
# which is currently YamlAssistant.parsed_yaml property setter
for a in ['fullname', 'description', 'icon_path']:
if a in attrs:
cached_ass['attrs'][a] = attrs.get(a)
# args have different processing, we can't just take them from assistant
if 'args' in attrs:
cached_ass['attrs']['args'] = {}
for argname, argparams in attrs.get('args', {}).items():
if 'use' in argparams or 'snippet' in argparams:
snippet_name = argparams.pop('use', None) or argparams.pop('snippet')
snippet = yaml_snippet_loader.YamlSnippetLoader.get_snippet_by_name(snippet_name)
cached_ass['attrs']['args'][argname] = snippet.get_arg_by_name(argname)
cached_ass['attrs']['args'][argname].update(argparams)
cached_ass['snippets'][snippet.name] = self._get_snippet_ctime(snippet.name)
else:
cached_ass['attrs']['args'][argname] = argparams |
Returns a completely new cache hierarchy for given assistant file.
Args:
file_ass: the assistant from filesystem hierarchy to create cache hierarchy for
(for format see what refresh_role accepts)
Returns:
the newly created cache hierarchy
def _new_ass_hierarchy(self, file_ass):
"""Returns a completely new cache hierarchy for given assistant file.
Args:
file_ass: the assistant from filesystem hierarchy to create cache hierarchy for
(for format see what refresh_role accepts)
Returns:
the newly created cache hierarchy
"""
ret_struct = {'source': '',
'subhierarchy': {},
'attrs': {},
'snippets': {}}
ret_struct['source'] = file_ass['source']
self._ass_refresh_attrs(ret_struct, file_ass)
for name, subhierarchy in file_ass['subhierarchy'].items():
ret_struct['subhierarchy'][name] = self._new_ass_hierarchy(subhierarchy)
return ret_struct |
Returns and remembers (during this DevAssistant invocation) last ctime of given
snippet.
Calling ctime costs lost of time and some snippets, like common_args, are used widely,
so we don't want to call ctime bazillion times on them during one invocation.
Args:
snip_name: name of snippet to get ctime for
Returns:
ctime of the snippet
def _get_snippet_ctime(self, snip_name):
"""Returns and remembers (during this DevAssistant invocation) last ctime of given
snippet.
Calling ctime costs lost of time and some snippets, like common_args, are used widely,
so we don't want to call ctime bazillion times on them during one invocation.
Args:
snip_name: name of snippet to get ctime for
Returns:
ctime of the snippet
"""
if snip_name not in self.snip_ctimes:
snippet = yaml_snippet_loader.YamlSnippetLoader.get_snippet_by_name(snip_name)
self.snip_ctimes[snip_name] = os.path.getctime(snippet.path)
return self.snip_ctimes[snip_name] |
Expands dependency section, e.g. substitues "use: foo" for its contents, but
doesn't evaluate conditions nor substitue variables.
def expand_dependencies_section(section, kwargs):
"""Expands dependency section, e.g. substitues "use: foo" for its contents, but
doesn't evaluate conditions nor substitue variables."""
deps = []
for dep in section:
for dep_type, dep_list in dep.items():
if dep_type in ['call', 'use']:
deps.extend(Command(dep_type, dep_list, kwargs).run())
elif dep_type.startswith('if ') or dep_type == 'else':
deps.append({dep_type: expand_dependencies_section(dep_list, kwargs)})
else:
deps.append({dep_type: dep_list})
return deps |
Returns name of loop control variable(s), iteration type (in/word_in) and
expression to iterate on.
For example:
- given "for $i in $foo", returns (['i'], '$foo')
- given "for ${i} in $(ls $foo)", returns (['i'], '$(ls $foo)')
- given "for $k, $v in $foo", returns (['k', 'v'], '$foo')
def parse_for(control_line):
"""Returns name of loop control variable(s), iteration type (in/word_in) and
expression to iterate on.
For example:
- given "for $i in $foo", returns (['i'], '$foo')
- given "for ${i} in $(ls $foo)", returns (['i'], '$(ls $foo)')
- given "for $k, $v in $foo", returns (['k', 'v'], '$foo')
"""
error = 'For loop call must be in form \'for $var in expression\', got: ' + control_line
regex = re.compile(r'for\s+(\${?\S+}?)(?:\s*,\s+(\${?\S+}?))?\s+(in|word_in)\s+(\S.+)')
res = regex.match(control_line)
if not res:
raise exceptions.YamlSyntaxError(error)
groups = res.groups()
control_vars = []
control_vars.append(get_var_name(groups[0]))
if groups[1]:
control_vars.append(get_var_name(groups[1]))
iter_type = groups[2]
expr = groups[3]
return (control_vars, iter_type, expr) |
Returns tuple that consists of control variable name and iterable that is result
of evaluated expression of given for loop.
For example:
- given 'for $i in $(echo "foo bar")' it returns (['i'], ['foo', 'bar'])
- given 'for $i, $j in $foo' it returns (['i', 'j'], [('foo', 'bar')])
def get_for_control_var_and_eval_expr(comm_type, kwargs):
"""Returns tuple that consists of control variable name and iterable that is result
of evaluated expression of given for loop.
For example:
- given 'for $i in $(echo "foo bar")' it returns (['i'], ['foo', 'bar'])
- given 'for $i, $j in $foo' it returns (['i', 'j'], [('foo', 'bar')])
"""
# let possible exceptions bubble up
control_vars, iter_type, expression = parse_for(comm_type)
eval_expression = evaluate_expression(expression, kwargs)[1]
iterval = []
if len(control_vars) == 2:
if not isinstance(eval_expression, dict):
raise exceptions.YamlSyntaxError('Can\'t expand {t} to two control variables.'.
format(t=type(eval_expression)))
else:
iterval = list(eval_expression.items())
elif isinstance(eval_expression, six.string_types):
if iter_type == 'word_in':
iterval = eval_expression.split()
else:
iterval = eval_expression
else:
iterval = eval_expression
return control_vars, iterval |
Returns section that should be used from given if/else sections by evaluating given
condition.
Args:
if_section - section with if clause
else_section - section that *may* be else clause (just next section after if_section,
this method will check if it really is else); possibly None if not present
Returns:
tuple (<0 or 1>, <True or False>, section), where
- the first member says whether we're going to "if" section (0) or else section (1)
- the second member says whether we should skip next section during further evaluation
(True or False - either we have else to skip, or we don't)
- the third member is the appropriate section to run or None if there is only "if"
clause and condition evaluates to False
def get_section_from_condition(if_section, else_section, kwargs):
"""Returns section that should be used from given if/else sections by evaluating given
condition.
Args:
if_section - section with if clause
else_section - section that *may* be else clause (just next section after if_section,
this method will check if it really is else); possibly None if not present
Returns:
tuple (<0 or 1>, <True or False>, section), where
- the first member says whether we're going to "if" section (0) or else section (1)
- the second member says whether we should skip next section during further evaluation
(True or False - either we have else to skip, or we don't)
- the third member is the appropriate section to run or None if there is only "if"
clause and condition evaluates to False
"""
# check if else section is really else
skip = True if else_section is not None and else_section[0] == 'else' else False
if evaluate_expression(if_section[0][2:].strip(), kwargs)[0]:
return (0, skip, if_section[1])
else:
return (1, skip, else_section[1]) if skip else (1, skip, None) |
Returns 2-tuple with names of catch control vars, e.g. for "catch $was_exc, $exc"
it returns ('was_exc', 'err').
Args:
catch: the whole catch line
Returns:
2-tuple with names of catch control variables
Raises:
exceptions.YamlSyntaxError if the catch line is malformed
def get_catch_vars(catch):
"""Returns 2-tuple with names of catch control vars, e.g. for "catch $was_exc, $exc"
it returns ('was_exc', 'err').
Args:
catch: the whole catch line
Returns:
2-tuple with names of catch control variables
Raises:
exceptions.YamlSyntaxError if the catch line is malformed
"""
catch_re = re.compile(r'catch\s+(\${?\S+}?),\s*(\${?\S+}?)')
res = catch_re.match(catch)
if res is None:
err = 'Catch must have format "catch $x, $y", got "{0}"'.format(catch)
raise exceptions.YamlSyntaxError(err)
return get_var_name(res.group(1)), get_var_name(res.group(2)) |
Assigns given result (resp. logical result and result) to a variable
(resp. to two variables). log_res and res are already computed result
of an exec/input section. For example:
$foo~: $spam and $eggs
$log_res, $foo~: $spam and $eggs
$foo:
some: struct
$log_res, $foo:
some:
other:
struct
Args:
variable: variable (or two variables separated by ",") to assign to
log_res: logical result of evaluated section
res: result of evaluated section
Raises:
YamlSyntaxError: if there are more than two variables
def assign_variable(variable, log_res, res, kwargs):
"""Assigns given result (resp. logical result and result) to a variable
(resp. to two variables). log_res and res are already computed result
of an exec/input section. For example:
$foo~: $spam and $eggs
$log_res, $foo~: $spam and $eggs
$foo:
some: struct
$log_res, $foo:
some:
other:
struct
Args:
variable: variable (or two variables separated by ",") to assign to
log_res: logical result of evaluated section
res: result of evaluated section
Raises:
YamlSyntaxError: if there are more than two variables
"""
if variable.endswith('~'):
variable = variable[:-1]
comma_count = variable.count(',')
if comma_count > 1:
raise exceptions.YamlSyntaxError('Max two variables allowed on left side.')
if comma_count == 1:
var1, var2 = map(lambda v: get_var_name(v), variable.split(','))
kwargs[var1] = log_res
else:
var2 = get_var_name(variable)
kwargs[var2] = res
return log_res, res |
Adds symbol 'id' to symbol_table if it does not exist already,
if it does it merely updates its binding power and returns it's
symbol class
def symbol(self, id, bp=0):
"""
Adds symbol 'id' to symbol_table if it does not exist already,
if it does it merely updates its binding power and returns it's
symbol class
"""
try:
s = self.symbol_table[id]
except KeyError:
class s(self.symbol_base):
pass
s.id = id
s.lbp = bp
self.symbol_table[id] = s
else:
s.lbp = max(bp, s.lbp)
return s |
Advance to next token, optionally check that current token is 'id'
def advance(self, id=None):
"""
Advance to next token, optionally check that current token is 'id'
"""
if id and self.token.id != id:
raise SyntaxError("Expected {0}".format(id))
self.token = self.next() |
A decorator - adds the decorated method to symbol 'symbol_name'
def method(self, symbol_name):
"""
A decorator - adds the decorated method to symbol 'symbol_name'
"""
s = self.symbol(symbol_name)
def bind(fn):
setattr(s, fn.__name__, fn)
return bind |
Evaluates 'expression' and returns it's value(s)
def parse(self, expression):
"""
Evaluates 'expression' and returns it's value(s)
"""
if isinstance(expression, (list, dict)):
return (True if expression else False, expression)
if sys.version_info[0] > 2:
self.next = self.tokenize(expression).__next__
else:
self.next = self.tokenize(expression).next
self.token = self.next()
return self.expression() |
Returns set of all possible platforms
def get_platforms_set():
'''Returns set of all possible platforms'''
# arch and mageia are not in Py2 _supported_dists, so we add them manually
# Ubuntu adds itself to the list on Ubuntu
platforms = set([x.lower() for x in platform._supported_dists])
platforms |= set(['darwin', 'arch', 'mageia', 'ubuntu'])
return platforms |
If given relative path exists in one of DevAssistant load paths,
return its full path.
Args:
relpath: a relative path, e.g. "assitants/crt/test.yaml"
Returns:
absolute path of the file, e.g. "/home/x/.devassistant/assistanta/crt/test.yaml
or None if file is not found
def find_file_in_load_dirs(relpath):
"""If given relative path exists in one of DevAssistant load paths,
return its full path.
Args:
relpath: a relative path, e.g. "assitants/crt/test.yaml"
Returns:
absolute path of the file, e.g. "/home/x/.devassistant/assistanta/crt/test.yaml
or None if file is not found
"""
if relpath.startswith(os.path.sep):
relpath = relpath.lstrip(os.path.sep)
for ld in settings.DATA_DIRECTORIES:
possible_path = os.path.join(ld, relpath)
if os.path.exists(possible_path):
return possible_path |
Function that behaves exactly like Python's atexit, but runs atexit functions
in the order in which they were registered, not reversed.
def run_exitfuncs():
"""Function that behaves exactly like Python's atexit, but runs atexit functions
in the order in which they were registered, not reversed.
"""
exc_info = None
for func, targs, kargs in _exithandlers:
try:
func(*targs, **kargs)
except SystemExit:
exc_info = sys.exc_info()
except:
exc_info = sys.exc_info()
if exc_info is not None:
six.reraise(exc_info[0], exc_info[1], exc_info[2]) |
Strip the prefix from the string
If 'regex' is specified, prefix is understood as a regular expression.
def strip_prefix(string, prefix, regex=False):
"""Strip the prefix from the string
If 'regex' is specified, prefix is understood as a regular expression."""
if not isinstance(string, six.string_types) or not isinstance(prefix, six.string_types):
msg = 'Arguments to strip_prefix must be string types. Are: {s}, {p}'\
.format(s=type(string), p=type(prefix))
raise TypeError(msg)
if not regex:
prefix = re.escape(prefix)
if not prefix.startswith('^'):
prefix = '^({s})'.format(s=prefix)
return _strip(string, prefix) |
Strip the suffix from the string.
If 'regex' is specified, suffix is understood as a regular expression.
def strip_suffix(string, suffix, regex=False):
"""Strip the suffix from the string.
If 'regex' is specified, suffix is understood as a regular expression."""
if not isinstance(string, six.string_types) or not isinstance(suffix, six.string_types):
msg = 'Arguments to strip_suffix must be string types. Are: {s}, {p}'\
.format(s=type(string), p=type(suffix))
raise TypeError(msg)
if not regex:
suffix = re.escape(suffix)
if not suffix.endswith('$'):
suffix = '({s})$'.format(s=suffix)
return _strip(string, suffix) |
Return complement of pattern in string
def _strip(string, pattern):
"""Return complement of pattern in string"""
m = re.compile(pattern).search(string)
if m:
return string[0:m.start()] + string[m.end():len(string)]
else:
return string |
Registers console logging handler to given logger.
def register_console_logging_handler(cls, lgr, level=logging.INFO):
"""Registers console logging handler to given logger."""
console_handler = logger.DevassistantClHandler(sys.stdout)
if console_handler.stream.isatty():
console_handler.setFormatter(logger.DevassistantClColorFormatter())
else:
console_handler.setFormatter(logger.DevassistantClFormatter())
console_handler.setLevel(level)
cls.cur_handler = console_handler
lgr.addHandler(console_handler) |
Runs the whole cli:
1. Registers console logging handler
2. Creates argparser from all assistants and actions
3. Parses args and decides what to run
4. Runs a proper assistant or action
def run(cls):
"""Runs the whole cli:
1. Registers console logging handler
2. Creates argparser from all assistants and actions
3. Parses args and decides what to run
4. Runs a proper assistant or action
"""
sigint_handler.override()
# set settings.USE_CACHE before constructing parser, since constructing
# parser requires loaded assistants
settings.USE_CACHE = False if '--no-cache' in sys.argv else True
cls.register_console_logging_handler(logger.logger)
is_log_file = logger.add_log_file_handler(settings.LOG_FILE)
if not is_log_file:
logger.logger.warning("Could not create log file '{0}'.".format(settings.LOG_FILE))
cls.inform_of_short_bin_name(sys.argv[0])
top_assistant = bin.TopAssistant()
tree = top_assistant.get_subassistant_tree()
argparser = argparse_generator.ArgparseGenerator.\
generate_argument_parser(tree, actions=actions.actions)
parsed_args = vars(argparser.parse_args())
parsed_args_decoded = dict()
for k, v in parsed_args.items():
parsed_args_decoded[k] = \
v.decode(utils.defenc) if not six.PY3 and isinstance(v, str) else v
parsed_args_decoded['__ui__'] = 'cli'
if parsed_args.get('da_debug'):
cls.change_logging_level(logging.DEBUG)
# Prepare Action/PathRunner
if actions.is_action_run(**parsed_args_decoded):
to_run = actions.get_action_to_run(**parsed_args_decoded)(**parsed_args_decoded)
else:
parsed_args = cls.transform_executable_assistant_alias(parsed_args_decoded)
path = top_assistant.get_selected_subassistant_path(**parsed_args_decoded)
to_run = path_runner.PathRunner(path, parsed_args_decoded)
try:
to_run.run()
except exceptions.ExecutionException:
# error is already logged, just catch it and silently exit here
sys.exit(1) |
Historically, we had "devassistant" binary, but we chose to go with
shorter "da". We still allow "devassistant", but we recommend using "da".
def inform_of_short_bin_name(cls, binary):
"""Historically, we had "devassistant" binary, but we chose to go with
shorter "da". We still allow "devassistant", but we recommend using "da".
"""
binary = os.path.splitext(os.path.basename(binary))[0]
if binary != 'da':
msg = '"da" is the preffered way of running "{binary}".'.format(binary=binary)
logger.logger.info('*' * len(msg))
logger.logger.info(msg)
logger.logger.info('*' * len(msg)) |
Function returns a full dir name
def get_full_dir_name(self):
"""
Function returns a full dir name
"""
return os.path.join(self.dir_name.get_text(), self.entry_project_name.get_text()) |
Function opens the run Window who executes the
assistant project creation
def next_window(self, widget, data=None):
"""
Function opens the run Window who executes the
assistant project creation
"""
# check whether deps-only is selected
deps_only = ('deps_only' in self.args and self.args['deps_only']['checkbox'].get_active())
# preserve argument value if it is needed to be preserved
for arg_dict in [x for x in self.args.values() if 'preserved' in x['arg'].kwargs]:
preserve_key = arg_dict['arg'].kwargs['preserved']
# preserve entry text (string value)
if 'entry' in arg_dict:
if self.arg_is_selected(arg_dict):
config_manager.set_config_value(preserve_key, arg_dict['entry'].get_text())
# preserve if checkbox is ticked (boolean value)
else:
config_manager.set_config_value(preserve_key, self.arg_is_selected(arg_dict))
# save configuration into file
config_manager.save_configuration_file()
# get project directory and name
project_dir = self.dir_name.get_text()
full_name = self.get_full_dir_name()
# check whether project directory and name is properly set
if not deps_only and self.current_main_assistant.name == 'crt':
if project_dir == "":
return self.gui_helper.execute_dialog("Specify directory for project")
else:
# check whether directory is existing
if not os.path.isdir(project_dir):
response = self.gui_helper.create_question_dialog(
"Directory {0} does not exists".format(project_dir),
"Do you want to create them?"
)
if response == Gtk.ResponseType.NO:
# User do not want to create a directory
return
else:
# Create directory
try:
os.makedirs(project_dir)
except OSError as os_err:
return self.gui_helper.execute_dialog("{0}".format(os_err))
elif os.path.isdir(full_name):
return self.check_for_directory(full_name)
if not self._build_flags():
return
if not deps_only and self.current_main_assistant.name == 'crt':
self.kwargs['name'] = full_name
self.kwargs['__ui__'] = 'gui_gtk+'
self.data['kwargs'] = self.kwargs
self.data['top_assistant'] = self.top_assistant
self.data['current_main_assistant'] = self.current_main_assistant
self.parent.run_window.open_window(widget, self.data)
self.path_window.hide() |
Function builds kwargs variable for run_window
def _build_flags(self):
"""
Function builds kwargs variable for run_window
"""
# Check if all entries for selected arguments are nonempty
for arg_dict in [x for x in self.args.values() if self.arg_is_selected(x)]:
if 'entry' in arg_dict and not arg_dict['entry'].get_text():
self.gui_helper.execute_dialog("Entry {0} is empty".format(arg_dict['label']))
return False
# Check for active CheckButtons
for arg_dict in [x for x in self.args.values() if self.arg_is_selected(x)]:
arg_name = arg_dict['arg'].get_dest()
if 'entry' in arg_dict:
self.kwargs[arg_name] = arg_dict['entry'].get_text()
else:
if arg_dict['arg'].get_gui_hint('type') == 'const':
self.kwargs[arg_name] = arg_dict['arg'].kwargs['const']
else:
self.kwargs[arg_name] = True
# Check for non active CheckButtons but with defaults flag
for arg_dict in [x for x in self.args.values() if not self.arg_is_selected(x)]:
arg_name = arg_dict['arg'].get_dest()
if 'default' in arg_dict['arg'].kwargs:
self.kwargs[arg_name] = arg_dict['arg'].get_gui_hint('default')
elif arg_name in self.kwargs:
del self.kwargs[arg_name]
return True |
Function opens the Options dialog
def open_window(self, data=None):
"""
Function opens the Options dialog
"""
self.args = dict()
if data is not None:
self.top_assistant = data.get('top_assistant', None)
self.current_main_assistant = data.get('current_main_assistant', None)
self.kwargs = data.get('kwargs', None)
self.data['debugging'] = data.get('debugging', False)
project_dir = self.get_default_project_dir()
self.dir_name.set_text(project_dir)
self.label_full_prj_dir.set_text(project_dir)
self.dir_name.set_sensitive(True)
self.dir_name_browse_btn.set_sensitive(True)
self._remove_widget_items()
if self.current_main_assistant.name != 'crt' and self.project_name_shown:
self.box6.remove(self.box_project)
self.project_name_shown = False
elif self.current_main_assistant.name == 'crt' and not self.project_name_shown:
self.box6.remove(self.box_path_main)
self.box6.pack_start(self.box_project, False, False, 0)
self.box6.pack_end(self.box_path_main, False, False, 0)
self.project_name_shown = True
caption_text = "Project: "
row = 0
# get selectected assistants, but without TopAssistant itself
path = self.top_assistant.get_selected_subassistant_path(**self.kwargs)[1:]
caption_parts = []
# Finds any dependencies
found_deps = [x for x in path if x.dependencies()]
# This bool variable is used for showing text "Available options:"
any_options = False
for assistant in path:
caption_parts.append("<b>" + assistant.fullname + "</b>")
for arg in sorted([x for x in assistant.args if not '--name' in x.flags], key=lambda y: y.flags):
if not (arg.name == "deps_only" and not found_deps):
row = self._add_table_row(arg, len(arg.flags) - 1, row) + 1
any_options = True
if not any_options:
self.title.set_text("")
else:
self.title.set_text("Available options:")
caption_text += ' -> '.join(caption_parts)
self.label_caption.set_markup(caption_text)
self.path_window.show_all()
self.entry_project_name.set_text(os.path.basename(self.kwargs.get('name', '')))
self.entry_project_name.set_sensitive(True)
self.run_btn.set_sensitive(not self.project_name_shown or self.entry_project_name.get_text() != "")
if 'name' in self.kwargs:
self.dir_name.set_text(os.path.dirname(self.kwargs.get('name', '')))
for arg_name, arg_dict in [(k, v) for (k, v) in self.args.items() if self.kwargs.get(k)]:
if 'checkbox' in arg_dict:
arg_dict['checkbox'].set_active(True)
if 'entry' in arg_dict:
arg_dict['entry'].set_sensitive(True)
arg_dict['entry'].set_text(self.kwargs[arg_name])
if 'browse_btn' in arg_dict:
arg_dict['browse_btn'].set_sensitive(True) |
Function manipulates with entries and buttons.
def _check_box_toggled(self, widget, data=None):
"""
Function manipulates with entries and buttons.
"""
active = widget.get_active()
arg_name = data
if 'entry' in self.args[arg_name]:
self.args[arg_name]['entry'].set_sensitive(active)
if 'browse_btn' in self.args[arg_name]:
self.args[arg_name]['browse_btn'].set_sensitive(active)
self.path_window.show_all() |
Function deactivate options in case of deps_only and opposite
def _deps_only_toggled(self, widget, data=None):
"""
Function deactivate options in case of deps_only and opposite
"""
active = widget.get_active()
self.dir_name.set_sensitive(not active)
self.entry_project_name.set_sensitive(not active)
self.dir_name_browse_btn.set_sensitive(not active)
self.run_btn.set_sensitive(active or not self.project_name_shown or self.entry_project_name.get_text() != "") |
Function returns to Main Window
def prev_window(self, widget, data=None):
"""
Function returns to Main Window
"""
self.path_window.hide()
self.parent.open_window(widget, self.data) |
Function opens the file chooser dialog for settings project dir
def browse_path(self, window):
"""
Function opens the file chooser dialog for settings project dir
"""
text = self.gui_helper.create_file_chooser_dialog("Choose project directory", self.path_window, name="Select")
if text is not None:
self.dir_name.set_text(text) |
Function adds options to a grid
def _add_table_row(self, arg, number, row):
"""
Function adds options to a grid
"""
self.args[arg.name] = dict()
self.args[arg.name]['arg'] = arg
check_box_title = arg.flags[number][2:].title()
self.args[arg.name]['label'] = check_box_title
align = self.gui_helper.create_alignment()
if arg.kwargs.get('required'):
# If argument is required then red star instead of checkbox
star_label = self.gui_helper.create_label('<span color="#FF0000">*</span>')
star_label.set_padding(0, 3)
label = self.gui_helper.create_label(check_box_title)
box = self.gui_helper.create_box()
box.pack_start(star_label, False, False, 6)
box.pack_start(label, False, False, 6)
align.add(box)
else:
chbox = self.gui_helper.create_checkbox(check_box_title)
chbox.set_alignment(0, 0)
if arg.name == "deps_only":
chbox.connect("clicked", self._deps_only_toggled)
else:
chbox.connect("clicked", self._check_box_toggled, arg.name)
align.add(chbox)
self.args[arg.name]['checkbox'] = chbox
if row == 0:
self.grid.add(align)
else:
self.grid.attach(align, 0, row, 1, 1)
label = self.gui_helper.create_label(arg.kwargs['help'], justify=Gtk.Justification.LEFT)
label.set_alignment(0, 0)
label.set_padding(0, 3)
self.grid.attach(label, 1, row, 1, 1)
label_check_box = self.gui_helper.create_label(name="")
self.grid.attach(label_check_box, 0, row, 1, 1)
if arg.get_gui_hint('type') not in ['bool', 'const']:
new_box = self.gui_helper.create_box(spacing=6)
entry = self.gui_helper.create_entry(text="")
align = self.gui_helper.create_alignment()
align.add(entry)
new_box.pack_start(align, False, False, 6)
align_btn = self.gui_helper.create_alignment()
''' If a button is needed please add there and in function
_check_box_toggled
Also do not forget to create a function for that button
This can not be done by any automatic tool from those reasons
Some fields needs a input user like user name for GitHub
and some fields needs to have interaction from user like selecting directory
'''
entry.set_text(arg.get_gui_hint('default'))
entry.set_sensitive(arg.kwargs.get('required') == True)
if arg.get_gui_hint('type') == 'path':
browse_btn = self.gui_helper.button_with_label("Browse")
browse_btn.connect("clicked", self.browse_clicked, entry)
browse_btn.set_sensitive(arg.kwargs.get('required') == True)
align_btn.add(browse_btn)
self.args[arg.name]['browse_btn'] = browse_btn
elif arg.get_gui_hint('type') == 'str':
if arg.name == 'github' or arg.name == 'github-login':
link_button = self.gui_helper.create_link_button(text="For registration visit GitHub Homepage",
uri="https://www.github.com")
align_btn.add(link_button)
new_box.pack_start(align_btn, False, False, 6)
row += 1
self.args[arg.name]['entry'] = entry
self.grid.attach(new_box, 1, row, 1, 1)
else:
if 'preserved' in arg.kwargs and config_manager.get_config_value(arg.kwargs['preserved']):
if 'checkbox' in self.args[arg.name]:
self.args[arg.name]['checkbox'].set_active(True)
return row |
Function sets the directory to entry
def browse_clicked(self, widget, data=None):
"""
Function sets the directory to entry
"""
text = self.gui_helper.create_file_chooser_dialog("Please select directory", self.path_window)
if text is not None:
data.set_text(text) |
Function controls whether run button is enabled
def project_name_changed(self, widget, data=None):
"""
Function controls whether run button is enabled
"""
if widget.get_text() != "":
self.run_btn.set_sensitive(True)
else:
self.run_btn.set_sensitive(False)
self.update_full_label() |
Function is used for controlling
label Full Directory project name
and storing current project directory
in configuration manager
def dir_name_changed(self, widget, data=None):
"""
Function is used for controlling
label Full Directory project name
and storing current project directory
in configuration manager
"""
config_manager.set_config_value("da.project_dir", self.dir_name.get_text())
self.update_full_label() |
Checks whether loaded yaml is well-formed according to syntax defined for
version 0.9.0 and later.
Raises:
YamlError: (containing a meaningful message) when the loaded Yaml
is not well formed
def check(self):
"""Checks whether loaded yaml is well-formed according to syntax defined for
version 0.9.0 and later.
Raises:
YamlError: (containing a meaningful message) when the loaded Yaml
is not well formed
"""
if not isinstance(self.parsed_yaml, dict):
msg = 'In {0}:\n'.format(self.sourcefile)
msg += 'Assistants and snippets must be Yaml mappings, not "{0}"!'.\
format(self.parsed_yaml)
raise exceptions.YamlTypeError(msg)
self._check_fullname(self.sourcefile)
self._check_description(self.sourcefile)
self._check_section_names(self.sourcefile)
self._check_project_type(self.sourcefile)
self._check_args(self.sourcefile)
self._check_files(self.sourcefile)
self._check_dependencies(self.sourcefile)
self._check_run(self.sourcefile) |
Validate the argument section.
Args may be either a dict or a list (to allow multiple positional args).
def _check_args(self, source):
'''Validate the argument section.
Args may be either a dict or a list (to allow multiple positional args).
'''
path = [source]
args = self.parsed_yaml.get('args', {})
self._assert_struct_type(args, 'args', (dict, list), path)
path.append('args')
if isinstance(args, dict):
for argn, argattrs in args.items():
self._check_one_arg(path, argn, argattrs)
else: # must be list - already asserted struct type
for argdict in args:
self._assert_command_dict(argdict, '[list-item]', path)
argn, argattrs = list(argdict.items())[0] # safe - length asserted on previous line
self._check_one_arg(path, argn, argattrs) |
Checks whether struct is a command dict (e.g. it's a dict and has 1 key-value pair.
def _assert_command_dict(self, struct, name, path=None, extra_info=None):
"""Checks whether struct is a command dict (e.g. it's a dict and has 1 key-value pair."""
self._assert_dict(struct, name, path, extra_info)
if len(struct) != 1:
err = [self._format_error_path(path + [name])]
err.append('Commands of run, dependencies, and argument sections must be mapping with '
'exactly 1 key-value pair, got {0}: {1}'.format(len(struct), struct))
if extra_info:
err.append(extra_info)
raise exceptions.YamlSyntaxError('\n'.join(err)) |
Asserts that given structure is of any of given types.
Args:
struct: structure to check
name: displayable name of the checked structure (e.g. "run_foo" for section run_foo)
types: list/tuple of types that are allowed for given struct
path: list with a source file as a first element and previous names
(as in name argument to this method) as other elements
extra_info: extra information to print if error is found (e.g. hint how to fix this)
Raises:
YamlTypeError: if given struct is not of any given type; error message contains
source file and a "path" (e.g. args -> somearg -> flags) specifying
where the problem is
def _assert_struct_type(self, struct, name, types, path=None, extra_info=None):
"""Asserts that given structure is of any of given types.
Args:
struct: structure to check
name: displayable name of the checked structure (e.g. "run_foo" for section run_foo)
types: list/tuple of types that are allowed for given struct
path: list with a source file as a first element and previous names
(as in name argument to this method) as other elements
extra_info: extra information to print if error is found (e.g. hint how to fix this)
Raises:
YamlTypeError: if given struct is not of any given type; error message contains
source file and a "path" (e.g. args -> somearg -> flags) specifying
where the problem is
"""
wanted_yaml_typenames = set()
for t in types:
wanted_yaml_typenames.add(self._get_yaml_typename(t))
wanted_yaml_typenames = ' or '.join(wanted_yaml_typenames)
actual_yaml_typename = self._get_yaml_typename(type(struct))
if not isinstance(struct, types):
err = []
if path:
err.append(self._format_error_path(path + [name]))
err.append(' Expected {w} value for "{n}", got value of type {a}: "{v}"'.
format(w=wanted_yaml_typenames,
n=name,
a=actual_yaml_typename,
v=struct))
if extra_info:
err.append('Tip: ' + extra_info)
raise exceptions.YamlTypeError('\n'.join(err)) |
Returns all individual licenses in the input
def _split_license(license):
'''Returns all individual licenses in the input'''
return (x.strip() for x in (l for l in _regex.split(license) if l)) |
Returns True if given license field is correct
Taken from rpmlint.
It's named match() to mimic a compiled regexp.
def match(license):
'''Returns True if given license field is correct
Taken from rpmlint.
It's named match() to mimic a compiled regexp.'''
if license not in VALID_LICENSES:
for l1 in _split_license(license):
if l1 in VALID_LICENSES:
continue
for l2 in _split_license(l1):
if l2 not in VALID_LICENSES:
return False
valid_license = False
return True |
Decorator that registers a command runner. Accepts either:
- CommandRunner directly or
- String prefix to register a command runner under (returning a decorator)
def register_command_runner(arg):
"""Decorator that registers a command runner. Accepts either:
- CommandRunner directly or
- String prefix to register a command runner under (returning a decorator)
"""
if isinstance(arg, str):
def inner(command_runner):
command_runners.setdefault(arg, [])
command_runners[arg].append(command_runner)
return command_runner
return inner
elif issubclass(arg, CommandRunner):
command_runners.setdefault('', [])
command_runners[''].append(arg)
return arg
else:
msg = 'register_command_runner expects str or CommandRunner as argument, got: {0}'.\
format(arg)
raise ValueError(msg) |
Version comparing, returns 0 if are the same,
returns >0 if first is bigger, <0 if first is smaller,
excepts valid version
def compare(ver1, ver2):
'''Version comparing, returns 0 if are the same,
returns >0 if first is bigger, <0 if first is smaller,
excepts valid version'''
if ver1 == ver2:
return 0
ver1 = _cut(ver1)
ver2 = _cut(ver2)
# magic multiplier
m = 1
# if the first one is shorter, replace them
if len(ver1) < len(ver2):
ver1, ver2 = ver2, ver1
# and reverse magic multiplier
m = -1
# compare all items that both have
for i, part in enumerate(ver2):
if ver1[i] > ver2[i]:
return m * 1
if ver1[i] < ver2[i]:
return m * -1
# if the first "extra" item is not negative, it's bigger
if ver1[len(ver2)] >= 0:
return m * 1
else:
return m * -1 |
Cuts the version to array, excepts valid version
def _cut(ver):
'''Cuts the version to array, excepts valid version'''
ver = ver.split('.')
for i, part in enumerate(ver):
try:
ver[i] = int(part)
except:
if part[-len('dev'):] == 'dev':
ver[i] = int(part[:-len('dev')])
ver.append(-3)
else:
ver[i] = int(part[:-len('a')])
if part[-len('a'):] == 'a':
ver.append(-2)
else:
ver.append(-1)
return ver |
Generates argument parser for given assistant tree and actions.
Args:
tree: assistant tree as returned by
devassistant.assistant_base.AssistantBase.get_subassistant_tree
actions: dict mapping actions (devassistant.actions.Action subclasses) to their
subaction dicts
Returns:
instance of devassistant_argparse.ArgumentParser (subclass of argparse.ArgumentParser)
def generate_argument_parser(cls, tree, actions={}):
"""Generates argument parser for given assistant tree and actions.
Args:
tree: assistant tree as returned by
devassistant.assistant_base.AssistantBase.get_subassistant_tree
actions: dict mapping actions (devassistant.actions.Action subclasses) to their
subaction dicts
Returns:
instance of devassistant_argparse.ArgumentParser (subclass of argparse.ArgumentParser)
"""
cur_as, cur_subas = tree
parser = devassistant_argparse.ArgumentParser(argument_default=argparse.SUPPRESS,
usage=argparse.SUPPRESS,
add_help=False)
cls.add_default_arguments_to(parser)
# add any arguments of the top assistant
for arg in cur_as.args:
arg.add_argument_to(parser)
if cur_subas or actions:
# then add the subassistants as arguments
subparsers = cls._add_subparsers_required(parser,
dest=settings.SUBASSISTANT_N_STRING.format('0'))
for subas in sorted(cur_subas, key=lambda x: x[0].name):
for alias in [subas[0].name] + getattr(subas[0], 'aliases', []):
cls.add_subassistants_to(subparsers, subas, level=1, alias=alias)
for action, subactions in sorted(actions.items(), key=lambda x: x[0].name):
cls.add_action_to(subparsers, action, subactions, level=1)
return parser |
Adds assistant from given part of assistant tree and all its subassistants to
a given argument parser.
Args:
parser: instance of devassistant_argparse.ArgumentParser
assistant_tuple: part of assistant tree (see generate_argument_parser doc)
level: level of subassistants that given assistant is at
def add_subassistants_to(cls, parser, assistant_tuple, level, alias=None):
"""Adds assistant from given part of assistant tree and all its subassistants to
a given argument parser.
Args:
parser: instance of devassistant_argparse.ArgumentParser
assistant_tuple: part of assistant tree (see generate_argument_parser doc)
level: level of subassistants that given assistant is at
"""
name = alias or assistant_tuple[0].name
p = parser.add_parser(name,
description=assistant_tuple[0].description,
argument_default=argparse.SUPPRESS)
for arg in assistant_tuple[0].args:
arg.add_argument_to(p)
if len(assistant_tuple[1]) > 0:
subparsers = cls._add_subparsers_required(p,
dest=settings.SUBASSISTANT_N_STRING.format(level),
title=cls.subparsers_str,
description=cls.subparsers_desc)
for subas_tuple in sorted(assistant_tuple[1], key=lambda x: x[0].name):
cls.add_subassistants_to(subparsers, subas_tuple, level + 1)
elif level == 1:
subparsers = cls._add_subparsers_required(p,
dest=settings.SUBASSISTANT_N_STRING.format(level),
title=cls.subparsers_str,
description=devassistant_argparse.ArgumentParser.no_assistants_msg) |
Adds given action to given parser
Args:
parser: instance of devassistant_argparse.ArgumentParser
action: devassistant.actions.Action subclass
subactions: dict with subactions - {SubA: {SubB: {}}, SubC: {}}
def add_action_to(cls, parser, action, subactions, level):
"""Adds given action to given parser
Args:
parser: instance of devassistant_argparse.ArgumentParser
action: devassistant.actions.Action subclass
subactions: dict with subactions - {SubA: {SubB: {}}, SubC: {}}
"""
p = parser.add_parser(action.name,
description=action.description,
argument_default=argparse.SUPPRESS)
for arg in action.args:
arg.add_argument_to(p)
if subactions:
subparsers = cls._add_subparsers_required(p,
dest=settings.SUBASSISTANT_N_STRING.format(level),
title=cls.subactions_str,
description=cls.subactions_desc)
for subact, subsubacts in sorted(subactions.items(), key=lambda x: x[0].name):
cls.add_action_to(subparsers, subact, subsubacts, level + 1) |
Format a log entry according to its level and context
def format_entry(record, show_level=False, colorize=False):
"""
Format a log entry according to its level and context
"""
if show_level:
log_str = u'{}: {}'.format(record.levelname, record.getMessage())
else:
log_str = record.getMessage()
if colorize and record.levelname in LOG_COLORS:
log_str = u'<span color="{}">'.format(LOG_COLORS[record.levelname]) + log_str + u'</span>'
return log_str |
Functions switches the cursor to cursor type
def switch_cursor(cursor_type, parent_window):
"""
Functions switches the cursor to cursor type
"""
watch = Gdk.Cursor(cursor_type)
window = parent_window.get_root_window()
window.set_cursor(watch) |
Function inserts log messages to list_view
def emit(self, record):
"""
Function inserts log messages to list_view
"""
msg = record.getMessage()
list_store = self.list_view.get_model()
Gdk.threads_enter()
if msg:
# Underline URLs in the record message
msg = replace_markup_chars(record.getMessage())
record.msg = URL_FINDER.sub(r'<u>\1</u>', msg)
self.parent.debug_logs['logs'].append(record)
# During execution if level is bigger then DEBUG
# then GUI shows the message.
event_type = getattr(record, 'event_type', '')
if event_type:
if event_type == 'dep_installation_start':
switch_cursor(Gdk.CursorType.WATCH, self.parent.run_window)
list_store.append([format_entry(record)])
if event_type == 'dep_installation_end':
switch_cursor(Gdk.CursorType.ARROW, self.parent.run_window)
if not self.parent.debugging:
# We will show only INFO messages and messages who have no dep_ event_type
if int(record.levelno) > 10:
if event_type == "dep_check" or event_type == "dep_found":
list_store.append([format_entry(record)])
elif not event_type.startswith("dep_"):
list_store.append([format_entry(record, colorize=True)])
if self.parent.debugging:
if event_type != "cmd_retcode":
list_store.append([format_entry(record, show_level=True, colorize=True)])
Gdk.threads_leave() |
Function opens the run window
def open_window(self, widget, data=None):
"""
Function opens the run window
"""
if data is not None:
self.kwargs = data.get('kwargs', None)
self.top_assistant = data.get('top_assistant', None)
self.current_main_assistant = data.get('current_main_assistant', None)
self.debugging = data.get('debugging', False)
if not self.debugging:
self.debug_btn.set_label('Debug logs')
else:
self.debug_btn.set_label('Info logs')
self.store.clear()
self.debug_logs = dict()
self.debug_logs['logs'] = list()
self.thread = threading.Thread(target=self.dev_assistant_start)
# We need only project name for github
project_name = self.parent.path_window.get_data()[1]
if self.kwargs.get('github'):
self.link = self.gui_helper.create_link_button(
"Link to project on Github",
"http://www.github.com/{0}/{1}".format(self.kwargs.get('github'), project_name))
self.link.set_border_width(6)
self.link.set_sensitive(False)
self.info_box.pack_start(self.link, False, False, 12)
self.run_list_view.connect('size-allocate', self.list_view_changed)
# We need to be in /home directory before each project creations
os.chdir(os.path.expanduser('~'))
self.run_window.show_all()
self.disable_buttons()
self.thread.start() |
Function removes link button from Run Window
def remove_link_button(self):
"""
Function removes link button from Run Window
"""
if self.link is not None:
self.info_box.remove(self.link)
self.link.destroy()
self.link = None |
Event cancels the project creation
def delete_event(self, widget, event, data=None):
"""
Event cancels the project creation
"""
if not self.close_win:
if self.thread.isAlive():
dlg = self.gui_helper.create_message_dialog("Do you want to cancel project creation?",
buttons=Gtk.ButtonsType.YES_NO)
response = dlg.run()
if response == Gtk.ResponseType.YES:
if self.thread.isAlive():
self.info_label.set_label('<span color="#FFA500">Cancelling...</span>')
self.dev_assistant_runner.stop()
self.project_canceled = True
else:
self.info_label.set_label('<span color="#008000">Done</span>')
self.allow_close_window()
dlg.destroy()
return True
else:
return False |
Function shows last rows.
def list_view_changed(self, widget, event, data=None):
"""
Function shows last rows.
"""
adj = self.scrolled_window.get_vadjustment()
adj.set_value(adj.get_upper() - adj.get_page_size()) |
Function disables buttons
def disable_buttons(self):
"""
Function disables buttons
"""
self.main_btn.set_sensitive(False)
self.back_btn.hide()
self.info_label.set_label('<span color="#FFA500">In progress...</span>')
self.disable_close_window()
if self.link is not None:
self.link.hide() |
Function allows buttons
def allow_buttons(self, message="", link=True, back=True):
"""
Function allows buttons
"""
self.info_label.set_label(message)
self.allow_close_window()
if link and self.link is not None:
self.link.set_sensitive(True)
self.link.show_all()
if back:
self.back_btn.show()
self.main_btn.set_sensitive(True) |
Thread executes devassistant API.
def dev_assistant_start(self):
"""
Thread executes devassistant API.
"""
#logger_gui.info("Thread run")
path = self.top_assistant.get_selected_subassistant_path(**self.kwargs)
kwargs_decoded = dict()
for k, v in self.kwargs.items():
kwargs_decoded[k] = \
v.decode(utils.defenc) if not six.PY3 and isinstance(v, str) else v
self.dev_assistant_runner = path_runner.PathRunner(path, kwargs_decoded)
try:
self.dev_assistant_runner.run()
Gdk.threads_enter()
if not self.project_canceled:
message = '<span color="#008000">Done</span>'
link = True
back = False
else:
message = '<span color="#FF0000">Failed</span>'
link = False
back = True
self.allow_buttons(message=message, link=link, back=back)
Gdk.threads_leave()
except exceptions.ClException as cle:
msg = replace_markup_chars(cle.message)
if not six.PY3:
msg = msg.encode(utils.defenc)
self.allow_buttons(back=True, link=False,
message='<span color="#FF0000">Failed: {0}</span>'.
format(msg))
except exceptions.ExecutionException as exe:
msg = replace_markup_chars(six.text_type(exe))
if not six.PY3:
msg = msg.encode(utils.defenc)
self.allow_buttons(back=True, link=False,
message='<span color="#FF0000">Failed: {0}</span>'.
format((msg[:80] + '...') if len(msg) > 80 else msg))
except IOError as ioe:
self.allow_buttons(back=True, link=False,
message='<span color="#FF0000">Failed: {0}</span>'.
format((ioe.message[:80] + '...') if len(ioe.message) > 80 else ioe.message)) |
Event in case that debug button is pressed.
def debug_btn_clicked(self, widget, data=None):
"""
Event in case that debug button is pressed.
"""
self.store.clear()
self.thread = threading.Thread(target=self.logs_update)
self.thread.start() |
Function updates logs.
def logs_update(self):
"""
Function updates logs.
"""
Gdk.threads_enter()
if not self.debugging:
self.debugging = True
self.debug_btn.set_label('Info logs')
else:
self.debugging = False
self.debug_btn.set_label('Debug logs')
for record in self.debug_logs['logs']:
if self.debugging:
# Create a new root tree element
if getattr(record, 'event_type', '') != "cmd_retcode":
self.store.append([format_entry(record, show_level=True, colorize=True)])
else:
if int(record.levelno) > 10:
self.store.append([format_entry(record, colorize=True)])
Gdk.threads_leave() |
Function copies logs to clipboard.
def clipboard_btn_clicked(self, widget, data=None):
"""
Function copies logs to clipboard.
"""
_clipboard_text = []
for record in self.debug_logs['logs']:
if self.debugging:
_clipboard_text.append(format_entry(record, show_level=True))
else:
if int(record.levelno) > 10:
if getattr(record, 'event_type', ''):
if not record.event_type.startswith("dep_"):
_clipboard_text.append(format_entry(record))
else:
_clipboard_text.append(format_entry(record))
self.gui_helper.create_clipboard(_clipboard_text) |
Event for back button.
This occurs in case of devassistant fail.
def back_btn_clicked(self, widget, data=None):
"""
Event for back button.
This occurs in case of devassistant fail.
"""
self.remove_link_button()
self.run_window.hide()
self.parent.path_window.path_window.show() |
Button switches to Dev Assistant GUI main window
def main_btn_clicked(self, widget, data=None):
"""
Button switches to Dev Assistant GUI main window
"""
self.remove_link_button()
data = dict()
data['debugging'] = self.debugging
self.run_window.hide()
self.parent.open_window(widget, data) |
Function opens the firefox window with relevant link
def list_view_row_clicked(self, list_view, path, view_column):
"""
Function opens the firefox window with relevant link
"""
model = list_view.get_model()
text = model[path][0]
match = URL_FINDER.search(text)
if match is not None:
url = match.group(1)
import webbrowser
webbrowser.open(url) |
Create an authorization for a GitHub user using two-factor
authentication. Unlike its non-two-factor counterpart, this method
does not traverse the available authentications as they are not
visible until the user logs in.
Please note: cls._user's attributes are not accessible until the
authorization is created due to the way (py)github works.
def _github_create_twofactor_authorization(cls, ui):
"""Create an authorization for a GitHub user using two-factor
authentication. Unlike its non-two-factor counterpart, this method
does not traverse the available authentications as they are not
visible until the user logs in.
Please note: cls._user's attributes are not accessible until the
authorization is created due to the way (py)github works.
"""
try:
try: # This is necessary to trigger sending a 2FA key to the user
auth = cls._user.create_authorization()
except cls._gh_exceptions.GithubException:
onetime_pw = DialogHelper.ask_for_password(ui, prompt='Your one time password:')
auth = cls._user.create_authorization(scopes=['repo', 'user', 'admin:public_key'],
note="DevAssistant",
onetime_password=onetime_pw)
cls._user = cls._gh_module.Github(login_or_token=auth.token).get_user()
logger.debug('Two-factor authorization for user "{0}" created'.format(cls._user.login))
cls._github_store_authorization(cls._user, auth)
logger.debug('Two-factor authorization token stored')
except cls._gh_exceptions.GithubException as e:
logger.warning('Creating two-factor authorization failed: {0}'.format(e)) |
Create a GitHub authorization for the given user in case they don't
already have one.
def _github_create_simple_authorization(cls):
"""Create a GitHub authorization for the given user in case they don't
already have one.
"""
try:
auth = None
for a in cls._user.get_authorizations():
if a.note == 'DevAssistant':
auth = a
if not auth:
auth = cls._user.create_authorization(
scopes=['repo', 'user', 'admin:public_key'],
note="DevAssistant")
cls._github_store_authorization(cls._user, auth)
except cls._gh_exceptions.GithubException as e:
logger.warning('Creating authorization failed: {0}'.format(e)) |
Store an authorization token for the given GitHub user in the git
global config file.
def _github_store_authorization(cls, user, auth):
"""Store an authorization token for the given GitHub user in the git
global config file.
"""
ClHelper.run_command("git config --global github.token.{login} {token}".format(
login=user.login, token=auth.token), log_secret=True)
ClHelper.run_command("git config --global github.user.{login} {login}".format(
login=user.login)) |
Starts ssh-agent and returns the environment variables related to it
def _start_ssh_agent(cls):
"""Starts ssh-agent and returns the environment variables related to it"""
env = dict()
stdout = ClHelper.run_command('ssh-agent -s')
lines = stdout.split('\n')
for line in lines:
if not line or line.startswith('echo '):
continue
line = line.split(';')[0]
parts = line.split('=')
if len(parts) == 2:
env[parts[0]] = parts[1]
return env |
Creates a local ssh key, if it doesn't exist already, and uploads it to Github.
def _github_create_ssh_key(cls):
"""Creates a local ssh key, if it doesn't exist already, and uploads it to Github."""
try:
login = cls._user.login
pkey_path = '{home}/.ssh/{keyname}'.format(
home=os.path.expanduser('~'),
keyname=settings.GITHUB_SSH_KEYNAME.format(login=login))
# generate ssh key only if it doesn't exist
if not os.path.exists(pkey_path):
ClHelper.run_command('ssh-keygen -t rsa -f {pkey_path}\
-N \"\" -C \"DevAssistant\"'.
format(pkey_path=pkey_path))
try:
ClHelper.run_command('ssh-add {pkey_path}'.format(pkey_path=pkey_path))
except exceptions.ClException:
# ssh agent might not be running
env = cls._start_ssh_agent()
ClHelper.run_command('ssh-add {pkey_path}'.format(pkey_path=pkey_path), env=env)
public_key = ClHelper.run_command('cat {pkey_path}.pub'.format(pkey_path=pkey_path))
cls._user.create_key("DevAssistant", public_key)
except exceptions.ClException as e:
msg = 'Couldn\'t create a new ssh key: {0}'.format(e)
raise exceptions.CommandException(msg) |
Returns True if any key on Github matches a local key, else False.
def _github_ssh_key_exists(cls):
"""Returns True if any key on Github matches a local key, else False."""
remote_keys = map(lambda k: k._key, cls._user.get_keys())
found = False
pubkey_files = glob.glob(os.path.expanduser('~/.ssh/*.pub'))
for rk in remote_keys:
for pkf in pubkey_files:
local_key = io.open(pkf, encoding='utf-8').read()
# in PyGithub 1.23.0, remote key is an object, not string
rkval = rk if isinstance(rk, six.string_types) else rk.value
# don't use "==" because we have comments etc added in public_key
if rkval in local_key:
found = True
break
return found |
Does user authentication, creates SSH keys if needed and injects "_user" attribute
into class/object bound to the decorated function.
Don't call any other methods of this class manually, this should be everything you need.
def github_authenticated(cls, func):
"""Does user authentication, creates SSH keys if needed and injects "_user" attribute
into class/object bound to the decorated function.
Don't call any other methods of this class manually, this should be everything you need.
"""
def inner(func_cls, *args, **kwargs):
if not cls._gh_module:
logger.warning('PyGithub not installed, skipping Github auth procedures.')
elif not func_cls._user:
# authenticate user, possibly also creating authentication for future use
login = kwargs['login'].encode(utils.defenc) if not six.PY3 else kwargs['login']
func_cls._user = cls._get_github_user(login, kwargs['ui'])
if func_cls._user is None:
msg = 'Github authentication failed, skipping Github command.'
logger.warning(msg)
return (False, msg)
# create an ssh key for pushing if we don't have one
if not cls._github_ssh_key_exists():
cls._github_create_ssh_key()
# next, create ~/.ssh/config entry for the key, if system username != GH login
if cls._ssh_key_needs_config_entry():
cls._create_ssh_config_entry()
return func(func_cls, *args, **kwargs)
return inner |
Returns list of assistants that are subassistants of given superassistants
(I love this docstring).
Args:
roles: list of names of roles, defaults to all roles
Returns:
list of YamlAssistant instances with specified roles
def get_assistants(cls, superassistants):
"""Returns list of assistants that are subassistants of given superassistants
(I love this docstring).
Args:
roles: list of names of roles, defaults to all roles
Returns:
list of YamlAssistant instances with specified roles
"""
_assistants = cls.load_all_assistants(superassistants)
result = []
for supa in superassistants:
result.extend(_assistants[supa.name])
return result |
Fills self._assistants with loaded YamlAssistant instances of requested roles.
Tries to use cache (updated/created if needed). If cache is unusable, it
falls back to loading all assistants.
Args:
roles: list of required assistant roles
def load_all_assistants(cls, superassistants):
"""Fills self._assistants with loaded YamlAssistant instances of requested roles.
Tries to use cache (updated/created if needed). If cache is unusable, it
falls back to loading all assistants.
Args:
roles: list of required assistant roles
"""
# mapping of assistant roles to lists of top-level assistant instances
_assistants = {}
# {'crt': CreatorAssistant, ...}
superas_dict = dict(map(lambda a: (a.name, a), superassistants))
to_load = set(superas_dict.keys())
for tl in to_load:
dirs = [os.path.join(d, tl) for d in cls.assistants_dirs]
file_hierarchy = cls.get_assistants_file_hierarchy(dirs)
# load all if we're not using cache or if we fail to load it
load_all = not settings.USE_CACHE
if settings.USE_CACHE:
try:
cch = cache.Cache()
cch.refresh_role(tl, file_hierarchy)
_assistants[tl] = cls.get_assistants_from_cache_hierarchy(cch.cache[tl],
superas_dict[tl],
role=tl)
except BaseException as e:
logger.debug('Failed to use DevAssistant cachefile {0}: {1}'.format(
settings.CACHE_FILE, e))
load_all = True
if load_all:
_assistants[tl] = cls.get_assistants_from_file_hierarchy(file_hierarchy,
superas_dict[tl],
role=tl)
return _assistants |
Accepts cache_hierarch as described in devassistant.cache and returns
instances of YamlAssistant (only with cached attributes) for loaded files
Args:
cache_hierarchy: structure as described in devassistant.cache
role: role of all assistants in this hierarchy (we could find
this out dynamically but it's not worth the pain)
Returns:
list of top level assistants from given hierarchy; these assistants contain
references to instances of their subassistants (and their subassistants, ...)
Note, that the assistants are not fully loaded, but contain just cached attrs.
def get_assistants_from_cache_hierarchy(cls, cache_hierarchy, superassistant,
role=settings.DEFAULT_ASSISTANT_ROLE):
"""Accepts cache_hierarch as described in devassistant.cache and returns
instances of YamlAssistant (only with cached attributes) for loaded files
Args:
cache_hierarchy: structure as described in devassistant.cache
role: role of all assistants in this hierarchy (we could find
this out dynamically but it's not worth the pain)
Returns:
list of top level assistants from given hierarchy; these assistants contain
references to instances of their subassistants (and their subassistants, ...)
Note, that the assistants are not fully loaded, but contain just cached attrs.
"""
result = []
for name, attrs in cache_hierarchy.items():
ass = cls.assistant_from_yaml(attrs['source'],
{name: attrs['attrs']},
superassistant,
fully_loaded=False,
role=role)
ass._subassistants = cls.get_assistants_from_cache_hierarchy(attrs['subhierarchy'],
ass,
role=role)
result.append(ass)
return result |
Accepts file_hierarch as returned by cls.get_assistant_file_hierarchy and returns
instances of YamlAssistant for loaded files
Args:
file_hierarchy: structure as described in cls.get_assistants_file_hierarchy
role: role of all assistants in this hierarchy (we could find
this out dynamically but it's not worth the pain)
Returns:
list of top level assistants from given hierarchy; these assistants contain
references to instances of their subassistants (and their subassistants, ...)
def get_assistants_from_file_hierarchy(cls, file_hierarchy, superassistant,
role=settings.DEFAULT_ASSISTANT_ROLE):
"""Accepts file_hierarch as returned by cls.get_assistant_file_hierarchy and returns
instances of YamlAssistant for loaded files
Args:
file_hierarchy: structure as described in cls.get_assistants_file_hierarchy
role: role of all assistants in this hierarchy (we could find
this out dynamically but it's not worth the pain)
Returns:
list of top level assistants from given hierarchy; these assistants contain
references to instances of their subassistants (and their subassistants, ...)
"""
result = []
warn_msg = 'Failed to load assistant {source}, skipping subassistants.'
for name, attrs in file_hierarchy.items():
loaded_yaml = yaml_loader.YamlLoader.load_yaml_by_path(attrs['source'])
if loaded_yaml is None: # there was an error parsing yaml
logger.warning(warn_msg.format(source=attrs['source']))
continue
try:
ass = cls.assistant_from_yaml(attrs['source'],
loaded_yaml,
superassistant,
role=role)
except exceptions.YamlError as e:
logger.warning(e)
continue
ass._subassistants = cls.get_assistants_from_file_hierarchy(attrs['subhierarchy'],
ass,
role=role)
result.append(ass)
return result |
Returns assistants file hierarchy structure (see below) representing assistant
hierarchy in given directories.
It works like this:
1. It goes through all *.yaml files in all given directories and adds them into
hierarchy (if there are two files with same name in more directories, the file
from first directory wins).
2. For each {name}.yaml file, it calls itself recursively for {name} subdirectories
of all given directories.
Args:
dirs: directories to search
Returns:
hierarchy structure that looks like this:
{'assistant1':
{'source': '/path/to/assistant1.yaml',
'subhierarchy': {<hierarchy of subassistants>}},
'assistant2':
{'source': '/path/to/assistant2.yaml',
'subhierarchy': {<another hierarchy of subassistants}}
}
def get_assistants_file_hierarchy(cls, dirs):
"""Returns assistants file hierarchy structure (see below) representing assistant
hierarchy in given directories.
It works like this:
1. It goes through all *.yaml files in all given directories and adds them into
hierarchy (if there are two files with same name in more directories, the file
from first directory wins).
2. For each {name}.yaml file, it calls itself recursively for {name} subdirectories
of all given directories.
Args:
dirs: directories to search
Returns:
hierarchy structure that looks like this:
{'assistant1':
{'source': '/path/to/assistant1.yaml',
'subhierarchy': {<hierarchy of subassistants>}},
'assistant2':
{'source': '/path/to/assistant2.yaml',
'subhierarchy': {<another hierarchy of subassistants}}
}
"""
result = {}
for d in filter(lambda d: os.path.exists(d), dirs):
for f in filter(lambda f: f.endswith('.yaml'), os.listdir(d)):
assistant_name = f[:-5]
if assistant_name not in result:
subas_dirs = [os.path.join(dr, assistant_name) for dr in dirs]
result[assistant_name] = {'source': os.path.join(d, f),
'subhierarchy':
cls.get_assistants_file_hierarchy(subas_dirs)}
return result |
Constructs instance of YamlAssistant loaded from given structure y, loaded
from source file source.
Args:
source: path to assistant source file
y: loaded yaml structure
superassistant: superassistant of this assistant
Returns:
YamlAssistant instance constructed from y with source file source
Raises:
YamlError: if the assistant is malformed
def assistant_from_yaml(cls, source, y, superassistant, fully_loaded=True,
role=settings.DEFAULT_ASSISTANT_ROLE):
"""Constructs instance of YamlAssistant loaded from given structure y, loaded
from source file source.
Args:
source: path to assistant source file
y: loaded yaml structure
superassistant: superassistant of this assistant
Returns:
YamlAssistant instance constructed from y with source file source
Raises:
YamlError: if the assistant is malformed
"""
# In pre-0.9.0, we required assistant to be a mapping of {name: assistant_attributes}
# now we allow that, but we also allow omitting the assistant name and putting
# the attributes to top_level, too.
name = os.path.splitext(os.path.basename(source))[0]
yaml_checker.check(source, y)
assistant = yaml_assistant.YamlAssistant(name, y, source, superassistant,
fully_loaded=fully_loaded, role=role)
return assistant |
name is in dotted format, e.g. topsnippet.something.wantedsnippet
def get_snippet_by_name(cls, name):
"""name is in dotted format, e.g. topsnippet.something.wantedsnippet"""
name_with_dir_separators = name.replace('.', os.path.sep)
loaded = yaml_loader.YamlLoader.load_yaml_by_relpath(cls.snippets_dirs,
name_with_dir_separators + '.yaml')
if loaded:
return cls._create_snippet(name, *loaded)
raise exceptions.SnippetNotFoundException('no such snippet: {name}'.
format(name=name_with_dir_separators)) |
`5.6.1 Schema Validation Requirement <http://shex.io/shex-semantics/#validation-requirement>`_
A graph G is said to conform with a schema S with a ShapeMap m when:
Every, SemAct in the startActs of S has a successful evaluation of semActsSatisfied.
Every node n in m conforms to its associated shapeExprRefs sen where for each shapeExprRef sei in sen:
sei references a ShapeExpr in shapes, and
satisfies(n, sei, G, m) for each shape sei in sen.
:return:
def conforms(cntxt: Context, n: Node, S: ShExJ.Shape) -> bool:
""" `5.6.1 Schema Validation Requirement <http://shex.io/shex-semantics/#validation-requirement>`_
A graph G is said to conform with a schema S with a ShapeMap m when:
Every, SemAct in the startActs of S has a successful evaluation of semActsSatisfied.
Every node n in m conforms to its associated shapeExprRefs sen where for each shapeExprRef sei in sen:
sei references a ShapeExpr in shapes, and
satisfies(n, sei, G, m) for each shape sei in sen.
:return:
"""
# return semActsSatisfied(cntxt.schema.startActs, cntxt) and \
# all(reference_of(cntxt.schema, sa.shapeLabel) is not None and
#
return True |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.