ddc@`s dZddlmZmZmZmZddlTddlZddl Z ddl Z ddl Z ddl Z ddl Z ddlZddlZyddlZWnek rddlZnXyddlZWnek reZnXeZddlZddlZddlZddlmZddlmZdd lmZ dd lm!Z"ddlmZ#ddl$Td d d ddgZ%dejj&e j'e(fdYZ)de)fdYZ*de)fdYZ+de)fdYZ,de)fdYZ-dS(uLoading and saving settings.i(tabsolute_importtdivisiontprint_functiontunicode_literals(t*Ni(t constants(tutilsi(tgroup(tsettingsuSourceuGimpShelfSourceuGimpParasiteSourceuPickleFileSourceuJsonFileSourcetSourcecB`seZdZdZdZdZdZedZdZ dZ dZ d Z d Z d Zd Zd ZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZ dZ!dZ"d Z#d!Z$e%ed"Z&e'j(d#Z)e'j(d$Z*e'j(d%Z+e'j(d&Z,RS('uAbstract class for reading and writing settings to a source. Attributes: * `source_name` - A unique identifier to distinguish entries from different GIMP plug-ins or procedures. * `source_type` - If `'persistent'`, this indicates that the setting source should store settings permanently. If `'session'`, this indicates that the source should store settings within a single GIMP session (i.e. until the currently running GIMP instance is closed). u ignore_loadu ignore_saveicC`s||_||_g|_dS(N(t source_namet source_typet_settings_not_loaded(tselfR R ((sQ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/sources.pyt__init__Fs  cC`s t|jS(uList of all settings and groups that were not found in the data or their `setting_source` attribute is not `None` and does does not contain `source_type`. (tlistR (R ((sQ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/sources.pytsettings_not_loadedLscC`sV|j}|dkr9ttdj|jng|_|j||dS(ueReads setting attributes from data and assigns them to existing settings specified in the `settings_or_groups` iterable, or creates settings within groups specified in `settings_or_groups`. If a setting value from the source is invalid, the setting will be reset to its default value. All settings that were not loaded in the source will be stored in the `settings_not_loaded` property. This property is reset on each call to `read()`. The following criteria determine whether a setting specified in `setting_or_groups` is not loaded: * The setting is not found in the source. * The setting or any of its parent groups contains 'ignore_load' in its `tags` attribute. * The setting does not contain `source_type` in its `setting_sources` attribute. Raises: * `SourceNotFoundError` - Could not find the source having the `source_name` attribute as its name. * `SourceInvalidFormatError` - Existing data in the source have an invalid format. This could happen if the source was edited manually. u#Could not find setting source "{}".N(tread_data_from_sourcetNonetSourceNotFoundErrort_tformatR R t_update_settings(R tsettings_or_groupstdata((sQ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/sources.pytreadTs    cC`s|j|}x|D]}|j}||kr||}t|tjrs|j|||j||qt|tjr|j |||j ||||qt dq|j j |qWdS(Nu?settings_or_groups must contain only Setting or Group instances(t_create_data_dicttget_patht isinstancet settings_tSettingt _check_if_setting_dict_has_valuet_update_settingtgroup_tGroupt#_check_if_setting_dict_has_settingst _update_groupt TypeErrorR tappend(R RRt data_dicttsetting_or_groupt setting_patht setting_dict((sQ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/sources.pyR|s    c C`s'tj}||d\}}|dk r|jr|kr||fVqdS(N(Rt startswith(t.0RMR7(RI(sQ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/sources.pys s (R+R,RB(R R'RI((RIsQ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/sources.pyR>sc`stj}x|jdtD]}|j|j|jkrS|jntfd|Druqn||<|krt |t j rt |dkr|j j|qq|j j|qqW|||<|S(Ntinclude_groupsc3`s|]}j|VqdS(N(RN(ROtprefix(t child_path(sQ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/sources.pys si(R+R,twalktTrueRt_IGNORE_LOAD_TAGttagstaddtanyRR!R"tlenR R&(R RRIRJRKRLtchild((RRsQ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/sources.pyR@s     c`stj}x}|jD]o\}|j|jdgkr\|kr\|jntfd|Dr~qn||s(R+R,RBRUtgetRWRX(R RJRLRKtfiltered_matching_dictsR7((RMsQ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/sources.pyRAs 'cC`sM|j|sdSy|j|dWntjk rH|jnXdS(Nuvalue(t_should_setting_be_loadedt set_valueRtSettingValueErrortreset(R tsettingR*((sQ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/sources.pyR s cC`sO|j|jkrtS|jdk rK|j|jkrK|jj|tStS(N( RURVtFalsetsetting_sourcesRR R R&RT(R Ra((sQ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/sources.pyR]s !cC`s|j|jkS(N(RURV(R R((sQ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/sources.pyR=scC`s5|jdd}|dk r1|j|kr1tStS(Nusetting_sources(R[RR RbRT(R R7Rc((sQ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/sources.pyt_should_dict_be_loadedscC`s|j|sdS|jtjdd}||ks>t||}t|}|jdd|j|g||d}d|kr|j ||n|||j Returns `True` if the source contains data, `False` otherwise.N((R ((sQ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/sources.pythas_data scC`sdS(uReads data representing settings from the source. Usually you do not need to call this method. Use `read()` instead which assigns values to existing settings or creates settings dynamically from the data. If the source does not exist, `None` is returned. Raises: * `SourceInvalidFormatError` - Data could not be read due to being corrupt. N((R ((sQ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/sources.pyRscC`sdS(uqWrites data representing settings to the source. The entire setting source is overwritten by the specified data. Settings not specified thus will be removed. Usually you do not need to call this method. Use `write()` instead which creates an appropriate persistent representation of the settings that can later be loaded via `read()`. N((R R((sQ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/sources.pyRos (-t__name__t __module__t__doc__RURt/_MAX_LENGTH_OF_OBJECT_AS_STRING_ON_ERROR_OUTPUTRtpropertyRRRRR$R>R@RAR R]R=RdRDRFRpRnRsRtRxR{R|RqR-R1R2RR#RCREt staticmethodRtabctabstractmethodRRRRo(((sQ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/sources.pyR 3sP   (  "                    tGimpShelfSourcecB`sGeZdZddZdZdZdZdZdZRS(uClass for reading and writing settings to the GIMP shelf. This class is appropriate to maintain settings within a single GIMP session as the GIMP shelf is reset when closing GIMP. usessioncC`stj||dS(N(tsuperR(R R R ((sQ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/sources.pyR4scC`sdtj|jeZdZddZdZdZdZdZRS(uClass reading and writing settings to the `parasiterc` file maintained by GIMP. This class is useful as a persistent source (i.e. permanent storage) of settings. u persistentcC`s2tj||tjjtjd|_dS(Nu parasiterc(RRtosRMR5Rt directoryt_parasite_filepath(R R R ((sQ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/sources.pyR[scC`s0tj|jdkrdStj|jdS(N(Rt parasite_findR Rtparasite_detach(R ((sQ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/sources.pyR`scC`stj|jdk S(N(RRR R(R ((sQ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/sources.pyRfscC`sntj|j}|dkr"dSytj|j}Wn/tk ritt dj |j nX|S(NuSettings for this plug-in stored in "{}" may be corrupt. This could happen if the file was edited manually. To fix this, save the settings again or reset them.( RRR RtpickletloadsRRRGRRR(R tparasiteR((sQ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/sources.pyRis   cC`s/tjtj|jtjtj|dS(N(Rtparasite_attachtParasiteR t gimpenumstPARASITE_PERSISTENTRtdumps(R R((sQ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/sources.pyRoys(RRRRRRRRo(((sQ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/sources.pyRSs     tPickleFileSourcecB`sweZdZdZddZedZdZdZdZ dZ d Z d Z d Z d ZRS( uClass reading and writing settings to a file, formatted using the Python `pickle` module. This class is useful as a persistent source (i.e. permanent storage) of settings. This class is appropriate to use when saving settings to a file path chosen by the user. u u persistentcC`s tj||||_dS(N(RRt _filepath(R R tfilepathR ((sQ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/sources.pyRscC`s|jS(N(R(R ((sQ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/sources.pyRscC`sE|j}|dk rA|j|krA||j=|j|ndS(N(t read_all_dataRR twrite_all_data(R tall_data((sQ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/sources.pyRs  cC`s3y|j}Wntk r$dSX|dk SdS(uYReturns `True` if the source contains data and the data have a valid format, `'invalid_format'` if the source contains some data, but the data have an invalid format, and `False` otherwise. `'invalid_format'` represents an ambiguous value since there is no way to determine if there are data under `source_name` or not. uinvalid_formatN(Rt SourceErrorR(R R((sQ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/sources.pyRs  cC`sC|j}|dk r;|j|kr;|j||jSdSdS(N(RRR t_get_settings_from_pickled_data(R R((sQ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/sources.pyRs cC`sc|j|}|j}|dkrEtj|j|fg}n |||j<|j|dS(N(t_pickle_settingsRRR+R,R R(R Rtraw_dataR((sQ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/sources.pyRos    cC`stjj|jsdStj}y|tj|jddt j X}xN|D]F}|j |j d}t |dkrP|\}}|||}tj||dtdddd }|jt |Wd QXWn#t k rt t j nXd S( uWrites `all_data` into the file, overwriting the entire file contents. `all_data` is a dictionary of (source name, contents) pairs. uwRt sort_keystindentit separatorsu,u: N(u,u: (RRRRRRRRbRptunicodeRRRR(R RRR((sQ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/sources.pyR:s !$ ( RRRRRRRRRRoRR(((sQ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/sources.pyRs      (.Rt __future__RRRRtfuture.builtinst future.utilstfutureRRR+RRRRtcPickleRt ImportErrorRRbRRTRRRtRRRRRR!RRR3t_sources_errorst__all__twith_metaclasstABCMetatobjectR RRRR(((sQ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/setting/sources.pytsN"                 (&+l# -*- coding: utf-8 -*- """Helper classes and functions for modules in the `setting` package.""" from __future__ import absolute_import, division, print_function, unicode_literals from future.builtins import * import collections import itertools import types __all__ = [ 'SETTING_PATH_SEPARATOR', 'SETTING_ATTRIBUTE_SEPARATOR', 'SettingParentMixin', 'SettingEventsMixin', 'get_pdb_name', 'get_setting_name', 'value_to_str_prefix', 'get_processed_display_name', 'generate_display_name', 'get_processed_description', 'generate_description', 'get_setting_path', 'check_setting_name', ] SETTING_PATH_SEPARATOR = '/' SETTING_ATTRIBUTE_SEPARATOR = '.' class SettingParentMixin(object): """ This mixin provides `Setting` and `Group` instances with a parent reference, allowing settings and groups to form a tree-like structure. """ def __init__(self): super().__init__() self._parent = None @property def parent(self): return self._parent @property def parents(self): """ Return a list of parents (setting groups), starting from the topmost parent. """ parent = self._parent parents = [] while parent is not None: parents.insert(0, parent) parent = parent.parent return parents def _set_as_parent_for_setting(self, setting): setting._parent = self class SettingEventsMixin(object): """ This mixin provides `Setting` and `Group` instances with the capability of setting up and invoking events. """ _event_handler_id_counter = itertools.count(start=1) def __init__(self): super().__init__() # key: event type # value: collections.OrderedDict{ # event handler ID: [event handler, arguments, keyword arguments, is enabled]} self._event_handlers = collections.defaultdict(collections.OrderedDict) # This allows faster lookup of events via IDs. # key: event handler ID; value: event type self._event_handler_ids_and_types = {} def connect_event( self, event_type, event_handler, *event_handler_args, **event_handler_kwargs): """ Connect an event handler. `event_type` can be an arbitrary string. To invoke an event manually, call `invoke_event`. Several event types are invoked automatically. For the list of such event types, consult the documentation for `Setting` or `Group` classes. The `event_handler` function must always contain at least one argument - the instance this method is called from (a setting or a setting group). Multiple event handlers can be connected. Each new event handler is invoked as the last. Parameters: * `event_type` - Event type as a string. * `event_handler` - Function to be called when the event given by `event_type` is invoked. * `*event_handler_args` - Arguments to `event_handler`. * `**event_handler_kwargs` - Keyword arguments to `event_handler`. Returns: * `event_id` - Numeric ID of the event handler (can be used to remove the event via `remove_event`). Raises: * `TypeError` - `event_handler` is not a function or the wrong number of arguments was passed in `event_handler_args`. """ if not callable(event_handler): raise TypeError('not a function') event_id = self._event_handler_id_counter.next() self._event_handlers[event_type][event_id] = [ event_handler, event_handler_args, event_handler_kwargs, True] self._event_handler_ids_and_types[event_id] = event_type return event_id def remove_event(self, event_id): """ Remove the event handler specified by its ID as returned by `connect_event()`. """ if event_id not in self._event_handler_ids_and_types: raise ValueError('event handler with ID {} does not exist'.format(event_id)) event_type = self._event_handler_ids_and_types[event_id] del self._event_handlers[event_type][event_id] del self._event_handler_ids_and_types[event_id] def set_event_enabled(self, event_id, enabled): """ Enable or disable the event handler specified by its ID. If the event ID is already enabled and `enabled` is `True` or is already disabled and `enabled` is `False`, do nothing. Raises: * `ValueError` - Event ID is invalid. """ if not self.has_event(event_id): raise ValueError('event ID {} is invalid'.format(event_id)) event_type = self._event_handler_ids_and_types[event_id] self._event_handlers[event_type][event_id][3] = enabled def has_event(self, event_id): """ Return `True` if the event handler specified by its ID is connected to the setting, `False` otherwise. """ return event_id in self._event_handler_ids_and_types def invoke_event(self, event_type, *additional_args, **additional_kwargs): """ Call all connected event handlers of the specified event type. Additional arguments and keyword arguments are passed via `*additional_args` and `**additional_kwargs`, respectively. These arguments are prepended to the arguments specified in `connect_event` (if any). The same keyword arguments in `connect_event` override keyword arguments in `**additional_kwargs`. """ for (event_handler, args, kwargs, enabled) in self._event_handlers[event_type].values(): if enabled: event_handler_args = additional_args + tuple(args) event_handler_kwargs = dict(additional_kwargs, **kwargs) event_handler(self, *event_handler_args, **event_handler_kwargs) def get_pdb_name(setting_name): """ Return name suitable for the description of the setting in the GIMP PDB. """ return setting_name.replace('_', '-') def get_setting_name(pdb_name): """ Return setting name based on the specified name from GIMP PDB. """ return pdb_name.replace('-', '_') def value_to_str_prefix(value): """ Return stringified setting value useful as a prefix to an error message. If `value` is empty or `None`, return empty string. """ if value: return '"{}": '.format(value) else: return '' def get_processed_display_name(setting_display_name, setting_name): if setting_display_name is not None: return setting_display_name else: return generate_display_name(setting_name) def generate_display_name(setting_name): return setting_name.replace('_', ' ').capitalize() def get_processed_description(setting_description, setting_display_name): if setting_description is not None: return setting_description else: return generate_description(setting_display_name) def generate_description(display_name): """ Generate setting description from a display name. Underscores in display names used as mnemonics are usually undesired in descriptions, hence their removal. """ return display_name.replace('_', '') def get_setting_path(setting, relative_path_group=None): """ Get the full setting path consisting of names of parent setting groups and the specified setting. The path components are separated by '/'. If `relative_path_group` is specified, the setting group is used to relativize the setting path. If the path of the setting group to the topmost parent does not match, return the full path. If `relative_path_group` is equal to `'root'` and the setting has at least one parent, omit the topmost group. """ def _get_setting_path(path_components): return SETTING_PATH_SEPARATOR.join([setting.name for setting in path_components]) if relative_path_group == 'root': if setting.parents: setting_path_without_root = _get_setting_path( (setting.parents + [setting])[1:]) return setting_path_without_root else: return setting.name else: setting_path = _get_setting_path(setting.parents + [setting]) if relative_path_group is not None: root_path = _get_setting_path( relative_path_group.parents + [relative_path_group]) if setting_path.startswith(root_path): return setting_path[len(root_path + SETTING_PATH_SEPARATOR):] return setting_path def check_setting_name(setting_name): """ Check if the specified setting name is valid. If not, raise `ValueError`. A setting name must not contain `SETTING_PATH_SEPARATOR` or `SETTING_ATTRIBUTE_SEPARATOR`. """ if not isinstance(setting_name, types.StringTypes): raise TypeError('setting name must be a string') if (SETTING_PATH_SEPARATOR in setting_name or SETTING_ATTRIBUTE_SEPARATOR in setting_name): raise ValueError('setting name "{}" is not valid'.format(setting_name))