ó âdc@`s‘dZddlmZmZmZmZddlTddlZddlZddl Z de fd„ƒYZ ej ddd d d d gƒZ dS( u9Class to filter objects according to the specified rules.i(tabsolute_importtdivisiontprint_functiontunicode_literals(t*Nt ObjectFiltercB`s2eZdZdZ\ZZejddƒZedd„Z e d„ƒZ e d„ƒZ d„Z d „Zd „Zd „Zdddd „Zd „Zd„Zddddd„Zejdddd„ƒZejddddd„ƒZd„Zd„Zd„Zdddd„Zd„Zd„ZRS(uëClass containing a list of rules determining whether an object matches given rules. Attributes: * `match_type` (read-only) - Match type. Possible match types: * MATCH_ALL - For `is_match()` to return `True`, an object must match all rules. * MATCH_ANY - For `is_match()` to return `True`, an object must match at least one rule. * `name` (read-only) - Name of the filter. The name does not have to be unique and can be used to manipulate multiple rules (functions or nested filters) with the same name at once (e.g. by removing them with `remove()`). A rule can be a callable (function) or a nested `ObjectFilter` instance (with its own rules and different matching type if needed). iitstartucC`s%||_||_tjƒ|_dS(N(t _match_typet_namet collectionst OrderedDictt_rules(tselft match_typetname((sN/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/objectfilter.pyt__init__'s  cC`s|jS(N(R(R ((sN/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/objectfilter.pyR /scC`s|jS(N(R(R ((sN/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/objectfilter.pyR3scC`s t|jƒS(u=Returns `True` if the filter is not empty, `False` otherwise.(tboolR (R ((sN/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/objectfilter.pyt__bool__7scC`s ||jkS(ušReturns `True` if the filter contains the given rule, `False` otherwise. Parameters: * `rule_id` - rule ID as returned by `add()`. (R (R trule_id((sN/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/objectfilter.pyt __contains__;scC`s |j|S(uãReturns the specified rule - a `_Rule` instance or a nested filter. Parameters: * `rule_id` - rule ID as returned by `add()`. Raises * `KeyError` - `rule_id` is not found in the filter. (R (R R((sN/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/objectfilter.pyt __getitem__Ds cC`s t|jƒS(ubReturns the number of rules in the filter. Rules within nested filters do not count. (tlenR (R ((sN/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/objectfilter.pyt__len__QscC`s¼|dk r|nd}|dk r*|ni}|jƒ}t|tƒr\||j|<|St|ƒr£|}t||||j||ƒ|ƒ}||j|<|Stdj |ƒƒ‚dS(u²Adds the specified callable or a nested filter as a rule to the filter. Parameters: * `func_or_filter` - A callable (function) or nested filter to filter objects by. If a callable, it must have at least one argument - the object to match (used by `is_match()`). * `args` - Arguments for `func_or_filter` if it is a callable. * `kwargs` - Keyword arguments for `func_or_filter` if it is a callable. * `name` - Name of the added rule if `func_or_filter` is a callable. If an empty string, the `__name__` attribute is used if it exists. `name` does not have to be unique and can be used to manipulate multiple rules with the same name at once (e.g. by removing them with `remove()`). Returns: If `func_or_filter` is a callable, a `_Rule` instance is returned, containing the input parameters and a unique identifier. If `func_or_filter` is a nested filter, a unique identifier is used. The identifier can be used to e.g. access (via `__getitem__`) or remove a rule. Raises: * `TypeError` - `func_or_filter` is not a callable or an `ObjectFilter` instance. u-"{}": not a callable or ObjectFilter instanceN(( tNonet _get_rule_idt isinstanceRR tcallablet_Rulet_get_rule_name_for_funct TypeErrortformat(R tfunc_or_filtertargstkwargsRRtfunctrule((sN/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/objectfilter.pytaddXs"     cC`s%| rt|dƒr|jS|SdS(Nu__name__(thasattrt__name__(R R"R((sN/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/objectfilter.pyRŽscC`s |jjƒS(N(t_rule_id_countertnext(R ((sN/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/objectfilter.pyR”scC`sÉ|dkr3|dkr3|dkr3tdƒ‚ng}|dk sQ|dk rr|jd|d|d|ƒ}n||krš||krš|j|ƒng|D]}|jj|ƒ^q¡}||fS(uîRemoves rules from the filter matching one or more criteria. Parameters: * `rule_id` - rule ID as returned by `add()`. * `name` - See `find()`. * `func_or_filter` - See `find()`. * `count` - See `find()`. Raises: * `ValueError` - If `rule_id`, `name` and `func_or_filter` are all `None`. Returns: A list of removed removed rules (callables or nested filters) and a list of the corresponding IDs. u0at least one removal criterion must be specifiedRRtcountN(Rt ValueErrortfindtappendR tpop(R RRRR)t matching_idstid_tmatching_rules((sN/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/objectfilter.pytremove—s$!%cc`sˆ|dk r|nd}|dk r*|ni}|j||||ƒ}z |VWdt|tƒrv|j|jƒn |j|ƒXdS(uTemporarily adds a callable or nested filter as a rule to the filter. Use this function as a context manager: with filter.add_temp(func_or_filter) as rule_or_id: # do stuff See `add()` for further information about parameters and exceptions. N((RR$RRR1tid(R RR R!Rt rule_or_id((sN/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/objectfilter.pytadd_temp¼s  c c`sn|jd|d|d|d|ƒ\}}z||fVWdx*t||ƒD]\}}||j|RRR=R?R R!(R R<R=R@R#((sN/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/objectfilter.pyR;s!cC`s|dkr'|dkr'tdƒ‚ntjƒ}xž|jjƒD]\}}|dk rz|j|krzd||s"    ÿT# -*- coding: utf-8 -*- """Handling of conflicting files - overwrite, skip, etc.""" from __future__ import absolute_import, division, print_function, unicode_literals from future.builtins import * import future.utils import abc import os from . import path as pgpath class OverwriteChooser(future.utils.with_metaclass(abc.ABCMeta, object)): """ This class is an interface to indicate how to handle existing files. Attributes: * `overwrite_mode` (read-only) - Overwrite mode chosen by the user. """ @abc.abstractmethod def overwrite_mode(self): pass @abc.abstractmethod def choose(self, filepath=None): """ Return a value indicating how to handle the conflicting file by letting the user choose the value. The actual overwrite modes (possible values one of which the user chooses) and the implementation of handling conflicting files are left to the programmer using the return value provided by this method. Parameters: * `filepath` - File path that conflicts with an existing file. This class uses the file path to simply display it to the user. Defaults to `None`. """ pass class NoninteractiveOverwriteChooser(OverwriteChooser): """ This class simply stores overwrite mode specified upon the object instantiation. The object is suitable to use in a non-interactive environment, i.e. with no user interaction. """ def __init__(self, overwrite_mode): super().__init__() self._overwrite_mode = overwrite_mode @property def overwrite_mode(self): return self._overwrite_mode def choose(self, filepath=None): return self._overwrite_mode class InteractiveOverwriteChooser( future.utils.with_metaclass(abc.ABCMeta, OverwriteChooser)): """ This class is an interface for interactive overwrite choosers, requiring the user choose the overwrite mode. Additional attributes: * `values_and_display_names` - List of (value, display name) tuples which define overwrite modes and their human-readable names. * `default_value` - Default value. Must be one of the values in the `values_and_display_names` list. * `default_response` - Default value to return if the user made a choice that returns a value not in `values_and_display_names`. `default_response` does not have to be any of the values in `values_and_display_names`. * `is_apply_to_all` (read-only) - Whether the user-made choice applies to the current file (`False`) or to the current and all subsequent files (`True`). """ def __init__(self, values_and_display_names, default_value, default_response): super().__init__() self.values_and_display_names = values_and_display_names self._values = [value for value, unused_ in self.values_and_display_names] if default_value not in self._values: raise ValueError( 'invalid default value "{}"; must be one of the following: {}'.format( default_value, self._values)) self.default_value = default_value self.default_response = default_response self._overwrite_mode = self.default_value self._is_apply_to_all = False @property def overwrite_mode(self): return self._overwrite_mode @property def is_apply_to_all(self): return self._is_apply_to_all def choose(self, filepath=None): if self._overwrite_mode is None or not self._is_apply_to_all: return self._choose(filepath) else: return self._overwrite_mode @abc.abstractmethod def _choose(self, filepath): """ Let the user choose the overwrite mode and return it. If the choice results in a value that is not in `values_and_display_names`, return `default_response`. """ pass def handle_overwrite(filepath, overwrite_chooser, position=None): """ If a file with the specified file path exists, handle the file path conflict via `overwrite_chooser` (an `OverwriteChooser` instance). `filepath` indicates a file path for a new file to be saved. `overwrite_chooser` should support all overwrite modes specified in `OverwriteModes`. `RENAME_NEW` mode renames `filepath`. `RENAME_EXISTING` renames the existing file in the file system. If the overwrite mode indicates that the file path should be renamed and `position` is not `None`, the `position` specifies where in the file path to insert a unique substring (`' (number)'`). By default, the substring is inserted at the end of the file path to be renamed. Returns: * the overwrite mode as returned by `overwrite_chooser`, which the caller of this function can further use (especially `SKIP` or `CANCEL` values), * the file path passed as the argument, modified if `RENAME_NEW` mode is returned. """ if os.path.exists(filepath): overwrite_chooser.choose(filepath=os.path.abspath(filepath)) if overwrite_chooser.overwrite_mode in ( OverwriteModes.RENAME_NEW, OverwriteModes.RENAME_EXISTING): uniq_filepath = pgpath.uniquify_filepath(filepath, position) if overwrite_chooser.overwrite_mode == OverwriteModes.RENAME_NEW: filepath = uniq_filepath else: os.rename(filepath, uniq_filepath) return overwrite_chooser.overwrite_mode, filepath else: return OverwriteModes.DO_NOTHING, filepath class OverwriteModes(object): """ This class defines common overwrite modes for convenience. `SKIP` should be used if a file path already exists and no action should be taken. `DO_NOTHING` should be used if a file path does not exist and no action should be taken. `CANCEL` should be used if the user terminated the overwrite chooser (e.g. closed the overwrite dialog when an interactive chooser is used). """ OVERWRITE_MODES = REPLACE, SKIP, RENAME_NEW, RENAME_EXISTING, CANCEL, DO_NOTHING = ( 0, 1, 2, 3, 4, 5)