pytree2 0.2.2__tar.gz → 0.2.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytree2
-Version: 0.2.2
+Version: 0.2.3
 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.2 → pytree2-0.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pytree2"
-version = "0.2.2"
+version = "0.2.3"
 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,7 +20,7 @@ Issues = "https://github.com/angelo-angonezi/pytree/issues"
 
 [project.scripts]
 pytree = "pytree.main:main"
-pytree-loc = "pytree.main:main_loc"
+pytree-loc = "pytree.main_loc:main"
 
 [tool.setuptools]
 package-dir = {"" = "src"}

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

@@ -9,19 +9,23 @@
 
 # importing required libraries
 from os import walk
+from sys import platform
 from treelib import Tree
 from os.path import join
 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 get_loc
 from pytree.utils.aux_funcs import is_cache
+from pytree.utils.aux_funcs import get_loc_str
 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_skip_file
 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.aux_funcs import get_skip_folder
 from pytree.utils.global_vars import CACHE_FOLDERS
 from pytree.classes.ProgressTracker import ProgressTracker
 
@@ -57,6 +61,7 @@ class ModuleProgressTracker(ProgressTracker):
 
         # end string
         self.end_string = ''
+        self.print_end_string = ''
 
     # overwriting class methods (using current module specific attributes)
 
@@ -123,10 +128,10 @@ class ModuleProgressTracker(ProgressTracker):
             folder_path, _, files = item
 
             # 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)
+            skip_folder = get_skip_folder(folder_path=folder_path,
+                                          start_path=start_path,
+                                          start_is_cache=start_is_cache,
+                                          cache_folders=CACHE_FOLDERS)
 
             # checking whether to skip current folder
             if skip_folder:
@@ -168,7 +173,7 @@ class ModuleProgressTracker(ProgressTracker):
 
         # printing end string
         print(self.end_string,
-              end='')
+              end=self.print_end_string)
 
 #####################################################################
 # PyTree definition
@@ -186,6 +191,7 @@ class PyTree:
                  extension: str or None,
                  keyword: str or None,
                  level: int,
+                 mode: str,
                  cache_folders: list = CACHE_FOLDERS,
                  progress_tracker: ModuleProgressTracker = ModuleProgressTracker
                  ) -> None:
@@ -201,9 +207,13 @@ class PyTree:
         self.extension = extension
         self.keyword = keyword
         self.level = level
+        self.mode = mode
         self.cache_folders = cache_folders
         self.progress_tracker = progress_tracker
 
+        # getting mode is loc bool
+        self.mode_is_loc = (self.mode == 'loc')
+
         # getting start is cache bool
         self.start_is_cache = is_cache(path=self.start_path,
                                        cache_folders=self.cache_folders)
@@ -221,10 +231,12 @@ class PyTree:
         self.total_folders = 0
         self.total_files = 0
         self.total_size = 0
+        self.total_loc = 0
 
         # defining placeholder values for current folder size/count
         self.current_folder_size = 0
         self.current_items_count = 0
+        self.current_folder_loc = 0
 
         # valid files
         self.valid_files = 0
@@ -293,6 +305,15 @@ class PyTree:
             # updating base dict
             base_dict['size'] = file_size
 
+        # checking mode
+        if self.mode_is_loc:
+
+            # getting lines of code
+            lines_of_code = get_loc(file_path=file_path)
+
+            # updating base dict
+            base_dict['loc'] = lines_of_code
+
         # returning base dict
         return base_dict
 
@@ -323,195 +344,229 @@ class PyTree:
             # updating base dict
             base_dict['count'] = self.current_items_count
 
+        # checking mode
+        if self.mode_is_loc:
+
+            # updating base dict
+            base_dict['loc'] = self.current_folder_loc
+
         # returning base dict
         return base_dict
 
     def scan_file(self,
+                  file_name: str,
                   file_path: str
                   ) -> None:
-        pass
-
-    def scan_folder(self,
-                    folder_path: str
-                    ) -> None:
-        pass
-
-    def get_tree_dict(self) -> dict:
         """
-        Docstring.
+        Given a file name/path updates tree
+        dict accordingly.
         """
-        # getting folders/subfolders/files in start path
-        folders_subfolders_files = walk(self.start_path,
-                                        topdown=False)
+        # getting current file dict
+        file_dict = self.get_file_dict(file_name=file_name,
+                                       file_path=file_path)
 
-        # iterating over folders/subfolders/files
-        for item in folders_subfolders_files:
+        # assembling path dict
+        path_dict = {file_path: file_dict}
 
-            # getting current folder path/subfolders/files
-            folder_path, subfolders, files = item
+        # updating tree dict
+        self.tree_dict.update(path_dict)
 
-            # 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 include sizes toggle
+        if self.include_sizes:
 
-            # checking whether to skip current folder
-            if skip_folder:
+            # getting file size
+            file_size = file_dict['size']
 
-                # skipping current folder
-                continue
+            # updating folder size
+            self.current_folder_size += file_size
 
-            # updating progress tracker attributes
-            self.progress_tracker.current_folder += 1
+            # updating total size
+            self.total_size += file_size
 
-            # updating totals
-            self.total_folders += 1
+        # checking include counts toggle
+        if self.include_counts:
 
-            # sorting subfolders/files alphabetically
-            subfolders = sorted(subfolders)
-            files = sorted(files)
+            # updating items count
+            self.current_items_count += 1
+            self.valid_files += 1
 
-            # getting current folder name
-            folder_name = get_path_name(path=folder_path)
+        # checking mode
+        if self.mode_is_loc:
 
-            # getting current files num
-            files_num = len(files)
+            # getting file loc
+            file_loc = file_dict['loc']
 
-            # updating progress tracker attributes
-            self.progress_tracker.files_num = files_num
+            # updating folder loc
+            self.current_folder_loc += file_loc
 
-            # resetting progress tracker attributes
-            self.progress_tracker.current_file = 0
-            self.current_folder_size = 0
-            self.current_items_count = 0
+            # updating total loc
+            self.total_loc += file_loc
 
-            # iterating over current files
-            for file_name in files:
+    def scan_subfolder(self,
+                       subfolder_path: str
+                       ) -> None:
+        """
+        Given a folder path and respective
+        subfolder/files lists, updates tree
+        dict accordingly.
+        """
+        # 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 a previous iteration!
 
-                # updating progress tracker attributes
-                self.progress_tracker.current_iteration += 1
-                self.progress_tracker.current_file += 1
+        # checking include sizes toggle
+        if self.include_sizes:
 
-                # updating totals
-                self.total_files += 1
+            # getting file size
+            subfolder_size = subfolder_dict['size']
 
-                # checking extension toggle
-                if self.extension is not None:
+            # updating folder size
+            self.current_folder_size += subfolder_size
 
-                    # getting file matches extension bool
-                    file_matches_extension = file_name.endswith(self.extension)
+        # checking include counts toggle
+        if self.include_counts:
 
-                    # checking if current file matches extension
-                    if not file_matches_extension:
+            # updating items count
+            self.current_items_count += 1
 
-                        # skipping file
-                        continue
+        # checking mode
+        if self.mode_is_loc:
 
-                    # checking include counts toggle
-                    if self.include_counts:
+            # getting file loc
+            subfolder_loc = subfolder_dict['loc']
 
-                        # updating valid files count
-                        self.valid_files += 1
+            # updating folder loc
+            self.current_folder_loc += subfolder_loc
 
-                # checking keyword toggle
-                if self.keyword is not None:
+    def scan_folder(self,
+                    folder_path: str,
+                    subfolders: list,
+                    files: list
+                    ) -> None:
+        """
+        Given a folder path and respective
+        subfolder/files lists, updates tree
+        dict accordingly.
+        """
+        # sorting subfolders/files alphabetically
+        subfolders = sorted(subfolders)
+        files = sorted(files)
 
-                    # getting file matches keyword bool
-                    file_matches_keyword = (self.keyword in file_name)
+        # getting current folder name
+        folder_name = get_path_name(path=folder_path)
 
-                    # checking if current file matches keyword
-                    if not file_matches_keyword:
+        # getting current files num
+        files_num = len(files)
 
-                        # skipping file
-                        continue
+        # updating progress tracker attributes
+        self.progress_tracker.files_num = files_num
 
-                    # checking include counts toggle
-                    if self.include_counts:
+        # resetting progress tracker attributes
+        self.progress_tracker.current_file = 0
+        self.current_folder_size = 0
+        self.current_items_count = 0
 
-                        # updating valid files count
-                        self.valid_files += 1
+        # iterating over current files
+        for file_name in files:
 
-                # getting current file path
-                file_path = join(folder_path,
-                                 file_name)
+            # updating progress tracker attributes
+            self.progress_tracker.current_iteration += 1
+            self.progress_tracker.current_file += 1
 
-                # getting current file dict
-                file_dict = self.get_file_dict(file_name=file_name,
-                                               file_path=file_path)
+            # updating totals
+            self.total_files += 1
 
-                # assembling path dict
-                path_dict = {file_path: file_dict}
+            # getting skip file bool
+            skip_file = get_skip_file(file_name=file_name,
+                                      extension=self.extension,
+                                      keyword=self.keyword)
 
-                # updating tree dict
-                self.tree_dict.update(path_dict)
+            # checking whether to skip current file
+            if skip_file:
 
-                # checking include sizes toggle
-                if self.include_sizes:
+                # skipping current file
+                continue
 
-                    # getting file size
-                    file_size = file_dict['size']
+            # getting current file path
+            file_path = join(folder_path,
+                             file_name)
 
-                    # updating folder size
-                    self.current_folder_size += file_size
+            # scanning current file
+            self.scan_file(file_name=file_name,
+                           file_path=file_path)
 
-                    # updating total size
-                    self.total_size += file_size
+        # iterating over current subfolders
+        for subfolder_name in subfolders:
 
-                # checking include counts toggle
-                if self.include_counts:
+            # getting current subfolder path
+            subfolder_path = join(folder_path,
+                                  subfolder_name)
 
-                    # updating items count
-                    self.current_items_count += 1
+            # getting skip folder bool
+            skip_folder = get_skip_folder(folder_path=subfolder_path,
+                                          start_path=self.start_path,
+                                          start_is_cache=self.start_is_cache,
+                                          cache_folders=self.cache_folders)
 
-            # iterating over current subfolders
-            for subfolder_name in subfolders:
+            # checking whether to skip current folder
+            if skip_folder:
 
-                # getting current subfolder path
-                subfolder_path = join(folder_path,
-                                      subfolder_name)
+                # skipping current folder
+                continue
 
-                # 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)
+            # scanning current subfolder
+            self.scan_subfolder(subfolder_path=subfolder_path)
 
-                # checking whether to skip current folder
-                if skip_folder:
+        # getting current folder dict
+        folder_dict = self.get_folder_dict(folder_name=folder_name,
+                                           folder_path=folder_path)
 
-                    # skipping current folder
-                    continue
+        # assembling path dict
+        path_dict = {folder_path: folder_dict}
 
-                # 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 a previous iteration!
+        # updating tree dict
+        self.tree_dict.update(path_dict)
 
-                # checking include sizes toggle
-                if self.include_sizes:
+    def get_tree_dict(self) -> dict:
+        """
+        Scans start path for subfolders/files
+        and returns dictionary of tree structure,
+        containing sizes/counts/loc info, according
+        to specified parameters.
+        """
+        # getting folders/subfolders/files in start path
+        folders_subfolders_files = walk(self.start_path,
+                                        topdown=False)
+
+        # iterating over folders/subfolders/files
+        for item in folders_subfolders_files:
 
-                    # getting file size
-                    subfolder_size = subfolder_dict['size']
+            # getting current folder path/subfolders/files
+            folder_path, subfolders, files = item
 
-                    # updating folder size
-                    self.current_folder_size += subfolder_size
+            # getting skip folder bool
+            skip_folder = get_skip_folder(folder_path=folder_path,
+                                          start_path=self.start_path,
+                                          start_is_cache=self.start_is_cache,
+                                          cache_folders=self.cache_folders)
 
-                # checking include counts toggle
-                if self.include_counts:
+            # checking whether to skip current folder
+            if skip_folder:
 
-                    # updating items count
-                    self.current_items_count += 1
+                # skipping current folder
+                continue
 
-            # getting current folder dict
-            folder_dict = self.get_folder_dict(folder_name=folder_name,
-                                               folder_path=folder_path)
+            # updating progress tracker attributes
+            self.progress_tracker.current_folder += 1
 
-            # assembling path dict
-            path_dict = {folder_path: folder_dict}
+            # updating totals
+            self.total_folders += 1
 
-            # updating tree dict
-            self.tree_dict.update(path_dict)
+            # scanning current folder
+            self.scan_folder(folder_path=folder_path,
+                             subfolders=subfolders,
+                             files=files)
 
         # reversing dict (required since topdown was set to False in os.walk to enable size obtaining optimization)
         tree_dict = reverse_dict(a_dict=self.tree_dict)
@@ -545,6 +600,18 @@ class PyTree:
             # updating file tag
             file_tag += f' ({size_str})'
 
+        # checking mode
+        if self.mode_is_loc:
+
+            # getting additional path dict info
+            file_loc = path_dict['loc']
+
+            # getting loc string
+            loc_str = get_loc_str(loc=file_loc)
+
+            # updating file tag
+            file_tag += f' {{{loc_str}}}'
+
         # returning file tag
         return file_tag
 
@@ -740,9 +807,38 @@ class PyTree:
             # updating end string
             end_string += f', {total_size_str}'
 
+        # checking mode
+        if self.mode_is_loc:
+
+            # getting total loc string
+            total_loc_str = get_loc_str(loc=self.total_loc)
+
+            # updating end string
+            end_string += f', {total_loc_str}'
+
         # updating progress tracker attributes
         self.progress_tracker.end_string = end_string
 
+    def update_print_end_string(self) -> None:
+        """
+        Updates end string with folder/files
+        description summary (counts/sizes).
+        """
+        # defining placeholder value for new print end string
+        print_end_string = ''
+
+        # getting os is linux bool
+        os_is_linux = (platform == 'linux')
+
+        # checking if os is linux
+        if os_is_linux:
+
+            # updating print end string
+            print_end_string = '\n'
+
+        # updating progress tracker attributes
+        self.progress_tracker.print_end_string = print_end_string
+
     def run(self):
         """
         Runs main PyTree methods to

{pytree2-0.2.2 → pytree2-0.2.3}/src/pytree/main.py

@@ -103,6 +103,7 @@ def pytree(start_path: str,
            extension: str,
            keyword: str,
            level: int,
+           mode: str,
            progress_tracker: ModuleProgressTracker
            ) -> None:
     """
@@ -117,6 +118,7 @@ def pytree(start_path: str,
                   extension=extension,
                   keyword=keyword,
                   level=level,
+                  mode=mode,
                   progress_tracker=progress_tracker)
 
     # running pytree main
@@ -152,6 +154,9 @@ def parse_and_run(args_dict: dict,
     # getting level
     level = args_dict['level']
 
+    # getting mode
+    mode = 'tree'
+
     # running pytree function
     pytree(start_path=start_path,
            dirs_only=dirs_only,
@@ -160,6 +165,7 @@ def parse_and_run(args_dict: dict,
            extension=extension,
            keyword=keyword,
            level=level,
+           mode=mode,
            progress_tracker=progress_tracker)
 
 ######################################################################

{pytree2-0.2.2 → pytree2-0.2.3}/src/pytree/main_loc.py

@@ -27,7 +27,7 @@ def get_args_dict() -> dict:
     :return: Dictionary. Represents the parsed arguments.
     """
     # defining program description
-    description = "pytree - a python cli utility for visualizing folder trees with sizes and counts"
+    description = "pytree-loc - a python cli utility for counting lines of code in python projects"
 
     # creating a parser instance
     parser = ArgumentParser(description=description)
@@ -63,14 +63,6 @@ def get_args_dict() -> dict:
                         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',
@@ -104,6 +96,7 @@ def pytree(start_path: str,
            extension: str,
            keyword: str,
            level: int,
+           mode: str,
            progress_tracker: ModuleProgressTracker
            ) -> None:
     """
@@ -118,6 +111,7 @@ def pytree(start_path: str,
                   extension=extension,
                   keyword=keyword,
                   level=level,
+                  mode=mode,
                   progress_tracker=progress_tracker)
 
     # running pytree main
@@ -145,7 +139,7 @@ def parse_and_run(args_dict: dict,
     include_sizes = args_dict['show_sizes']
 
     # getting extension
-    extension = args_dict['extension']
+    extension = '.py'
 
     # getting keyword
     keyword = args_dict['keyword']
@@ -153,6 +147,9 @@ def parse_and_run(args_dict: dict,
     # getting level
     level = args_dict['level']
 
+    # getting mode
+    mode = 'loc'
+
     # running pytree function
     pytree(start_path=start_path,
            dirs_only=dirs_only,
@@ -161,6 +158,7 @@ def parse_and_run(args_dict: dict,
            extension=extension,
            keyword=keyword,
            level=level,
+           mode=mode,
            progress_tracker=progress_tracker)
 
 ######################################################################

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

@@ -189,11 +189,11 @@ 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:
+def get_skip_folder(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,
@@ -224,12 +224,53 @@ def get_skip_bool(folder_path: str,
             # appending current condition to skip conditions list
             skip_conditions.append(folder_is_cache)
 
-    # updating skip bool
+    # getting skip bool
     skip_bool = any(skip_conditions)
 
     # returning skip bool
     return skip_bool
 
+
+def get_skip_file(file_name: str,
+                  extension: str or None,
+                  keyword: str or None
+                  ) -> bool:
+    """
+    Given a file name, returns True
+    if file should be skipped, and
+    False otherwise.
+    """
+    # defining placeholder value for skip conditions list
+    skip_conditions = []
+
+    # checking extension toggle
+    if extension is not None:
+
+        # getting file matches extension bool
+        file_matches_extension = file_name.endswith(extension)
+
+        # appending current condition to skip conditions list
+        skip_conditions.append(file_matches_extension)
+
+    # checking keyword toggle
+    if keyword is not None:
+
+        # getting file matches keyword bool
+        file_matches_keyword = (keyword in file_name)
+
+        # appending current condition to skip conditions list
+        skip_conditions.append(file_matches_keyword)
+
+    # reversing condition bools (skip should happen if they DON'T match)
+    skip_conditions = [(not condition) for condition in skip_conditions]
+
+    # getting 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
@@ -307,6 +348,97 @@ def get_size_str(size_in_bytes: int) -> str:
     return size_str
 
 
+def get_loc(file_path: str) -> int:
+    """
+    Given a path to a python file,
+    returns number of lines of code
+    (disconsidering comments and enters)
+    """
+    # defining placeholder value for lines of code (loc)
+    loc = 0
+
+    # defining bracket likes start/end
+    bracketlikes_start = ['"""', '(', '[', '{']
+    bracketlikes_end = ['"""', '(', '[', '{']
+
+    # defining read mode
+    read_mode = 'r'
+
+    # defining placeholder for skip next line bool
+    skip_next = False
+
+    # reading file
+    with open(file_path, read_mode) as open_file:
+
+        # getting file lines
+        lines = open_file.readlines()
+
+        # iterating over lines
+        for line in lines:
+
+            # checking skip next bool
+            if skip_next:
+
+                # skipping line
+                continue
+
+            # cleaning line
+            line = line.replace(' ', '')
+
+            # getting line is comment bool
+            line_is_comment = line.startswith('#')
+
+            # getting line is emtpy bool
+            line_is_empty = line.startswith('\n')
+
+            # getting line starts with bracket-like bool
+            startswith_bracketlike = any([line.startswith(bracketlike) for bracketlike in bracketlikes_start])
+            endswith_bracketlike = any([line.endswith(bracketlike) for bracketlike in bracketlikes_end])
+
+            # checking whether line starts with bracket-like
+            if startswith_bracketlike:
+
+                # updating skip next bool
+                skip_next = True
+
+            # checking whether line ends with bracket-like
+            if endswith_bracketlike:
+
+                # updating skip next bool
+                skip_next = False
+
+            # assembling skip conditions list
+            skip_conditions = [line_is_comment,
+                               line_is_empty]
+
+            # getting skip bool
+            skip_bool = any(skip_conditions)
+
+            # checking whether line should be skipped
+            if skip_bool:
+
+                # skipping current line
+                continue
+
+            # updating lines of code count
+            loc += 1
+
+    # returning lines of code count
+    return loc
+
+
+def get_loc_str(loc: int) -> str:
+    """
+    Given a file/folder lines of code
+    count, returns its formatted string.
+    """
+    # assembling loc string
+    loc_str = f'{loc} lines'
+
+    # returning loc string
+    return loc_str
+
+
 def reverse_dict(a_dict: dict) -> dict:
     """
     Given a dictionary, returns

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytree2
-Version: 0.2.2
+Version: 0.2.3
 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.2 → pytree2-0.2.3}/src/pytree2.egg-info/entry_points.txt

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