ó dòôdc@`sdZddlmZmZmZmZddlTddlZddl Z ddl Z ddl m Z ddl mZdd l mZdd l mZddl m Zd d d gZd„Zej jdej jejejejƒfd„ƒYƒZdefd„ƒYZdS(uFClass that groups settings for easier setting creation and management.i(tabsolute_importtdivisiontprint_functiontunicode_literals(t*Ni(tutilsi(tmeta(t persistor(tsettingsu create_groupsuGroupuGroupWalkCallbackscC`s^|jddƒ}|dkr'g}nt|}x$|D]}|jt|ƒgƒq:W|S(u_ Create a hierarchy of setting groups (`Group` instances) from a dictionary containing attributes for the groups. This function simplifies adding setting groups (via `Group.add`). Groups are specified under the `'groups'` key as a list of dictionaries. Only `'groups'` and the names of parameters for `Group.__init__` are valid keys for `setting_dict`. Other keys raise `TypeError`. Example: settings = create_groups({ 'name': 'main', 'groups': [ { 'name': 'procedures' }, { 'name': 'constraints' } ] }) ugroupsN(tpoptNonetGrouptaddt create_groups(t setting_dictt group_dictstgroupt group_dict((sO/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/group.pyR s    R cB`sµeZdZd(d(d(d(ed„Zed„ƒZed„ƒZed„ƒZ ed„ƒZ ed„ƒZ ed„ƒZ d„Z d „Zd „Zd „Zd „Zd „Zd„Zd„Zd(d„Zd„Zd„Zd„Zd„Zd„Zd„Zd„Zd„Zd(d„Zd„Zd„Z d„Z!d„Z"d„Z#d„Z$d(e%e%d(d „Z&d!„Z'd"„Z(d#„Z)d$„Z*d(d%„Z+d&„Z,d'„Z-RS()uÏ This class: * allows to create a group of related settings (`Setting` objects), * allows to store existing setting groups, * can perform certain operations on all settings and nested groups at once. Unless otherwise stated, "settings" in the rest of the documentation for this class refers to both `Setting` and `Group` instances. Attributes: * `name` (read-only) - A name (string) that uniquely identifies the setting group. * `display_name` (read-only) - Setting group name in human-readable format. * `description` (read-only) - A more detailed description of the group. By default, description is derived from `display_name`. * `tags` - A set of arbitrary tags attached to the group. Tags can be used to e.g. iterate over a specific subset of settings. * `setting_attributes` (read-only) - Dictionary of (setting attribute: value) pairs to assign to each new setting created in the group. Attributes in individual settings override these attributes. `setting_attributes` are not applied to already created settings that are later added to the group via `add()`. * `recurse_setting_attributes` (read-only) - If `True`, `setting_attributes` is recursively applied to child settings of any depth. If a child group defines its own `setting_attributes`, it will override its parent's `setting_attributes`. If `False`, `setting_attributes` will only be applied to immediate child settings. cC`sÁtjj|ƒtjj|ƒtj|ƒ||_tj||jƒ|_tj||jƒ|_ |dk r~t |ƒnt ƒ|_ ||_ ||_tjƒ|_g|_d|_dS(N(tutils_tSettingParentMixint__init__tSettingEventsMixintcheck_setting_namet_nametget_processed_display_namet _display_nametget_processed_descriptiont _descriptionR tsett_tagst_setting_attributest_recurse_setting_attributest collectionst OrderedDictt _settingst _setting_listt_settings_iterator(tselftnamet display_namet descriptionttagstsetting_attributestrecurse_setting_attributes((sO/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/group.pyRgs  $   cC`s|jS(N(R(R%((sO/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/group.pyR&†scC`s|jS(N(R(R%((sO/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/group.pyR'ŠscC`s|jS(N(R(R%((sO/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/group.pyR(ŽscC`s|jS(N(R(R%((sO/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/group.pyR)’scC`s |jdk rt|jƒSdS(N(RR tdict(R%((sO/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/group.pyR*–scC`s|jS(N(R(R%((sO/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/group.pyR+›scC`stj||jƒS(N(tpgutilststringify_objectR&(R%((sO/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/group.pyt__str__ŸscC`stj||jƒS(N(R-treprify_objectR&(R%((sO/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/group.pyt__repr__¢scC`s^tj|kr|j|ƒSy|j|SWn,tk rYtdj||jƒƒ‚nXdS(ux Access the setting or group by its name (string). If a setting is inside a nested group, you can access the setting as follows: settings['main']['file_extension'] As a more compact alternative, you may specify a setting path: settings['main/file_extension'] If the name or path does not exist, raise `KeyError`. u$setting "{}" not found in group "{}"N(RtSETTING_PATH_SEPARATORt_get_setting_from_pathR"tKeyErrortformatR&(R%tsetting_name_or_path((sO/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/group.pyt __getitem__¥s   cC`sMtj|kr<y|j|ƒWntk r4tSXtSn ||jkSdS(N(RR2R3R4tFalsetTrueR"(R%R6((sO/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/group.pyt __contains__½s cC`s§|jtjƒ}|}xF|d D]:}||krE|j|}q#tdj||ƒƒ‚q#Wy||d}Wn-tk r¢tdj|d|ƒƒ‚nX|S(Niÿÿÿÿu&group "{}" in path "{}" does not existu#setting "{}" not found in path "{}"(tsplitRR2R"R4R5(R%t setting_pathtsetting_path_componentst current_groupt group_nametsetting((sO/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/group.pyR3Ès    cc`sx|jD] }|Vq WdS(u#Iterates over child settings or groups. This method does not iterate over nested groups. Use `walk()` in that case. By default, the children are iterated in the order they were created or added into the group. The order of children can be modified via `reorder()`. N(R#(R%R@((sO/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/group.pyt__iter__ÚscC`s t|jƒS(N(tlenR"(R%((sO/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/group.pyt__len__åscC`s t|jƒS(N(treversedR#(R%((sO/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/group.pyt __reversed__èscC`stj||ƒS(uw This is a wrapper method for `setting.utils.get_setting_path()`. Consult the method for more information. (Rtget_setting_path(R%trelative_path_group((sO/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/group.pytget_pathëscC`s[xT|D]L}t|tjtfƒr7|j|ƒ}n|j|ƒ}|j|ƒqWdS(uQ Add settings to the group. The order of settings in the list corresponds to the order in which the settings are iterated. `setting_list` is a list that can contain `Setting` objects, `Group` instances or dictionaries representing `Setting` objects to be created. Each dictionary contains (attribute name: value) pairs, where `'attribute name'` is a string that represents an argument passed when instantiating the setting. The following attributes must always be specified: * `'type'` - Type of the Setting object to instantiate. * `'name'` - Setting name. The `'name'` attribute must not contain forward slashes (`'/'`) (which are used to access settings via paths). For more attributes, check the documentation of the setting classes. Some `Setting` subclasses may require specifying additional required attributes. Multiple settings with the same name and in different nested groups are possible. Each such setting can be accessed like any other: settings['main/file_extension'] settings['advanced/file_extension'] Settings created from dictionaries are by default assigned setting attributes specified during the initialization of this class. These attributes can be overridden by attributes in individual settings. N(t isinstancet settings_tSettingR t _add_settingt_create_settingt_set_as_parent_for_setting(R%t setting_listR@((sO/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/group.pyR òs ! cC`su|j|jkr-tdj||ƒƒ‚n||krQtdj|ƒƒ‚n||j|j<|jj|ƒ|S(Nu{} already exists in {}u"cannot add {} as a child of itself(R&R"t ValueErrorR5R#tappend(R%R@((sO/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/group.pyRLs c`sMyˆd}Wn)tk r9t|jdgƒƒ‚nXtj|ƒ}‡fd†ˆDƒ}y |dWn)tk r–t|jdgƒƒ‚nXtj|dkrÌtdj|dtjƒƒ‚n|d|j krûtdj|dƒƒ‚nx9|j ƒj ƒD]%\}}||kr|||1s unameu6setting name "{}" must not contain path separator "{}"usetting "{}" already exists( R4t TypeErrort(_get_missing_required_attributes_messageRJtprocess_setting_typeRR2RPR5R"t_get_setting_attributestitemst_instantiate_setting(R%RTt setting_typetsetting_data_copytsetting_attributetsetting_attribute_valueR@((RTsO/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/group.pyRM's*    cC`st|j}|dkr[xCt|jƒD]/}|js8Pn|jdk r%|j}Pq%q%Wn|dkrpi}n|S(N(RR RDtparentsR+R*(R%R*tgroup_or_parent((sO/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/group.pyRXHs       cC`sy||}WnUtk rg}|j||ƒ}|rL|j|ƒ}n t|ƒ}t|ƒ‚nX||j|d<|jj|ƒ|S(Nuname(RUt_get_missing_required_argumentsRVtstrR"R#RQ(R%R[R\R@tetmissing_required_argumentstmessage((sO/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/group.pyRZYs  cC`s5|j|jƒ}g|D]}||kr|^qS(N(t_get_required_argument_namesR(R%R[RTtrequired_arg_namestarg_name((sO/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/group.pyRajscC`sxtj|ƒ}|ddk r)|dng}t|dƒt|ƒ}|dd|!}|ddkrt|d=n|S(Niiuself(tinspectt getargspecR RB(R%tfunctarg_spectarg_default_valuestnum_required_argst required_args((sO/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/group.pyRfns  cC`sdjdj|ƒƒS(Nu5missing the following required setting attributes: {}u, (R5tjoin(R%tattribute_names((sO/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/group.pyRVyscC`s.y||}Wntk r"|SX|jSdS(u‹ Return the value of the setting specified by its name or path. If the setting does not exist, return `default_value` instead. N(R4tvalue(R%R6t default_valueR@((sO/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/group.pyt get_value}s  cC`sStjƒ}x@|D]8}|j|ƒ\}}t|||ƒ}||||dkr!tjdtƒ}n|dkr9tƒ}n|g}xõ|r9y|djƒ}WnEtk r¦|d|kr“|j|dƒn|jdƒqEnXt |t ƒr||ƒrð|j d|ƒ|r|j |ƒ|Vqq6|rE|j d|ƒqEq6qEqE||ƒrE|j |ƒ|VqEqEqEWdS(u- Return a generator that walks (iterates over) all settings in the group, including settings in nested groups. The generator performs a pre-order traversal. If `include_setting_func` is `None`, iterate over all settings. Otherwise, `include_setting_func` is a function that should return `True` if a setting should be yielded and `False` if a setting should be skipped. The function must accept one positional parameter - the current setting or group. If `include_if_parent_skipped` is `False`, settings or groups within a parent group that does not match `include_setting_func` are skipped, `True` otherwise. If `True` and `include_groups` is `True`, the parent group will still be ignored by `walk_callbacks`. If `include_groups` is `True`, yield setting groups as well. `walk_callbacks` is an `GroupWalkCallbacks` instance that invokes additional commands during the walk of the group. By default, the callbacks do nothing. For more information, see the `GroupWalkCallbacks` class. t return_valueiN(R R-tcreate_empty_funcR9tGroupWalkCallbackst_nextt StopIterationton_end_group_walkR RIR R…ton_visit_groupton_visit_setting(R%tinclude_setting_functinclude_groupstinclude_if_parent_skippedtwalk_callbackstgroupstsetting_or_group((sO/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/group.pyR|øs6            cC`sb|jdkr$t|jƒ|_nyt|jƒ}Wn tk rYd|_t‚nX|SdS(uP Return the next element when iterating the settings. Used by `walk()`. N(R$R titerR#tnextR(R%t next_element((sO/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/group.pyRŒ8s   cC`s4d„}x$|jd|ƒD]}|jƒqWdS(u^ Reset all settings in this group. Ignore settings with the `'ignore_reset'` tag. cS`s d|jkS(Nu ignore_reset(R)(R@((sO/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/group.pyt_has_ignore_reset_tagLsR‘N(R|treset(R%RšR@((sO/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/group.pyR›Gs cO`stjj|g||ŽS(uLoads settings in the current group from the specified setting source(s). See `setting.persistor.Persistor.load()` for information about parameters. If the `tags` attribute contains `'ignore_load'`, this method will have no effect. (t persistor_t Persistortload(R%targstkwargs((sO/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/group.pyRžRscO`stjj|g||ŽS(uSaves values of settings from the current group to the specified setting source(s). See `setting.persistor.Persistor.save()` for information about parameters. If the `tags` attribute contains `'ignore_save'`, this method will have no effect. (RœRtsave(R%RŸR ((sO/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/group.pyR¡\s cC`sd„}|dkri}nx\|jd|ƒD]H}|jdƒ|krY|jƒq1||jdƒ}|j|Œq1WdS(uÊ Initialize GUI for all settings. Ignore settings with the `'ignore_initialize_gui'` tag. Settings that are not provided with a readily available GUI can have their GUI initialized using the `custom_gui` dict. `custom_gui` contains (setting name, list of arguments to `setting.Setting.set_gui()`) pairs. The 'enable GUI update?' boolean in the list is optional and defaults to `True`. For more information about parameters in the list, see `setting.Setting.set_gui()`. Example: file_extension_entry = gtk.Entry() ... main_settings.initialize_gui({ 'file_extension': [SettingGuiTypes.entry, file_extension_entry] ... }) cS`s d|jkS(Nuignore_initialize_gui(R)(R@((sO/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/group.pyt_should_not_ignore}sR‘urootN(R R|RHtset_gui(R%t custom_guiR¢R@t set_gui_args((sO/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/group.pytinitialize_guigs    cC`sÀd„}g}g}xg|jd|ƒD]S}y|jjƒWq(tjk rz}|jt|ƒƒ|j|jƒq(Xq(W|r¼dj|ƒ}tj|d|dd|d|ƒ‚ndS( u’ Apply GUI element values, entered by the user, to settings. Ignore settings with the `'ignore_apply_gui_value_to_setting'` tag. This method will not have any effect on settings with automatic GUI-to-setting value updating. Raises: * `SettingValueError` - One or more values are invalid. The exception message contains messages from all invalid settings. cS`s d|jkS(Nu!ignore_apply_gui_value_to_setting(R)(R@((sO/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/group.pyR¢˜sR‘u R@itmessagesRN( R|tguitupdate_setting_valueRJtSettingValueErrorRQRbR@Rp(R%R¢texception_messagestexception_settingsR@Rctexception_message((sO/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/group.pytapply_gui_values_to_settingsŠs   cC`sRt|jƒ}d|kr2t|dƒ|ds("      &  (ÿÿ„# -*- coding: utf-8 -*- """Metaclasses for settings and mappings of types.""" from __future__ import absolute_import, division, print_function, unicode_literals from future.builtins import * import collections import functools import inspect import re import types from .. import utils as pgutils class _TypeMap(object): def __init__(self, description=None): self._description = description self._name_to_type_map = collections.OrderedDict() self._type_to_names_map = collections.defaultdict(list) def __getitem__(self, type_or_name): if isinstance(type_or_name, types.StringTypes): try: return self._name_to_type_map[type_or_name] except KeyError: raise TypeError(self._get_error_message(type_or_name)) else: return_all_names = False if isinstance(type_or_name, (list, tuple)): type_ = type_or_name[0] if len(type_or_name) > 1: return_all_names = type_or_name[1] else: type_ = type_or_name if type_ not in self._type_to_names_map: raise TypeError(self._get_error_message(type_)) names = self._type_to_names_map[type_] if return_all_names: return names else: return names[0] def __contains__(self, key): if isinstance(key, types.StringTypes): return key in self._name_to_type_map else: return key in self._type_to_names_map def __getattr__(self, name): try: return self._name_to_type_map[name] except KeyError: raise TypeError(self._get_error_message(name)) def __hasattr__(self, name): return name in self._name_to_type_map def _get_error_message(self, value): error_message = 'unrecognized type "{}"'.format(value) if self._description: error_message += '; are you sure this is a {}?'.format(self._description) return error_message SettingTypes = _TypeMap(description='setting type') SettingGuiTypes = _TypeMap(description='setting GUI type') class SettingMeta(type): """Metaclass for the `setting.Setting` class and its subclasses. The metaclass is responsible for the following: * Creating a mapping of `Setting` subclasses and human-readable names for easier specification of the `'type'` field when creating settings via `setting.Group.add()`. * Tracking names and values of arguments passed to instantiation of a setting. The names and values are then passed to `Setting.to_dict()` to allow persisting the setting with the arguments it was instantiated with. * Ensuring that `Setting` classes documented as abstract cannot be initialized (`TypeError` is raised on `__init__()`). """ def __new__(mcls, name, bases, namespace): # @NoSelf _handle_abstract_attribute(namespace) _set_init_wrapper(mcls, namespace) cls = super(SettingMeta, mcls).__new__(mcls, name, bases, namespace) _register_type_and_aliases(namespace, cls, name, SettingTypes, 'Setting') return cls @staticmethod def _get_init_wrapper(orig_init): @functools.wraps(orig_init) def init_wrapper(self, *args, **kwargs): if getattr(self, '_ABSTRACT', False): raise TypeError('cannot initialize abstract setting class "{}"'.format( self.__class__.__name__)) # This check prevents a parent class' `__init__()` from overriding the # contents of `_dict_on_init`, which may have different arguments. if not hasattr(self, '_dict_on_init'): self._dict_on_init = dict(kwargs) # Exclude `self` as the first argument arg_names = inspect.getargspec(orig_init)[0][1:] for arg_name, arg in zip(arg_names, args): self._dict_on_init[arg_name] = arg if inspect.getargspec(orig_init)[1] is not None: raise TypeError( ('__init__ in Setting subclasses cannot accept variable positional arguments' ' (found in "{}")').format(self.__class__.__name__)) orig_init(self, *args, **kwargs) return init_wrapper class GroupMeta(type): """Metaclass for the `setting.Group` class. The metaclass is responsible for the following: * Tracking names and values of arguments passed to instantiation of a group. The names and values are then passed to `Group.to_dict()` to allow persisting the group with the arguments it was instantiated with. """ def __new__(mcls, name, bases, namespace): # @NoSelf _set_init_wrapper(mcls, namespace) cls = super(GroupMeta, mcls).__new__(mcls, name, bases, namespace) return cls @staticmethod def _get_init_wrapper(orig_init): @functools.wraps(orig_init) def init_wrapper(self, *args, **kwargs): # This check prevents a parent class' `__init__()` from overriding the # contents of `_dict_on_init`, which may have different arguments. if not hasattr(self, '_dict_on_init'): self._dict_on_init = dict(kwargs) # Exclude `self` as the first argument arg_names = inspect.getargspec(orig_init)[0][1:] for arg_name, arg in zip(arg_names, args): self._dict_on_init[arg_name] = arg if inspect.getargspec(orig_init)[1] is not None: raise TypeError('Group.__init__() cannot accept variable positional arguments') orig_init(self, *args, **kwargs) return init_wrapper class PresenterMeta(type): """Metaclass for the `setting.Presenter` class and its subclasses. The metaclass is responsible for the following: * Creating a mapping of `Presenter` subclasses and human-readable names for easier specification of the `'gui_type'` field when creating settings via `setting.Group.add()`. * Ensuring that `Presenter` classes documented as abstract cannot be initialized (`TypeError` is raised on `__init__()`). """ def __new__(mcls, name, bases, namespace): # @NoSelf _handle_abstract_attribute(namespace) _set_init_wrapper(mcls, namespace) cls = super(PresenterMeta, mcls).__new__(mcls, name, bases, namespace) _register_type_and_aliases(namespace, cls, name, SettingGuiTypes, 'Presenter') return cls @staticmethod def _get_init_wrapper(orig_init): @functools.wraps(orig_init) def init_wrapper(self, *args, **kwargs): if getattr(self, '_ABSTRACT', False): raise TypeError('cannot initialize abstract presenter class "{}"'.format( self.__class__.__name__)) orig_init(self, *args, **kwargs) return init_wrapper def _set_init_wrapper(mcls, namespace): # Only wrap `__init__` if the (sub)class defines or overrides it. # Otherwise, the argument list of `__init__` for a subclass would be # overridden the parent class' `__init__` argument list. if '__init__' in namespace: namespace['__init__'] = mcls._get_init_wrapper(namespace['__init__']) def _handle_abstract_attribute(namespace): if '_ABSTRACT' not in namespace: namespace['_ABSTRACT'] = False def _register_type_and_aliases(namespace, cls, type_name, type_map, base_class_name): processed_type_name = pgutils.safe_decode(type_name, 'utf-8') human_readable_name = _get_human_readable_class_name(processed_type_name, base_class_name) if human_readable_name not in type_map._name_to_type_map: if not namespace['_ABSTRACT']: type_map._name_to_type_map[human_readable_name] = cls type_map._type_to_names_map[cls].append(human_readable_name) if '_ALIASES' in namespace: for alias in namespace['_ALIASES']: if alias not in type_map._name_to_type_map: type_map._name_to_type_map[alias] = cls else: raise TypeError( 'alias "{}" matches a {} class name or is already specified'.format( alias, base_class_name)) type_map._type_to_names_map[cls].append(alias) else: raise TypeError( 'Setting subclass with the name "{}" already exists ({})'.format( cls.__name__, type_map._name_to_type_map[human_readable_name])) def _get_human_readable_class_name(name, suffix_to_strip=None): processed_name = name if suffix_to_strip and processed_name.endswith(suffix_to_strip): processed_name = processed_name[:-len(suffix_to_strip)] # Converts the class name in CamelCase to snake_case. # Source: https://stackoverflow.com/a/1176023 processed_name = re.sub(r'(?