pax_global_header00006660000000000000000000000064150074031240014506gustar00rootroot0000000000000052 comment=c414f744e0f01c2e3d351fd9f4376a72b6c37d68 Flametree-0.2.1/000077500000000000000000000000001500740312400134125ustar00rootroot00000000000000Flametree-0.2.1/.codeclimate.yml000066400000000000000000000000671500740312400164670ustar00rootroot00000000000000exclude_patterns: - "ez_setup.py" - "tests/" - "docs/" Flametree-0.2.1/.github/000077500000000000000000000000001500740312400147525ustar00rootroot00000000000000Flametree-0.2.1/.github/workflows/000077500000000000000000000000001500740312400170075ustar00rootroot00000000000000Flametree-0.2.1/.github/workflows/build.yml000066400000000000000000000015111500740312400206270ustar00rootroot00000000000000name: build on: [push, workflow_dispatch] jobs: build: runs-on: ubuntu-24.04 steps: - uses: actions/checkout@v4 - name: Set up Python uses: actions/setup-python@v5 with: python-version: "3.12" - name: Install dependencies run: | python -m pip install --upgrade pip pip install pytest pytest-cov coveralls pip install matplotlib pandas weasyprint - name: Install run: | pip install -e . - name: Test with pytest run: | python -m pytest --cov flametree --cov-report term-missing - name: Coveralls uses: coverallsapp/github-action@v2 continue-on-error: true with: github-token: ${{ secrets.GITHUB_TOKEN }} env: COVERALLS_SERVICE_NAME: github Flametree-0.2.1/.github/workflows/document.yml000066400000000000000000000007251500740312400213540ustar00rootroot00000000000000name: documentation on: workflow_dispatch: release: types: [created] jobs: document: runs-on: ubuntu-24.04 environment: name: github-pages url: ${{ steps.deployment.outputs.page_url }} permissions: pages: write id-token: write steps: - id: deployment uses: sphinx-notes/pages@v3 with: python_version: 3.12 documentation_path: ./docs requirements_path: ./docs/requirements.txt Flametree-0.2.1/.github/workflows/publish.yml000066400000000000000000000017361500740312400212070ustar00rootroot00000000000000name: Publish to PyPI on: release: types: [created] jobs: test: runs-on: ubuntu-24.04 steps: - uses: actions/checkout@v4 - name: Set up Python uses: actions/setup-python@v5 with: python-version: "3.12" - name: Install run: | pip install pytest pip install matplotlib pandas weasyprint pip install -e . - name: Test run: | python -m pytest deploy: runs-on: ubuntu-24.04 needs: [test] permissions: id-token: write steps: - uses: actions/checkout@v4 - name: Set up Python uses: actions/setup-python@v5 with: python-version: '3.12' cache: pip cache-dependency-path: '**/pyproject.toml' - name: Install dependencies run: | pip install setuptools wheel build - name: Build run: | python -m build - name: Publish uses: pypa/gh-action-pypi-publish@release/v1 Flametree-0.2.1/.gitignore000066400000000000000000000034071500740312400154060ustar00rootroot00000000000000# Byte-compiled / optimized / DLL files __pycache__/ *.py[cod] *$py.class # C extensions *.so # Distribution / packaging .Python build/ develop-eggs/ dist/ downloads/ eggs/ .eggs/ lib/ lib64/ parts/ sdist/ var/ wheels/ pip-wheel-metadata/ share/python-wheels/ *.egg-info/ .installed.cfg *.egg MANIFEST # PyInstaller # Usually these files are written by a python script from a template # before PyInstaller builds the exe, so as to inject date/other infos into it. *.manifest *.spec # Installer logs pip-log.txt pip-delete-this-directory.txt # Unit test / coverage reports htmlcov/ .tox/ .nox/ .coverage .coverage.* .cache nosetests.xml coverage.xml *.cover *.py,cover .hypothesis/ .pytest_cache/ # Translations *.mo *.pot # Django stuff: *.log local_settings.py db.sqlite3 db.sqlite3-journal # Flask stuff: instance/ .webassets-cache # Scrapy stuff: .scrapy # Sphinx documentation docs/_build/ # PyBuilder target/ # Jupyter Notebook .ipynb_checkpoints # IPython profile_default/ ipython_config.py # pyenv .python-version # pipenv # According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. # However, in case of collaboration, if having platform-specific dependencies or dependencies # having no cross-platform support, pipenv may install dependencies that don't work, or not # install all needed dependencies. #Pipfile.lock # PEP 582; used by e.g. github.com/David-OConnor/pyflow __pypackages__/ # Celery stuff celerybeat-schedule celerybeat.pid # SageMath parsed files *.sage.py # Environments .env .venv env/ venv/ ENV/ env.bak/ venv.bak/ # Spyder project settings .spyderproject .spyproject # Rope project settings .ropeproject # mkdocs documentation /site # mypy .mypy_cache/ .dmypy.json dmypy.json # Pyre type checker .pyre/ Flametree-0.2.1/.vscode/000077500000000000000000000000001500740312400147535ustar00rootroot00000000000000Flametree-0.2.1/.vscode/settings.json000066400000000000000000000000551500740312400175060ustar00rootroot00000000000000{ "python.formatting.provider": "black" }Flametree-0.2.1/LICENSE000066400000000000000000000021221500740312400144140ustar00rootroot00000000000000MIT License Copyright (c) 2017 Edinburgh Genome Foundry, University of Edinburgh Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. Flametree-0.2.1/README.rst000066400000000000000000000254611500740312400151110ustar00rootroot00000000000000.. raw:: html

Flametree Logo

Python file operations made easy

.. image:: https://github.com/Edinburgh-Genome-Foundry/Flametree/actions/workflows/build.yml/badge.svg :target: https://github.com/Edinburgh-Genome-Foundry/Flametree/actions/workflows/build.yml :alt: GitHub CI build status .. image:: https://coveralls.io/repos/github/Edinburgh-Genome-Foundry/Flametree/badge.svg :target: https://coveralls.io/github/Edinburgh-Genome-Foundry/Flametree Flametree is a Python library which provides a simple syntax for handling files and folders (no ``os.path.join``, ``os.listdir`` etc.), and works the same way for different file systems. Write a Flametree program to read/write files in disk folders, and your code will also be able to read/write in zip archives and virtual (in-memory) archives - which is particularly useful on web servers. As an illustration, here is how to use Flametree to read a file ``texts/poems/the_raven.txt``, replace all occurences of the word "raven" by "seagull" in the text, and write the result to a new file ``the_seagull.txt`` in the same folder: .. code:: python from flametree import file_tree with file_tree("texts") as root: poem_text = root.poems.the_raven_txt.read() new_text = poem_text.replace("raven", "seagull") root.poems._file("the_seagull.txt").write(new_text) Even in this very simple use case, the syntax is clearer than the ``os`` way, which would write as follows: .. code:: python import os with open(os.path.join("poems", "the_raven.txt"), "r") as f: poem_text = f.read() new_text = poem_text.replace("raven", "seagull") with open(os.path.join("poems", "the_seagull.txt"), "w") as f: content = f.write(new_text) Moreover, the same Flametree code also works for files inside a zip archive: .. code:: python with file_tree("my_archive.zip") as root: poem_text = root.poems.the_raven_txt.read() new_text = poem_text.replace("raven", "seagull") root.poems._file("the_seagull.txt").write(new_text) Now in hard mode: suppose that your server receives binary zip data of an archive containing ``poems/the_raven.txt``, and must return back a new zip containing a file ``poems/the_seagull.txt``. Here again, the syntax of the core operations is the same: .. code:: python destination_zip = file_tree("@memory") # Create a new virtual zip with file_tree(the_raven_zip_data) as root: poem_text = root.poems.the_raven_txt.read() new_text = poem_text.replace("raven", "seagull") destination_zip._dir("poems")._file("the_seagull.txt").write(new_text) destination_zip_data = destination_zip._close() # Now send the data to the client See section *Usage* below for more examples and features. Installation ------------ Flametree should work on Windows/Max/Linux, with Python 2 and 3, and has no external dependency. It can be installed by unzipping the source code in one directory and using this command: :: python setup.py install You can also install it directly from the Python Package Index with this command: :: pip install flametree Contribute ---------- Flametree is an open-source software originally written by Zulko_ and released on Github_ under the MIT licence (Copyright 2017 Edinburgh Genome Foundry, University of Edinburgh). Everyone is welcome to contribute! In particular if you have ideas of new kinds of file systems to add to Flametree. Usage ----- Opening a file tree ~~~~~~~~~~~~~~~~~~~ Here is how you open different kinds of file systems: .. code:: python from flametree import file_tree # Open a directory from the disk's file system: root = file_tree("my_folder/") # Open a zip archive on the disk: root = file_tree("my_archive.zip") # Connect to a file-like object (file handle, StringIO...) of a zip: root = file_tree(file_like_object) # Create a virtual 'in-memory' zip file: root = file_tree("@memory") # Open some data string representing a zip to read root = file_tree(some_big_zip_data_string) In the two first examples, if ``my_folder`` or ``my_archive.zip`` do not exist, they will be automatically created. If they do exist, it is possible to completely overwrite them with the option ``replace=True``. Exploring a file tree: ~~~~~~~~~~~~~~~~~~~~~~ Once you have created the ``root`` element with one of the methods above, you can display the whole file tree with ``root._tree_view()`` : .. code:: >>> print (root._tree_view()) texts/ poems/ dover_beach.txt the_raven.txt the_tyger.txt todo_list.txt figures/ figure1.png figure2.png Readme.md The attributes of a directory like ``root`` are its files and subdirectories. For instance to print the content of ``dover_beach.txt`` you would write: .. code:: python print( root.texts.poems.dover_beach_txt.read() ) or even simpler: .. code:: python root.texts.poems.dover_beach_txt.print_content() Notice that the ``.`` before ``txt`` was replaced by ``_`` so as to form a valid attribute name. This syntactic sugar is particularly useful to explore a file tree in IPython Notebooks or other editors offering auto-completion: .. image:: https://raw.githubusercontent.com/Edinburgh-Genome-Foundry/Flametree/master/images/autocomplete.png :alt: [illustration] :align: center Alternatively, you can access files and directories using dictionary calls: .. code:: python root["texts"]["poems"]["dover_beach.txt"] To iterate through the subdirectories of a directory, use the ``_dirs`` attribute: .. code:: python for subdirectory in root._dirs: print (subdirectory._name) # Will print 'texts' and 'figures' To iterate through the files of a directory, use the ``_files`` attribute: .. code:: python for f in root.figures._files: print (f._name) # Will print 'figure1.png' and 'figure2.png' Finally, use ``_all_files`` to iterate through all files nested in a directory. The snippet below prints the content of all ``.txt`` files in the file tree: .. code:: python for f in root._all_files: if f._name.endswith(".txt"): f.print_content() Creating files and folders ~~~~~~~~~~~~~~~~~~~~~~~~~~ To create a new subdirectory use ``_dir``: .. code:: python root._dir("data") # create a 'data' folder at the root root.data._dir("reports") # create a 'reports' folder under `root/data` To create a new file use ``_file``: .. code:: python root._file("joke.txt") # create a 'joke.txt' file at the root. root.texts._file("hello.txt") # create 'hello.txt' in `root/texts`. To write content in a file, use ``.write``: .. code:: python root.joke_txt.write("A plateau is the highest form of flattery.") Writing to a file will use mode ``a`` (append) by default. To overwrite the file set the write mode to ``"w"``. Let's erase and rewrite that ``joke.txt``: .. code:: python root.joke_txt.write("'DNA' stands for National Dyslexic Association.", "w") File and directory creation commands can be chained. Let us create some new folders ``data/`` and ``data/test_1/``, and write to file ``data/test_1/values.csv``, all in a single line: .. code:: python root._dir("data")._dir("test_1")._file("values.csv").write("1,15,25") Beware that ``._dir`` and ``._file`` **overwrite their target by default**, which means that if you write: .. code:: python root._dir("data")._file("values_1.csv").write("1,4,7") root._dir("data")._file("values_2.csv").write("2,9,7") The directory ``data`` will only contain ``values_2.csv``, because the second line's ``_dir("data")`` erases the ``data`` directory and starts a new one. To avoid this, either use ``root.data`` in the second line: .. code:: python root._dir("data")._file("values_1.csv").write("1,4,7") root.data._file("values_2.csv").write("2,9,7") Or use ``replace=False`` in ``_dir``: .. code:: python root._dir("data")._file("values_1.csv").write("1,4,7") root._dir("data", replace=False)._file("values_2.csv").write("2,9,7") Other operations ~~~~~~~~~~~~~~~~ You can move, copy, and delete a file with ``.move(folder)``, ``.copy(folder)``, ``.delete()``, and a directory with ``._move(folder)``, ``._copy(folder)``, ``._delete()``. .. code:: python root.data.values1_csv.delete() # delete file 'values1.csv' root.data._delete() # delete directory 'data' # Move folder `plots` from `root/figures` to `other_root/figures` root.figures.plots._move(other_root.figures) # Move file `fig.png` from `root/figures` to `other_root/figures` root.figures.fig_png.move(other_root.figures) Special rules for ZIP archives ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ It is not currently possible to modify/delete a file that is already zipped into an archive (because zips are not really made for that, it would be doable but would certainly be a hack). When creating files and folders in a zip with Flametree, the changes in the actual zip will only be performed by closing the ``root`` with ``root._close()`` (after which the ``root`` can't be used any more). If it is an in-memory zip, ``root._close()`` returns the value of the zip content as a string (Python 2) or bytes (Python 3). Here are a few examples: .. code:: python root = file_tree("archive.zip") root._file("hello.txt").write("Hi there !") root._close() # Equivalent to the previous, using `with`: with file_tree("archive.zip") as root: root._file("hello.txt").write("Hi there !") # Getting binary data of an in-memory zip file: root = file_tree("@memory") root._file("hello.txt").write("Hi there !") binary_data = root._close() Using file writers from other libraries ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Some libraries have file-generating methods which expect a file name or a file object to write too. You can also feed Flametree files to these functions. for instance here is how to use Weasyprint to create a PDF ``pdfs/report.pdf`` .. code:: python import weasyprint from flametree import file_tree root = file_tree(".") # or 'archive.zip' to write in an archive. html = weasyprint.HTML(string="Hello world!", base_url='.') html.write_pdf(root._dir("pdfs")._file("test.pdf")) And here is how you would save a Matplotlib figure in a zip archive: .. code:: python import matplotlib.pyplot as plt from flametree import file_tree fig, ax = plt.subplots(1) ax.plot([1, 2, 3], [3, 1, 2]) with file_tree("archive.zip") as root: fig.savefig(root._dir("plots")._file("figure.png"), format="png") That's all folks ! .. _Zulko: https://github.com/Zulko/ .. _Github: https://github.com/Edinburgh-Genome-Foundry/flametree Flametree-0.2.1/docs/000077500000000000000000000000001500740312400143425ustar00rootroot00000000000000Flametree-0.2.1/docs/Makefile000066400000000000000000000011721500740312400160030ustar00rootroot00000000000000# Minimal makefile for Sphinx documentation # # You can set these variables from the command line, and also # from the environment for the first two. SPHINXOPTS ?= SPHINXBUILD ?= sphinx-build SOURCEDIR = . BUILDDIR = _build # Put it first so that "make" without argument is like "make help". help: @$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) .PHONY: help Makefile # Catch-all target: route all unknown targets to Sphinx using the new # "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS). %: Makefile @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) Flametree-0.2.1/docs/conf.py000066400000000000000000000022271500740312400156440ustar00rootroot00000000000000# Configuration file for the Sphinx documentation builder. # # For the full list of built-in configuration values, see the documentation: # https://www.sphinx-doc.org/en/master/usage/configuration.html import os import sys sys.path.insert(0, os.path.abspath("../flametree/")) # -- Project information ----------------------------------------------------- # https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information project = "flametree" copyright = "2017 Edinburgh Genome Foundry, University of Edinburgh" author = "Zulko" # -- General configuration --------------------------------------------------- # https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration extensions = [ "sphinx.ext.autodoc", "sphinx.ext.napoleon", # "sphinx_autodoc_typehints", ] templates_path = ["_templates"] exclude_patterns = ["_build", "Thumbs.db", ".DS_Store"] napoleon_numpy_docstring = True # -- Options for HTML output ------------------------------------------------- # https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output html_theme = "sphinx_rtd_theme" html_static_path = ["_static"] Flametree-0.2.1/docs/index.rst000066400000000000000000000004701500740312400162040ustar00rootroot00000000000000.. flametree documentation master file, created by sphinx-quickstart on Fri Mar 28 14:35:51 2025. Flametree ========= `General documentation `_ :doc:`API reference ` ---- .. toctree:: :hidden: :maxdepth: 1 :caption: Flametree ref Flametree-0.2.1/docs/make.bat000066400000000000000000000014401500740312400157460ustar00rootroot00000000000000@ECHO OFF pushd %~dp0 REM Command file for Sphinx documentation if "%SPHINXBUILD%" == "" ( set SPHINXBUILD=sphinx-build ) set SOURCEDIR=. set BUILDDIR=_build %SPHINXBUILD% >NUL 2>NUL if errorlevel 9009 ( echo. echo.The 'sphinx-build' command was not found. Make sure you have Sphinx echo.installed, then set the SPHINXBUILD environment variable to point echo.to the full path of the 'sphinx-build' executable. Alternatively you echo.may add the Sphinx directory to PATH. echo. echo.If you don't have Sphinx installed, grab it from echo.https://www.sphinx-doc.org/ exit /b 1 ) if "%1" == "" goto help %SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O% goto end :help %SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O% :end popd Flametree-0.2.1/docs/ref.rst000066400000000000000000000006761500740312400156610ustar00rootroot00000000000000API reference ============= .. autoclass:: flametree.Directory :members: :inherited-members: .. autoclass:: flametree.File :members: :inherited-members: .. autoclass:: flametree.DiskFileManager :members: :inherited-members: .. autoclass:: flametree.ZipFileManager :members: :inherited-members: .. autofunction:: flametree.file_tree .. .. automodule:: flametree .. :members: .. :undoc-members: .. :show-inheritance: Flametree-0.2.1/docs/requirements.txt000066400000000000000000000000211500740312400176170ustar00rootroot00000000000000sphinx_rtd_theme Flametree-0.2.1/flametree/000077500000000000000000000000001500740312400153565ustar00rootroot00000000000000Flametree-0.2.1/flametree/Directory.py000066400000000000000000000173731500740312400177070ustar00rootroot00000000000000import os import re non_alphanum_regexpr = re.compile(r"[^a-zA-Z\d]") def sanitize_name(name): """Return the name with all non-alphanumerics replaced by '_'.""" if name[0] in "0123456789": name = "_" + name return re.sub(non_alphanum_regexpr, "_", name) class FileTreeElement: """Base class for Directories and Files.""" def __init__(self, location=".", name=None, file_manager=None): # Initialize the properties and the files manager self._name = name self._location = location self._file_manager = file_manager if name is None: self._path = self._location else: self._path = os.path.join(self._location._path, self._name) # Automatically explore the folder and subfolders to build a tree if self._is_dir: self._dict = {} self._files = [] self._dirs = [] for filename in self._file_manager.list_files(self): self._file(filename, replace=False) for dirname in self._file_manager.list_dirs(self): self._dir(dirname, replace=False) def _close(self): """Close the file manager.""" return self._file_manager.close() def __exit__(self, *a): """Exit and close the file manager.""" self._close() def __enter__(self): """Enter the Matrix.""" return self def __repr__(self): """Pretty representation of the element, as its path""" return "<%s%s>" % (self._path, "/" if self._is_dir else "") class Directory(FileTreeElement): """Directories contains a list of ``_files`` and subdirectories ``_dirs``. You can also access all files in the directory's subtree with ``._all_files`` """ _is_dir = True def _dir(self, name, replace=True): """Create and return a new subdirectory in the current directory. If replace is True and the subdirectory exists, it is overwritten. """ if name in self._dict: subdir = self[name] if replace: self[name]._delete() else: return self[name] subdir = Directory(location=self, name=name, file_manager=self._file_manager) # From here we create self._file_manager.create(subdir, replace=replace) self._dirs.append(subdir) self._dict[name] = subdir self.__dict__[sanitize_name(subdir._name)] = subdir return subdir def _file(self, name, replace=True): """Create a new file or overwrite an existing one.""" if name in self._dict: f = self[name] if replace: f.delete() else: return f else: f = File(location=self, name=name, file_manager=self._file_manager) # From here we create self._file_manager.create(f, replace=replace) self._files.append(f) self._dict[f._name] = f self.__dict__[sanitize_name(f._name)] = f return f @property def _filenames(self): """Return the list of names of all files in the dir (not nested)""" return [f._name for f in self._files] @property def _dirnames(self): """Return the list of names of all subdirectories (not nested)""" return [subdir._name for subdir in self._dirs] @property def _all_files(self): """Return a list of all file objects in that tree.""" return self._files + sum([d._all_files for d in self._dirs], []) def _tree_view(self, indent_size=2, indent_level=0, as_lines=False): """Return a string representation of the tree for pretty printing.""" lines = [] space = indent_size * indent_level * " " for subdir in sorted(self._dirs, key=lambda subdir: subdir._name): lines.append("%s%s/" % (space, subdir._name)) lines += subdir._tree_view( indent_size=indent_size, indent_level=indent_level + 1, as_lines=True ) for f in sorted(self._files, key=lambda f: f._name): lines.append("%s%s" % (space, f._name)) return lines if as_lines else "\n".join(lines) def _move(self, directory, replace_dirs=True, replace_files=True): """Move this directory into the specified directory. If ``replace_dirs`` is True, existing directories will be erased or overwritten. If ``replace_files`` is True, existing files will be overwritten. """ # TODO: That's not the most memory-efficient way: better file-by-file self._copy(directory, replace_dirs=replace_dirs, replace_files=replace_files) self._delete() def _copy(self, directory, replace_dirs=True, replace_files=True): """Copy this directory into the specified directory. If ``replace_dirs`` is True, existing directories will be erased or overwritten. If ``replace_files`` is True, existing files will be overwritten. """ target = directory._dir(self._name, replace=replace_dirs) for f in self._files: f.copy(target, replace=replace_files) for subdir in self._dirs: # print ("subdir", subdir) # new_target = target._dir(subdir._name, replace=replace_dirs) subdir._copy(target, replace_dirs=replace_dirs, replace_files=replace_files) def _delete(self): """Delete this folder or file""" if isinstance(self._location, str): raise IOError("You can't delete the root dir with Flametree.") self._file_manager.delete(self) location = self._location location._dict.pop(self._name) location.__dict__.pop(self._name, None) location._dirs = [ subdir for subdir in location._dirs if subdir._name != self._name ] def __getitem__(self, it): return self._dict[it] class File(FileTreeElement): _is_dir = False def read(self, mode="r", **kw): """Return the file's content as a string (mode 'r') or bytes ('rb').""" return self._file_manager.read(self, mode=mode) def write(self, content, mode="a"): """Write data in the file.""" if hasattr(content, "decode") and not mode.endswith("b"): mode += "b" # You'll thank me for this. Unless it breaks something. self._file_manager.write(self, content, mode=mode) def print_content(self): """Print the file's content.""" print(self.read()) def move(self, target, replace=True): """Move this file to the specified target (a directory or a file)""" self.copy(target, replace=replace) self.delete() def copy(self, target, replace=True): if target._is_dir: if replace or (self._name not in target._dict): target._file(self._name).write(self.read(mode="rb"), mode="wb") else: target.write(self.read(mode="rb"), mode="wb") def delete(self): """Delete this file""" self._file_manager.delete(self) location = self._location location._dict.pop(self._name) location.__dict__.pop(self._name, None) location._files = [f for f in location._files if f._name != self._name] def open(self, mode="a"): return self._file_manager.open(self, mode=mode) @property def _name_no_extension(self): """File name without the extension""" return self._name.split(".")[0] @property def _path_no_extension(self): """File path without the extension""" return self._path.split(".")[0] @property def _extension(self): """File path without the extension""" return "" if "." not in self._name else self._name.split(".")[-1] def __lt__(self, other): return self._path < other._path Flametree-0.2.1/flametree/DiskFileManager.py000066400000000000000000000055421500740312400207230ustar00rootroot00000000000000import os import shutil class DiskFileManager: """Reader and Writer for disk files. Parameters ---------- target : str A directory on the disk. If it doesn't exist, it will be created. replace : bool If the `target` directory exists, should it be completely replaced or simply appended to? """ def __init__(self, target, replace=False): self.target = target if replace and os.path.exists(target): shutil.rmtree(target) if not os.path.exists(target): os.makedirs(target) @staticmethod def list_directory_content(directory, element_type="file"): """Return the list of all file or dir objects in the directory.""" filtr = os.path.isfile if (element_type == "file") else os.path.isdir path = directory._path return ( [] if not os.path.exists(path) else [name for name in os.listdir(path) if filtr(os.path.join(path, name))] ) @classmethod def list_files(cls, directory): """Return the list of all file objects in the directory.""" return cls.list_directory_content(directory, element_type="file") @classmethod def list_dirs(cls, directory): """Return the list of all directory objects in the directory.""" return cls.list_directory_content(directory, element_type="dirs") @staticmethod def read(fileobject, mode="r"): """Return the entire content of a file. The mode can be 'r' or 'rb'.""" with open(fileobject._path, mode=mode) as f: result = f.read() return result @staticmethod def write(fileobject, content, mode="a"): """Write the content (str, bytes) to the given file object.""" with open(fileobject._path, mode=mode) as f: f.write(content) @staticmethod def delete(target): """Delete the file on disk.""" if target._is_dir: shutil.rmtree(target._path) else: os.remove(target._path) def create(self, target, replace=False): """Create a new, empty file or directory on disk.""" path = target._path if replace and os.path.exists(path): self.delete(target) if replace or (not os.path.exists(path)): if target._is_dir: os.mkdir(path) else: with open(path, "w") as f: pass @staticmethod def join_paths(*paths): """Join paths in a system/independent way -- actually os.path.join.""" return os.path.join(*paths) @staticmethod def close(): """This method does nothing for DiskFileManagers.""" pass def open(self, fileobject, mode="a"): """Open a file on disk at the location given by the file object.""" return open(fileobject._path, mode=mode) Flametree-0.2.1/flametree/ZipFileManager.py000066400000000000000000000136621500740312400205750ustar00rootroot00000000000000import os import sys import zipfile import re from collections import defaultdict PYTHON3 = sys.version_info[0] == 3 if PYTHON3: from io import StringIO, BytesIO StringBytesIO = BytesIO else: from StringIO import StringIO BytesIO = StringIO StringBytesIO = StringIO EMPTY_ZIP_BYTES = b"PK\x05\x06" + 18 * b"\x00" class ZipFileManager: """Reader and Writer of ZIP files. Parameters ---------- path : str Path to a zip archive to be read or written to. source : str or bytes or file-like object Either a string/bytes representing zipped data, or a file-like object connected to zipped data. replace : bool In case the provided `path` is pointing to an already-existing file, should it be erased or appended to? """ # The Zipfile manager manages at the same time files already in the zip # archive when it was created, and files left uncompressed in memory. # The uncompressed files in memory are flushed into the archive upon # closing of the manager, with the ``.close`` method. def __init__(self, path=None, source=None, replace=False): self.path = "." if path is None else path if path == "@memory": # VIRTUAL ZIP FROM SCRATCH self.source = StringBytesIO() self.writer = zipfile.ZipFile( self.source, "a", compression=zipfile.ZIP_DEFLATED ) self.reader = zipfile.ZipFile(StringBytesIO(EMPTY_ZIP_BYTES), "r") elif path is not None: # ON DISK ZIP self.source = path if replace or not os.path.exists(path): with open(self.source, "wb") as f: f.write(EMPTY_ZIP_BYTES) self.writer = zipfile.ZipFile( self.source, "a", compression=zipfile.ZIP_DEFLATED ) self.reader = zipfile.ZipFile(self.source, "r") else: # VIRTUAL ZIP FROM EXISTING DATA self.source = source if isinstance(self.source, (str, bytes)): self.source = StringBytesIO(source) self.writer = zipfile.ZipFile( self.source, "a", compression=zipfile.ZIP_DEFLATED ) self.reader = zipfile.ZipFile(self.source, "r") self.files_data = defaultdict(lambda *a: StringBytesIO()) def relative_path(self, target): path = target._path[len(self.path) + 1 :] if target._is_dir and path != "": path += "/" return path def list_directory_components(self, directory, regexpr): path = self.relative_path(directory) matches = [ re.match(regexpr % re.escape(path), name) for name in self.reader.namelist() ] return sorted( set( [ match.groups()[0] for match in matches if match is not None and (match.groups()[0] != "") ] ) ) def list_files(self, directory): return self.list_directory_components(directory, regexpr=r"%s([^/]*)$") def list_dirs(self, directory): return self.list_directory_components(directory, regexpr=r"%s([^/]*)/") def read(self, fileobject, mode="r"): path = self.relative_path(fileobject).strip("/") if path in self.files_data: result = self.files_data[path].getvalue() else: result = self.reader.read(path) if (mode == "r") and hasattr(result, "decode"): result = result.decode("utf8") return result def write(self, fileobject, content, mode="w"): path = self.relative_path(fileobject) if self.path_exists_in_file(fileobject): raise NotImplementedError( "Rewriting a file already zipped is not currently supported. " "It may actually not even be possible, or in an inelegant way." ) if mode in ("w", "wb"): # i.e. not append self.files_data.pop(path, None) # overwrite if exists! if not isinstance(content, bytes): content = content.encode("utf-8") self.files_data[path].write(content) def delete(self, directory): raise NotImplementedError( "Deleting/modifying/overwriting an already-zipped file " "is not currently supported. " "It may actually not even be possible, or in a very inelegant way." ) def create(self, directory, replace=False): if self.path_exists_in_file(directory) and replace: self.delete(directory) # TODO: I don't know how to create an empty dir in a zip but right # now it doesn't really matter because the directories are created # the moment we create a file whose address in this directory. def path_exists_in_file(self, directory): return self.relative_path(directory) in self.reader.namelist() @staticmethod def join_paths(*paths): return "/".join(*paths) def close(self): for path, data in self.files_data.items(): self.writer.writestr(path, data.getvalue()) self.writer.close() if hasattr(self.source, "getvalue"): return self.source.getvalue() def open(self, fileobject, mode="a"): path = self.relative_path(fileobject) if mode in ("r", "rb"): container = {"r": StringIO, "rb": BytesIO}[mode] if path in self.files_data: content = self.files_data[path].getvalue() if mode == "r": content = content.decode() return container(content) else: return container(self.read(fileobject, mode=mode)) else: if mode == "w" and path not in self.files_data: self.files_data[path] = StringIO() elif mode == "wb" and path not in self.files_data: self.files_data[path] = BytesIO() return self.files_data[path] Flametree-0.2.1/flametree/__init__.py000066400000000000000000000003531500740312400174700ustar00rootroot00000000000000""" flametree/__init__.py """ # __all__ = [] from .version import __version__ from .Directory import Directory, File from .DiskFileManager import DiskFileManager from .ZipFileManager import ZipFileManager from .utils import file_tree Flametree-0.2.1/flametree/utils.py000066400000000000000000000026401500740312400170720ustar00rootroot00000000000000import os import shutil from .ZipFileManager import ZipFileManager from .DiskFileManager import DiskFileManager from .Directory import Directory import string printable = set(string.printable) - set("\x0b\x0c") def is_hex(s): return any(c not in printable for c in s) def file_tree(target, replace=False): """Open a connection to a file tree which can be either a disk folder, a zip archive, or an in-memory zip archive. Parameters ---------- target : str or flametree directory Either the path to a target folder, or a zip file, or '@memory' to write a zip file in memory (at which case a string of the zip file is returned). If the target is already a flametree directory, it is returned as-is. replace : bool If True, will remove the target if it already exists. If False, new files will be written inside the target and some files may be overwritten. """ if isinstance(target, Directory): return target if (not isinstance(target, str)) or is_hex(target): return Directory(file_manager=ZipFileManager(source=target)) elif target == "@memory": return Directory("@memory", file_manager=ZipFileManager("@memory")) elif target.lower().endswith(".zip"): return Directory(target, file_manager=ZipFileManager(target, replace=replace)) else: return Directory(target, file_manager=DiskFileManager(target)) Flametree-0.2.1/flametree/version.py000066400000000000000000000000261500740312400174130ustar00rootroot00000000000000__version__ = "0.2.1" Flametree-0.2.1/images/000077500000000000000000000000001500740312400146575ustar00rootroot00000000000000Flametree-0.2.1/images/autocomplete.png000066400000000000000000000226301500740312400200710ustar00rootroot00000000000000PNG  IHDRtwsBITOtEXtSoftwareShutterc IDATx{PS Y5i՝T6DMS!:GU9VqNQzϯ nq=#[T@3b7%UUJB%BRcAXB|Y}wp\ 5RWWV\i9oW##{N$=Ҝu#O=Աr6/CuƘ_CѤ7]{]a1h>φ,&y᦯^XtI, M'ZWtC|v If2K 5l?wR~ Elyw{ p` {'ٰq@@υC|aIų?z2)!9i%XvVUHiDp+{p} sWV1 ǵ37ǽl0Z1 gH(c.y ;[ %%+D%%Z.%"ԧVo{)k֞8H j[aܭ@0 )}/$\QQ SZ+Xk֚V80 U[9셋yGG7 UGV'ڴ`.&#.~.Y Hrg! Ny-0(])$&>>^[}duV[ |"~VnKCƻq0sޝQQ_>-V~W+ dt|v=%K .E-!&c%`ʕ+36SVj/{;ν&xj޻zk܁>z36z5 Q ͊0\qw=Z7<, fW' 김|Łs%$>'1+, ./7mpJBX#jpFkF G5iյ^#sKŋg/_5ԐTΕ;DJoTbuY3nX4M설__'#)/~i^: VjO[Kl:z벺+, Ipn(ڵk@4}.lݕވ#" Ds8Pbbѥ» D+;5KH$eo.u[,KU:<>> De1s$C_I.pXVX,to|CBsv1>BBeۃ!+A8W 0cXL03I_EsAe aϹЃ#to PKwϹ"<-8BĸKň~0c˻+0-]1-ȸ 38G!2H^< 8*wH5*Lsa0[>rC|wUAʸ%flB8WvwwE&ZPܲ2}!v;-.555~o\@"ȣǴl=]Z) D$ē( h4 p^ݍʂ 6w~3^?j?<5]6kk6=j= -yT{7}{3dN8].!xSEMF3f2u$ e!-/!e?5cQ gixl6ۭiɞӭf9[et:DKT/k|`5L&d=x"fK#nSAw/SI'/>+Hheq:!:I$KD3&'DyD;dT؍GMwAx<‹ąVI0 Qb+4 G+eQuPp:<{say *.#g{E.^'ZQ-f u $do>c-/wX,ѿߛ6:+e B^t:$A0# `Y=xdk6v jmvc`42k£&3Kב1A6Փ: {_ܠ`NFTƫ;_.XA/f"s(fɨ#*laVܔoE F,;5iĖ di-(p8hq!)1! BE G:;o)!1yB -fർHUN f?0.8I(ż-p?"7u~j'g'oFrGA_#^_g;T -Ad廣4RW]^mt:؞ WG@[N4W78=T7=*UoX^֨h(hQ6Gn{faGTP+CVnG,~1basQ`l Ck,c^rX={Rxv65GeZ+VEA瑾o]%֗MY EgE'D #^^{jnE ֊f;|_gmX`F7W"pxaXhc_1_ w}~fD%pb]f!.A]=ʨ7So[B>`9W`p)/GG<+7C4gLQA`raYΆo ➃ʧ1\Ux:sa`yw@h}wNF֞c4 R`"<[k Ϯu|Kmb6tCO !A13yTVàaPX7y W7]wHHfyk?o\;.H~c 'VܱU"re aLzhq1 ~-K0b~9(v'ߠNv=n>un͘ =Ul?W˲u EI Emg, ]\ kOFnةhuF·U .`fIn&b7Vn6AZaRp1AMeeeP 5Da۫?IAϮ3tRmCC쿋f5 xӶlE//7G绁5'oXwˣEVX8d5K?oEX50q `EAQW\ 6ٽ*8K,x<̕/lfYosM3dM09l TJj0<'?'Zʷy}gw6{zقk֞r-ÔyC+Rssըys'IEAkJrJχt$_9c<= `EBbJ]>HO|&·m 鿣4iY?8Pn@A|BSoY\zpg7Lټv6!3Ŷ "f:oh;\)"~J,W_ot8L~ϼ@jG0зS֊o`Mn3 N+F<;L_[;=/ Vj EA·u ܙ !CPXZ(86/Dx&h @O3#f<>+^ai>th&"nr\/.0*f;b]Tr>+!U0(gH-Z,м"pu:ֻ Ek @m5 xy D ?O# ܦXzJ.\^u!8?nf &,JyEBHX,/GFDOOfW\Ijw@0B+ҘCF=Dߦx~⭁pWd'ܩY6vvO BwNNK2b s|$BŸpA+{%Oؒ%VoXp%)"(3uYLxxHJY hú3rq4;K, ~G (6=".(+[e]na@!  2F,9A(B] YuxeJ Bӌ2Q^I=&CCtl_MdJ N@K`+OQWWWGG͛7O8Axd * ȲY\.XD7I(6yNY#MvA+[>U"Pl>$ˇ>h/HDvM|^M * 6_cir,EEEEE;E=sZ ܍VPy.+`^/hT"*y@±nf#*l Wdcnܣ>" (v4?駟_vv믿vuugշ'NݻY,J?p8<^/_ $qZjlu |TWFÎ)F24`,TSh,)u @º TjO;qc2rm[\{!.=Plfbp?oE`ѸGEݡL X!PȅmŐ0*o7= o!˗Ǻ斖ֶ`X>=PXvjj*0(5/s8Dh.i &"/6&7'LÐZԗlxzf~n/U(+Ta$O߯W?+L`U(uWʔ^GOt0bo.PgZ@y*&/3<wI} L%il @Sl Lz Pe ~32 &ye;T|\e9k "h~'66-'B:ړEXA"[VRP&*43$'0\͈Pue)?-Y8+xe {T@T*VV:X D >"T-5̔ge:*'gWO9 bMQEq {OdiչOrқ !|+X@dfINX!OM+LidSq;|hKOi*2rls03e Gk>}1KIV&bNIXIub'Z歅ە$"ߒ^MY\\էQiMܙ֓ Eʊ0~Θ'bfbh2X!OIAU~EUWXjEVWT]{,Sɱ$aKDu @_J:^:3jPjcE)]n͢cuu{4Pg$:HR[ZYh.kjxړ2u@S_/Y1̘C+5Ĝ䗖A-&]v͎ꊜXseД1H ˜PLtn}UX-I. U& BX{Hmn _dZSY\TAZ\T@;iyM&(n} {ިY1vW{2,/i9CX!|+k Qr&r\Y!MI@;_A}R}Ҭ\^~|l9Vc"gPW\,=EIU2l}ae^h|]{])uy;B4Uff">%QsPdJ" Wy|/MV;3!xK+GVڜ4/9r.'03Gy9d|vUgrk׮\Po~jGJ"fC,0";Y!q VH|~KTL4t5;GzHRO}<(-4۱&A# H },vbau.=9zڈ^Xzj;*LdQ3C&8bx̱nKq|췾ֹ444\~֭[2kgggWWWw07n{EZ  ˔/B)Gx)>fM©ʴp>?\"jڽ{_G7 ' UKxUĉ  s<0yu&Lue6dMBٻP0 gߢ R2#euQjQYHK-WoKSk}SKOĭEpk Z+Xl-R_%h{O$ڷZZZ'ZEڭE<Sэ---7oKgggwwhn߾}Νw KqEpkZdm-[g5kR52g!.lqk"kE[nkǏ>WoI|fNVz$"s_k(IDATH5",`n-2pkQZă&Sn&.( _ӣL7j!WSaήfYJ|҈ c"7IP֏ZPx՚5~Y0#5A!go ..볳'+^+Dy0OzAj`6A#*O!@\Y1T!C$+{6' JF[Y> 06}Ѓ }ڙjʂ -.#:1\{w~ŝpí[<pКVeAA(=(,̡s[S Ng[8<&PYԲx\֮ /nl <&AeECn5ac R))CPBZ22,r\;놮%A{\Ќu.]^ςy3/ `@"]wcwA^q oPs+bS <]"}y˨ 1"8's <=4y0zC˥]1\]LA,IENDB`Flametree-0.2.1/images/logo.png000066400000000000000000000402131500740312400163250ustar00rootroot00000000000000PNG  IHDRVWf sBIT|d pHYstEXtSoftwarewww.inkscape.org< IDATxy\Wu]{sjQɲed 2$J.)/&!2 !727#!Mb N\ 0xز-[5CMTwuu˲VKϧ>]]CZ~KXTގa^alV X) w2]W)oRnGy+^D"H$'X ,9#uΡC:we^=0(o(ȩΗH$D"qX@EAx[T]yilj#9\a1F!4WRpÄgᛔP+J$D"qnXJ \z79mjXj(98Q,ΕZ z?Vm"pheO2[D"H$ցU TWro'%{"H$GɲQӗ>f8߾qМ7F} uz2Jl"M\DWa S8]>TQV?#XGq ,mɛ{tJ\1o}+&D"8K1zP_[ #yWpPZ ? r'܏Q|c%$!1lV'(u_2+5rt̸1tBGoZx'+H* &D"8 )2UåGtՐc^x 䝀%nb6F%@{yu yoj˥6d df'9ɘ fa+XZ*tOU"H$3)g*S6PэN`eb& Bj !c^7ߍ _/LJ*DN`e#Ɣj[vB]`,t_|'LU"H$aNa-4RUۇ*J@@) Wr9B %dy9w]9焛qz%/(*࠹}=")`v1FGxXhq\pr012k7@ ,˃} )J$D"q:G:YQT  * 0<87ؚ Zܠ!-e lsl~ f)LI:8Xs֋{?o>4XiWD"H$Üjj/,hnTJNuT lUa:uEM{K;"j8B_f8r^U܏A)]B-x=I֘i<\ϸY@ypϞ.yދW)kH$DbGTY*W {fI@eazr|bG,Ya9^8dX@5vx: HNUUn<[A! e3+cXh^Ír0dY])UW !RpH$D4vV_bN H\) U a4`0 --GqmP(&:f;.coAe+œ~j']~~-i~GiLJhPDO#4(gyey}GCAxUr+. C-1eZiݒIN삫dH$D2gTm7̏X=GivsZt&jt0&F(uIoxѶ9Yhcpě#Wn!xJD"H$j1`ǀg:0Tc0=n* tkp1$0l1vo&Q?2$݆J˥@>`J@˝v+V= l<5&g9l2_X̸LʩnAV8@Z%D"pחAU_VdSC7wde(tEhu`G0|M#rN2.`LK-Tk|K>p"jPx1׌$9KQ aRmCA^B +9QFB-}r]S {#K6o]@m͎^cl>'V u1}?G{Y _0whȁ.ZT:gƇ797q5iU>ON0`toKm%7n,ܐTMM 'L՘7Rfr\hЕ1ZK9*{93 /ίl'Sr0ʗ"qaԣr#dCBaGo .7|9%WEųxqt} #]Fl) qj?ĎG`}bTf'5 Ⱥq95b pd{Y| Y ^ I) x*珁׬1Osa3sGfYg?:[Yƽof<+VrU8{WqΆ U̵eQWdN -o"stz9a#d6o:9wz8/:R3L4xjxW-1Z4;bޛ+"5`4~&'\< X+rB3,rLŲR1ҒUJ<A^tr:p7*8_xB~$c:E-A8 !f:u0-me-(m*c78hr(uDΧL~cq?uzF!ST{Q %r |RT,]"b8d.EA0MՒ 405iAȌ (W*;JY'з_)O}Ix 0yۄ\b>&=8p:o#6y*u||5O/3e Q%MYY3x? |e ?̲f`}WU<biIafJnaqRxGe>C$'b(#,0\}:DO˶%y~AP u儱 n9G$)8VZ($*N1m3##L6Է GQ ,7eS&DA2)9n, U`/ |\o".Y>b]gpW`9<Y6ٲRoU8jsw I,l{ c=gY qfIi/Xw,V}M T[5.UPl768L.hj8.io FaQͤUߤmekgm#ņ^Xa3SeŒbCk0Gbsb:80 dZ4W*1sk־ۀo]9WDb84LnMuQbU0K;aZTJBVIHPaCF)MnruT ^؛2.όhɵ4F# 9ČAqqm=1WwbDg̓I#Thh4Q'0Ni& fdy?F7kЕ^rЮ[Z@"1xdH>Jl|~h}D;q2FJ$V[c@sVnzIl``lՁ*[T4WQC/&br>=_\_CYAEl4Ĺb+Q}}Xw}=&͋BA6W"qK>,x:Vðop0[ul [* RWsh(ʞ YZ#UV pEhE5QfQ9tx^o$+j,qt*F4Vl|>k8~C:n2kt5ln9ZUVNV||MvAuDbox p`1kw,N?[pl븇Dbr^aR3~@j>p4 `誡 `Q2 #ekiI,xS@_MQ!XW-]; rmQD %A"&jr-Or_Ӗ2̘+Adxp s};/vtX#;HJ S ؼ:]fyw%fo⇁+sߡH6Z:fi@'࠶j*F_gE]3fy(tX!6{x\X&-rƅ.yS`4`5T|ڣTis wy+WRJm< OOZ6 ]FraRá Km,jΡeyin-"~b[ y+l78s _T~ *ThfjB,YZza%CC]<}' M>%{"v|ՎZC1K.vi..gBi5ӥNLJA1^3Uᔖ8 b '6#XG 9+fMDבL.D)J,cX{<0&6^ڿY?$ڍ$":!Vf 1x0A@' ́lLԂA% +^r}94CG Q%8pT . 3n1hj) {B\{4Q\=V8-"Z7>ȕ9i.KNrD2qńؽ8rߞD\aԟprk%yp*k52CkcMe,H,%"GWXh-`+K ¬.VO =5e@B]i\G٩걀 Cmc 8]6;[ia1 omeGI. 7XxG`?ڡ-sKda !Kz 3 arNAU"r2`?`i߱Q9Yݿ+vN"^6HfA_dʀPSAPXC'd)!` c/ekf~}0(,UL~4jJ8D,&G+'DZRDan~l#HFIG٘ Jc5[e簾bHD.]?lLi Kx7r#,DT lA܉$,vV~)ir`0U[(Ҝ&QETQsCkiz2 Q%Q&Ɂ /V\㏂-0Z [-8`qB|a:2jEOcK\q;ua/i8vU8v"q>xVfz7 JR뫨r*J"` dxr5f]d!!m8POfq3"Bj[9Z^;ʛjb8F\,9ĀuJ1 5f$)~K@D(xTQi4:UBR,URYPN}T|lRާ ظ~>S8`*Z&&[v]]$ΘE~6/\`*tU^D.q#@?QÍ$8Gk{37>!_05:Ҡ4Ѥ&s\,EGJ#1z * j)UȉAdz_>̾ٓ XsqlԬĬU9μ{'!H\<+&6(n#pQp}-BϹw[c_8 i~wǷ̜֎ۉYA߭)b?^ pho#8Uw T*9P`)%TQ5UQx,kctɪ9!5nA s |Jԉ(1jPMVxMv収[kZΔ;R`u:dhT ', Fw[k|'1&Q#'곆y3 I7 O^?OA VXm8]ΊԈ=eTw8YHG&*c0QqB=7&OuUb6E-Գۼ\x䔒35 [0u Ӡ+MzҠAlhb@"{'EL,O1Pa6 Yq"S,ilMʰh-gxZۈ#W8N鏲?c~y\F[quIBǬ1R=Ӓ12 e=bPcCʋyT,FK8!f|492JF\\]l,~Zޮm'Ţx@Ԁ1xIvU:Qb)K8l7b75g[z'NGKsF@%`:QtlJc'(}/{cdi]v8?zsߐm ġЁ@ uJsQskO3 .dS_r7pkWn5 |m$cOvKGCo t5fq޳9$?pU<+|*U7ˋ0(!U,wy223N)Řވ5P51Aȫ}],R8X8us؁4b32#z'ˆA|wD ϙDgAQbñ:DT;Lh2H(ktM8-D\!@hMvZxHQh0#fA>1N2M4PW"bj#BPK?gՍýf+<M̢$%/m:r n+v6 J# I$gxvƔV~q%M#PE OxhxQ'g`훁;j,'ۈgk5rKzVJl( Y>&J&SI?+[(e@) 駁JosմɊ~pթB,ExD=h zyB^(7Q9*o%x#BD5 yF2# E5*Jjɫ`m^,1S?h\BAyuav"PRB0Ъsh1WԖd#gIґ3}OڗA>nčȇ =FYeF,K1閖Z^ y0hL>w{x8d<<"] 3Ը77Qu5k J[2K+5ʱcV 'T|hL.?ZV3GfOi/F_XC9+jQ3(X7MzLxeZIJC=WٍqQ*BCcqDQQ/e-^PWx0XE8J1A%WM$X[|[.~s ;i -D:(]Drw{p% %dX4ʔQVNaoߺkZ{/X䩜&K} +ܖH\˧(n xOMR E`V_q B%d:]vbTuY^U9xjLlB*>gLJ. G1a,TELCDNC+!ĸr ]I_Ue;χ g3e5p,7|^?nGV%em9x.gv.w%Tm=-QSPCr?s8TMS ߍ1o %C2eQ#m$#%? Lp'9BPJL<63+Y00h D#|Lqs[Qm#ŅSYOa2&Xj m`y]|:lw?P]^EM$ )Zv^c}F뀁rJd=Oi؛9Z80"XT #5>v0{뼏]ax/FgVXuKbX:_Zej6`|Ifs'pbcâuUeԞe7S<ĵϹ D $iWzy1!(>,c"~9FzB"*B&yH5姑E)"Kj6[a25}2]H^]@xڽ߯>n":sH$Ξ>9 *7zobL c~h(b$>s) m%A  Q)sc*ؚ[DeQ+# QhMTc1{8Wy?L00TU"bjFa[ 7dO`\ާfkW`@L.oz1c,XZo޵ bO$+%&~u! {5l% &1f̰S &oA>Uubcaq4+Dz bmB)JPO4R]tsWf>?R$o"qxQԮbFb7n1CZԳ6R =j݀ol~nE0y"ҡn`fhm/ew A6Psʒ)eus|50u>;a&f%b-A h`3wqq1NRdcxT/C0c X4dx[vޟ#d^w.6*SԀq:Yvk7P-lECJg(lJ^Wԕ}R]\V?u|a#$Yo0[X(e]uO}yNw|K?̽v53 ;`)gNr**^tc\!wU/c־}&*r|[~v.QoQqѐѣMqVWdz sN&,( UlՂhi~2·n>v2- ˿zws1/V_ 9=^Rj,ZźNG o{`^7$P!Z2%oxJg6gqғqWxwn LryAh;2w}='̤4mhV,hKŠ тҿ@o/DoABڏRi:N3c>=1mK6g͙|py/;=I0~8@;F;G۝'v[_n}ڍL^v+a/egJIR=Pin* nČv zL`(0¹ZrV{: C" DOiIY^GKgnljTqo")F K#ͣ6Px[pYb 6/q~elciIY@ ޭG'j.D*\bHm7( = s~U&d2[69'cVY;f{wl ndlN#pVq0LF^>m?~ۉk:8bs|>+x[𶈋LR+tbCq"%BjZɝud2L&l/`-F@zc.\"]wM`ސDjбVI2p<,r<ϋz7)"JB8J9E,$8=Wt#&gN'@8M*j@ecBLWv͞&0h&QutVeN,2L&lbͱͮ^<5|(+ FNBs{iQzLB/or~?gtMP]\c\3YJ'PZc3Dlt@V=VдJ!=7hEPF># }USnU&d2mlVpmKӞK?VDPh"I[QXIDIyty-Q{1kP(vFKvעJJ}B-XYs{lh썉 9f!d2;bVPxymq(G\*tq46AtiONPPXA(ژ4 /wn]^UAgWk?LcqDdH! 2 C"# 1m#K\PѬ:U-%nU&d2VX=G]'I4~qUU,=C]PKQ2uJjO#H6T4^lF) 9e|J 6ڌ֊Nfohvu6Ve2L&.+,؞o`-hMmiLQG]:l<- `΃4I3G-5aX_!25^L~M HH XI|C'5HlP8j];L;Ll})nU&d2 W\5ʡ(\:sDeu,GQ8R$L5EO5MrDJ+KhH(c$ńj$Ȅ&R+HUFҙR0W>DUv2L&ɬ]Xੑp sAoCI8GE*+ppQ&)>)uRw(~tDSĤkj T&1HDûHQnTKTemkԸ(tOH!6U [d2Lf݄\S\_ hړ(M$̘nR!e1aGM+ #۸U) 4~Ut©rO|–\6k1륿S.6vnNUUL&d +fYv7WsI(RD$ bK})`9]}i+dXL1?IĸD{>s D Q!L&d27۪/ IENDB`Flametree-0.2.1/pypi-readme.rst000066400000000000000000000050541500740312400163640ustar00rootroot00000000000000Flametree ========= Flametree is a Python library which provides a simple syntax for handling files and folders (no ``os.path.join``, ``os.listdir`` etc.), and works the same way for different file systems. Write a Flametree program to read/write files in disk folders, and your code will also be able to read/write in zip archives and virtual (in-memory) archives - which is particularly useful on web servers. As an illustration, here is how to use Flametree to read a file ``texts/poems/the_raven.txt``, replace all occurences of the word "raven" by "seagull" in the text, and write the result to a new file ``the_seagull.txt`` in the same folder: .. code:: python from flametree import file_tree with file_tree("texts") as root: poem_text = root.poems.the_raven_txt.read() new_text = poem_text.replace("raven", "seagull") root.poems._file("the_seagull.txt").write(new_text) Even in this very simple use case, the syntax is clearer than the ``os`` way, which would write as follows: .. code:: python import os with open(os.path.join("poems", "the_raven.txt"), "r") as f: poem_text = f.read() new_text = poem_text.replace("raven", "seagull") with open(os.path.join("poems", "the_seagull.txt"), "w") as f: content = f.write(new_text) Moreover, the same Flametree code also works for files inside a zip archive: .. code:: python with file_tree("my_archive.zip") as root: poem_text = root.poems.the_raven_txt.read() new_text = poem_text.replace("raven", "seagull") root.poems._file("the_seagull.txt").write(new_text) Now in hard mode: suppose that your server receives binary zip data of an archive containing ``poems/the_raven.txt``, and must return back a new zip containing a file ``poems/the_seagull.txt``. Here again, the syntax of the core operations is the same: .. code:: python destination_zip = file_tree("@memory") # Create a new virtual zip with file_tree(the_raven_zip_data) as root: poem_text = root.poems.the_raven_txt.read() new_text = poem_text.replace("raven", "seagull") destination_zip._dir("poems")._file("the_seagull.txt").write(new_text) destination_zip_data = destination_zip._close() # Now send the data to the client See section *Usage* below for more examples and features. Infos ----- **PIP installation:** .. code:: bash pip install flametree **Github Page:** ``_ **License:** MIT Copyright 2017 Edinburgh Genome Foundry, University of Edinburgh Flametree-0.2.1/pyproject.toml000066400000000000000000000007301500740312400163260ustar00rootroot00000000000000[project] name = "flametree" version = "0.2.1" license = "MIT" authors = [{ name = "Zulko" }] description = "Python file and zip operations made easy" readme = "pypi-readme.rst" keywords = ["file system", "zip", "archive", "file", "directory"] [project.urls] Homepage = "https://github.com/Edinburgh-Genome-Foundry/Flametree" [build-system] requires = ["setuptools"] build-backend = "setuptools.build_meta" [tool.setuptools.packages.find] exclude = ["docs*", "tests*"] Flametree-0.2.1/tests/000077500000000000000000000000001500740312400145545ustar00rootroot00000000000000Flametree-0.2.1/tests/test_basics.py000066400000000000000000000141641500740312400174370ustar00rootroot00000000000000import os import sys from flametree import file_tree, DiskFileManager, ZipFileManager import pytest PYTHON3 = sys.version_info[0] == 3 zip_path = "test.zip" test_dir = "testdir" ALL_FILES = set(["bla.txt", "bli.txt", "blu.txt", "Readme.md"]) def test_directory(tmpdir): # CREATE AND POPULATE A DIRECTORY FROM SCRATCH dir_path = os.path.join(str(tmpdir), "test_dir") root = file_tree(dir_path) assert root._file_manager.__class__ == DiskFileManager root._file("Readme.md").write("This is a test zip") root._dir("texts")._dir("shorts")._file("bla.txt").write("bla bla bla") root.texts.shorts._file("bli.txt").write("bli bli bli") root.texts.shorts._file("blu.txt").write("blu blu blu") # READ AN EXISTING FILE (two ways) assert root.texts.shorts.bla_txt.read() == "bla bla bla" with root.texts.shorts.bla_txt.open("r") as f: assert f.read() == "bla bla bla" # TEST REPLACE BEHAVIOR (replace=False) root._dir("trash")._file("bla.txt").write("bla bla bla") root._dir("trash")._file("blu.txt").write("blu blu blu") assert root.trash._filenames == ["blu.txt"] root.trash._delete() root._dir("trash")._file("bla.txt").write("bla bla bla") root._dir("trash", replace=False)._file("blu.txt").write("blu blu blu") assert set(root.trash._filenames) == set(["bla.txt", "blu.txt"]) # READ AN EXISTING DIRECTORY root = file_tree(dir_path) assert set([f._name for f in root._all_files]) == ALL_FILES # APPEND TO AN EXISTING DIRECTORY root._dir("newdir")._file("new_file.txt").write("I am a new file") root = file_tree(dir_path) assert set([f._name for f in root._all_files]) == ALL_FILES.union( set(["new_file.txt"]) ) # TEST DELETION path = root.newdir.new_file_txt._path assert os.path.exists(path) root.newdir.new_file_txt.delete() assert not os.path.exists(path) assert not any([f._path == path for f in root.newdir._files]) # TEST DIRECTORY COPYING root._dir("new_folder") root.texts._copy(root.new_folder) assert [d._name for d in root.new_folder._dirs] == ["texts"] # TEST DIRECTORY MOVING root._dir("newer_folder") root.new_folder.texts._move(root.newer_folder) assert [d._name for d in root.new_folder._dirs] == [] assert [d._name for d in root.newer_folder._dirs] == ["texts"] # TEST FILE COPYING root._dir("newest_folder") root.newer_folder.texts.shorts.bla_txt.copy(root.newest_folder) assert [f._name for f in root.newest_folder._files] == ["bla.txt"] # TEST FILE MOVING root._dir("newester_folder") root.newer_folder.texts.shorts.bla_txt.move(root.newester_folder) assert [f._name for f in root.newester_folder._files] == ["bla.txt"] remaining_files = set([d._name for d in root.newer_folder._all_files]) assert remaining_files == set(["bli.txt", "blu.txt"]) def test_zip(tmpdir): # CREATE AND POPULATE A ZIP FROM SCRATCH, IN MEMORY root = file_tree("@memory") assert root._file_manager.__class__ == ZipFileManager root._file("Readme.md").write("This is a test zip") root._dir("texts")._dir("shorts")._file("bla.txt").write("bla bla bla") root.texts.shorts._file("bli.txt").write("bli bli bli") root.texts.shorts._file("blu.txt").write("blu blu blu") data = root._close() # READ A ZIP FROM DATA IN MEMORY root = file_tree(data) assert set([f._name for f in root._all_files]) == ALL_FILES # APPEND TO A CREATED ZIP IN MEMORY root._dir("newdir")._file("new_file.txt").write("I am a new file") new_data = root._close() # VERIFY THAT THE DATA RECEIVED CAN BE WRITTEN TO A VALID ZIP zip_path = os.path.join(str(tmpdir), "test.zip") with open(zip_path, ("wb" if PYTHON3 else "w")) as f: f.write(new_data) root = file_tree(zip_path) # READ ZIP FROM DISK, APPEND TO IT assert set([f._name for f in root._all_files]) == ALL_FILES.union( set(["new_file.txt"]) ) root.newdir._file("new_file2.txt").write("I am another new file") root._close() # REOPEN A ZIP root = file_tree(zip_path) assert set([f._name for f in root._all_files]) == ALL_FILES.union( set(["new_file.txt", "new_file2.txt"]) ) print(root._tree_view()) root.newdir._file("new_file_that_doesnt_exist.txt") with pytest.raises(NotImplementedError): root.newdir._file("new_file.txt") # overwrite is not supported. # Open/read file in zip with root.texts.shorts.bla_txt.open("r") as f: assert f.read() == "bla bla bla" def test_file_tree(tmpdir): """Assert that the directory function dispatches as expected.""" root = file_tree(os.path.join(str(tmpdir), "my_folder/")) assert root._file_manager.__class__ == DiskFileManager root = file_tree(os.path.join(str(tmpdir), "my_archive.zip")) assert root._file_manager.__class__ == ZipFileManager root = file_tree("@memory") assert root._file_manager.__class__ == ZipFileManager root._file("test.txt").write("bla bla bla bla bla bla bla bla") data = root._close() root = file_tree(data) assert root._file_manager.__class__ == ZipFileManager assert [f._name for f in root._all_files] == ["test.txt"] def test_matplotlib_writer(tmpdir): zip_path = os.path.join(str(tmpdir), "archive.zip") folder_path = os.path.join(str(tmpdir), "test_folder") try: import matplotlib.pyplot as plt except ImportError: print("Not running test_matplotlib_writer: Matplotlib not available.") return True fig, ax = plt.subplots(1) with file_tree(zip_path) as zip_root: fig_dir = zip_root._dir("figures", replace=False) fig.savefig(fig_dir._file("fig.png").open("wb"), format="png") fig.savefig(fig_dir._file("fig.pdf").open("wb"), format="pdf") with file_tree(folder_path) as root: fig_dir = root._dir("figures", replace=False) fig.savefig(fig_dir._file("fig.png").open("wb"), format="png") # fig.savefig(fig_dir._file("fig.pdf").open("wb"), format="pdf") assert set([f._name for f in root._all_files]) == set(["fig.png", "fig.pdf"]) assert os.path.exists(os.path.join(folder_path, "figures", "fig.pdf")) Flametree-0.2.1/tests/test_third_parties.py000066400000000000000000000027611500740312400210340ustar00rootroot00000000000000import os import sys from flametree import file_tree, DiskFileManager, ZipFileManager import pytest # THIRD PARTY LIBS BEING TESTED import matplotlib matplotlib.use("Agg") import matplotlib.pyplot as plt from matplotlib.backends.backend_pdf import PdfPages import weasyprint import pandas PYTHON3 = sys.version_info[0] == 3 def test_weasyprint(tmpdir): path = str(tmpdir) root = file_tree(str(tmpdir)) # or 'archive.zip' to write in an archive. html = weasyprint.HTML(string="Hello world!", base_url=".") html.write_pdf(root._dir("pdfs")._file("test.pdf")) with open(os.path.join(path, "pdfs", "test.pdf"), "rb") as f: filesize = len(f.read()) assert 4000 < filesize def test_matplotlib(tmpdir): path = str(tmpdir) root = file_tree(path) fig, ax = plt.subplots(1) fig.savefig(root._file("fig1.png").open("wb"), format="png") with PdfPages(root._file("plots.pdf").open("wb")) as pdf_io: for i in range(3): fig, ax = plt.subplots(1) pdf_io.savefig(fig) plt.close(fig) with open(os.path.join(path, "fig1.png"), "rb") as f: filesize = len(f.read()) assert filesize > 7000 with open(os.path.join(path, "plots.pdf"), "rb") as f: filesize = len(f.read()) assert filesize > 6000 def test_pandas(tmpdir): path = str(tmpdir) root = file_tree("@memory") root._file("test.csv").write("A,B,C\n1,2,3\n4,5,6") dataframe = pandas.read_csv(root.test_csv.open("r"))