# PrettyPrintTree
This package allows you to print trees (the datastructure) in a readable fashion.
<br>
It supports trees with any kind of data, as long it can be turned into a string.
<br>
And even supports multi-lined nodes (strings with \n).
# Table Of Contents
- [Requirements](#requirements)
- [Install](#install)
- [Import](#import)
- [Documentation](#documentation)
- [Example](#example)
- [Tree](#tree)
- [Linked List](#linked-list)
- [Other Settings](#other-settings)
- [Horizontal](#horizontal)
- [Trim](#trim)
- [Return Instead of Print](#return-instead-of-print)
- [Color](#color)
- [Border](#border)
- [Escape NewLines](#escape-newlines)
- [Max Depth](#max-depth)
- [Start Message](#start-message)
- [Dictionaries \\ JSON](#dictionaries--json)
- [Labels](#labels)
- [Advanced Examples](#advanced-examples)
- [Binary Tree](#binary-tree)
- [Filtering](#filtering)
- [C#](#c)
- [Java](#java)
# Requirements
Python 3.7 and up
# Install
You can easily install **PrettyPrintTree** via **pip**:
```bash
pip install PrettyPrintTree
```
# Import
Once installed, you can import it in your Python script:
```python
from PrettyPrint import PrettyPrintTree
```
# Documentation
To ensure flexibility, PrettyPrintTree requires you to define how to print your specific tree structure. This is achieved by providing two callable functions (lambdas):
1) **get_children:** This function, given a node of your tree type, returns an iterable of all its children, from left to right.
For instance, if your tree implementation looks like this:
```python
class Tree:
def __init__(self, val):
self.val = val
self.children = []
```
Your **get_children** function would be as simple as:
```python
lambda node: node.children
```
2) **get_value:** Given a node of your tree type, this function should return that node's value.
<br>
For a tree implementation like this:
```python
class Tree:
def __init__(self, val):
self.val = val
```
The **get_value** function would be:
```python
lambda node: node.val
```
*Note: if the value of the tree doesn't implement `__str__`, the **get_value** function should convert it into a string.*
To print the tree, you first need to create a PrettyPrintTree object by providing your lambdas and any additional settings. You can then call this object whenever needed without repeatedly specifying the lambdas.
### Linked Lists
Printing a linked-list is similar, instead of **get_children** you will need:
<br>
**get_next:** This function, given a node of your linked-list type, returns the next node.
And optionally:
<br>
**get_prev:** Given a node of your linked-list type, this function should return the previous node.
# Example
### Tree
```python
from PrettyPrint import PrettyPrintTree
class Tree:
def __init__(self, value):
self.val = value
self.children = []
def add_child(self, child):
self.children.append(child)
return child
pt = PrettyPrintTree(lambda x: x.children, lambda x: x.val)
tree = Tree(1)
child1 = tree.add_child(Tree(2))
child2 = tree.add_child(Tree(3))
child1.add_child(Tree(4))
child1.add_child(Tree(5))
child1.add_child(Tree(6))
child2.add_child(Tree(7))
pt(tree)
```
### Linked List
```python
from PrettyPrint import PrettyPrintLinkedList
class Node:
def __init__(self, val):
self.val = val
self.next_node = None
self.prev_node = None
n1, n2, n3, n4 = Node("Node1"), Node("Node2"), Node("Node\nJs"), Node("Node4")
n1.next_node = n2
n2.next_node = n3
n3.next_node = n4
n3.prev_node = n2
pt = PrettyPrintLinkedList(
lambda x: x.val,
lambda x: x.next_node,
lambda x: x.prev_node,
orientation=PrettyPrintLinkedList.Horizontal,
)
pt(n1)
```
# Other Settings
***These settings can either be set when initializing the `PrettyPrintTree` object or when calling the function (which will override the initial setting)***
## Horizontal
You can print trees from left to right instead of the default top-to-bottom layout:
```python
pt = PrettyPrintTree(
lambda x: x.children,
lambda x: x.val,
orientation=PrettyPrintTree.Horizontal
)
```
## Trim
If you want to print only a limited number of characters from each node to keep the tree concise and readable, you can use the **trim** setting:
```python
pt = PrettyPrintTree(lambda x: x.children, lambda x: x.val, trim=5)
```
To use a different trim symbol instead of `...`, you can do this:
```python
pt = PrettyPrintTree(
lambda x: x.children, lambda x: x.val, trim=5,
trim_symbol=' ' + colorama.Back.GREEN
)
```
## Return Instead of Print
If you prefer to get the tree as a string instead of printing it directly, you can enable the **return_instead_of_print** setting:
```python
to_str = PrettyPrintTree(lambda x: x.children, lambda x: x.val, return_instead_of_print=True)
tree_as_str = to_str(tree)
```
## Color
You can change the background color of each node or opt for no color at all:
```python
from colorama import Back
pt = PrettyPrintTree(lambda x: x.children, lambda x: x.val, color=Back.BLACK)
```
For no color:
```python
pt = PrettyPrintTree(lambda x: x.children, lambda x: x.val, color='')
```
## Border
You can surround each node with a border:
```python
pt = PrettyPrintTree(lambda x: x.children, lambda x: x.val, border=True)
```
## Escape NewLines
To print each node on one line, you can escape the newline characters:
```python
pt = PrettyPrintTree(lambda x: x.children, lambda x: x.val, show_newline_literal=True)
```
<br>
In order to distinguish between \n and \\n you can highlight the \n's:
```python
PrettyPrintTree(
lambda x: x.children, lambda x: x.val,
show_newline_literal=True,
newline_literal=colorama.Fore.LIGHTGREEN_EX + '\\n' + colorama.Fore.RESET
)
```
## Max Depth
Limit the depth to control how many levels of nodes are printed:
```python
pt = PrettyPrintTree(lambda x: x.children, lambda x: x.val, max_depth=10)
```
*Note: the head node has a depth of 0*
## Start Message
You can add a message to be printed before the tree. Use a lambda that receives the tree and returns a message:
```python
pt = PrettyPrintTree(
lambda x: x.children,
lambda x: x.val,
start_message=lambda node: f'printing tree of type {node.typ}:'
)
```
## Dictionaries \ JSON
**PrettyPrintTree** can also print JSON structures, although they need to be converted into a dictionary, list, or tuple first:
```python
some_json = {'foo': 1, 'bar': ('a', 'b'), 'qux': {'foo': 1, 'bar': ['a', 'b']}}
pt = PrettyPrintTree()
pt.print_json(some_json, name="DICT")
```
## Labels
You can label the branches in your tree by providing a lambda that returns a label between the node and its parent. Use `None` or `False` if no label is needed:
```python
pt = PrettyPrintTree(
lambda x: x.children,
lambda x: x.val,
lambda x: x.label
)
```
You can even apply color to the labels using **label_color**:
```python
from colorama import Back
pt = PrettyPrintTree(
lambda x: x.children,
lambda x: x.val,
lambda x: x.label,
label_color=Back.BLACK
)
```
# Advanced Examples
### Binary Tree
Here's how to print a binary tree:
```python
class Tree:
def __init__(self, val):
self.val = val
self.right = None
self.left = None
```
One approach is to define **get_children** as follows:
```python
PrettyPrintTree(
lambda x: [x for x in [x.prev_node, x.next_node] if x is not None],
lambda x: x.val
)
```
However, this approach does not preserve the direction of the children when only one child is present. For better results, use this approach:
```python
PrettyPrintTree(
lambda x: [] if x is None or x.prev_node is x.next_node is None else [x.prev_node, x.next_node],
lambda x: x.val if x else (colorama.Back.BLACK + ' ' + colorama.Back.LIGHTBLACK_EX)
)
```
## Filtering
You can easily filter specific nodes by adding a filter in the **get_children** lambda:
```python
PrettyPrintTree(lambda node: filter(lambda n: "to print" in str(n.val), node.children), ...
```
```python
PrettyPrintTree(lambda node: [n for n in node.children if n.val > 3.141], ...
```
# C#
A C# version of PrettyPrintTree is also available:
https://github.com/AharonSambol/PrettyPrintTreeCSharp
# Java
A Java version of PrettyPrintTree is also available:
https://github.com/AharonSambol/PrettyPrintTreeJava
Raw data
{
"_id": null,
"home_page": "https://github.com/AharonSambol/PrettyPrintTree",
"name": "PrettyPrintTree",
"maintainer": "",
"docs_url": null,
"requires_python": "",
"maintainer_email": "",
"keywords": "tree,pretty,print,pretty-print,display",
"author": "Aharon Sambol",
"author_email": "email@example.com",
"download_url": "https://files.pythonhosted.org/packages/67/8f/a0999cada8db0d23c4b4b32ffb79a5ce9bcbb5f45447728b2ee19936b730/PrettyPrintTree-2.0.0.tar.gz",
"platform": null,
"description": "# PrettyPrintTree\r\n\r\nThis package allows you to print trees (the datastructure) in a readable fashion.\r\n<br>\r\nIt supports trees with any kind of data, as long it can be turned into a string.\r\n<br>\r\nAnd even supports multi-lined nodes (strings with \\n).\r\n\r\n\r\n\r\n# Table Of Contents\r\n- [Requirements](#requirements)\r\n- [Install](#install)\r\n- [Import](#import)\r\n- [Documentation](#documentation)\r\n- [Example](#example)\r\n - [Tree](#tree)\r\n - [Linked List](#linked-list)\r\n- [Other Settings](#other-settings)\r\n - [Horizontal](#horizontal)\r\n - [Trim](#trim)\r\n - [Return Instead of Print](#return-instead-of-print)\r\n - [Color](#color)\r\n - [Border](#border)\r\n - [Escape NewLines](#escape-newlines)\r\n - [Max Depth](#max-depth)\r\n - [Start Message](#start-message)\r\n - [Dictionaries \\\\ JSON](#dictionaries--json)\r\n - [Labels](#labels)\r\n- [Advanced Examples](#advanced-examples)\r\n - [Binary Tree](#binary-tree)\r\n - [Filtering](#filtering)\r\n- [C#](#c)\r\n- [Java](#java)\r\n\r\n# Requirements\r\nPython 3.7 and up\r\n\r\n# Install\r\nYou can easily install **PrettyPrintTree** via **pip**:\r\n\r\n```bash\r\npip install PrettyPrintTree\r\n```\r\n\r\n\r\n# Import\r\nOnce installed, you can import it in your Python script:\r\n\r\n```python\r\nfrom PrettyPrint import PrettyPrintTree\r\n```\r\n\r\n\r\n# Documentation\r\n\r\nTo ensure flexibility, PrettyPrintTree requires you to define how to print your specific tree structure. This is achieved by providing two callable functions (lambdas):\r\n\r\n1) **get_children:** This function, given a node of your tree type, returns an iterable of all its children, from left to right.\r\nFor instance, if your tree implementation looks like this:\r\n ```python\r\n class Tree:\r\n def __init__(self, val):\r\n self.val = val\r\n self.children = []\r\n ```\r\n Your **get_children** function would be as simple as:\r\n ```python\r\n lambda node: node.children\r\n ```\r\n\r\n2) **get_value:** Given a node of your tree type, this function should return that node's value.\r\n<br>\r\nFor a tree implementation like this:\r\n ```python\r\n class Tree:\r\n def __init__(self, val):\r\n self.val = val\r\n ```\r\n The **get_value** function would be: \r\n ```python\r\n lambda node: node.val\r\n ```\r\n *Note: if the value of the tree doesn't implement `__str__`, the **get_value** function should convert it into a string.*\r\n\r\nTo print the tree, you first need to create a PrettyPrintTree object by providing your lambdas and any additional settings. You can then call this object whenever needed without repeatedly specifying the lambdas.\r\n\r\n### Linked Lists\r\nPrinting a linked-list is similar, instead of **get_children** you will need: \r\n<br>\r\n**get_next:** This function, given a node of your linked-list type, returns the next node.\r\n\r\nAnd optionally:\r\n<br>\r\n**get_prev:** Given a node of your linked-list type, this function should return the previous node.\r\n\r\n\r\n# Example\r\n### Tree\r\n```python\r\nfrom PrettyPrint import PrettyPrintTree\r\n\r\n\r\nclass Tree:\r\n def __init__(self, value):\r\n self.val = value\r\n self.children = []\r\n\r\n def add_child(self, child):\r\n self.children.append(child)\r\n return child\r\n\r\n\r\npt = PrettyPrintTree(lambda x: x.children, lambda x: x.val)\r\ntree = Tree(1)\r\nchild1 = tree.add_child(Tree(2))\r\nchild2 = tree.add_child(Tree(3))\r\nchild1.add_child(Tree(4))\r\nchild1.add_child(Tree(5))\r\nchild1.add_child(Tree(6))\r\nchild2.add_child(Tree(7))\r\npt(tree)\r\n```\r\n\r\n\r\n### Linked List\r\n```python\r\nfrom PrettyPrint import PrettyPrintLinkedList\r\n\r\nclass Node:\r\n def __init__(self, val):\r\n self.val = val\r\n self.next_node = None\r\n self.prev_node = None\r\n\r\n\r\nn1, n2, n3, n4 = Node(\"Node1\"), Node(\"Node2\"), Node(\"Node\\nJs\"), Node(\"Node4\")\r\nn1.next_node = n2\r\nn2.next_node = n3\r\nn3.next_node = n4\r\nn3.prev_node = n2\r\npt = PrettyPrintLinkedList(\r\n lambda x: x.val,\r\n lambda x: x.next_node,\r\n lambda x: x.prev_node,\r\n orientation=PrettyPrintLinkedList.Horizontal,\r\n)\r\npt(n1)\r\n```\r\n\r\n\r\n# Other Settings\r\n\r\n***These settings can either be set when initializing the `PrettyPrintTree` object or when calling the function (which will override the initial setting)***\r\n## Horizontal\r\nYou can print trees from left to right instead of the default top-to-bottom layout:\r\n```python\r\npt = PrettyPrintTree(\r\n lambda x: x.children, \r\n lambda x: x.val, \r\n orientation=PrettyPrintTree.Horizontal\r\n)\r\n```\r\n\r\n\r\n\r\n## Trim\r\nIf you want to print only a limited number of characters from each node to keep the tree concise and readable, you can use the **trim** setting:\r\n\r\n```python\r\npt = PrettyPrintTree(lambda x: x.children, lambda x: x.val, trim=5)\r\n```\r\n\r\n\r\nTo use a different trim symbol instead of `...`, you can do this:\r\n\r\n```python\r\npt = PrettyPrintTree(\r\n lambda x: x.children, lambda x: x.val, trim=5,\r\n trim_symbol=' ' + colorama.Back.GREEN\r\n)\r\n```\r\n\r\n\r\n\r\n## Return Instead of Print\r\n\r\nIf you prefer to get the tree as a string instead of printing it directly, you can enable the **return_instead_of_print** setting:\r\n\r\n```python\r\nto_str = PrettyPrintTree(lambda x: x.children, lambda x: x.val, return_instead_of_print=True)\r\ntree_as_str = to_str(tree)\r\n```\r\n\r\n\r\n## Color\r\nYou can change the background color of each node or opt for no color at all:\r\n\r\n```python\r\nfrom colorama import Back\r\n\r\npt = PrettyPrintTree(lambda x: x.children, lambda x: x.val, color=Back.BLACK)\r\n```\r\n\r\n\r\nFor no color:\r\n\r\n```python\r\npt = PrettyPrintTree(lambda x: x.children, lambda x: x.val, color='')\r\n```\r\n\r\n\r\n\r\n## Border\r\nYou can surround each node with a border:\r\n\r\n```python\r\npt = PrettyPrintTree(lambda x: x.children, lambda x: x.val, border=True)\r\n```\r\n\r\n\r\n\r\n## Escape NewLines\r\nTo print each node on one line, you can escape the newline characters:\r\n\r\n```python\r\npt = PrettyPrintTree(lambda x: x.children, lambda x: x.val, show_newline_literal=True)\r\n```\r\n\r\n<br>\r\nIn order to distinguish between \\n and \\\\n you can highlight the \\n's:\r\n\r\n```python\r\nPrettyPrintTree(\r\n lambda x: x.children, lambda x: x.val,\r\n show_newline_literal=True,\r\n newline_literal=colorama.Fore.LIGHTGREEN_EX + '\\\\n' + colorama.Fore.RESET\r\n)\r\n```\r\n\r\n\r\n\r\n## Max Depth\r\nLimit the depth to control how many levels of nodes are printed:\r\n\r\n```python\r\npt = PrettyPrintTree(lambda x: x.children, lambda x: x.val, max_depth=10)\r\n```\r\n*Note: the head node has a depth of 0*\r\n\r\n\r\n## Start Message\r\nYou can add a message to be printed before the tree. Use a lambda that receives the tree and returns a message:\r\n\r\n```python\r\npt = PrettyPrintTree(\r\n lambda x: x.children, \r\n lambda x: x.val, \r\n start_message=lambda node: f'printing tree of type {node.typ}:'\r\n)\r\n```\r\n\r\n\r\n\r\n## Dictionaries \\ JSON\r\n\r\n**PrettyPrintTree** can also print JSON structures, although they need to be converted into a dictionary, list, or tuple first:\r\n \r\n```python\r\nsome_json = {'foo': 1, 'bar': ('a', 'b'), 'qux': {'foo': 1, 'bar': ['a', 'b']}}\r\npt = PrettyPrintTree()\r\npt.print_json(some_json, name=\"DICT\")\r\n```\r\n\r\n\r\n\r\n## Labels\r\n\r\nYou can label the branches in your tree by providing a lambda that returns a label between the node and its parent. Use `None` or `False` if no label is needed:\r\n\r\n```python\r\npt = PrettyPrintTree(\r\n lambda x: x.children, \r\n lambda x: x.val, \r\n lambda x: x.label\r\n)\r\n```\r\n\r\n\r\nYou can even apply color to the labels using **label_color**:\r\n\r\n```python\r\nfrom colorama import Back\r\n\r\npt = PrettyPrintTree(\r\n lambda x: x.children, \r\n lambda x: x.val, \r\n lambda x: x.label,\r\n label_color=Back.BLACK\r\n)\r\n```\r\n\r\n\r\n# Advanced Examples\r\n\r\n### Binary Tree\r\nHere's how to print a binary tree:\r\n\r\n```python\r\nclass Tree:\r\n def __init__(self, val):\r\n self.val = val\r\n self.right = None\r\n self.left = None\r\n```\r\nOne approach is to define **get_children** as follows:\r\n\r\n```python\r\nPrettyPrintTree(\r\n lambda x: [x for x in [x.prev_node, x.next_node] if x is not None],\r\n lambda x: x.val\r\n)\r\n```\r\n\r\n\r\nHowever, this approach does not preserve the direction of the children when only one child is present. For better results, use this approach:\r\n\r\n```python\r\nPrettyPrintTree(\r\n lambda x: [] if x is None or x.prev_node is x.next_node is None else [x.prev_node, x.next_node],\r\n lambda x: x.val if x else (colorama.Back.BLACK + ' ' + colorama.Back.LIGHTBLACK_EX)\r\n)\r\n```\r\n\r\n\r\n\r\n## Filtering\r\n\r\nYou can easily filter specific nodes by adding a filter in the **get_children** lambda:\r\n\r\n```python\r\nPrettyPrintTree(lambda node: filter(lambda n: \"to print\" in str(n.val), node.children), ...\r\n```\r\n```python\r\nPrettyPrintTree(lambda node: [n for n in node.children if n.val > 3.141], ...\r\n```\r\n\r\n# C#\r\n\r\nA C# version of PrettyPrintTree is also available: \r\nhttps://github.com/AharonSambol/PrettyPrintTreeCSharp\r\n\r\n\r\n# Java\r\n\r\nA Java version of PrettyPrintTree is also available: \r\nhttps://github.com/AharonSambol/PrettyPrintTreeJava\r\n",
"bugtrack_url": null,
"license": "MIT License",
"summary": "A tool to print trees to the console",
"version": "2.0.0",
"project_urls": {
"Homepage": "https://github.com/AharonSambol/PrettyPrintTree"
},
"split_keywords": [
"tree",
"pretty",
"print",
"pretty-print",
"display"
],
"urls": [
{
"comment_text": "",
"digests": {
"blake2b_256": "a1cc139cd3f7b484f83775d35cd688fb44b058084892e184929f67887665f8b8",
"md5": "023615b4c7d96b1b8a112b3887edcb7b",
"sha256": "8a8a60b8d35e81913c6074b6491f300da42ef4ea1265bf9817395308e6e3ed41"
},
"downloads": -1,
"filename": "PrettyPrintTree-2.0.0-py3-none-any.whl",
"has_sig": false,
"md5_digest": "023615b4c7d96b1b8a112b3887edcb7b",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": null,
"size": 22834,
"upload_time": "2023-10-19T15:59:59",
"upload_time_iso_8601": "2023-10-19T15:59:59.831049Z",
"url": "https://files.pythonhosted.org/packages/a1/cc/139cd3f7b484f83775d35cd688fb44b058084892e184929f67887665f8b8/PrettyPrintTree-2.0.0-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "678fa0999cada8db0d23c4b4b32ffb79a5ce9bcbb5f45447728b2ee19936b730",
"md5": "e3b6612cc246da4f2b8b2bbfdec28dcf",
"sha256": "ab9487a24f9f194f12753c32a63bdb2232dc36be7255f5531e36f29d12747a84"
},
"downloads": -1,
"filename": "PrettyPrintTree-2.0.0.tar.gz",
"has_sig": false,
"md5_digest": "e3b6612cc246da4f2b8b2bbfdec28dcf",
"packagetype": "sdist",
"python_version": "source",
"requires_python": null,
"size": 15807,
"upload_time": "2023-10-19T16:00:02",
"upload_time_iso_8601": "2023-10-19T16:00:02.817703Z",
"url": "https://files.pythonhosted.org/packages/67/8f/a0999cada8db0d23c4b4b32ffb79a5ce9bcbb5f45447728b2ee19936b730/PrettyPrintTree-2.0.0.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2023-10-19 16:00:02",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "AharonSambol",
"github_project": "PrettyPrintTree",
"travis_ci": false,
"coveralls": false,
"github_actions": false,
"lcname": "prettyprinttree"
}
JSON
