megadetector 5.0.29__py3-none-any.whl → 10.0.1__py3-none-any.whl

megadetector/utils/path_utils.py

@@ -24,7 +24,6 @@ import tarfile
 import webbrowser
 import subprocess
 import re
-import tempfile
 
 from zipfile import ZipFile
 from datetime import datetime
@@ -139,7 +138,7 @@ def folder_list(base_dir,
             the native path separator
         return_relative_paths (bool, optional): return paths that are relative to [base_dir],
             rather than absolute paths
-        sort_files (bool, optional): force folders to be sorted, otherwise uses the sorting
+        sort_folders (bool, optional): force folders to be sorted, otherwise uses the sorting
             provided by os.walk()
         recursive (bool, optional): enumerate recursively
 
@@ -315,7 +314,7 @@ def split_path(path):
         return ''
     if path is None:
         return None
-    
+
     parts = []
     while True:
         # ntpath seems to do the right thing for both Windows and Unix paths
@@ -351,6 +350,8 @@ def safe_create_link(link_exists,link_new):
     and if it has a different target than [link_exists], removes and re-creates
     it.
 
+    Creates a *real* directory if necessary.
+
     Errors if [link_new] already exists but it's not a link.
 
     Args:
@@ -358,14 +359,21 @@ def safe_create_link(link_exists,link_new):
         link_new (str): the target of the (possibly-new) symlink
     """
 
+    # If the new file already exists...
     if os.path.exists(link_new) or os.path.islink(link_new):
+        # Error if it's not already a link
         assert os.path.islink(link_new)
+        # If it's already a link, and it points to the "exists" file,
+        # leave it alone, otherwise redirect it.
         if not os.readlink(link_new) == link_exists:
             os.remove(link_new)
             os.symlink(link_exists,link_new)
     else:
+        os.makedirs(os.path.dirname(link_new),exist_ok=True)
         os.symlink(link_exists,link_new)
 
+ # ...def safe_create_link(...)
+
 
 def remove_empty_folders(path, remove_root=False):
     """
@@ -435,7 +443,7 @@ def path_join(*paths, convert_slashes=True):
     else:
         return joined_path
 
-    
+
 #%% Image-related path functions
 
 def is_image_file(s, img_extensions=IMG_EXTENSIONS):
@@ -642,8 +650,8 @@ def wsl_path_to_windows_path(filename, failure_behavior='none'):
 
     Args:
         filename (str): filename to convert
-        failure_behavior (str): what to do if the path can't be processed as a WSL path.
-            'none' to return None in this case, 'original' to return the original path.
+        failure_behavior (str, optional): what to do if the path can't be processed as a
+            WSL path. 'none' to return None in this case, 'original' to return the original path.
 
     Returns:
         str: Windows equivalent to the WSL path [filename]
@@ -690,7 +698,7 @@ def windows_path_to_wsl_path(filename, failure_behavior='none'):
 
     Args:
         filename (str): filename to convert
-        failure_behavior (str): what to do if the path can't be processed as a Windows path.
+        failure_behavior (str, optional): what to do if the path can't be processed as a Windows path.
             'none' to return None in this case, 'original' to return the original path.
 
     Returns:
@@ -841,7 +849,9 @@ def open_file_in_chrome(filename):
     return False
 
 
-def open_file(filename, attempt_to_open_in_wsl_host=False, browser_name=None):
+def open_file(filename,
+              attempt_to_open_in_wsl_host=False,
+              browser_name=None):
     """
     Opens [filename] in the default OS file handler for this file type.
 
@@ -855,9 +865,9 @@ def open_file(filename, attempt_to_open_in_wsl_host=False, browser_name=None):
 
     Args:
         filename (str): file to open
-        attempt_to_open_in_wsl_host: if this is True, and we're in WSL, attempts to open
-            [filename] in the Windows host environment
-        browser_name: see above
+        attempt_to_open_in_wsl_host (bool, optional): if this is True, and we're in WSL, attempts
+            to open [filename] in the Windows host environment
+        browser_name (str, optional): see above
     """
 
     if browser_name is not None:
@@ -1148,7 +1158,7 @@ def parallel_get_file_sizes(filenames,
 
 #%% Compression (zip/tar) functions
 
-def zip_file(input_fn, output_fn=None, overwrite=False, verbose=False, compresslevel=9):
+def zip_file(input_fn, output_fn=None, overwrite=False, verbose=False, compress_level=9):
     """
     Zips a single file.
 
@@ -1158,7 +1168,7 @@ def zip_file(input_fn, output_fn=None, overwrite=False, verbose=False, compressl
             [input_fn].zip
         overwrite (bool, optional): whether to overwrite an existing target file
         verbose (bool, optional): enable existing debug console output
-        compresslevel (int, optional): compression level to use, between 0 and 9
+        compress_level (int, optional): compression level to use, between 0 and 9
 
     Returns:
         str: the output zipfile, whether we created it or determined that it already exists
@@ -1174,10 +1184,12 @@ def zip_file(input_fn, output_fn=None, overwrite=False, verbose=False, compressl
         return output_fn
 
     if verbose:
-        print('Zipping {} to {} with level {}'.format(input_fn,output_fn,compresslevel))
+        print('Zipping {} to {} with level {}'.format(input_fn,output_fn,compress_level))
 
     with ZipFile(output_fn,'w',zipfile.ZIP_DEFLATED) as zipf:
-        zipf.write(input_fn,arcname=basename,compresslevel=compresslevel,
+        zipf.write(input_fn,
+                   arcname=basename,
+                   compresslevel=compress_level,
                    compress_type=zipfile.ZIP_DEFLATED)
 
     return output_fn
@@ -1223,8 +1235,12 @@ def add_files_to_single_tar_file(input_files, output_fn, arc_name_base,
     return output_fn
 
 
-def zip_files_into_single_zipfile(input_files, output_fn, arc_name_base,
-                                  overwrite=False, verbose=False, compresslevel=9):
+def zip_files_into_single_zipfile(input_files,
+                                  output_fn,
+                                  arc_name_base,
+                                  overwrite=False,
+                                  verbose=False,
+                                  compress_level=9):
     """
     Zip all the files in [input_files] into [output_fn].  Archive names are relative to
     arc_name_base.
@@ -1237,7 +1253,7 @@ def zip_files_into_single_zipfile(input_files, output_fn, arc_name_base,
             [arc_name_base]
         overwrite (bool, optional): whether to overwrite an existing .tar file
         verbose (bool, optional): enable additional debug console output
-        compresslevel (int, optional): compression level to use, between 0 and 9
+        compress_level (int, optional): compression level to use, between 0 and 9
 
     Returns:
         str: the output zipfile, whether we created it or determined that it already exists
@@ -1250,20 +1266,20 @@ def zip_files_into_single_zipfile(input_files, output_fn, arc_name_base,
 
     if verbose:
         print('Zipping {} files to {} (compression level {})'.format(
-            len(input_files),output_fn,compresslevel))
+            len(input_files),output_fn,compress_level))
 
     with ZipFile(output_fn,'w',zipfile.ZIP_DEFLATED) as zipf:
         for input_fn_abs in tqdm(input_files,disable=(not verbose)):
             input_fn_relative = os.path.relpath(input_fn_abs,arc_name_base)
             zipf.write(input_fn_abs,
                        arcname=input_fn_relative,
-                       compresslevel=compresslevel,
+                       compresslevel=compress_level,
                        compress_type=zipfile.ZIP_DEFLATED)
 
     return output_fn
 
 
-def zip_folder(input_folder, output_fn=None, overwrite=False, verbose=False, compresslevel=9):
+def zip_folder(input_folder, output_fn=None, overwrite=False, verbose=False, compress_level=9):
     """
     Recursively zip everything in [input_folder] into a single zipfile, storing files as paths
     relative to [input_folder].
@@ -1273,7 +1289,7 @@ def zip_folder(input_folder, output_fn=None, overwrite=False, verbose=False, com
         output_fn (str, optional): output filename; if this is None, we'll write to [input_folder].zip
         overwrite (bool, optional): whether to overwrite an existing .tar file
         verbose (bool, optional): enable additional debug console output
-        compresslevel (int, optional): compression level to use, between 0 and 9
+        compress_level (int, optional): compression level to use, between 0 and 9
 
     Returns:
         str: the output zipfile, whether we created it or determined that it already exists
@@ -1289,7 +1305,7 @@ def zip_folder(input_folder, output_fn=None, overwrite=False, verbose=False, com
 
     if verbose:
         print('Zipping {} to {} (compression level {})'.format(
-            input_folder,output_fn,compresslevel))
+            input_folder,output_fn,compress_level))
 
     relative_filenames = recursive_file_list(input_folder,return_relative_paths=True)
 
@@ -1298,7 +1314,7 @@ def zip_folder(input_folder, output_fn=None, overwrite=False, verbose=False, com
             input_fn_abs = os.path.join(input_folder,input_fn_relative)
             zipf.write(input_fn_abs,
                        arcname=input_fn_relative,
-                       compresslevel=compresslevel,
+                       compresslevel=compress_level,
                        compress_type=zipfile.ZIP_DEFLATED)
 
     return output_fn
@@ -1307,7 +1323,7 @@ def zip_folder(input_folder, output_fn=None, overwrite=False, verbose=False, com
 def parallel_zip_files(input_files,
                        max_workers=16,
                        use_threads=True,
-                       compresslevel=9,
+                       compress_level=9,
                        overwrite=False,
                        verbose=False):
     """
@@ -1315,11 +1331,11 @@ def parallel_zip_files(input_files,
     original files in place.  Each file is zipped to [filename].zip.
 
     Args:
-        input_file (str): list of files to zip
+        input_files (str): list of files to zip
         max_workers (int, optional): number of concurrent workers, set to <= 1 to disable parallelism
         use_threads (bool, optional): whether to use threads (True) or processes (False); ignored if
             max_workers <= 1
-        compresslevel (int, optional): zip compression level between 0 and 9
+        compress_level (int, optional): zip compression level between 0 and 9
         overwrite (bool, optional): whether to overwrite an existing .tar file
         verbose (bool, optional): enable additional debug console output
     """
@@ -1333,23 +1349,27 @@ def parallel_zip_files(input_files,
 
     with tqdm(total=len(input_files)) as pbar:
         for i,_ in enumerate(pool.imap_unordered(partial(zip_file,
-          output_fn=None,overwrite=overwrite,verbose=verbose,compresslevel=compresslevel),
+          output_fn=None,overwrite=overwrite,verbose=verbose,compress_level=compress_level),
           input_files)):
             pbar.update()
 
 
-def parallel_zip_folders(input_folders, max_workers=16, use_threads=True,
-                         compresslevel=9, overwrite=False, verbose=False):
+def parallel_zip_folders(input_folders,
+                         max_workers=16,
+                         use_threads=True,
+                         compress_level=9,
+                         overwrite=False,
+                         verbose=False):
     """
     Zips one or more folders to separate output files in parallel, leaving the
     original folders in place.  Each folder is zipped to [folder_name].zip.
 
     Args:
-        input_folder (list): list of folders to zip
+        input_folders (list): list of folders to zip
         max_workers (int, optional): number of concurrent workers, set to <= 1 to disable parallelism
         use_threads (bool, optional): whether to use threads (True) or processes (False); ignored if
             max_workers <= 1
-        compresslevel (int, optional): zip compression level between 0 and 9
+        compress_level (int, optional): zip compression level between 0 and 9
         overwrite (bool, optional): whether to overwrite an existing .tar file
         verbose (bool, optional): enable additional debug console output
     """
@@ -1364,13 +1384,19 @@ def parallel_zip_folders(input_folders, max_workers=16, use_threads=True,
     with tqdm(total=len(input_folders)) as pbar:
         for i,_ in enumerate(pool.imap_unordered(
                 partial(zip_folder,overwrite=overwrite,
-                        compresslevel=compresslevel,verbose=verbose),
+                        compress_level=compress_level,verbose=verbose),
                 input_folders)):
             pbar.update()
 
 
-def zip_each_file_in_folder(folder_name,recursive=False,max_workers=16,use_threads=True,
-                            compresslevel=9,overwrite=False,required_token=None,verbose=False,
+def zip_each_file_in_folder(folder_name,
+                            recursive=False,
+                            max_workers=16,
+                            use_threads=True,
+                            compress_level=9,
+                            overwrite=False,
+                            required_token=None,
+                            verbose=False,
                             exclude_zip=True):
     """
     Zips each file in [folder_name] to its own zipfile (filename.zip), optionally recursing.  To
@@ -1382,7 +1408,7 @@ def zip_each_file_in_folder(folder_name,recursive=False,max_workers=16,use_threa
         max_workers (int, optional): number of concurrent workers, set to <= 1 to disable parallelism
         use_threads (bool, optional): whether to use threads (True) or processes (False); ignored if
             max_workers <= 1
-        compresslevel (int, optional): zip compression level between 0 and 9
+        compress_level (int, optional): zip compression level between 0 and 9
         overwrite (bool, optional): whether to overwrite an existing .tar file
         required_token (str, optional): only zip files whose names contain this string
         verbose (bool, optional): enable additional debug console output
@@ -1400,7 +1426,7 @@ def zip_each_file_in_folder(folder_name,recursive=False,max_workers=16,use_threa
         input_files = [fn for fn in input_files if (not fn.endswith('.zip'))]
 
     parallel_zip_files(input_files=input_files,max_workers=max_workers,
-                       use_threads=use_threads,compresslevel=compresslevel,
+                       use_threads=use_threads,compress_level=compress_level,
                        overwrite=overwrite,verbose=verbose)
 
 
@@ -1435,6 +1461,8 @@ def compute_file_hash(file_path, algorithm='sha256', allow_failures=True):
     Args:
         file_path (str): the file to hash
         algorithm (str, optional): the hashing algorithm to use (e.g. md5, sha256)
+        allow_failures (bool, optional): if True, read failures will silently return
+            None; if false, read failures will raise exceptions
 
     Returns:
         str: the hash value for this file
@@ -1584,7 +1612,7 @@ class TestPathUtils:
         """
         Test the find_images function.
         """
-        
+
         # Create some dummy files
         img1_abs = os.path.join(self.test_dir, 'img1.jpg')
         img2_abs = os.path.join(self.test_dir, 'img2.PNG')
@@ -1609,7 +1637,7 @@ class TestPathUtils:
         expected_non_recursive_rel = sorted(['img1.jpg', 'img2.PNG'])
         found_non_recursive_rel = find_images(self.test_dir, recursive=False, return_relative_paths=True)
         assert sorted(found_non_recursive_rel) == expected_non_recursive_rel
-        
+
         # Test recursive
         expected_recursive_abs = sorted([
             img1_abs.replace('\\', '/'),
@@ -1632,7 +1660,7 @@ class TestPathUtils:
         empty_dir = os.path.join(self.test_dir, 'empty_dir')
         os.makedirs(empty_dir, exist_ok=True)
         assert find_images(empty_dir, recursive=True) == []
-        
+
         # Test with a directory that doesn't exist (should assert)
         try:
             find_images(os.path.join(self.test_dir, 'non_existent_dir'))
@@ -1656,7 +1684,7 @@ class TestPathUtils:
         #       file4.png
         #   subdir2/
         #     file5.doc
-        
+
         list_dir = os.path.join(self.test_dir,'recursive_list')
 
         f1 = os.path.join(list_dir, 'file1.txt')
@@ -1677,32 +1705,32 @@ class TestPathUtils:
 
         # Test recursive_file_list (recursive=True by default)
         expected_all_files_abs = sorted([
-            f1.replace('\\', '/'), f2.replace('\\', '/'), f3.replace('\\', '/'), 
+            f1.replace('\\', '/'), f2.replace('\\', '/'), f3.replace('\\', '/'),
             f4.replace('\\', '/'), f5.replace('\\', '/')
         ])
-        all_files_abs = recursive_file_list(list_dir, convert_slashes=True, 
+        all_files_abs = recursive_file_list(list_dir, convert_slashes=True,
                                             return_relative_paths=False)
         assert sorted(all_files_abs) == expected_all_files_abs
 
         # Test recursive_file_list with relative paths
         expected_all_files_rel = sorted([
-            'file1.txt', 'file2.jpg', 
+            'file1.txt', 'file2.jpg',
             os.path.join('subdir1', 'file3.txt').replace('\\', '/'),
             os.path.join('subdir1', 'subsubdir', 'file4.png').replace('\\', '/'),
             os.path.join('subdir2', 'file5.doc').replace('\\', '/')
         ])
-        all_files_rel = recursive_file_list(list_dir, convert_slashes=True, 
+        all_files_rel = recursive_file_list(list_dir, convert_slashes=True,
                                             return_relative_paths=True)
         assert sorted(all_files_rel) == expected_all_files_rel
 
         # Test file_list (non-recursive by default via wrapper)
         expected_top_level_files_abs = sorted([f1.replace('\\', '/'), f2.replace('\\', '/')])
-        top_level_files_abs = file_list(list_dir, convert_slashes=True, 
+        top_level_files_abs = file_list(list_dir, convert_slashes=True,
                                         return_relative_paths=False, recursive=False)
         assert sorted(top_level_files_abs) == expected_top_level_files_abs
-        
+
         # Test file_list (recursive explicitly) - should be same as recursive_file_list
-        recursive_via_file_list = file_list(list_dir, convert_slashes=True, 
+        recursive_via_file_list = file_list(list_dir, convert_slashes=True,
                                             return_relative_paths=False, recursive=True)
         assert sorted(recursive_via_file_list) == expected_all_files_abs
 
@@ -1757,33 +1785,33 @@ class TestPathUtils:
         expected_folders_non_recursive_abs = sorted([
             subdir1.replace('\\', '/'), subdir2.replace('\\', '/')
         ])
-        folders_non_recursive_abs = folder_list(folder_list_dir, recursive=False, 
+        folders_non_recursive_abs = folder_list(folder_list_dir, recursive=False,
                                                 return_relative_paths=False)
         assert sorted(folders_non_recursive_abs) == expected_folders_non_recursive_abs
 
         # Test non-recursive, relative paths
         expected_folders_non_recursive_rel = sorted(['subdir1', 'subdir2'])
-        folders_non_recursive_rel = folder_list(folder_list_dir, recursive=False, 
+        folders_non_recursive_rel = folder_list(folder_list_dir, recursive=False,
                                                 return_relative_paths=True)
         assert sorted(folders_non_recursive_rel) == expected_folders_non_recursive_rel
 
         # Test recursive
         expected_folders_recursive_abs = sorted([
-            subdir1.replace('\\', '/'), 
-            subsubdir1.replace('\\', '/'), 
+            subdir1.replace('\\', '/'),
+            subsubdir1.replace('\\', '/'),
             subdir2.replace('\\', '/')
         ])
-        folders_recursive_abs = folder_list(folder_list_dir, recursive=True, 
+        folders_recursive_abs = folder_list(folder_list_dir, recursive=True,
                                             return_relative_paths=False)
         assert sorted(folders_recursive_abs) == expected_folders_recursive_abs
 
         # Test recursive, relative paths
         expected_folders_recursive_rel = sorted([
-            'subdir1', 
-            os.path.join('subdir1', 'subsubdir1').replace('\\', '/'), 
+            'subdir1',
+            os.path.join('subdir1', 'subsubdir1').replace('\\', '/'),
             'subdir2'
         ])
-        folders_recursive_rel = folder_list(folder_list_dir, recursive=True, 
+        folders_recursive_rel = folder_list(folder_list_dir, recursive=True,
                                             return_relative_paths=True)
         assert sorted(folders_recursive_rel) == expected_folders_recursive_rel
 
@@ -1793,7 +1821,7 @@ class TestPathUtils:
         with open(os.path.join(empty_dir_for_folders, 'temp.txt'), 'w') as f: f.write('t')
         assert folder_list(empty_dir_for_folders, recursive=True) == []
         assert folder_list(empty_dir_for_folders, recursive=False) == []
-        
+
         # Test with a non-existent directory
         try:
             folder_list(os.path.join(self.test_dir, "non_existent_dir"))
@@ -1815,11 +1843,11 @@ class TestPathUtils:
         #     img2.png
         #     img3.png
 
-        fodler_summary_dir = os.path.join(self.test_dir,'folder_summary')
+        folder_summary_dir = os.path.join(self.test_dir,'folder_summary')
 
-        f1 = os.path.join(fodler_summary_dir, 'file1.txt')
-        img1 = os.path.join(fodler_summary_dir, 'img1.jpg')
-        subdir = os.path.join(fodler_summary_dir, 'subdir')
+        f1 = os.path.join(folder_summary_dir, 'file1.txt')
+        img1 = os.path.join(folder_summary_dir, 'img1.jpg')
+        subdir = os.path.join(folder_summary_dir, 'subdir')
         os.makedirs(subdir, exist_ok=True)
         f2 = os.path.join(subdir, 'file2.txt')
         img2 = os.path.join(subdir, 'img2.png')
@@ -1828,24 +1856,24 @@ class TestPathUtils:
         for filepath in [f1, img1, f2, img2, img3]:
             with open(filepath, 'w') as f:
                 f.write('test')
-        
-        summary = folder_summary(fodler_summary_dir, print_summary=False)
-        
+
+        summary = folder_summary(folder_summary_dir, print_summary=False)
+
         assert summary['n_files'] == 5
         assert summary['n_folders'] == 1 # 'subdir'
         assert summary['extension_to_count']['.txt'] == 2
         assert summary['extension_to_count']['.jpg'] == 1
         assert summary['extension_to_count']['.png'] == 2
-        
+
         # Check order (sorted by value, desc)
-		#
-        # The specific order of keys with the same counts can vary based on file system list 
-		# order.  We'll check that the counts are correct and the number of unique extensions is
-		# right.
+        #
+        # The specific order of keys with the same counts can vary based on file system list
+        # order.  We'll check that the counts are correct and the number of unique extensions is
+        # right.
         assert len(summary['extension_to_count']) == 3
 
 
-        empty_dir = os.path.join(fodler_summary_dir, "empty_summary_dir")
+        empty_dir = os.path.join(folder_summary_dir, "empty_summary_dir")
         os.makedirs(empty_dir, exist_ok=True)
         empty_summary = folder_summary(empty_dir, print_summary=False)
         assert empty_summary['n_files'] == 0
@@ -1879,10 +1907,10 @@ class TestPathUtils:
         assert insert_before_extension('path/to/file.ext', 'tag') == 'path/to/file.tag.ext'
         assert insert_before_extension('path/to/file', 'tag') == 'path/to/file.tag'
         assert insert_before_extension('file.tar.gz', 'new') == 'file.tar.new.gz'
-        
+
         # Test with custom separator
         assert insert_before_extension('file.ext', 'inserted', separator='_') == 'file_inserted.ext'
-        
+
         # Test with s=None (timestamp) - check format roughly
         fname_with_ts = insert_before_extension('file.ext', None)
         parts = fname_with_ts.split('.')
@@ -1912,10 +1940,10 @@ class TestPathUtils:
         else: # POSIX
             assert split_path('/dir/subdir/file.jpg') == ['/', 'dir', 'subdir', 'file.jpg']
             assert split_path('/') == ['/']
-        
+
         assert split_path('dir/file.txt') == ['dir', 'file.txt']
         assert split_path('file.txt') == ['file.txt']
-        assert split_path('') == '' 
+        assert split_path('') == ''
         assert split_path('.') == ['.']
         assert split_path('..') == ['..']
         assert split_path('../a/b') == ['..', 'a', 'b']
@@ -1971,7 +1999,7 @@ class TestPathUtils:
         safe_create_link(other_source_path, link_path) # Should remove and re-create
         assert os.path.islink(link_path)
         assert os.readlink(link_path) == other_source_path
-        
+
         # Link_new path exists and is a file (not a link)
         file_path_conflict = os.path.join(self.test_dir, 'conflict_file.txt')
         with open(file_path_conflict, 'w') as f:
@@ -1981,7 +2009,7 @@ class TestPathUtils:
             raise AssertionError("AssertionError not raised for file conflict")
         except AssertionError:
             pass
-        os.remove(file_path_conflict) 
+        os.remove(file_path_conflict)
 
         # Link_new path exists and is a directory
         dir_path_conflict = os.path.join(self.test_dir, 'conflict_dir')
@@ -2010,7 +2038,7 @@ class TestPathUtils:
         #       file.txt
         #   non_empty_top/
         #     file_in_top.txt
-        
+
         empty_top = os.path.join(self.test_dir, 'empty_top')
         empty_mid = os.path.join(empty_top, 'empty_mid')
         empty_leaf = os.path.join(empty_mid, 'empty_leaf')
@@ -2044,7 +2072,7 @@ class TestPathUtils:
         assert not os.path.exists(empty_leaf_in_mixed)
         assert os.path.exists(non_empty_mid)
         assert os.path.exists(os.path.join(non_empty_mid, 'file.txt'))
-        
+
         # Process non_empty_top; should remove nothing.
         remove_empty_folders(non_empty_top, remove_root=True)
         assert os.path.exists(non_empty_top)
@@ -2081,7 +2109,7 @@ class TestPathUtils:
         else:
             # On POSIX, os.path.join uses '/', so convert_slashes=False should still be '/'
             assert path_join('a', 'b', convert_slashes=False) == 'a/b'
-        
+
         assert path_join('a', '', 'b') == 'a/b' # os.path.join behavior
         assert path_join('/a', 'b') == '/a/b'
         assert path_join('a', '/b') == '/b' # '/b' is absolute
@@ -2107,7 +2135,7 @@ class TestPathUtils:
         assert clean_path("path\\to\\file.txt") == "path\\to\\file.txt" # backslashes allowed
         assert clean_path("path:to:file.txt") == "path:to:file.txt" # colons allowed
         assert clean_path("path/to<illegal>/file.txt") == "path/toillegal/file.txt"
-        
+
         # flatten_path
         assert flatten_path("path/to/file.txt") == "path~to~file.txt"
         assert flatten_path("path:to:file.txt", separator_char_replacement='_') == "path_to_file.txt"
@@ -2137,7 +2165,7 @@ class TestPathUtils:
         """
 
         test_list = ["item1", "item2 with space", "item3/with/slash"]
-        
+
         # Test with .json
         json_file_path = os.path.join(self.test_dir, "test_list.json")
         write_list_to_file(json_file_path, test_list)
@@ -2194,7 +2222,7 @@ class TestPathUtils:
             content = f"content of file {i}"
             with open(src_path, 'w') as f:
                 f.write(content)
-            
+
             file_mappings[src_path] = tgt_path
             source_files_content[tgt_path] = content
 
@@ -2204,11 +2232,11 @@ class TestPathUtils:
             assert os.path.exists(tgt_path)
             with open(tgt_path, 'r') as f:
                 assert f.read() == expected_content
-        
+
         existing_target_path = list(source_files_content.keys())[0]
         with open(existing_target_path, 'w') as f:
             f.write("old content")
-        
+
         parallel_copy_files(file_mappings, max_workers=1, use_threads=True, overwrite=False)
         with open(existing_target_path, 'r') as f:
             assert f.read() == "old content"
@@ -2248,7 +2276,7 @@ class TestPathUtils:
         content2 = "01234567890123456789" # 20 bytes
         with open(f2_path, 'w') as f:
             f.write(content2)
-        
+
         sizes_relative = get_file_sizes(file_sizes_test_dir)
         expected_sizes_relative = {
             'file1.txt': len(content1),
@@ -2264,14 +2292,19 @@ class TestPathUtils:
         }
         assert sizes_parallel_abs == expected_sizes_parallel_abs
 
-        sizes_parallel_folder_abs = parallel_get_file_sizes(file_sizes_test_dir, max_workers=1, return_relative_paths=False)
+        sizes_parallel_folder_abs = parallel_get_file_sizes(file_sizes_test_dir,
+                                                            max_workers=1,
+                                                            return_relative_paths=False)
         assert sizes_parallel_folder_abs == expected_sizes_parallel_abs
 
-        sizes_parallel_folder_rel = parallel_get_file_sizes(file_sizes_test_dir, max_workers=1, return_relative_paths=True)
+        sizes_parallel_folder_rel = parallel_get_file_sizes(file_sizes_test_dir,
+                                                            max_workers=1,
+                                                            return_relative_paths=True)
         assert sizes_parallel_folder_rel == expected_sizes_relative
 
         non_existent_file = os.path.join(file_sizes_test_dir, "no_such_file.txt")
-        sizes_with_error = parallel_get_file_sizes([f1_path, non_existent_file], max_workers=1)
+        sizes_with_error = parallel_get_file_sizes([f1_path, non_existent_file],
+                                                   max_workers=1)
         expected_with_error = {
             f1_path.replace('\\','/'): len(content1),
             non_existent_file.replace('\\','/'): None
@@ -2302,7 +2335,7 @@ class TestPathUtils:
         assert os.path.exists(unzipped_file_path_default)
         with open(unzipped_file_path_default, 'r') as f:
             assert f.read() == content
-        
+
         custom_zip_output_name = "custom_archive.zip"
         custom_zip_output_path = os.path.join(self.test_dir, custom_zip_output_name)
         zip_file(file_to_zip_path, output_fn=custom_zip_output_path, overwrite=True)
@@ -2329,7 +2362,7 @@ class TestPathUtils:
 
         folder_to_zip = os.path.join(self.test_dir, "folder_to_zip")
         os.makedirs(folder_to_zip, exist_ok=True)
-        
+
         file1_name = "file1.txt"; path1 = os.path.join(folder_to_zip, file1_name)
         file2_name = "file2.log"; path2 = os.path.join(folder_to_zip, file2_name)
         subdir_name = "sub"; subdir_path = os.path.join(folder_to_zip, subdir_name)
@@ -2355,7 +2388,7 @@ class TestPathUtils:
         with open(os.path.join(unzip_output_dir, file1_name), 'r')as f: assert f.read() == content1
         with open(os.path.join(unzip_output_dir, file2_name), 'r')as f: assert f.read() == content2
         with open(os.path.join(unzip_output_dir, subdir_name, file3_name), 'r')as f: assert f.read() == content3
-        
+
         mtime_before = os.path.getmtime(default_zip_path)
         zip_folder(folder_to_zip, output_fn=None, overwrite=False)
         mtime_after = os.path.getmtime(default_zip_path)
@@ -2388,7 +2421,7 @@ class TestPathUtils:
 
         expected_unzipped_file1 = os.path.join(unzip_dir, os.path.relpath(file1_path, self.test_dir))
         expected_unzipped_file2 = os.path.join(unzip_dir, os.path.relpath(file2_path, self.test_dir))
-        
+
         assert os.path.exists(expected_unzipped_file1)
         with open(expected_unzipped_file1, 'r') as f: assert f.read() == content1
         assert os.path.exists(expected_unzipped_file2)
@@ -2415,7 +2448,7 @@ class TestPathUtils:
         input_files = [file1_path, file2_path]
         output_tar_path = os.path.join(self.test_dir, "archive.tar.gz")
 
-        add_files_to_single_tar_file(input_files, output_tar_path, arc_name_base=self.test_dir, 
+        add_files_to_single_tar_file(input_files, output_tar_path, arc_name_base=self.test_dir,
                                      overwrite=True, mode='x:gz')
         assert os.path.exists(output_tar_path)
 
@@ -2442,7 +2475,7 @@ class TestPathUtils:
         file2_to_zip = os.path.join(self.test_dir, "pz_file2.txt")
         with open(file1_to_zip, 'w') as f: f.write("pz_content1")
         with open(file2_to_zip, 'w') as f: f.write("pz_content2")
-        
+
         parallel_zip_files([file1_to_zip, file2_to_zip], max_workers=1, overwrite=True)
         assert os.path.exists(file1_to_zip + ".zip")
         assert os.path.exists(file2_to_zip + ".zip")
@@ -2475,13 +2508,13 @@ class TestPathUtils:
 
         for p_path in [zef_file1, zef_file2_png, zef_file3_zip, zef_file_in_sub]:
             with open(p_path, 'w') as f: f.write(f"content of {os.path.basename(p_path)}")
-        
+
         zip_each_file_in_folder(zef_folder, recursive=False, max_workers=1, overwrite=True)
         assert os.path.exists(zef_file1 + ".zip")
         assert os.path.exists(zef_file2_png + ".zip")
-        assert not os.path.exists(zef_file3_zip + ".zip") 
-        assert not os.path.exists(zef_file_in_sub + ".zip") 
-        
+        assert not os.path.exists(zef_file3_zip + ".zip")
+        assert not os.path.exists(zef_file_in_sub + ".zip")
+
         if os.path.exists(zef_file1 + ".zip"): os.remove(zef_file1 + ".zip")
         if os.path.exists(zef_file2_png + ".zip"): os.remove(zef_file2_png + ".zip")
 
@@ -2498,13 +2531,13 @@ class TestPathUtils:
         assert os.path.exists(zef_file1 + ".zip")
         assert not os.path.exists(zef_file2_png + ".zip")
         assert not os.path.exists(zef_file_in_sub + ".zip")
-        
+
         if os.path.exists(zef_file1 + ".zip"): os.remove(zef_file1 + ".zip")
         dummy_to_zip = os.path.join(zef_folder,"dummy.txt")
         with open(dummy_to_zip,'w') as f: f.write('d')
         zip_each_file_in_folder(zef_folder, recursive=False, exclude_zip=False, max_workers=1, overwrite=True)
         assert os.path.exists(dummy_to_zip + ".zip")
-        assert os.path.exists(zef_file3_zip + ".zip") 
+        assert os.path.exists(zef_file3_zip + ".zip")
         if os.path.exists(dummy_to_zip + ".zip"): os.remove(dummy_to_zip + ".zip")
         if os.path.exists(zef_file3_zip + ".zip"): os.remove(zef_file3_zip + ".zip")
 
@@ -2520,12 +2553,12 @@ class TestPathUtils:
         with open(file1_path, 'w') as f:
             f.write(content1)
 
-        file2_name = "hash_me2.txt" 
+        file2_name = "hash_me2.txt"
         file2_path = os.path.join(self.test_dir, file2_name)
         with open(file2_path, 'w') as f:
-            f.write(content1) 
+            f.write(content1)
 
-        file3_name = "hash_me3.txt" 
+        file3_name = "hash_me3.txt"
         file3_path = os.path.join(self.test_dir, file3_name)
         content3 = "This is a different test string for hashing."
         with open(file3_path, 'w') as f:
@@ -2558,7 +2591,7 @@ class TestPathUtils:
 
         files_to_hash = [file1_path, file3_path, non_existent_path]
         hashes_parallel = parallel_compute_file_hashes(files_to_hash, max_workers=1)
-        
+
         norm_f1 = file1_path.replace('\\','/')
         norm_f3 = file3_path.replace('\\','/')
         norm_non = non_existent_path.replace('\\','/')
@@ -2623,6 +2656,3 @@ def test_path_utils():
         test_instance.test_compute_file_hash()
     finally:
         test_instance.tear_down()
-
-# from IPython import embed; embed()
-# test_path_utils()