pytree2 0.2.1__tar.gz → 0.2.2__tar.gz

{pytree2-0.2.1 → pytree2-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytree2
-Version: 0.2.1
+Version: 0.2.2
 Summary: A Python CLI utility for visualizing folder trees with sizes and counts.
 Author-email: Angelo Luiz Angonezi <angeloangonezi2@gmail.com>
 License-Expression: MIT

{pytree2-0.2.1 → pytree2-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pytree2"
-version = "0.2.1"
+version = "0.2.2"
 description = "A Python CLI utility for visualizing folder trees with sizes and counts."
 authors = [{name = "Angelo Luiz Angonezi", email = "angeloangonezi2@gmail.com"}]
 readme = "README.md"
@@ -20,6 +20,7 @@ Issues = "https://github.com/angelo-angonezi/pytree/issues"
 
 [project.scripts]
 pytree = "pytree.main:main"
+pytree-loc = "pytree.main:main_loc"
 
 [tool.setuptools]
 package-dir = {"" = "src"}

{pytree2-0.2.1 → pytree2-0.2.2}/src/pytree/classes/PyTree.py

@@ -11,14 +11,15 @@
 from os import walk
 from treelib import Tree
 from os.path import join
-from os.path import split
-from os.path import islink
 from os.path import abspath
 from os.path import dirname
 from os.path import getsize
 from os import _exit  # noqa
 from pytree.utils.aux_funcs import is_cache
+from pytree.utils.aux_funcs import reverse_dict
 from pytree.utils.aux_funcs import get_size_str
+from pytree.utils.aux_funcs import get_skip_bool
+from pytree.utils.aux_funcs import get_path_name
 from pytree.utils.aux_funcs import get_path_depth
 from pytree.utils.aux_funcs import get_start_path
 from pytree.utils.global_vars import CACHE_FOLDERS
@@ -107,6 +108,10 @@ class ModuleProgressTracker(ProgressTracker):
         start_path = args_dict['start_path']
         start_path = get_start_path(start_path)
 
+        # getting start is cache bool
+        start_is_cache = is_cache(path=start_path,
+                                  cache_folders=CACHE_FOLDERS)
+
         # getting folders/subfolders/files in start path
         folders_subfolders_files = walk(start_path,
                                         topdown=False)
@@ -117,30 +122,17 @@ class ModuleProgressTracker(ProgressTracker):
             # getting current folder path/subfolders/files
             folder_path, _, files = item
 
-            # getting path is root bool
-            path_is_root = (folder_path == start_path)
-
-            # checking if current path is root
-            if not path_is_root:
-
-                # getting folder is symlink bool
-                folder_is_symlink = islink(path=folder_path)
-
-                # checking if current folder is symlink
-                if folder_is_symlink:
-
-                    # skipping symlink folder
-                    continue
-
-                # getting folder is cache bool
-                folder_is_cache = is_cache(path=folder_path,
-                                           cache_folders=CACHE_FOLDERS)
+            # getting skip folder bool
+            skip_folder = get_skip_bool(folder_path=folder_path,
+                                        start_path=start_path,
+                                        start_is_cache=start_is_cache,
+                                        cache_folders=CACHE_FOLDERS)
 
-                # checking if current folder is cache
-                if folder_is_cache:
+            # checking whether to skip current folder
+            if skip_folder:
 
-                    # skipping cache folder
-                    continue
+                # skipping current folder
+                continue
 
             # updating progress tracker attributes
             self.folders_num += 1
@@ -212,6 +204,10 @@ class PyTree:
         self.cache_folders = cache_folders
         self.progress_tracker = progress_tracker
 
+        # getting start is cache bool
+        self.start_is_cache = is_cache(path=self.start_path,
+                                       cache_folders=self.cache_folders)
+
         # getting start level
         self.start_level = get_path_depth(path=self.start_path)
 
@@ -226,6 +222,10 @@ class PyTree:
         self.total_files = 0
         self.total_size = 0
 
+        # defining placeholder values for current folder size/count
+        self.current_folder_size = 0
+        self.current_items_count = 0
+
         # valid files
         self.valid_files = 0
 
@@ -298,9 +298,7 @@ class PyTree:
 
     def get_folder_dict(self,
                         folder_name: str,
-                        folder_path: str,
-                        folder_size: int,
-                        items_count: int
+                        folder_path: str
                         ) -> dict:
         """
         Given a folder path, returns
@@ -317,17 +315,27 @@ class PyTree:
         if self.include_sizes:
 
             # updating base dict
-            base_dict['size'] = folder_size
+            base_dict['size'] = self.current_folder_size
 
         # checking include counts toggle
         if self.include_counts:
 
             # updating base dict
-            base_dict['count'] = items_count
+            base_dict['count'] = self.current_items_count
 
         # returning base dict
         return base_dict
 
+    def scan_file(self,
+                  file_path: str
+                  ) -> None:
+        pass
+
+    def scan_folder(self,
+                    folder_path: str
+                    ) -> None:
+        pass
+
     def get_tree_dict(self) -> dict:
         """
         Docstring.
@@ -342,30 +350,17 @@ class PyTree:
             # getting current folder path/subfolders/files
             folder_path, subfolders, files = item
 
-            # getting path is root bool
-            path_is_root = (folder_path == self.start_path)
+            # getting skip folder bool
+            skip_folder = get_skip_bool(folder_path=folder_path,
+                                        start_path=self.start_path,
+                                        start_is_cache=self.start_is_cache,
+                                        cache_folders=self.cache_folders)
 
-            # checking if current path is root
-            if not path_is_root:
+            # checking whether to skip current folder
+            if skip_folder:
 
-                # getting folder is symlink bool
-                folder_is_symlink = islink(path=folder_path)
-
-                # checking if current folder is symlink
-                if folder_is_symlink:
-
-                    # skipping symlink folder
-                    continue
-
-                # getting folder is cache bool
-                folder_is_cache = is_cache(path=folder_path,
-                                           cache_folders=self.cache_folders)
-
-                # checking if current folder is cache
-                if folder_is_cache:
-
-                    # skipping cache folder
-                    continue
+                # skipping current folder
+                continue
 
             # updating progress tracker attributes
             self.progress_tracker.current_folder += 1
@@ -377,17 +372,8 @@ class PyTree:
             subfolders = sorted(subfolders)
             files = sorted(files)
 
-            # getting current folder split
-            folder_split = split(p=folder_path)
-
             # getting current folder name
-            folder_name = folder_split[-1]
-
-            # defining placeholder value for current folder size/count
-            # TODO: convert this to class attributes
-            #  (update this function to smaller functions, which update/reset these attributes)
-            folder_size = 0
-            items_count = 0
+            folder_name = get_path_name(path=folder_path)
 
             # getting current files num
             files_num = len(files)
@@ -397,9 +383,11 @@ class PyTree:
 
             # resetting progress tracker attributes
             self.progress_tracker.current_file = 0
+            self.current_folder_size = 0
+            self.current_items_count = 0
 
             # iterating over current files
-            for file in files:
+            for file_name in files:
 
                 # updating progress tracker attributes
                 self.progress_tracker.current_iteration += 1
@@ -412,7 +400,7 @@ class PyTree:
                 if self.extension is not None:
 
                     # getting file matches extension bool
-                    file_matches_extension = file.endswith(self.extension)
+                    file_matches_extension = file_name.endswith(self.extension)
 
                     # checking if current file matches extension
                     if not file_matches_extension:
@@ -430,7 +418,7 @@ class PyTree:
                 if self.keyword is not None:
 
                     # getting file matches keyword bool
-                    file_matches_keyword = (self.keyword in file)
+                    file_matches_keyword = (self.keyword in file_name)
 
                     # checking if current file matches keyword
                     if not file_matches_keyword:
@@ -446,10 +434,10 @@ class PyTree:
 
                 # getting current file path
                 file_path = join(folder_path,
-                                 file)
+                                 file_name)
 
                 # getting current file dict
-                file_dict = self.get_file_dict(file_name=file,
+                file_dict = self.get_file_dict(file_name=file_name,
                                                file_path=file_path)
 
                 # assembling path dict
@@ -465,7 +453,7 @@ class PyTree:
                     file_size = file_dict['size']
 
                     # updating folder size
-                    folder_size += file_size
+                    self.current_folder_size += file_size
 
                     # updating total size
                     self.total_size += file_size
@@ -474,38 +462,31 @@ class PyTree:
                 if self.include_counts:
 
                     # updating items count
-                    items_count += 1
+                    self.current_items_count += 1
 
             # iterating over current subfolders
-            for subfolder in subfolders:
+            for subfolder_name in subfolders:
 
                 # getting current subfolder path
                 subfolder_path = join(folder_path,
-                                      subfolder)
-
-                # getting subfolder is symlink bool
-                subfolder_is_symlink = islink(path=subfolder_path)
-
-                # checking if current subfolder is symlink
-                if subfolder_is_symlink:
-
-                    # skipping symlink subfolder
-                    continue
+                                      subfolder_name)
 
-                # getting subfolder is cache bool
-                subfolder_is_cache = is_cache(path=subfolder_path,
-                                              cache_folders=self.cache_folders)
+                # getting skip folder bool
+                skip_folder = get_skip_bool(folder_path=subfolder_path,
+                                            start_path=self.start_path,
+                                            start_is_cache=self.start_is_cache,
+                                            cache_folders=self.cache_folders)
 
-                # checking if current subfolder is cache
-                if subfolder_is_cache:
+                # checking whether to skip current folder
+                if skip_folder:
 
-                    # skipping cache subfolder
+                    # skipping current folder
                     continue
 
                 # getting current subfolder dict
                 subfolder_dict = self.tree_dict.get(subfolder_path)  # this will never be None due to topdown=False!
                                                                      # The subfolder will always have already been a
-                                                                     # folder in previous iteration!
+                                                                     # folder in a previous iteration!
 
                 # checking include sizes toggle
                 if self.include_sizes:
@@ -514,19 +495,17 @@ class PyTree:
                     subfolder_size = subfolder_dict['size']
 
                     # updating folder size
-                    folder_size += subfolder_size
+                    self.current_folder_size += subfolder_size
 
                 # checking include counts toggle
                 if self.include_counts:
 
                     # updating items count
-                    items_count += 1
+                    self.current_items_count += 1
 
             # getting current folder dict
             folder_dict = self.get_folder_dict(folder_name=folder_name,
-                                               folder_path=folder_path,
-                                               folder_size=folder_size,
-                                               items_count=items_count)
+                                               folder_path=folder_path)
 
             # assembling path dict
             path_dict = {folder_path: folder_dict}
@@ -535,7 +514,7 @@ class PyTree:
             self.tree_dict.update(path_dict)
 
         # reversing dict (required since topdown was set to False in os.walk to enable size obtaining optimization)
-        tree_dict = dict(reversed(self.tree_dict.items()))
+        tree_dict = reverse_dict(a_dict=self.tree_dict)
 
         # returning tree dict
         return tree_dict

pytree2-0.2.2/src/pytree/main_loc.py

@@ -0,0 +1,187 @@
+# pytree main loc module
+
+print('initializing...')  # noqa
+
+# Code destined to scanning python files lines of
+# code count in given input folder, and creating
+# tree structure to print on console.
+
+######################################################################
+# imports
+
+# importing required libraries
+print('importing required libraries...')  # noqa
+from argparse import ArgumentParser
+from pytree.classes.PyTree import PyTree
+from pytree.utils.aux_funcs import get_start_path
+from pytree.classes.PyTree import ModuleProgressTracker
+print('all required libraries successfully imported.')  # noqa
+
+#####################################################################
+# argument parsing related functions
+
+
+def get_args_dict() -> dict:
+    """
+    Parses the arguments and returns a dictionary of the arguments.
+    :return: Dictionary. Represents the parsed arguments.
+    """
+    # defining program description
+    description = "pytree - a python cli utility for visualizing folder trees with sizes and counts"
+
+    # creating a parser instance
+    parser = ArgumentParser(description=description)
+
+    # start path param
+    parser.add_argument('start_path',
+                        nargs='*',
+                        type=str or list,
+                        help='defines path to directory to start building the tree',
+                        default='.')
+
+    # dirs only param
+    parser.add_argument('-d', '--dirs-only',
+                        dest='dirs_only',
+                        required=False,
+                        action='store_true',
+                        help='tree displays directories only, and does not show files inside folders',
+                        default=False)
+
+    # show sizes param
+    parser.add_argument('-s', '--show-sizes',
+                        dest='show_sizes',
+                        required=False,
+                        action='store_true',
+                        help='tree displays files and folder sizes, in mega or gigabytes',
+                        default=False)
+
+    # show counts param
+    parser.add_argument('-c', '--show-counts',
+                        dest='show_counts',
+                        required=False,
+                        action='store_true',
+                        help='tree displays the number of files or folders inside each directory',
+                        default=False)
+
+    # extension param
+    parser.add_argument('-x', '--extension',
+                        dest='extension',
+                        required=False,
+                        type=str or None,
+                        help='tree will include only files that match given extension (e.g. ".txt", ".pdf")',
+                        default=None)
+
+    # keyword param
+    parser.add_argument('-k', '--keyword',
+                        dest='keyword',
+                        required=False,
+                        type=str or None,
+                        help='tree will include only files that contain specific keyword on file name',
+                        default=None)
+
+    # level param
+    parser.add_argument('-l', '--level',
+                        dest='level',
+                        required=False,
+                        type=int or None,
+                        help="defines tree's depth (until which subfolder tree will be created) [0=start_path, -1=all]",
+                        default=-1)
+
+    # creating arguments dictionary
+    args_dict = vars(parser.parse_args())
+
+    # returning the arguments dictionary
+    return args_dict
+
+######################################################################
+# defining auxiliary functions
+
+
+def pytree(start_path: str,
+           dirs_only: bool,
+           include_counts: bool,
+           include_sizes: bool,
+           extension: str,
+           keyword: str,
+           level: int,
+           progress_tracker: ModuleProgressTracker
+           ) -> None:
+    """
+    Prints folder structure tree
+    on the console.
+    """
+    # initializing PyTree object
+    tree = PyTree(start_path=start_path,
+                  dirs_only=dirs_only,
+                  include_counts=include_counts,
+                  include_sizes=include_sizes,
+                  extension=extension,
+                  keyword=keyword,
+                  level=level,
+                  progress_tracker=progress_tracker)
+
+    # running pytree main
+    tree.run()
+
+
+def parse_and_run(args_dict: dict,
+                  progress_tracker: ModuleProgressTracker
+                  ) -> None:
+    """
+    Extracts args from args_dict
+    and runs module function.
+    """
+    # getting start path
+    start_path = args_dict['start_path']
+    start_path = get_start_path(start_path)
+
+    # getting dirs only bool
+    dirs_only = args_dict['dirs_only']
+
+    # getting include counts bool
+    include_counts = args_dict['show_counts']
+
+    # getting include sizes bool
+    include_sizes = args_dict['show_sizes']
+
+    # getting extension
+    extension = args_dict['extension']
+
+    # getting keyword
+    keyword = args_dict['keyword']
+
+    # getting level
+    level = args_dict['level']
+
+    # running pytree function
+    pytree(start_path=start_path,
+           dirs_only=dirs_only,
+           include_counts=include_counts,
+           include_sizes=include_sizes,
+           extension=extension,
+           keyword=keyword,
+           level=level,
+           progress_tracker=progress_tracker)
+
+######################################################################
+# defining main function
+
+
+def main():
+    """Runs main code."""
+    # initializing current module progress tracker instance
+    progress_tracker = ModuleProgressTracker()
+
+    # running code in separate thread
+    progress_tracker.run(function=parse_and_run,
+                         args_parser=get_args_dict)
+
+######################################################################
+# running main function
+
+
+if __name__ == '__main__':
+    main()
+
+######################################################################
+# end of current module

{pytree2-0.2.1 → pytree2-0.2.2}/src/pytree/utils/aux_funcs.py

@@ -9,6 +9,7 @@
 # importing required libraries
 from sys import stdout
 from os.path import sep
+from os.path import islink
 from os.path import abspath
 from os import get_terminal_size
 from pytree.utils.global_vars import ONE_KB
@@ -134,6 +135,21 @@ def get_time_str(time_in_seconds: int) -> str:
     return time_string
 
 
+def get_path_name(path: str) -> str:
+    """
+    Given a full path, returns its
+    name (final split item).
+    """
+    # getting path split
+    path_split = get_path_split(path=path)
+
+    # getting path name
+    path_name = path_split[-1]
+
+    # returning path name
+    return path_name
+
+
 def is_cache(path: str,
              cache_folders: list
              ) -> bool:
@@ -173,6 +189,47 @@ def get_start_path(start_path: str or list) -> str:
     return start_path
 
 
+def get_skip_bool(folder_path: str,
+                  start_path: str,
+                  start_is_cache: bool,
+                  cache_folders: list
+                  ) -> bool:
+    """
+    Given a path to a folder, returns
+    True if folder should be skipped,
+    and False otherwise.
+    """
+    # defining placeholder value for skip conditions list
+    skip_conditions = []
+
+    # getting path is root bool
+    path_is_root = (folder_path == start_path)
+
+    # checking if current path is root
+    if not path_is_root:
+
+        # getting folder is symlink bool
+        folder_is_symlink = islink(path=folder_path)
+
+        # appending current condition to skip conditions list
+        skip_conditions.append(folder_is_symlink)
+
+        # checking if start path is cache
+        if not start_is_cache:
+
+            # getting folder is cache bool
+            folder_is_cache = is_cache(path=folder_path,
+                                       cache_folders=cache_folders)
+
+            # appending current condition to skip conditions list
+            skip_conditions.append(folder_is_cache)
+
+    # updating skip bool
+    skip_bool = any(skip_conditions)
+
+    # returning skip bool
+    return skip_bool
+
 def get_path_split(path: str) -> list:
     """
     Given a path, returns its split
@@ -249,5 +306,23 @@ def get_size_str(size_in_bytes: int) -> str:
     # returning size str
     return size_str
 
+
+def reverse_dict(a_dict: dict) -> dict:
+    """
+    Given a dictionary, returns
+    reversed dict.
+    """
+    # getting dict items
+    dict_items = a_dict.items()
+
+    # reversing items
+    reversed_items = reversed(dict_items)
+
+    # reassembling dict
+    reversed_dict = dict(reversed_items)
+
+    # returning reversed dict
+    return reversed_dict
+
 ######################################################################
 # end of current module

{pytree2-0.2.1 → pytree2-0.2.2}/src/pytree2.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytree2
-Version: 0.2.1
+Version: 0.2.2
 Summary: A Python CLI utility for visualizing folder trees with sizes and counts.
 Author-email: Angelo Luiz Angonezi <angeloangonezi2@gmail.com>
 License-Expression: MIT

{pytree2-0.2.1 → pytree2-0.2.2}/src/pytree2.egg-info/SOURCES.txt

@@ -3,6 +3,7 @@ README.md
 pyproject.toml
 src/pytree/__init__.py
 src/pytree/main.py
+src/pytree/main_loc.py
 src/pytree2.egg-info/PKG-INFO
 src/pytree2.egg-info/SOURCES.txt
 src/pytree2.egg-info/dependency_links.txt

{pytree2-0.2.1 → pytree2-0.2.2}/src/pytree2.egg-info/entry_points.txt

@@ -1,2 +1,3 @@
 [console_scripts]
 pytree = pytree.main:main
+pytree-loc = pytree.main:main_loc