Python UTF8 Treeview Project Feedback Request

I want to move beyond classroom assignments and Exercism.org toy exercises
and start work on my own project.  A major motivation is to have something
to show if I make it to an interview for a software curation and writing
job.

This kind of view of a file tree is everywhere in Python documentation.  It
would seem there is a utility, but I haven't been able to find it.

/home/user/Projects/flask-tutorial
├── flaskr/
│   ├── __init__.py
│   ├── db.py
│   ├── schema.sql
│   ├── auth.py
│   ├── blog.py
│   ├── templates/
│   │   ├── base.html
│   │   ├── auth/
│   │   │   ├── login.html
│   │   │   └── register.html
│   │   └── blog/
│   │       ├── create.html
│   │       ├── index.html
│   │       └── update.html
│   └── static/
│       └── style.css
├── tests/
│   ├── conftest.py
│   ├── data.sql
│   ├── test_factory.py
│   ├── test_db.py
│   ├── test_auth.py
│   └── test_blog.py
├── venv/
├── setup.py
└── MANIFEST.in

(https://flask.palletsprojects.com/en/2.2.x/tutorial/layout/  retrieved
2022-12-16)

What I have discovered is that writing your own program to make this kind
of ASCII representation of a file tree is a classic classroom assignment.
You write a simple general tree, you do recursion, you have to get the
output just right. It's not a bad little class assignment for a data
structures and algorithms second semester.

So I'm thinking I can put the ASCII tree classroom assignment on steroids
and gold plate it.

It would be nice to do a general implementation in C++, Rust, or Java, but
I'm spending a lot of time in Python at work. Since Python is pretty
friendly, I can probably produce a Python version with less effort than in
other languages. It might turn out to be a useful utility run from the
Python command or as a library, and it would then serve as a prototype for
an attempt in a more rigorous and generally applicable language.

*LAYERS*

The project will have Python CLI and library interfaces.  For example, it
might take a parameters such as start=top-left or start=top-center

Working from the output layer down, we have the layer which formats and
emits the file system as a pretty-printed UTF8 file.  By way of gold
plating, the program could have front ends which pretty-print in HTML,
LibreOffice Writer, and PDF.  Although it looks like ASCII representations
of file trees can be generated on the fly with a lexically ordered
depth-first traversal of the tree, there could be a tree structure and a
tree builder.  Then a tree formatter gets the populated tree collection or
data structure.  It walks the intermediate tree using a canned algorithm
provided as a parameter, the links/edges in the tree represent the tree's
structure, and the tree's nodes have default string representations which
will be printed as the nodes of the ASCII graphic.


*THE MISSING PYTHON LIBRARY*


The back of the library should be a utility which provides a general tree
data structure as a container or collection and functions providing
depth-first and breadth-first algorithms to traverse the tree.  I thought
there would certainly be a mature, robust, definitive library wrapping
optimized, long-used C implementations of the top 25 data structures and
their associated algorithms integrated into the Python ecosystem.  What I
managed to find was one recent library, implemented in Python with few
tests and little documentation (alltrees 1.2.4
https://pypi.org/search/?q=alltrees&o=  accessed 2022-12-16).  I didn't
find anything with specialized implementations of things like singly linked
lists or stacks which can be emulated by under-using Python's built-in
dictionaries, lists, sets, and tuples.

If there really isn't much in PyPI providing pure implementations of
classic data structures, then one could fill that space first by creating a
library of (inefficient) pure Python implementations of the desired data
structure containers, and then complementing the Python implementation with
a library providing wrappers around well-proven open-source implementations
of data structures written in C, and tooling the integration well enough
that using the resulting Python packages members provide idiomatic Python
syntax.  The data structure collections, while more specialized than
dictionaries, lists, sets, and tuples, would probably be reasonably useful
for hard-core Pythonistas. It's actually a much better project than the
walk-and-pretty-print-a-tree project I started out with.  Unfortunately,
The only C I even had was learned kind of in passing when I took one
semester of C++ in 1999, and except for sometimes reading a code snippet, I
haven't used it since.


I'm soliciting thoughts, feedback, and comments.