ó dņōdc@`sødZddlmZmZmZmZddlTddlZddl Z ddl Z yddl Z Wne k r…ddl Z nXddlZddlmZddlZddlmZddlmZddd f\ZZZd Zejjd ejje jeƒfd „ƒYƒZd efd„ƒYZdefd„ƒYZ defd„ƒYZ!ejjdefd„ƒYƒZ"e#d„Z$e#d„Z%e#d„Z&e#d„Z'dS(uFManaging items of a GIMP image (e.g. layers) in a tree-like structure.i(tabsolute_importtdivisiontprint_functiontunicode_literals(t*N(tpdbi(t objectfilter(tutilsiufoldertItemTreecB`sęeZdZdeejjd„Ze d„ƒZ e d„ƒZ d„Z d„Z d„Zd„Zeeed„Zd „Zeeed „Zeeed „Zd „Zd „Zd„Zejd„ƒZd„Zd„ZRS(uInterface to store `gimp.Item` objects in a tree-like structure. Use one of the subclasses for items of a certain type: * `LayerTree` for layers, * `ChannelTree` for channels, * `VectorTree` for vectors (paths). Each item in the tree is an `Item` instance. Each item contains `gimp.Item` attributes and additional derived attributes. Items can be directly accessed via their ID or name. Both ID and name are unique in the entire tree (GIMP readily ensures that item names are unique). Item groups (e.g. layer groups) are inserted twice in the tree - as folders and as items. Parents of items are always folders. `ItemTree` is a static data structure, i.e. it does not account for modifications, additions or removal of GIMP items by GIMP procedures outside this class. To refresh the contents of the tree, create a new `ItemTree` instance instead. Attributes: * `image` (read-only) - GIMP image to generate item tree from. * `name` (read-only) - Optional name of the item tree. The name is currently used as an identifier of the persistent source for tags in items. See `Item.tags` for more information. * `is_filtered` - If `True`, ignore items that do not match the filter (`ObjectFilter`) in this object when iterating. * `filter` - `ObjectFilter` instance that allows filtering items based on rules. cC`s_||_||_||_||_tj|jƒ|_tjƒ|_ i|_ |j ƒdS(N( t_imaget_namet is_filteredt_filter_match_typetpgobjectfiltert ObjectFiltertfiltert collectionst OrderedDictt _itemtreet_itemtree_namest _build_tree(tselftimagetnameR tfilter_match_type((sJ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/itemtree.pyt__init__Js     cC`s|jS(N(R (R((sJ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/itemtree.pyRescC`s|jS(N(R (R((sJ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/itemtree.pyRiscC`s/y|j|SWntk r*|j|SXdS(uCReturns an `Item` object by its ID or original name. An item's ID is the `Item.raw.ID` attribute. An item's original name is the `Item.orig_name` attribute. To access an item group as a folder, pass a tuple `(ID or name, 'folder')`. For example: item_tree['Frames', 'folder'] N(RtKeyErrorR(Rt id_or_name((sJ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/itemtree.pyt __getitem__ms  cC`s||jkp||jkS(uŃReturns `True` if an `Item` object is in the item tree, regardless of filters. Return `False` otherwise. The `Item` object is specified by its `Item.raw.ID` attribute or its `orig_name` attribute. (RR(RR((sJ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/itemtree.pyt __contains__}scC`stg|D] }|^q ƒS(uReturns the number of items in the tree. This includes immediate children of the image and nested children. Empty item groups (i.e. groups with no children) are excluded. The returned number of items depends on whether `is_filtered` is `True` or `False`. (tlen(Rtitem((sJ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/itemtree.pyt__len__„s cC`s|jdtdtƒS(uIterates over items, excluding folders and empty item groups. If the `is_filtered` attribute is `False`, iterate over all items. If `is_filtered` is `True`, iterate only over items that match the filter. Yields: * `item` - The current `Item` object. t with_folderstwith_empty_groups(titertFalse(R((sJ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/itemtree.pyt__iter__s cc`s»x“|jjƒD]£}t}| r;|jtkr;t}n| rq|jtkrqtj|j ƒd rqt}n|r„|r„|j r„|j j |ƒ r„t}q„n|r|VqqWdS(u˜Iterates over items, optionally including folders and empty item groups. Parameters: * `with_folders` - If `True`, include folders. Topmost folders are yielded first. Items are always yielded after all of its parent folders. * `with_empty_groups` - If `True`, include empty item groups. Empty item groups as folders are still yielded if `with_folders` is `True`. * `filtered` - If `True` and `is_filtered` attribute is also `True`, iterate only over items matching the filter. Set this to `False` if you need to iterate over all items. Yields: * `item` - The current `Item` object. iN( RtvaluestTruettypet TYPE_FOLDERR$t TYPE_GROUPRtgimp_item_get_childrentrawR Rtis_match(RR!R"tfilteredRtshould_yield_item((sJ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/itemtree.pyR#›s & " cc`s#x|jjƒD] }|VqWdS(uĆIterates over all items. This is equivalent to `iter(with_folders=True, with_empty_groups=True, filtered=False)`. Yields: * `item` - The current `Item` object. N(RR&(RR((sJ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/itemtree.pytiter_allæs cC`s|j||||dƒS(uÆReturns the previous item in the tree. Depending on the values of parameters, some items may be skipped. For the description of the parameters, see `iter()`. uprev(t _prev_next(RRR!R"R.((sJ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/itemtree.pytprevĢscC`s|j||||dƒS(u«Returns the next item in the tree. Depending on the values of parameters, some items may be skipped. For the description of the parameters, see `iter()`. unext(R1(RRR!R"R.((sJ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/itemtree.pytnextŌscC`sļ|}xātrźt||ƒ}|dkr.Pn|rJ|jtkr_Pq_n|jtkr_q n|r’|jtkr¾tj|jƒd r¾Pq¾n,|jtkr¾tj|jƒd r¾q n|rę|j rę|j j |ƒrēPqēq Pq W|S(Ni( R'tgetattrtNoneR(R)R*RR+R,R RR-(RRR!R"R.tadjacent_attr_namet adjacent_item((sJ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/itemtree.pyR1Üs,  cC`stj|jƒ|_dS(u7Resets the filter, creating a new empty `ObjectFilter`.N(R RR R(R((sJ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/itemtree.pyt reset_filterżsc C`sŃg}x¤|j|jƒD]}|j|ƒr|jt|tggdd|jƒƒ|jt|tggdd|jƒƒq|jt|t ggdd|jƒƒqW|}g}xŒ|rG|j dƒ}|j|ƒ|j tkr!||j |j jtf<||j|jtfscC`s tj|ƒS(N(Rtgimp_item_is_group(RRM((sJ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/itemtree.pyR:EsN(t__name__t __module__t__doc__R5R'R Rt MATCH_ALLRtpropertyRRRRR R%R$R#R0R2R3R1R8RtabctabstractmethodR9RDR:(((sJ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/itemtree.pyR!s('   $  !  5 t LayerTreecB`s#eZd„Zd„Zd„ZRS(cC`s|jS(N(tlayers(RR((sJ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/itemtree.pyR9KscC`s|jS(N(R\(RRM((sJ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/itemtree.pyRDNscC`st|tjƒS(N(t isinstancetgimpt GroupLayer(RRM((sJ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/itemtree.pyR:Qs(RTRUR9RDR:(((sJ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/itemtree.pyR[Is  t ChannelTreecB`seZd„ZRS(cC`s|jS(N(tchannels(RR((sJ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/itemtree.pyR9Ws(RTRUR9(((sJ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/itemtree.pyR`Ust VectorTreecB`seZd„ZRS(cC`s|jS(N(tvectors(RR((sJ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/itemtree.pyR9]s(RTRUR9(((sJ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/itemtree.pyRb[sR<cB`speZdZdddddd„Zed„ƒZed„ƒZed„ƒZej d„ƒZed„ƒZ e j d„ƒZ ed„ƒZ ed „ƒZ ed „ƒZ ed „ƒZed „ƒZed „ƒZed„ƒZed„ƒZed„ƒZed„ƒZd„Zd„Zd„Zd„Zed„Zd„Zd„Zd„Zd„ZRS(u' Wrapper for a `gimp.Item` object containing additional attributes. Note that the attributes will not be up to date if changes were made to the original `gimp.Item` object. Attributes: * `raw` (read-only) - Underlying `gimp.Item` object wrapped by this instance. * `type` (read-only) - Item type - one of the following: * `TYPE_ITEM` - regular item * `TYPE_GROUP` - item group (item whose raw `gimp.Item` is a group with children; this `Item` has no children and acts as a regular item) * `TYPE_FOLDER` - item containing children (raw item is a group with children) * `parents` - List of `Item` parents for this item, sorted from the topmost parent to the bottommost (immediate) parent. * `children` - List of `Item` children for this item. * `depth` (read-only) - Integer indicating the depth of the item in the item tree. 0 means the item is at the top level. The greater the depth, the lower the item is in the item tree. * `parent` (read-only) - Immediate `Item` parent of this object. If this object has no parent, return `None`. * `name` - Item name as a string, initially equal to `orig_name`. Modify this attribute instead of `gimp.Item.name` to avoid modifying the original item. * `prev` - Previous `Item` in the `ItemTree`, or `None` if there is no previous item. * `next` - Next `Item` in the `ItemTree`, or `None` if there is no next item. * `tags` - Set of arbitrary strings attached to the item. Tags can be used for a variety of purposes, such as special handling of items with specific tags. Tags are stored persistently in the `gimp.Item` object (`item` attribute) as parasites. The name of the parasite source is given by the `tags_source_name` attribute. * `orig_name` (read-only) - Original `gimp.Item.name` as a string. This attribute may be used to access `Item`s in `ItemTree`. * `orig_parents` (read-only) - Initial `parents` of this item. * `orig_children` (read-only) - Initial `children` of this item. * `orig_tags` (read-only) - Initial `tags` of this item. * `tags_source_name` - Name of the persistent source for the `tags` attribute. Defaults to `'tags'` if `None`. If `type` is `FOLDER`, `'_folder'` is appended to `tags_source_name`. cC`s|dkrtdƒ‚n||_||_|dk r?|ng|_|dk rZ|ng|_||_||_tj |j ƒ|_ t |r™|nd|jƒ|_ |j ƒ|_|j |_|j|_|j|_t|jƒ|_ddddg|_g|_dS(Nuitem cannot be Noneutagsunameu_parentsu _childrenu_tags(R5t TypeErrort _raw_itemt_typet_parentst _childrenRJRKtpgutilstsafe_decode_gimpRt_get_effective_tags_source_namet_tags_source_namet _load_tagst_tagst _orig_namet _orig_parentsREtsett _orig_tagst_item_attributest _saved_states(RRMt item_typeRCRFt prev_itemt next_itemttags_source_name((sJ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/itemtree.pyR›s$        cC`s|jS(N(Re(R((sJ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/itemtree.pyR,øscC`s|jS(N(Rf(R((sJ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/itemtree.pyR(¼scC`s|jS(N(Rg(R((sJ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/itemtree.pyRCĄscC`s ||_dS(N(Rg(RRC((sJ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/itemtree.pyRCÄscC`s|jS(N(Rh(R((sJ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/itemtree.pyRFČscC`s ||_dS(N(Rh(RRF((sJ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/itemtree.pyRFĢscC`s t|jƒS(N(RRg(R((sJ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/itemtree.pytdepthŠscC`s|jr|jdSdS(Ni’’’’(RgR5(R((sJ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/itemtree.pytparentŌscC`s|jS(N(RJ(R((sJ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/itemtree.pyR2ŲscC`s|jS(N(RK(R((sJ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/itemtree.pyR3ÜscC`s|jS(N(Rn(R((sJ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/itemtree.pyttagsąscC`s|jS(N(Rl(R((sJ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/itemtree.pyRxäscC`s|jS(N(Ro(R((sJ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/itemtree.pyRAčscC`s t|jƒS(N(R#Rp(R((sJ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/itemtree.pyt orig_parentsģscC`s t|jƒS(N(R#RE(R((sJ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/itemtree.pyt orig_childrenšscC`s t|jƒS(N(R#Rr(R((sJ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/itemtree.pyt orig_tagsōscC`stj||jƒS(N(Ritstringify_objectRA(R((sJ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/itemtree.pyt__str__ųscC`s1tj|dj|jtt|jƒƒgƒƒS(Nu (Ritreprify_objecttjoinRAtstrR(R,(R((sJ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/itemtree.pyt__repr__ūsc`s'ˆjj‡fd†ˆjDƒƒdS(u‡Saves the current values of item's attributes that can be modified. To restore the last saved values, call `pop_state()`. c`s"i|]}tˆ|ƒ|“qS((R4(t.0t attr_name(R(sJ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/itemtree.pys s N(RtR;Rs(R((RsJ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/itemtree.pyt push_state’s cC`sYy|jjƒ}Wntk r'dSXx*|jƒD]\}}t|||ƒq5WdS(uāSets the values of item's attributes to the values from the last call to `push_state()`. Calling `pop_state()` without any saved state (e.g. when `push_state()` has never been called before) does nothing. N(RtR>t IndexErrortitemstsetattr(Rt saved_statesR†t attr_value((sJ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/itemtree.pyt pop_states  cC`sO|j|_t|jƒ|_t|jƒ|_|rKt|jƒ|_ ndS(uvResets the item's attributes to the values upon its instantiation. Is `tags` is `True`, also reset tags. N( RoRRBRpRgRERhRqRrRn(RR{((sJ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/itemtree.pytresets  cC`s1||jkrdS|jj|ƒ|jƒdS(u‡Adds the specified tag to the item. If the tag already exists, do nothing. The tag is saved to the item persistently. N(Rntaddt _save_tags(Rttag((sJ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/itemtree.pytadd_tag!scC`sH||jkr*tdj||ƒƒ‚n|jj|ƒ|jƒdS(ueRemoves the specified tag from the item. If the tag does not exist, raise `ValueError`. utag "{}" not found in {}N(Rnt ValueErrortformattremoveR(RR‘((sJ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/itemtree.pyt remove_tag.scC`st|j|j|jƒdS(u$Saves tags persistently to the item.N(tset_tags_for_raw_itemReRnRl(R((sJ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/itemtree.pyR:scC`st|j|jƒS(N(tget_tags_from_raw_itemReRl(R((sJ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/itemtree.pyRm>sN(RTRURVR5RRXR,R(RCtsetterRFRyRzR2R3R{RxRAR|R}R~R€R„R‡RR$RŽR’R–RRm(((sJ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/itemtree.pyR<as88       cC`s`|jt||ƒƒ}|rUytj|jƒ}Wntk rPtƒ}nX|StƒSdS(u„Obtains a set of tags from a `gimp.Item` instance, i.e. a raw item. `tags_source_name` is the name of the persistent source (parasite) to obtain tags from. N(t parasite_findRktpickletloadstdatat ExceptionRq(RMt source_nameRutparasiteR{((sJ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/itemtree.pyR˜Bs  cC`sUt|||ƒ|rQ|jtjt||ƒtjtjBtj |ƒƒƒndS(N( tremove_tags_from_raw_itemtparasite_attachR^tParasiteRkt gimpenumstPARASITE_PERSISTENTtPARASITE_UNDOABLER›tdumps(RMR{RŸRu((sJ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/itemtree.pyR—Ts  cC`s|jt||ƒƒdS(N(tparasite_detachRk(RMRŸRu((sJ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/itemtree.pyR”_scC`s |tkr|dtS|SdS(Nu_(R)R@(RŸRu((sJ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/itemtree.pyRkcs  ((RVt __future__RRRRtfuture.builtinst future.utilstfutureRYRtcPickleR›t ImportErrorR^RR¤tRR RRiR=R*R)R@tpython_2_unicode_compatibletwith_metaclasstABCMetatobjectRR[R`RbR<R5R˜R—R”Rk(((sJ/home/josie/.config/GIMP/2.10/plug-ins/export_layers/pygimplib/itemtree.pyts8"        (’(  ą  # -*- coding: utf-8 -*- """Logging-related classes.""" # NOTE: In order to allow logging errors as early as possible (before plug-in # initialization): # * we are breaking the 'all imports at the beginning of module' convention # for some modules, # * the `future` library is not imported in case some modules in the library are # not available in the installed Python distribution and would thus cause an # `ImportError` to be raised. from __future__ import absolute_import, division, print_function, unicode_literals str = unicode import datetime import io import os import sys import traceback from . import _path_dirs _LOG_MODES = ('none', 'exceptions', 'files', 'gimp_console') _exception_logger = None def log_output( log_mode, log_dirpaths, log_stdout_filename, log_stderr_filename, log_header_title='', gimp_console_message_delay_milliseconds=0): """ Enable logging of output. Parameters: * `log_mode` - The log mode. Possible values: * 'none' - Do not log anything. * 'exceptions' - Only log exceptions to the error log file. * 'files' - Redirect `stdout` and `stderr` to log files. * 'gimp_console' - Redirect `stdout` and `stderr` to the GIMP error console. * `log_dirpaths` - List of directory paths for log files. If the first path is invalid or permission to write is denied, subsequent directories are used. For the `'gimp_console'` mode, this parameter has no effect. * `log_stdout_filename` - Filename of the log file to write standard output to. Applies to the `'files'` mode only. * `log_stderr_filename` - Filename of the log file to write error output to. Applies to the `'exceptions'` and `'files'` modes only. * `log_header_title` - Optional title in the log header, written before the first output to the log files. Applies to the `'exceptions'` and `'files'` modes only. * `gimp_console_message_delay_milliseconds` - The delay to display messages to the GIMP console in milliseconds. Only applies to the `'gimp_console'` mode. """ _restore_orig_state(log_mode) if log_mode == 'none': return if log_mode == 'exceptions': _redirect_exception_output_to_file( log_dirpaths, log_stderr_filename, log_header_title) elif log_mode == 'files': stdout_file = create_log_file(log_dirpaths, log_stdout_filename) if stdout_file is not None: sys.stdout = SimpleLogger(stdout_file, log_header_title) stderr_file = create_log_file(log_dirpaths, log_stderr_filename) if stderr_file is not None: sys.stderr = SimpleLogger(stderr_file, log_header_title) elif log_mode == 'gimp_console': from . import pdbutils as pgpdbutils sys.stdout = pgpdbutils.GimpMessageFile( message_delay_milliseconds=gimp_console_message_delay_milliseconds) sys.stderr = pgpdbutils.GimpMessageFile( message_prefix='Error: ', message_delay_milliseconds=gimp_console_message_delay_milliseconds) else: raise ValueError('invalid log mode "{}"; allowed values: {}'.format( log_mode, ', '.join(_LOG_MODES))) def get_log_header(log_header_title): return '\n'.join(('', '=' * 80, log_header_title, str(datetime.datetime.now()), '\n')) def create_log_file(log_dirpaths, log_filename, mode='a'): """ Create a log file in the first file path that can be written to. Return the log file upon successful creation, `None` otherwise. """ log_file = None for log_dirpath in log_dirpaths: try: _path_dirs.make_dirs(log_dirpath) except OSError: continue try: log_file = io.open(os.path.join(log_dirpath, log_filename), mode, encoding='utf-8') except IOError: continue else: break return log_file def _restore_orig_state(log_mode): global _exception_logger for file_ in [_exception_logger, sys.stdout, sys.stderr]: if (file_ is not None and hasattr(file_, 'close') and file_ not in [sys.__stdout__, sys.__stderr__]): try: file_.close() except IOError: # An exception could occur for an invalid file descriptor. pass _exception_logger = None sys.excepthook = sys.__excepthook__ sys.stdout = sys.__stdout__ sys.stderr = sys.__stderr__ def _redirect_exception_output_to_file(log_dirpaths, log_filename, log_header_title): global _exception_logger def create_file_upon_exception_and_log_exception(exc_type, exc_value, exc_traceback): global _exception_logger _exception_log_file = create_log_file(log_dirpaths, log_filename) if _exception_log_file is not None: _exception_logger = SimpleLogger(_exception_log_file, log_header_title) log_exception(exc_type, exc_value, exc_traceback) sys.excepthook = log_exception else: sys.excepthook = sys.__excepthook__ def log_exception(exc_type, exc_value, exc_traceback): global _exception_logger _exception_logger.write( ''.join(traceback.format_exception(exc_type, exc_value, exc_traceback))) sys.excepthook = create_file_upon_exception_and_log_exception class SimpleLogger(object): """ This class wraps a file object to write a header before the first output. """ def __init__(self, file_, log_header_title): self._log_file = file_ self._log_header_title = log_header_title def write(self, data): if self._log_header_title: self._write(get_log_header(self._log_header_title)) self._write(data) self.write = self._write def _write(self, data): self._log_file.write(str(data)) self.flush() def flush(self): self._log_file.flush() def close(self): self._log_file.close() # Original version by Peter Otten: # http://mail.python.org/pipermail/python-list/2007-May/438106.html class Tee(object): """ This class copies `stdout` or `stderr` output to a specified file, much like the Unix `tee` command. This class acts as a file-like object containing the `write()` and `flush()` methods. Attributes: * `stream` - Either `sys.stdout` or `sys.stderr`. Other objects are invalid and raise `ValueError`. * `log_header_title` - Header text to write when writing into the file for the first time. """ def __init__( self, stream, file_, log_header_title=None, start=True, flush_output=False): """ Parameters: * `file_` - File or file-like object to write to. * `start` - If `True`, start `Tee` upon instantiation. To start later, pass `start=False` and call `start()` when desired. * `flush_output` - If `True`, flush output after each write. """ self._streams = {sys.stdout: 'stdout', sys.stderr: 'stderr'} self.log_header_title = log_header_title if log_header_title is not None else '' self.flush_output = flush_output self._file = None self._is_running = False self._orig_stream = None self._stream_name = '' self._stream = None self.stream = stream if start: self.start(file_) def __del__(self): if self.is_running(): self.stop() @property def stream(self): return self._stream @stream.setter def stream(self, value): self._stream = value if value in self._streams: self._stream_name = self._streams[value] else: raise ValueError('invalid stream; must be sys.stdout or sys.stderr') def start(self, file_): """ Start `Tee` if not started during the object instantiation. Parameters: * `file_` - File or file-like object to write to. """ self._orig_stream = self.stream setattr(sys, self._stream_name, self) self._file = file_ self._is_running = True def stop(self): """ Stop `Tee`, i.e. stop writing to the file. """ setattr(sys, self._stream_name, self._orig_stream) self._file.close() self._file = None self._is_running = False def is_running(self): """ Return `True` if `Tee` is running (i.e. writing to file), `False` otherwise. """ return self._is_running def write(self, data): """ Write output to the stream and the specified file. If `log_header_title` is not empty, write the log header before the first output. """ if self.log_header_title: self._file.write(get_log_header(self.log_header_title)) self._write_with_flush(data) if not self.flush_output: self.write = self._write else: self.write = self._write_with_flush def _write(self, data): self._file.write(data) self._stream.write(data) def _write_with_flush(self, data): self._file.write(data) self._file.flush() self._stream.write(data) self._stream.flush() def flush(self): self._file.flush() self._stream.flush()