This file is indexed.

/usr/lib/python3/dist-packages/logging_tree-1.4.egg-info is in python3-logging-tree 1.4-1.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
Metadata-Version: 1.1
Name: logging_tree
Version: 1.4
Summary: Introspect and display the logger tree inside "logging"
Home-page: https://github.com/brandon-rhodes/logging_tree
Author: Brandon Rhodes
Author-email: brandon@rhodesmill.org
License: UNKNOWN
Description: Introspection for the ``logging`` logger tree in the Standard Library.
        
        While you can write programs that call this package's ``tree()``
        function and examine the hierarchy of logger objects that it finds
        inside of the Standard Library ``logging`` module, the simplest use of
        this package for debugging is to call ``printout()`` to print the
        loggers, filters, and handlers that your application has configured::
        
            >>> logging.getLogger('a')
            >>> logging.getLogger('a.b').setLevel(logging.DEBUG)
            >>> logging.getLogger('x.c')
            >>> from logging_tree import printout
            >>> printout()
            <--""
               Level WARNING
               |
               o<--"a"
               |   Level NOTSET so inherits level WARNING
               |   |
               |   o<--"a.b"
               |       Level DEBUG
               |
               o<--[x]
                   |
                   o<--"x.c"
                       Level NOTSET so inherits level WARNING
        
        The logger tree should always print successfully, no matter how
        complicated.  A node whose ``[name]`` is in square brackets is a "place
        holder" that has never actually been named in a ``getLogger()`` call,
        but was created automatically to serve as the parent of loggers further
        down the tree.
        
        There are several interfaces that ``logging_tree`` supports, depending
        on how much detail you need.
        
        ``logging_tree.printout(node=None)``
        
            Prints the current logger tree, or the tree based at the given
            `node`, to the standard output.
        
        ``logging_tree.format.build_description(node=None)``
        
            Builds and returns the multi-line description of the current logger
            tree, or the tree based at the given ``node``, as a single string
            with newlines inside and a newline at the end.
        
        ``logging_tree.format.describe(node)``
        
            A generator that yields a series of lines that describe the tree
            based at the given ``node``.  Note that the lines are returned
            without newline terminators attached.
        
        ``logging_tree.tree()``
        
            Fetch the current tree of loggers from the ``logging`` module.
            Returns a node, that is simply a tuple with three fields:
        
            | ``[0]`` the logger name (``""`` for the root logger).
            | ``[1]`` the ``logging.Logger`` object itself.
            | ``[2]`` a list of zero or more child nodes.
        
        I owe great thanks to `Rover Apps <http://roverapps.com/>`_ for letting
        me release this general-purpose tool, whose core logic I developed while
        working on one of their projects.  They care about the Python community!
        
        I welcome contributions and ideas as this package matures.  You can find
        the bug tracker at the `repository page on github
        <https://github.com/brandon-rhodes/logging_tree>`_.  Developers can run
        this package's tests with::
        
            $ python -m unittest discover logging_tree
        
        On older versions of Python you will instead have to install
        ``unittest2`` and use its ``unit2`` command line tool to run the tests.
        
        Changelog
        ---------
        
        **Version 1.4** - 2014 January 8
            Thanks to a contribution from Dave Brondsema, disabled loggers are
            now actually marked as "Disabled" to make it less of a surprise that
            they fail to log anything.
        
        **Version 1.3** - 2013 October 29
            Be explicit and display the logger level ``NOTSET`` along with the
            effective level inherited from the logger's ancestors; and display
            the list of ``.filters`` of a custom logging handler even though it
            might contain custom code that ignores them.
        
        **Version 1.2** - 2013 January 19
            Compatible with Python 3.3 thanks to @ralphbean.
        
        **Version 1.1** - 2012 February 17
            Now compatible with 2.3 <= Python <= 3.2.
        
        **Version 1.0** - 2012 February 13
            Can display the handler inside a MemoryHandler; entire public
            interface documented; 100% test coverage.
        
        **Version 0.6** - 2012 February 10
            Added a display format for every ``logging.handlers`` class.
        
        **Version 0.5** - 2012 February 8
            Initial release.
        
        
Platform: UNKNOWN
Classifier: Development Status :: 6 - Mature
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: BSD License
Classifier: Programming Language :: Python :: 2.3
Classifier: Programming Language :: Python :: 2.4
Classifier: Programming Language :: Python :: 2.5
Classifier: Programming Language :: Python :: 2.6
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3.2
Classifier: Programming Language :: Python :: 3.3
Classifier: Topic :: System :: Logging