ddc@`sdZddlmZmZmZmZddlTddlZddlZddl Z ddl Z ddl Z ddl m Z ddl mZddl mZddl mZdd l mZdd l mZdd l mZdd l mZdZd ZdZdefdYZdS(u@Batch-processing layers and exporting layers as separate images.i(tabsolute_importtdivisiontprint_functiontunicode_literals(t*N(tpdb(t pygimplib(tactions(tbuiltin_constraints(tbuiltin_procedures(t exceptions(texport(t placeholdersunamec`s"tjfd}|S(Nc `st|djjtj}|jt|jt|j }y|jdWnt k rrnXi}x't ||D]\}}|||d5Z?d6Z@d7ZAd8ZBd9ZCd:ZDd;ZEd<ZFed=ZGeHd>ZId?ZJd@ZKdAZLdBZMdCZNRS(EuwClass for batch-processing layers in the specified image with a sequence of actions (resize, rename, export, ...). iuupngcC`sd|_d|_d|_d|_d|_d|_g|_tj t |_ tj t |_ tj t |_ tj t |_t|_d|_tjj|_dS(N(tNonet _current_itemt_current_raw_itemt_current_proceduret_current_constraintt_current_imaget_orig_active_layert_exported_raw_itemst collectionst defaultdicttlistt_skipped_procedurest_skipped_constraintst_failed_procedurest_failed_constraintstFalset _should_stopt_invokertpgtinvokertInvokert_initial_invoker(Rtinitial_run_modet input_imaget procedurest constraintst edit_modetoutput_directorytlayer_filename_patterntfile_extensiontoverwrite_modetoverwrite_choosertprogress_updatert item_treet is_previewtprocess_contentst process_namestprocess_exporttexport_context_managertexport_context_manager_argstexport_context_manager_kwargs((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pyt__init__Ds         cC`s|jS(uThe run mode to use for the first layer. For subsequent layers, `gimpenums.RUN_WITH_LAST_VALS` is used. This usually has effect when exporting layers - if `initial_run_mode` is `gimpenums.RUN_INTERACTIVE`, a native file format GUI is displayed for the first layer and the same settings are then applied to subsequent layers. If the file format in which the layer is exported to cannot handle `gimpenums.RUN_WITH_LAST_VALS`, `gimpenums.RUN_INTERACTIVE` is forced. (t_initial_run_mode(R((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pyR@ms cC`s|jS(u)Input `gimp.Image` to process layers for.(t _input_image(R((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pyRAzscC`s|jS(umIf `True`, batch-edit layers directly in `input_image`. If `False`, batch-process and export layers. (t _edit_mode(R((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pyRDscC`s|jS(u/`setting.Group` instance containing procedures.(t _procedures(R((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pyRBscC`s|jS(u1`setting.Group` instance containing constraints..(t _constraints(R((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pyRCscC`s|jS(u1Output directory path to save exported layers to.(t_output_directory(R((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pyREscC`s|jS(u+Filename pattern for layers to be exported.(t_layer_filename_pattern(R((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pyRFscC`s|jS(u-Filename extension for layers to be exported.(t_file_extension(R((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pyRGscC`s|jS(umOne of the `pygimplib.overwrite.OverwriteModes` values indicating how to handle files with the same name.(t_overwrite_mode(R((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pyRHscC`s|jS(u`pygimplib.overwrite.OverwriteChooser` instance that is invoked during export if a file with the same name already exists. If `None`, then `pygimplib.overwrite.NoninteractiveOverwriteChooser` is used. (t_overwrite_chooser(R((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pyRIscC`s|jS(u`pygimplib.progres.ProgressUpdater` instance indicating the number of layers processed so far. If no progress update is desired, pass `None`. (t_progress_updater(R((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pyRJscC`s|jS(u`pygimplib.itemtree.ItemTree` instance containing layers to be processed. If `None` (the default), an item tree is automatically created at the start of processing. If `item_tree` has filters (constraints) set, they will be reset on each call to `run()`. (t _item_tree(R((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pyRKscC`s|jS(uIf `True`, only procedures and constraints that are marked as "enabled for previews" will be applied for previews. If `False`, this property has no effect (and effectively allows performing real processing). (t _is_preview(R((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pyRLscC`s|jS(uIf `True`, invoke procedures on layers. Setting this to `False` is useful if you require only layer names to be processed. (t_process_contents(R((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pyRMscC`s|jS(u,If `True`, process layer names before export to be suitable to save to disk (in particular to remove characters invalid for a file system). If `is_preview` is `True` and `process_names` is `True`, also invoke built-in procedures modifying item names only (e.g. renaming layers). (t_process_names(R((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pyRNscC`s|jS(uIf `True`, perform export of layers. Setting this to `False` is useful to preview the processed contents of a layer without saving it to a file. (t_process_export(R((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pyROscC`s|jS(uContext manager that wraps exporting a single layer. This can be used to perform GUI updates before and after export. Required parameters: current run mode, current image, layer to export, output filename of the layer. (t_export_context_manager(R((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pyRPscC`s|jS(uCAdditional positional arguments passed to `export_context_manager`.(t_export_context_manager_args(R((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pyRQscC`s|jS(u@Additional keyword arguments passed to `export_context_manager`.(t_export_context_manager_kwargs(R((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pyRRscC`s|jS(u?A `pygimplib.itemtree.Item` instance currently being processed.(R+(R((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pyt current_itemscC`s|jS(u2Raw item (`gimp.Layer`) currently being processed.(R,(R((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pytcurrent_raw_itemscC`s ||_dS(N(R,(Rtvalue((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pyRhscC`s|jS(u8The procedure currently being applied to `current_item`.(R-(R((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pytcurrent_procedurescC`s|jS(u5The most recent (last) constraint that was evaluated.(R.(R((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pytcurrent_constraint scC`s|jS(uThe current `gimp.Image` containing layer(s) being processed. If `edit_mode` is `True`, this is equivalent to `input_image`. If `edit_mode` is `False`, this is a copy of `input_image` to avoid modifying original layers. (R/(R((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pyt current_images cC`s t|jS(uList of layers that were successfully exported. Does not include layers skipped by the user (when files with the same names already exist). (R4R1(R((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pytexported_raw_itemsscC`s t|jS(uProcedures that were skipped during processing. A skipped procedure was not applied to one or more items and causes no adverse effects further during processing. (tdictR5(R((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pytskipped_procedures&scC`s t|jS(uConstraints that were skipped during processing. A skipped constraint was not evaluated for one or more items and causes no adverse effects further during processing. (RnR6(R((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pytskipped_constraints/scC`s t|jS(uProcedures that caused an error during processing. Failed procedures indicate a problem with the procedure parameters or potentially a bug in the plug-in. (RnR7(R((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pytfailed_procedures8scC`s t|jS(uConstraints that caused an error during processing. Failed constraints indicate a problem with the constraint parameters or potentially a bug in the plug-in. (RnR8(R((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pytfailed_constraintsAscC`s|jS(u`pygimplib.invoker.Invoker` instance to manage procedures and constraints applied on layers. This property is reset on each call of `run()`. (R;(R((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pyR=JscK`s|j||j|j|t}|jr<|jnz/y|jWntk rit}nXWd|jr|j |nX|jr|j r|j SdSdS(uBatch-processes and exports layers as separate images. A copy of the image and the layers to be processed are created so that the original image and its soon-to-be processed layers are left intact. The image copy is automatically destroyed once processing is done. To keep the image copy, pass `True` to `keep_image_copy`. In that case, this method returns the image copy. If an exception was raised or if no layer was exported, this method returns `None` and the image copy will be destroyed. `**kwargs` can contain arguments that can be passed to `Batcher.__init__()`. Arguments in `**kwargs` overwrite the corresponding `Batcher` properties. See the properties for details. N( Rt_prepare_for_processingR_R9Rat_setup_contentst_process_itemst ExceptiontTruet_cleanup_contentst_keep_image_copyt _image_copyR*(Rtkeep_image_copyRtexception_occurred((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pytrunSs       cC`s t|_dS(u}Terminates batch processing prematurely. The termination occurs after the current item is processed completely. N(RwR:(R((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pytstopvscO`s|jj||S(u Adds a procedure to be applied during `run()`. The signature is the same as for `pygimplib.invoker.Invoker.add()`. Procedures added by this method are placed before procedures added by `actions.add()`. Procedures are added immediately before the start of processing. Thus, calling this method during processing will have no effect. Unlike `actions.add()`, procedures added by this method do not act as settings, i.e. they are merely functions without GUI, are not saved persistently and are always enabled. This class recognizes several action groups that are invoked at certain places when `run()` is called: * `'before_process_items'` - invoked before starting processing the first item. Only one argument is accepted - instance of this class. * `'before_process_items_contents'` - same as `'before_process_items'`, but applied only if `process_contents` is `True`. * `'after_process_items'` - invoked after finishing processing the last item. Only one argument is accepted - instance of this class. * `'after_process_items_contents'` - same as `'after_process_items'`, but applied only if `process_contents` is `True`. * `'before_process_item'` - invoked immediately before applying procedures on the layer. Three arguments are accepted: * instance of this class * the current `pygimplib.itemtree.Item` to be processed * the current GIMP item to be processed * `'before_process_item_contents'` - same as `'before_process_item'`, but applied only if `process_contents` is `True`. * `'after_process_item'` - invoked immediately after all procedures have been applied to the layer. Three arguments are accepted: * instance of this class * the current `pygimplib.itemtree.Item` that has been processed * the current GIMP item that has been processed * `'after_process_item_contents'` - same as `'after_process_item'`, but applied only if `process_contents` is `True`. * `'cleanup_contents'` - invoked after processing is finished and cleanup is commenced (e.g. removing temporary internal images). Use this if you create temporary images or items of your own. While you may also achieve the same effect with `'after_process_items_contents'`, using `'cleanup_contents'` is safer as it is also invoked when an exception is raised. Only one argument is accepted - instance of this class. (R?tadd(RRR((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pyt add_procedure}s0cO`s|jj|j|||S(u Adds a constraint to be applied during `run()`. The first argument is the function to act as a filter (returning `True` or `False`). The rest of the signature is the same as for `pygimplib.invoker.Invoker.add()`. For more information, see `add_procedure()`. (R?Rt_get_constraint_func(RR$RR((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pytadd_constraints cO`s|jj||dS(uRemoves an action originally scheduled to be applied during `run()`. The signature is the same as for `pygimplib.invoker.Invoker.remove()`. N(R?R(RRR((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pyt remove_actionscO`s|jj||dS(uReorders an action to be applied during `run()`. The signature is the same as for `pygimplib.invoker.Invoker.reorder()`. N(R?treorder(RRR((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pytreorder_actionsc`s]djdrdjkr9tjdj}qdjkr_tjdj}qdjj}t j |d d n&djdr~t j djrt tjjdj}qd jrwd jdj}djkr*|jjjd |d fndjkr\|jjjd |d fnt j |d d qd Sn4d jdjj}t j |d d |d krd S|d k rtfd |D rd S|j}|j|}|d kr,dj}ntd|g}|jj|||d S(uAdds an action and wraps/processes the action's function according to the action's settings. For PDB procedures, the function name is converted to a proper function object. For constraints, the function is wrapped to act as a proper filter rule for `item_tree.filter`. Any placeholder objects (e.g. "current image") as function arguments are replaced with real objects during processing of each item. If `tags` is not `None`, the action will not be added if it does not contain any of the specified tags. If `action_groups` is not `None`, the action will be added to the specified action groups instead of the groups defined in `action['action_groups']`. uoriginubuiltinu procedureu orig_nameu constraintuFinvalid action "{}" - must contain "procedure" or "constraint" in tagsugimp_pdbufunctionuenableduPDB procedure "{}" not foundNu!invalid origin {} for action "{}"c3`s|]}|jkVqdS(N(ttags(t.0ttag(taction(s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pys su action_groupsu arguments(tis_itemRR tBUILTIN_PROCEDURES_FUNCTIONSRiRtBUILTIN_CONSTRAINTS_FUNCTIONSRtnameR t ActionErrorR*Rtgimp_procedural_db_proc_existsR<tutilstsafe_encode_gimpR7tappendR8tanyt_get_processed_functiont_handle_exceptions_from_actionR4R;R(RRRt action_groupstfunctiontmessagetprocessed_functiont invoker_args((Rs?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pyt_add_action_from_settingss>   ## ) c`sfd}|S(Nc`s|d |d}}js(tSj|}j||\}}djkrj|}j||dj}n|||S(Niu constraintu orig_name(t _is_enabledR9t%_set_current_procedure_and_constraintt_get_action_args_and_kwargsRt _set_apply_constraint_to_foldersRRi(taction_args_and_functiont action_argsRt orig_functionRR(RR(s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pyt_function_wrappers ((RRR((RRs?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pyRscC`s?|jr*|djo |djs;tSn|djs;tStS(Nuenableduenabled_for_previews(R`RiR9Rw(RR((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pyRs   cC`s:d|jkr||_nd|jkr6||_ndS(Nu procedureu constraint(RR-R.(RR((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pyR%s cC`so|j|}i}|djdre|jt|j|rei|dd6}|d}qen||fS(Nuoriginugimp_pdbitrun_modei(t_get_replaced_argsRtpopt _BATCHER_ARG_POSITION_IN_ACTIONSt_has_run_mode_param(RRRRRR((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pyR,s cC`sg}xt|D]l}t|tjrD|jtj|j|q t|tjjrl|j|jq |j|q W|S(uZReturns a list of action arguments, replacing any placeholder values with real values.( t isinstanceR tPlaceholderSettingRtget_replaced_argRiR<tsettingtSetting(Rtaction_argumentst replaced_argstargument((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pyR9s cC`s|jo|jdddkS(Niiurun-mode(tparams(Rt pdb_procedure((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pyRIsc`s(|djr fd}|SSdS(Nualso_apply_to_parent_foldersc`sb|d}t}xK|g|jdddD],}|oM||d|}|s.Pq.q.W|S(Niii(Rwtparents(Rt action_kwargstitemtresulttitem_or_parent(R(s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pyROs $(Ri(RRRR((Rs?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pyRLs  c`sfd}|S(Nc`sGjdk rn|}jjj||ddS(NR(t_get_args_for_constraint_funcR*R_tfilterR(RRt func_args(R$Rt orig_funcR(s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pyR_s ((RR$RRR((R$RRRs?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pyR]scC`sytj|jjd}Wntk r8d}nX|dk rN|}n7t|dkrit}nd}|| ||d}|S(Nubatcherii(RRRtindexRR*RR(RR$Rtbatcher_arg_positionR((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pyRhs     c`sfd}|S(Nc`sSy||SWn;tjk r}djkr^jjjjt|fndjkrOjjjjt|fqOnt k rN}t j }djkrj jjjt||fndjkr*j jjjt||fntjt|j|nXdS(Nu procedureu constraint(R t SkipActionRR5RRR+tstrR6Rvt tracebackt format_excR7R8R(RRtettrace(RRR(s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pyt_handle_exceptions{s), ,,((RRRR((RRRs?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pyRzscK`s2ttj|jj}|jdx[|jD]M\}}||krdt|d||q5tdj |t |q5W|j dkrt jj|j|_ n|jdkrt jjd|_n|jdkrt jj|_n|jdkrd|_n|jdkr.i|_ndS(Nuselfu_u4invalid argument "{}" encountered; must be one of {}((tsetRRt_orig___init__RtdiscardtitemsR RRR4R]R*R<t overwritetNoninteractiveOverwriteChooserR\R^tprogresstProgressUpdaterRdRt EmptyContextReRf(RRtinit_argspec_namesRRi((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pyRs&    cC`s>|dk r||_n$tjj|jdtjj|_|jjrX|jj n||_ d|_ d|_ d|_ d|_|j|_d|_d|_t|_g|_tjt|_tjt|_tjt|_tjt|_tjj|_|j|j |j!|j"j#dS(NR($R*R_R<titemtreet LayerTreeRUtconfigt SOURCE_NAMERt reset_filterRyR+R,R-R.R/RzR0R9R:R1R2R3R4R5R6R7R8R=R>R;t _add_actionst_add_name_only_actionst_set_constraintsR^treset(RRKR{((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pyRss0  $              cC`s1|jjtjtjg|jjtjtjgdt|jjtjtjgdt|j r|jjtj tjgdtn|jj|j |j j dt|j tjgx'tj|jD]}|j|qW|jtjgx'tj|jD]}|j|qWdS(Ntforeachtinclude_empty_groups(R;RR tset_active_and_current_layerRtDEFAULT_PROCEDURES_GROUPt)set_active_and_current_layer_after_actionRwt sync_item_name_and_raw_item_nameRVtpreserve_locks_between_actionsR?t list_groupst_add_default_rename_proceduretwalkRWRt_add_default_export_procedureRX(Rt proceduret constraint((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pyRs0          cC`s|jtgx6tj|jD]"}|j|tjgtgq#W|jtgx6tj|j D]"}|j|tjgtgqlWdS(N( Rt_NAME_ONLY_ACTION_GROUPRRRWRR t NAME_ONLY_TAGRRX(RRR((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pyRscC`sY|j rUtdtj|jD rU|jjtjd|d|j gndS(Ncs`s/|]%}|djdko&|djVqdS(u orig_nameurenameuenabledN(Ri(RR((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pys stgroupsR( RVRRRRWR;RR t rename_layerRZ(RR((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pyRs   cC`sh|j rdtdtj|jD rd|jjtjd|d|j |j tj j gndS(Ncs`s/|]%}|djdko&|djVqdS(u orig_nameuexportuenabledN(Ri(RR((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pys sRR( RVRRRRWR;Rtexport_R RYR[t ExportModest EACH_LAYER(RR((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pyR s   cC`s&|jjtjg|gdtdS(Ntadditional_args_position(R;tinvokeRtDEFAULT_CONSTRAINTS_GROUPR(R((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pyRs   cC`stj|j s|jrxtjj|j|_|j|_ tj |j tj j rtj |j |_qn|j|_ tj|j |j j|_dS(N(Rtgimp_context_pushRVR`R<tpdbutilstcreate_image_from_metadataRURzR/tgimp_image_undo_freezeRtDEBUG_IMAGE_PROCESSINGtgimp_display_newt _display_idtgimp_image_undo_group_startt active_layerR0(R((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pyRts    cC`s|jjdg|gdt|j s2|jr|j|j|jtj |jt j j rwtj |jn|j s|rt jj|jqn>tj|jr|j|j_ntj|jtjtjd|_d|_d|_d|_d|_dS(Nucleanup_contentsR(R;RRRVR`t_copy_non_modifying_parasitesR/RURtgimp_image_undo_thawR<RRtgimp_display_deleteRRyRttry_delete_imagetgimp_item_is_validR0Rtgimp_image_undo_group_endtgimp_displays_flushtgimp_context_popR*R+R,R-R.(RR|((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pyRx*s*         cC`sptj|\}}xT|D]L}|j|dkr|j|}|jdkrh|j|qhqqWdS(Ni(Rtgimp_image_get_parasite_listt parasite_findR*tflagstparasite_attach(t src_imaget dest_imagetunused_tparasite_namest parasite_nametparasite((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pyRHs  cC`st|j|j_|jjdg|gdt|jr_|jjdg|gdtnxg|jD]\}|jrt j dn|j r|jj t dj|jn|j|qiW|jr|jjdg|gdtn|jjdg|gdtdS(Nubefore_process_itemsRubefore_process_items_contentsustopped by useruProcessing "{}"uafter_process_items_contentsuafter_process_items(RR_R^tnum_total_tasksR;RRRaR:R tBatcherCancelErrorRVt update_textt_Rt orig_namet _process_item(RR((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pyRuSs2        %      cC`st||_|j|_|jr4|jr4|jn|jrc|j||j|j|jn|j j dS(N( R+trawR,R`Rbt$_process_item_with_name_only_actionsRat_process_item_with_actionst_refresh_current_imageR^t update_tasks(RR((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pyRus    cC`sy|jjdg||j|jgdt|jjtg|gdt|jjdg||j|jgdtdS(Nubefore_process_itemRuafter_process_item(R;RR+R,RR(R((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pyRs    cC`s|j s|jratjj||jdt|jjt t t }||_ |j |j _ n|jr|j rt j |rtjj||j|jt j|j|dt t t }||_ |j |j _ n|jjdg||j|j gdt|jr=|jjdg||j|j gdtn|jjtjg|gdt|jr|jjdg||j|j gdtn|jjdg||j|j gdtdS(Niubefore_process_itemRubefore_process_item_contentsuafter_process_item_contentsuafter_process_item(RVR`R<Rtcopy_and_paste_layerR/R*RtlayersRwR,RRtgimp_item_is_grouptparenttgimp_image_get_item_positionR;RR+RRaRR(RRtraw_itemt raw_item_copy((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pyRsD * "             cC`sE|j rA|j rAx*|jjD]}tj|j|q!WndS(N(RVRyR/RRtgimp_image_remove_layer(RRtlayer((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pyRsN(ORt __module__t__doc__R(R9tgimptuser_directoryR<RtOverwriteModestSKIPR*RwRStpropertyR@RARDRBRCRERFRGRHRIRJRKRLRMRNRORPRQRRRgRhtsetterRjRkRlRmRoRpRqRrR=R}R~RRRRRRRRRRRRRRRRRsRRRRRRtRxt staticmethodRRuRRRR(((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pyR)?s                 #  2  =         $ "    "  .(Rt __future__RRRRtfuture.builtinsR2R&RRR Rt export_layersRR<RRR R R RR RRR(tobjectR)(((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/batcher.pyts&"       !# -*- coding: utf-8 -*- """Built-in plug-in constraints.""" from __future__ import absolute_import, division, print_function, unicode_literals from future.builtins import * import collections from gimp import pdb from export_layers import pygimplib as pg def is_layer(item): return item.type == pg.itemtree.TYPE_ITEM def is_nonempty_group(item): return item.type == pg.itemtree.TYPE_GROUP and pdb.gimp_item_get_children(item.raw)[1] def has_matching_file_extension(item, file_extension): return pg.path.get_file_extension(item.name).lower() == file_extension.lower() def has_matching_default_file_extension(item, batcher): return pg.path.get_file_extension(item.name).lower() == batcher.file_extension.lower() def is_item_in_selected_items(item, selected_items): return item.raw.ID in selected_items def is_top_level(item): return item.depth == 0 def is_visible(item): return item.raw.visible def has_tags(item, tags=None): if tags: return any(tag for tag in tags if tag in item.tags) else: return bool(item.tags) def has_no_tags(item, tags=None): return not has_tags(item, tags) _BUILTIN_CONSTRAINTS_LIST = [ { 'name': 'layers', 'type': 'constraint', 'function': is_layer, 'display_name': _('Layers'), }, { 'name': 'layer_groups', 'type': 'constraint', 'function': is_nonempty_group, 'display_name': _('Layer groups'), }, { 'name': 'matching_file_extension', 'type': 'constraint', 'function': has_matching_default_file_extension, # FOR TRANSLATORS: Think of "Only layers matching file extension" when translating this 'display_name': _('Matching file extension'), }, { 'name': 'selected_in_preview', 'type': 'constraint', 'function': is_item_in_selected_items, # FOR TRANSLATORS: Think of "Only layers selected in preview" when translating this 'display_name': _('Selected in preview'), 'arguments': [ { 'type': 'set', 'name': 'selected_layers', 'display_name': _('Selected layers'), 'gui_type': None, }, ], }, { 'name': 'top_level', 'type': 'constraint', 'function': is_top_level, # FOR TRANSLATORS: Think of "Only top-level layers" when translating this 'display_name': _('Top-level'), }, { 'name': 'visible', 'type': 'constraint', 'function': is_visible, # FOR TRANSLATORS: Think of "Only visible layers" when translating this 'display_name': _('Visible'), }, { 'name': 'with_tags', 'type': 'constraint', 'function': has_tags, # FOR TRANSLATORS: Think of "Only layers with tags" when translating this 'display_name': _('With tags'), 'arguments': [ { 'type': 'array', 'name': 'tags', 'display_name': _('Tags'), 'element_type': 'string', 'default_value': (), }, ], }, { 'name': 'without_tags', 'type': 'constraint', 'function': has_no_tags, # FOR TRANSLATORS: Think of "Only layers without tags" when translating this 'display_name': _('Without tags'), 'arguments': [ { 'type': 'array', 'name': 'tags', 'display_name': _('Tags'), 'element_type': 'string', 'default_value': (), }, ], }, ] # Create a separate dictionary for functions since objects cannot be saved # to a persistent source. Saving them as strings would not be reliable as # function names and paths may change when refactoring or adding/modifying features. # The 'function' setting is set to an empty value as the function can be inferred # via the action's 'orig_name' setting. BUILTIN_CONSTRAINTS = collections.OrderedDict() BUILTIN_CONSTRAINTS_FUNCTIONS = collections.OrderedDict() for action_dict in _BUILTIN_CONSTRAINTS_LIST: function = action_dict['function'] action_dict['function'] = '' BUILTIN_CONSTRAINTS[action_dict['name']] = action_dict BUILTIN_CONSTRAINTS_FUNCTIONS[action_dict['name']] = function