Tree views of object structures recursively grouped by type.
Project description
Generate a type tree view of a Python object’s contents and attributes. The subtrees with the same type pattern are grouped together as a repeating structure, which forms a much more compact tree. This is very useful, for example, for quickly identifying the overall structure of a JSON object, which often contains many repeating type patterns.
Includes a GUI with mouse and keyboard navigation through the nodes.
Has Ctrl+C/double-click support for copying paths to the inner nodes.
No external dependency.
Installation
Install only typetree (no external dependency):
pip install typetree
Include pyperclip for better clipboard support (optional):
pip install typetree[clipboard]
Examples
Nested iterables:
import typetree
d = [{'a', 'b', 1, 2, (3, 4), (5, 6), 'c', .1}, {'a': 0, 'b': ...}]
typetree.print_tree(d)
<list>[2] ├── [0]: <set>[8] │ ├── (×1) <float> │ ├── (×2) <int> │ ├── (×2) <tuple>[2] │ │ └── [:2]: <int> │ └── (×3) <str> └── [1]: <dict>[2] ├── ['a']: <int> └── ['b']: <ellipsis>
Attributes
Only the mutable attributes returned by vars()
are shown by default.
If you wish to view the other attributes too, use include_dir=True
.
This will search the dir()
attributes, except the special
(__special__
) and the protected (_protected
) ones.
This can be changed by setting include_special=True
and
include_protected=True
. Beware that this will drastically increase
the tree size, so you should also limit the search depth max_depth
and/or number of branches max_branches
, or the application will
likely freeze.
typetree.print_tree((0,), include_dir=True, max_depth=2, max_lines=15)
<tuple>[1] ├── .count: <builtin_function_or_method> ├── .index: <builtin_function_or_method> └── [0]: <int> ├── .as_integer_ratio: <builtin_function_or_method> ├── .bit_count: <builtin_function_or_method> ├── .bit_length: <builtin_function_or_method> ├── .conjugate: <builtin_function_or_method> ├── .denominator: <int> │ └── ... ├── .from_bytes: <builtin_function_or_method> ├── .imag: <...> <int> │ └── ... ├── .numerator: <...> <int> ...
Note that the last two items have a special tag <...>
which means it
has identified an infinite recursion.
XML etree integration
Use type_name_lookup
to specify how to retrieve the string to be
displayed as the type name. End nodes of XML etrees are empty tuples, so
the parameter value_lookup
should also be given to specify how to
retrieve their values.
import urllib.request
import xml.etree.ElementTree
url = 'https://www.w3schools.com/xml/simple.xml'
with urllib.request.urlopen(url) as response:
r = response.read()
text = str(r, encoding='utf-8')
tree = xml.etree.ElementTree.fromstring(text)
typetree.print_tree(
tree,
type_name_lookup=lambda x: x.tag,
value_lookup=lambda x: x.text,
)
<breakfast_menu>[5] └── [:5]: <food>[4] ├── [0]: <name> ├── [1]: <price> ├── [2]: <description> └── [3]: <calories>
DOM integration
DOM objects are not directly iterable. Child nodes must be accessed through
attribute lookup, which can be specified by the parameter
items_lookup
:
import xml.dom.minidom
dom = xml.dom.minidom.parseString(text)
typetree.print_tree(
dom,
items_lookup=lambda x: x.childNodes,
type_name_lookup=lambda x: x.nodeName,
value_lookup=lambda x: x.text,
max_lines=10,
)
<#document>[1] └── [0]: <breakfast_menu>[11] ├── [0]: <#text> ├── [1]: <food>[9] │ ├── [0]: <#text> │ ├── [1]: <name>[1] │ │ └── [0]: <#text> │ ├── [2]: <#text> │ ├── [3]: <price>[1] ...
Alternatively, you can use configuration templates:
typetree.print_tree(dom, template=typetree.DOM, max_lines=10)
Which gives the same output.
Interactive GUI
import json
url2 = 'https://archive.org/metadata/TheAdventuresOfTomSawyer_201303'
with urllib.request.urlopen(url2) as response2:
r2 = response2.read()
text2 = str(r2, encoding='utf-8')
json2 = json.loads(text2)
typetree.view_tree(json2)
Double click or press Ctrl+C to copy the path to the selected node.
Use right-click on the plus/minus icons to expand/collapse each of the inner nodes without affecting the node you clicked on.
You can use the arrow keys to navigate and the space bar instead of the right-click.
Parameters
Configuration parameters
items_lookup: Callable[[Any], Any] = lambda var: var
type_name_lookup: Callable[[Any], str] = lambda var: type(var).__name__
value_lookup: Callable[[Any], Any] = lambda var: var
sort_keys: bool = True
show_lengths: bool = True
include_attributes: bool = True
include_dir: bool = False
include_protected: bool = False
include_special: bool = False
max_lines: float = 1000
max_search: float = 100_000
max_depth: float = 20
max_branches: float = float('inf')
items_lookup
: Function used to access the node’s content.type_name_lookup
: Function used to get the type name.value_lookup
: Function used to get the value when the node’s content is empty (tree leaves).sort_keys
: Flag for sorting keys alphabetically.show_lengths
: Flag for displaying lengths of iterables. This affects how subtrees are grouped together, since sequences with different sizes but same content types are considered equivalent.include_attributes
: Flag for including the mutable attributes returned byvars
.include_dir
: Flag for including the attributes returned bydir
, except the protected (_protected
) and the special (__special__
) ones.include_protected
: Flag for including the protected (_protected
) attributes.include_special
: Flag for including the special (__special__
) attributes.max_lines
: Maximum number of lines to be printed. For the GUI, it is the maximum number of rows to be displayed, not including the extra ellipsis at the end. Can be disabled by setting it to infinity (float('inf')
ormath.inf
).max_search
: Maximum number of nodes searched.max_depth
: Maximum search depth.max_branches
: Maximum number of branches displayed on each node. This only applies after grouping.
Additionally, there are also helper classes of configuration templates for common object types. Currently, the templates are:
Template
(default)DOM
HTML
XML
These templates can be passed to the parameter template
.
GUI
For the GUI, both the Tree(...).view
method and the
view_tree
function accept two additional arguments to configure
whether the new window is created asynchronously and by which method
(threading or multiprocessing):
spawn_thread: bool = True
spawn_process: bool = False
Project details
Release history Release notifications | RSS feed
Download files
Download the file for your platform. If you're not sure which to choose, learn more about installing packages.