batchmp 1.4__tar.gz → 1.4.2__tar.gz

{batchmp-1.4 → batchmp-1.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: batchmp
-Version: 1.4
+Version: 1.4.2
 Summary: Command-line tools for batch media processing
 Home-page: https://github.com/akpw/batch-mp-tools
 Author: Arseniy Kuznetsov
@@ -29,6 +29,9 @@ Requires-Dist: mutagen>=1.27
 Requires-Dist: pygtrie>=2.3.2
 Requires-Dist: filetype>=1.0.7
 Requires-Dist: mediafile>=0.13.0
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-mock; extra == "test"
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier
@@ -38,6 +41,7 @@ Dynamic: home-page
 Dynamic: keywords
 Dynamic: license
 Dynamic: license-file
+Dynamic: provides-extra
 Dynamic: requires-dist
 Dynamic: summary
 
@@ -133,7 +137,10 @@ Or preview how files would look organized by date without moving them:
         |- 02/
           |- video.mp4
 ```
-
+For more detailed examples and advanced organize / virtual views functionality, see:
+- [Renamer Organize & Virtual Views](https://akpw.github.io/articles/2025/09/22/Print-and-Organize.html)
+- [BatchMP Tools Tutorial, Part II: renaming files with renamer](https://akpw.github.io/articles/2015/04/11/batchmp-tutorial-part-ii.html)
+- Other related posts in [Practical BatchMP](https://akpw.github.io//tags.html#BatchMP+Tools)
 
 
 [**Tagger**](https://github.com/akpw/batch-mp-tools#tagger) manages media metadata, such as tags and artwork. Setting those in selected media file over multiple nested directories now becomes a breeze, with just a few simple commands working uniformly over almost any practically imaginable audio / video media formats. While easy to use, Tagger supports advanced metadata manipulation such as regexp-based replace, expandable template processing, etc. For example, to set the title tag to respective file names followed by the values of track and tracktotal tags:
@@ -160,6 +167,11 @@ Or preview how files would look organized by date without moving them:
 ```
 The commands above show some of the available global options:  `-r` for recursion into nested folders and `-in` to select media files. In the example above just one file was selected (for the sake of output brevity), which also could be achived via using `-f` for the file source mode.
 
+For more practical examples, see: 
+ - [BatchMP Tools Tutorial Part III: setting tags and artwork with tagger](https://akpw.github.io/articles/2015/04/12/batchmp-tutorial-part-iii.html)
+ - Other related posts in [Practical BatchMP](https://akpw.github.io//tags.html#BatchMP+Tools)
+
+
 
 [**BMFP**](https://github.com/akpw/batch-mp-tools/blob/master/README.md#bmfp-requires-ffmpeg) is all about efficient media content processing, such as conversion between various formats, normalizing sound volume, segmenting / fragmenting media files, denoising audio, detaching individual audio / video streams, etc. As processing media files can typically be resource consuming, BMFP is designed to take advantage of multi-core processors. By default, it automatically breaks up jobs into individual tasks that are then run as separate processes on available CPU cores.
 **BMFP is built on top of [FFmpeg](http://ffmpeg.org/download.html), which needs to be installed and available in the command line**. BMFP can be thought of as a batch FFmpeg runner, intended to make common uses of FFmpeg easy while not restricting its full power.
@@ -207,7 +219,10 @@ To check on the result, lets's just use the [tagger's](https://github.com/akpw/b
 ```
 From a brief glance, all looks OK. BMFP used FFmpeg to do the actual conversion, while taking care of all other things like preserving tags / artwork, etc.
 
-I will follow up with more examples and common use-cases in future blogs.
+For more practical examples, see: 
+ - [BatchMP Tools Tutorial, splitting a long media file with bmfp](https://akpw.github.io/articles/2015/04/10/batchmp-tutorial-part-i.html)
+ - Other related posts in [Practical BatchMP](https://akpw.github.io//tags.html#BatchMP+Tools)
+
 
 
 ## Brief Description of CLI Commands (use -h to expand on details for individual commands)
@@ -395,10 +410,23 @@ Support via FFmpeg: 'AVI', 'FLV', 'MKV', 'MKA'
 
 
 ## Installing Development version
-- Clone the repo, then run: `$ python -m pip install .`
+- Clone the repo, create a virtual environment, and activate it: 
+  ```bash
+  $ python3 -m venv .venv
+  $ source .venv/bin/activate
+  ```
+- Install the project in editable mode:
+  ```bash
+  $ pip install -e .
+  ```
 
 ## Running Tests
 
+To run the test suite, first ensure you have installed the development dependencies:
+```bash
+$ pip install -e ".[test]"
+```
+
 **Using pytest (recommended):**
 ```bash
 $ pytest -v --tb=short                              # Run all tests with verbose output

{batchmp-1.4 → batchmp-1.4.2}/README.md

@@ -90,7 +90,10 @@ Or preview how files would look organized by date without moving them:
         |- 02/
           |- video.mp4
 ```
-
+For more detailed examples and advanced organize / virtual views functionality, see:
+- [Renamer Organize & Virtual Views](https://akpw.github.io/articles/2025/09/22/Print-and-Organize.html)
+- [BatchMP Tools Tutorial, Part II: renaming files with renamer](https://akpw.github.io/articles/2015/04/11/batchmp-tutorial-part-ii.html)
+- Other related posts in [Practical BatchMP](https://akpw.github.io//tags.html#BatchMP+Tools)
 
 
 [**Tagger**](https://github.com/akpw/batch-mp-tools#tagger) manages media metadata, such as tags and artwork. Setting those in selected media file over multiple nested directories now becomes a breeze, with just a few simple commands working uniformly over almost any practically imaginable audio / video media formats. While easy to use, Tagger supports advanced metadata manipulation such as regexp-based replace, expandable template processing, etc. For example, to set the title tag to respective file names followed by the values of track and tracktotal tags:
@@ -117,6 +120,11 @@ Or preview how files would look organized by date without moving them:
 ```
 The commands above show some of the available global options:  `-r` for recursion into nested folders and `-in` to select media files. In the example above just one file was selected (for the sake of output brevity), which also could be achived via using `-f` for the file source mode.
 
+For more practical examples, see: 
+ - [BatchMP Tools Tutorial Part III: setting tags and artwork with tagger](https://akpw.github.io/articles/2015/04/12/batchmp-tutorial-part-iii.html)
+ - Other related posts in [Practical BatchMP](https://akpw.github.io//tags.html#BatchMP+Tools)
+
+
 
 [**BMFP**](https://github.com/akpw/batch-mp-tools/blob/master/README.md#bmfp-requires-ffmpeg) is all about efficient media content processing, such as conversion between various formats, normalizing sound volume, segmenting / fragmenting media files, denoising audio, detaching individual audio / video streams, etc. As processing media files can typically be resource consuming, BMFP is designed to take advantage of multi-core processors. By default, it automatically breaks up jobs into individual tasks that are then run as separate processes on available CPU cores.
 **BMFP is built on top of [FFmpeg](http://ffmpeg.org/download.html), which needs to be installed and available in the command line**. BMFP can be thought of as a batch FFmpeg runner, intended to make common uses of FFmpeg easy while not restricting its full power.
@@ -164,7 +172,10 @@ To check on the result, lets's just use the [tagger's](https://github.com/akpw/b
 ```
 From a brief glance, all looks OK. BMFP used FFmpeg to do the actual conversion, while taking care of all other things like preserving tags / artwork, etc.
 
-I will follow up with more examples and common use-cases in future blogs.
+For more practical examples, see: 
+ - [BatchMP Tools Tutorial, splitting a long media file with bmfp](https://akpw.github.io/articles/2015/04/10/batchmp-tutorial-part-i.html)
+ - Other related posts in [Practical BatchMP](https://akpw.github.io//tags.html#BatchMP+Tools)
+
 
 
 ## Brief Description of CLI Commands (use -h to expand on details for individual commands)
@@ -352,10 +363,23 @@ Support via FFmpeg: 'AVI', 'FLV', 'MKV', 'MKA'
 
 
 ## Installing Development version
-- Clone the repo, then run: `$ python -m pip install .`
+- Clone the repo, create a virtual environment, and activate it: 
+  ```bash
+  $ python3 -m venv .venv
+  $ source .venv/bin/activate
+  ```
+- Install the project in editable mode:
+  ```bash
+  $ pip install -e .
+  ```
 
 ## Running Tests
 
+To run the test suite, first ensure you have installed the development dependencies:
+```bash
+$ pip install -e ".[test]"
+```
+
 **Using pytest (recommended):**
 ```bash
 $ pytest -v --tb=short                              # Run all tests with verbose output

{batchmp-1.4 → batchmp-1.4.2}/batchmp/cli/base/bmp_options.py

@@ -31,7 +31,7 @@
 
 import os, sys, string
 from argparse import ArgumentParser, HelpFormatter
-from distutils.util import strtobool
+from batchmp.commons.utils import strtobool
 from urllib.parse import urlparse
 from batchmp.commons.utils import MiscHelpers
 from batchmp.fstools.fsutils import FSH

{batchmp-1.4 → batchmp-1.4.2}/batchmp/commons/utils.py

@@ -61,6 +61,16 @@ def run_cmd(cmd, shell = False):
     return output
 
 
+def strtobool(val):
+    val = str(val).lower()
+    if val in ('y', 'yes', 't', 'true', 'on', '1'):
+        return 1
+    elif val in ('n', 'no', 'f', 'false', 'off', '0'):
+        return 0
+    else:
+        raise ValueError("invalid truth value %r" % (val,))
+
+
 class MiscHelpers:
     @staticmethod
     def int_num_digits(num):

{batchmp-1.4 → batchmp-1.4.2}/batchmp/fstools/dirtools.py

@@ -15,13 +15,14 @@
 import os, sys
 from collections import namedtuple
 from collections.abc import Iterable
-from distutils.util import strtobool
+from batchmp.commons.utils import strtobool
 import pygtrie
 from batchmp.fstools.walker import DWalker
 from batchmp.fstools.fsutils import FSH
 from batchmp.fstools.builders.fsentry import FSEntry, FSEntryType, FSEntryDefaults
 from batchmp.fstools.builders.fsprms import FSEntryParamsExt, FSEntryParamsOrganize
 from batchmp.commons.progressbar import progress_bar, CmdProgressBarRefreshRate
+from batchmp.fstools.virtual_organizer import VirtualOrganizer
 # from profilehooks import profile
 
 
@@ -238,7 +239,6 @@ class DHandler:
     def rename_entries(fs_entry_params,
                         num_entries = 0,
                         formatter = None, check_unique = True):
-
         """ Renames directory entries via applying formatter function supplied by the caller
         """
         if not formatter or num_entries <= 0:
@@ -283,7 +283,6 @@ class DHandler:
 
     @staticmethod
     def remove_entries(fs_entry_params, formatter = None):
-
         """ Removes entries with formatter function supplied by the caller
         """
         if not formatter:
@@ -321,76 +320,26 @@ class DHandler:
     def organize(fs_entry_params):
         """ Organizes files into subdirectories based on specified attributes
         """
-        # Build a trie of the target directory structure
-        dir_trie = pygtrie.StringTrie(separator=os.path.sep)
-        entries_to_process = list(DWalker.entries(fs_entry_params))
-        fcnt = 0
-        for entry in entries_to_process:
-            if entry.type == FSEntryType.FILE and hasattr(entry, 'target_path'):
-                fcnt += 1
-                target_dir = os.path.dirname(entry.target_path)
-                if not dir_trie.has_key(target_dir):
-                    dir_trie[target_dir] = []
-                dir_trie[target_dir].append(entry)
 
-        if fcnt == 0:
+        # Create and configure the virtual organizer
+        organizer = VirtualOrganizer(fs_entry_params)
+        
+        # Build the virtual structure
+        if not organizer.build_virtual_structure():
             print("Nothing to process")
             return
-
-        # Create a custom walker for the virtual tree preview
-        def virtual_walker(root_dir):
-            # Build hierarchical tree structure from trie
-            tree = {}
-            for target_path, files in dir_trie.items():
-                rel_path = os.path.relpath(target_path, root_dir)
-                if rel_path == '.': continue  # Skip files that stay in root
-                
-                # Build nested tree structure
-                parts = rel_path.split(os.path.sep)
-                node = tree
-                for part in parts:
-                    node = node.setdefault(part, {})
-                node['__files__'] = [f.basename for f in files]
-
-            # Recursive function to yield all levels of the tree
-            def walk_tree(current_path, subtree):
-                # Get directories and files at current level
-                subdirs = sorted([k for k in subtree.keys() if k != '__files__'])
-                files = sorted(subtree.get('__files__', []))
-                
-                # Yield current directory
-                yield current_path, subdirs, files
-                
-                # Recursively yield subdirectories
-                for subdir in subdirs:
-                    subdir_path = os.path.join(current_path, subdir)
-                    yield from walk_tree(subdir_path, subtree[subdir])
-            
-            # Start walking from root
-            yield from walk_tree(root_dir, tree)
+        
+        # Get components for organize preview
+        virtual_walker = organizer.organize_virtual_walker()
+        max_depth = organizer.max_directory_depth()
+        preview_params = organizer.organize_preview_params(max_depth)
+        entries_to_process = list(DWalker.entries(fs_entry_params))
+        fcnt = sum(1 for entry in entries_to_process if entry.type == FSEntryType.FILE and hasattr(entry, 'target_path'))
 
         # Visualize the changes
         if fs_entry_params.quiet:
             proceed = True
         else:
-            # Calculate required depth based on organization structure
-            max_depth = 0
-            for target_path in dir_trie.keys():
-                rel_path = os.path.relpath(target_path, fs_entry_params.src_dir)
-                if rel_path != '.':
-                    depth = len(rel_path.split(os.path.sep))
-                    max_depth = max(max_depth, depth)
-            
-            # Create preview parameters directly
-            preview_params = FSEntryParamsOrganize({
-                'all_files': True,
-                'all_dirs': True,
-                'end_level': max_depth
-            })
-            preview_params.src_dir = fs_entry_params.src_dir  # Explicitly set src_dir
-            # Override builder for preview
-            from batchmp.fstools.builders.fsb import FSEntryBuilderOrganize
-            preview_params.__dict__['fs_entry_builder'] = FSEntryBuilderOrganize()
             proceed, _, _ = DHandler.visualise_changes(preview_params, virtual_walker)
 
         if proceed and fcnt > 0:
@@ -417,133 +366,24 @@ class DHandler:
     def print_organized_view(fs_entry_params):
         """ Print hierarchical organized-like virtual view
         """
-        # Build a trie of the virtual directory structure
-        dir_trie = pygtrie.StringTrie(separator=os.path.sep)
-        entries_to_process = list(DWalker.entries(fs_entry_params))
-        fcnt = 0
-        
-        for entry in entries_to_process:
-            if entry.type == FSEntryType.FILE and hasattr(entry, 'target_path'):
-                fcnt += 1
-                target_dir = os.path.dirname(entry.target_path)
-                if not dir_trie.has_key(target_dir):
-                    dir_trie[target_dir] = []
-                dir_trie[target_dir].append(entry)
+
+        # Create and configure the virtual organizer
+        organizer = VirtualOrganizer(fs_entry_params)
         
-        if fcnt == 0:
+        # Build the virtual structure
+        if not organizer.build_virtual_structure():
             print("No files to organize view")
             return
         
-        # Create a custom walker for the virtual tree preview
-        def virtual_walker(root_dir):
-            # Build hierarchical tree structure from trie
-            tree = {}
-            for target_path, files in dir_trie.items():
-                rel_path = os.path.relpath(target_path, root_dir)
-                if rel_path == '.': 
-                    # Files that stay in root
-                    tree.setdefault('__files__', []).extend([f.basename for f in files])
-                    continue
-                
-                # Build nested tree structure
-                parts = rel_path.split(os.path.sep)
-                node = tree
-                for part in parts:
-                    node = node.setdefault(part, {})
-                node['__files__'] = [f.basename for f in files]
-            
-            # Recursive function to yield all levels of the tree
-            def walk_tree(current_path, subtree):
-                # Get directories and files at current level
-                subdirs = sorted([k for k in subtree.keys() if k != '__files__'])
-                files = sorted(subtree.get('__files__', []))
-                
-                # Yield current directory
-                yield current_path, subdirs, files
-                
-                # Recursively yield subdirectories
-                for subdir in subdirs:
-                    subdir_path = os.path.join(current_path, subdir)
-                    yield from walk_tree(subdir_path, subtree[subdir])
-            
-            # Start walking from root
-            yield from walk_tree(root_dir, tree)
-        
-        # Calculate required depth based on organization structure
-        max_depth = 0
-        for target_path in dir_trie.keys():
-            rel_path = os.path.relpath(target_path, fs_entry_params.src_dir)
-            if rel_path != '.':
-                depth = len(rel_path.split(os.path.sep))
-                max_depth = max(max_depth, depth)
-        
-        # Pre-calculate directory sizes by aggregating file sizes
-        dir_sizes = {}
-        if fs_entry_params.show_size:
-            for target_path, files in dir_trie.items():
-                total_size = 0
-                for file_entry in files:
-                    try:
-                        fsize = os.path.getsize(file_entry.realpath)
-                        total_size += fsize
-                    except (OSError, IOError):
-                        pass
-                dir_sizes[target_path] = total_size
-        
-        # Create a custom formatter that shows sizes for both files and virtual dirs
-        def size_aware_formatter(entry):
-            if fs_entry_params.show_size:
-                if entry.type == FSEntryType.FILE:
-                    # For files, show size from their real path (original file location)
-                    # Find the original file in our file mapping
-                    original_file = None
-                    for target_path, files in dir_trie.items():
-                        for file_entry in files:
-                            if file_entry.basename == entry.basename:
-                                original_file = file_entry
-                                break
-                        if original_file:
-                            break
-                    
-                    if original_file:
-                        try:
-                            fsize = os.path.getsize(original_file.realpath)
-                            size_str = FSH.fs_size(fsize)
-                            return f" {size_str} {entry.basename}"
-                        except (OSError, IOError):
-                            pass
-                            
-                elif entry.type == FSEntryType.DIR:
-                    # For virtual directories, show aggregated size of contained files
-                    # Find the corresponding target path for this virtual directory
-                    virtual_path = entry.realpath
-                    if virtual_path in dir_sizes:
-                        total_size = dir_sizes[virtual_path]
-                        if total_size > 0:
-                            size_str = FSH.fs_size(total_size)
-                            return f" {size_str} {entry.basename}"
-            
-            # For directories without size info or when size not requested, just return basename
-            return entry.basename
-        
-        # Create preview parameters
-        from batchmp.fstools.builders.fsprms import FSEntryParamsOrganize
-        from batchmp.fstools.builders.fsb import FSEntryBuilderOrganize
-        
-        preview_params = FSEntryParamsOrganize({
-            'all_files': True,
-            'all_dirs': True,
-            'end_level': max_depth,
-            'show_size': False  # We handle sizes with custom formatter
-        })
-        preview_params.src_dir = fs_entry_params.src_dir
-        
-        # Override builder for preview
-        preview_params.__dict__['fs_entry_builder'] = FSEntryBuilderOrganize()
+        # Get components for virtual view
+        virtual_walker = organizer.print_virtual_walker()
+        size_formatter = organizer.print_formatter_with_sizes()
+        max_depth = organizer.max_directory_depth()
+        preview_params = organizer.print_preview_params(max_depth)
         
         # Print the virtual view
         print(f"Virtual view by {fs_entry_params.by}:")
-        DHandler.print_dir(preview_params, virtual_walker, formatter=size_aware_formatter)
+        DHandler.print_dir(preview_params, virtual_walker, formatter=size_formatter)
 
 
 

batchmp-1.4.2/batchmp/fstools/virtual_organizer.py

@@ -0,0 +1,301 @@
+# coding=utf8
+## Copyright (c) 2014 Arseniy Kuznetsov
+##
+## This program is free software; you can redistribute it and/or
+## modify it under the terms of the GNU General Public License
+## as published by the Free Software Foundation; either version 2
+## of the License, or (at your option) any later version.
+##
+## This program is distributed in the hope that it will be useful,
+## but WITHOUT ANY WARRANTY; without even the implied warranty of
+## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+## GNU General Public License for more details.
+
+import os
+import pygtrie
+from collections import namedtuple
+from batchmp.fstools.walker import DWalker
+from batchmp.fstools.builders.fsentry import FSEntryType
+from batchmp.fstools.fsutils import FSH
+from batchmp.fstools.builders.fsprms import FSEntryParamsOrganize
+from batchmp.fstools.builders.fsb import FSEntryBuilderOrganize
+
+
+class VirtualOrganizer:
+    """ Helper class for creating virtual organized views without moving files.
+    """
+    
+    def __init__(self, fs_entry_params):
+        self.fs_entry_params = fs_entry_params
+        self.dir_trie = pygtrie.StringTrie(separator=os.path.sep)
+        self.dir_sizes = {}
+        
+    def build_virtual_structure(self):
+        """ Build the virtual directory structure from FSEntry data.
+        """
+        entries_to_process = list(DWalker.entries(self.fs_entry_params))
+        fcnt = 0
+        
+        for entry in entries_to_process:
+            if entry.type == FSEntryType.FILE and hasattr(entry, 'target_path'):
+                fcnt += 1
+                target_dir = os.path.dirname(entry.target_path)
+                if not self.dir_trie.has_key(target_dir):
+                    self.dir_trie[target_dir] = []
+                self.dir_trie[target_dir].append(entry)
+        
+        if fcnt == 0:
+            return False
+            
+        self._calculate_directory_sizes()
+        return True
+    
+    def max_directory_depth(self):
+        """ Calculate required depth based on organization structure.
+        """
+        max_depth = 0
+        for target_path in self.dir_trie.keys():
+            rel_path = os.path.relpath(target_path, self.fs_entry_params.src_dir)
+            if rel_path != '.':
+                depth = len(rel_path.split(os.path.sep))
+                max_depth = max(max_depth, depth)
+        return max_depth        
+
+    def organize_virtual_walker(self):
+        """ Create walker for organize method with simple alphabetical sorting.
+        """
+        root_dir = self.fs_entry_params.src_dir
+        
+        def virtual_walker(root_dir):
+            # Build hierarchical tree structure from trie
+            tree = {}
+            for target_path, files in self.dir_trie.items():
+                rel_path = os.path.relpath(target_path, root_dir)
+                if rel_path == '.': 
+                    continue  # Skip files that stay in root
+                
+                # Build nested tree structure
+                parts = rel_path.split(os.path.sep)
+                node = tree
+                for part in parts:
+                    node = node.setdefault(part, {})
+                node['__files__'] = [f.basename for f in files]
+            
+            # Recursive function to yield all levels of the tree
+            def walk_tree(current_path, subtree):
+                # Get directories and files at current level (sorted alphabetically)
+                subdirs = sorted([k for k in subtree.keys() if k != '__files__'])
+                files = sorted(subtree.get('__files__', []))
+                
+                # Yield current directory
+                yield current_path, subdirs, files
+                
+                # Recursively yield subdirectories
+                for subdir in subdirs:
+                    subdir_path = os.path.join(current_path, subdir)
+                    yield from walk_tree(subdir_path, subtree[subdir])
+            
+            # Start walking from root
+            yield from walk_tree(root_dir, tree)
+        
+        return virtual_walker
+    
+    def organize_preview_params(self, max_depth):
+        """ Create FSEntry parameters for organize preview with standard sorting.
+        """
+        preview_params = FSEntryParamsOrganize({
+            'all_files': True,
+            'all_dirs': True,
+            'end_level': max_depth
+        })
+        preview_params.src_dir = self.fs_entry_params.src_dir
+        # Override builder for preview
+        preview_params.__dict__['fs_entry_builder'] = FSEntryBuilderOrganize()
+        return preview_params        
+    
+    def print_virtual_walker(self):
+        """ Create walker for print_organized_view with full sorting support.
+        """
+        root_dir = self.fs_entry_params.src_dir
+        
+        def virtual_walker(root_dir):
+            # Build hierarchical tree structure from trie
+            tree = {}
+            for target_path, files in self.dir_trie.items():
+                rel_path = os.path.relpath(target_path, root_dir)
+                if rel_path == '.': 
+                    # Files that stay in root
+                    tree.setdefault('__files__', []).extend([f.basename for f in files])
+                    continue
+                
+                # Build nested tree structure
+                parts = rel_path.split(os.path.sep)
+                node = tree
+                for part in parts:
+                    node = node.setdefault(part, {})
+                node['__files__'] = [f.basename for f in files]
+            
+            # Recursive function to yield all levels of the tree
+            def walk_tree(current_path, subtree):
+                # Get directories and files at current level
+                subdirs = [k for k in subtree.keys() if k != '__files__']
+                files = subtree.get('__files__', [])
+                
+                # Apply custom sorting for size-based sorts (FSEntry can't handle virtual paths)
+                if self.fs_entry_params.by_size:
+                    subdirs = self._sort_entries_by_size(subdirs, is_dir=True)
+                    files = self._sort_entries_by_size(files, is_dir=False)
+                
+                # Yield current directory (use copies to prevent DWalker from modifying our sorted lists)
+                yield current_path, subdirs.copy(), files.copy()
+                
+                # Recursively yield subdirectories
+                for subdir in subdirs:
+                    subdir_path = os.path.join(current_path, subdir)
+                    yield from walk_tree(subdir_path, subtree[subdir])
+            
+            # Start walking from root
+            yield from walk_tree(root_dir, tree)
+        
+        return virtual_walker
+    
+    def print_formatter_with_sizes(self):
+        """ Create formatter for print_organized_view that shows sizes for both files and virtual dirs.
+        """
+        def size_aware_formatter(entry):
+            if self.fs_entry_params.show_size:
+                if entry.type == FSEntryType.FILE:
+                    # For files, show size from their real path (original file location)
+                    # Find the original file in our file mapping
+                    original_file = None
+                    for target_path, files in self.dir_trie.items():
+                        for file_entry in files:
+                            if file_entry.basename == entry.basename:
+                                original_file = file_entry
+                                break
+                        if original_file:
+                            break
+                    
+                    if original_file:
+                        try:
+                            fsize = os.path.getsize(original_file.realpath)
+                            size_str = FSH.fs_size(fsize)
+                            return f" {size_str} {entry.basename}"
+                        except (OSError, IOError):
+                            pass
+                            
+                elif entry.type == FSEntryType.DIR:
+                    # For virtual directories, show aggregated size of contained files
+                    # Find the corresponding target path for this virtual directory
+                    virtual_path = entry.realpath
+                    if virtual_path in self.dir_sizes:
+                        total_size = self.dir_sizes[virtual_path]
+                        if total_size > 0:
+                            size_str = FSH.fs_size(total_size)
+                            return f" {size_str} {entry.basename}"
+            
+            # For directories without size info or when size not requested, just return basename
+            return entry.basename
+        
+        return size_aware_formatter
+    
+    def print_preview_params(self, max_depth):
+        """ Create FSEntry parameters for print_organized_view with advanced sorting.
+        """
+        
+        # For size-based sorting, we need to completely bypass FSEntry sorting
+        # since it tries to access virtual file paths that don't exist
+        if self.fs_entry_params.by_size:
+            # Create a custom FSEntry class that bypasses sorting
+            class NoSortFSEntryParamsOrganize(FSEntryParamsOrganize):
+                class NoSortFilesDescriptor:
+                    def __set__(self, instance, value):
+                        # Just store the files without any sorting or filtering
+                        # The virtual walker already sorted them correctly
+                        instance._fnames = value
+                    def __get__(self, instance, owner):
+                        return getattr(instance, '_fnames', [])
+                
+                class NoSortDirsDescriptor:
+                    def __set__(self, instance, value):
+                        # Just store the dirs without any sorting or filtering
+                        # The virtual walker already sorted them correctly
+                        DNames = namedtuple('DNames', ['passed', 'enclosing'])
+                        instance._dnames = DNames(value, [])
+                    def __get__(self, instance, owner):
+                        DNames = namedtuple('DNames', ['passed', 'enclosing'])
+                        return getattr(instance, '_dnames', DNames([], []))
+                
+                # Override the descriptors to bypass sorting
+                fnames = NoSortFilesDescriptor()
+                dnames = NoSortDirsDescriptor()
+            
+            preview_params = NoSortFSEntryParamsOrganize({
+                'all_files': True,
+                'all_dirs': True,
+                'end_level': max_depth,
+                'show_size': False  # We handle sizes with custom formatter
+            })
+            preview_params.src_dir = self.fs_entry_params.src_dir
+            preview_params.sort = 'na'  # Won't be used due to custom descriptors
+        else:
+            # For name-based sorting, let FSEntry handle it normally
+            preview_params = FSEntryParamsOrganize({
+                'all_files': True,
+                'all_dirs': True,
+                'end_level': max_depth,
+                'show_size': False  # We handle sizes with custom formatter
+            })
+            preview_params.src_dir = self.fs_entry_params.src_dir
+            preview_params.sort = self.fs_entry_params.sort
+        
+        # Override builder for preview
+        preview_params.__dict__['fs_entry_builder'] = FSEntryBuilderOrganize()
+        return preview_params
+
+
+    ## Helpers
+    def _calculate_directory_sizes(self):
+        """ Pre-calculate directory sizes by aggregating file sizes.
+        """
+        if self.fs_entry_params.show_size:
+            for target_path, files in self.dir_trie.items():
+                total_size = 0
+                for file_entry in files:
+                    try:
+                        fsize = os.path.getsize(file_entry.realpath)
+                        total_size += fsize
+                    except (OSError, IOError):
+                        pass
+                self.dir_sizes[target_path] = total_size
+    
+    def _sort_entries_by_size(self, items, is_dir):
+        """ Sort items by size when FSEntry sorting would fail due to virtual paths.
+        """
+        if not items:
+            return items
+            
+        if is_dir:
+            # For directories, use aggregated sizes from dir_sizes
+            def size_key(dirname):
+                # Find the virtual directory path that corresponds to this dirname
+                for target_path in self.dir_sizes.keys():
+                    if target_path.endswith(os.sep + dirname) or target_path.endswith(dirname):
+                        return self.dir_sizes.get(target_path, 0)
+                return 0
+            sort_key = size_key
+        else:
+            # For files, look up original file size from dir_trie
+            def file_size_key(filename):
+                # Find the file entry in dir_trie to get its real path
+                for target_path, files in self.dir_trie.items():
+                    for file_entry in files:
+                        if file_entry.basename == filename:
+                            try:
+                                return os.path.getsize(file_entry.realpath)
+                            except (OSError, IOError):
+                                return 0
+                return 0
+            sort_key = file_size_key
+        
+        return sorted(items, key=sort_key, reverse=self.fs_entry_params.descending)

{batchmp-1.4 → batchmp-1.4.2}/batchmp.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: batchmp
-Version: 1.4
+Version: 1.4.2
 Summary: Command-line tools for batch media processing
 Home-page: https://github.com/akpw/batch-mp-tools
 Author: Arseniy Kuznetsov
@@ -29,6 +29,9 @@ Requires-Dist: mutagen>=1.27
 Requires-Dist: pygtrie>=2.3.2
 Requires-Dist: filetype>=1.0.7
 Requires-Dist: mediafile>=0.13.0
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-mock; extra == "test"
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier
@@ -38,6 +41,7 @@ Dynamic: home-page
 Dynamic: keywords
 Dynamic: license
 Dynamic: license-file
+Dynamic: provides-extra
 Dynamic: requires-dist
 Dynamic: summary
 
@@ -133,7 +137,10 @@ Or preview how files would look organized by date without moving them:
         |- 02/
           |- video.mp4
 ```
-
+For more detailed examples and advanced organize / virtual views functionality, see:
+- [Renamer Organize & Virtual Views](https://akpw.github.io/articles/2025/09/22/Print-and-Organize.html)
+- [BatchMP Tools Tutorial, Part II: renaming files with renamer](https://akpw.github.io/articles/2015/04/11/batchmp-tutorial-part-ii.html)
+- Other related posts in [Practical BatchMP](https://akpw.github.io//tags.html#BatchMP+Tools)
 
 
 [**Tagger**](https://github.com/akpw/batch-mp-tools#tagger) manages media metadata, such as tags and artwork. Setting those in selected media file over multiple nested directories now becomes a breeze, with just a few simple commands working uniformly over almost any practically imaginable audio / video media formats. While easy to use, Tagger supports advanced metadata manipulation such as regexp-based replace, expandable template processing, etc. For example, to set the title tag to respective file names followed by the values of track and tracktotal tags:
@@ -160,6 +167,11 @@ Or preview how files would look organized by date without moving them:
 ```
 The commands above show some of the available global options:  `-r` for recursion into nested folders and `-in` to select media files. In the example above just one file was selected (for the sake of output brevity), which also could be achived via using `-f` for the file source mode.
 
+For more practical examples, see: 
+ - [BatchMP Tools Tutorial Part III: setting tags and artwork with tagger](https://akpw.github.io/articles/2015/04/12/batchmp-tutorial-part-iii.html)
+ - Other related posts in [Practical BatchMP](https://akpw.github.io//tags.html#BatchMP+Tools)
+
+
 
 [**BMFP**](https://github.com/akpw/batch-mp-tools/blob/master/README.md#bmfp-requires-ffmpeg) is all about efficient media content processing, such as conversion between various formats, normalizing sound volume, segmenting / fragmenting media files, denoising audio, detaching individual audio / video streams, etc. As processing media files can typically be resource consuming, BMFP is designed to take advantage of multi-core processors. By default, it automatically breaks up jobs into individual tasks that are then run as separate processes on available CPU cores.
 **BMFP is built on top of [FFmpeg](http://ffmpeg.org/download.html), which needs to be installed and available in the command line**. BMFP can be thought of as a batch FFmpeg runner, intended to make common uses of FFmpeg easy while not restricting its full power.
@@ -207,7 +219,10 @@ To check on the result, lets's just use the [tagger's](https://github.com/akpw/b
 ```
 From a brief glance, all looks OK. BMFP used FFmpeg to do the actual conversion, while taking care of all other things like preserving tags / artwork, etc.
 
-I will follow up with more examples and common use-cases in future blogs.
+For more practical examples, see: 
+ - [BatchMP Tools Tutorial, splitting a long media file with bmfp](https://akpw.github.io/articles/2015/04/10/batchmp-tutorial-part-i.html)
+ - Other related posts in [Practical BatchMP](https://akpw.github.io//tags.html#BatchMP+Tools)
+
 
 
 ## Brief Description of CLI Commands (use -h to expand on details for individual commands)
@@ -395,10 +410,23 @@ Support via FFmpeg: 'AVI', 'FLV', 'MKV', 'MKA'
 
 
 ## Installing Development version
-- Clone the repo, then run: `$ python -m pip install .`
+- Clone the repo, create a virtual environment, and activate it: 
+  ```bash
+  $ python3 -m venv .venv
+  $ source .venv/bin/activate
+  ```
+- Install the project in editable mode:
+  ```bash
+  $ pip install -e .
+  ```
 
 ## Running Tests
 
+To run the test suite, first ensure you have installed the development dependencies:
+```bash
+$ pip install -e ".[test]"
+```
+
 **Using pytest (recommended):**
 ```bash
 $ pytest -v --tb=short                              # Run all tests with verbose output

{batchmp-1.4 → batchmp-1.4.2}/batchmp.egg-info/SOURCES.txt

@@ -1,5 +1,6 @@
 LICENSE
 README.md
+pyproject.toml
 setup.cfg
 setup.py
 batchmp/__init__.py
@@ -52,6 +53,7 @@ batchmp/fstools/__init__.py
 batchmp/fstools/dirtools.py
 batchmp/fstools/fsutils.py
 batchmp/fstools/rename.py
+batchmp/fstools/virtual_organizer.py
 batchmp/fstools/walker.py
 batchmp/fstools/builders/__init__.py
 batchmp/fstools/builders/fsb.py

{batchmp-1.4 → batchmp-1.4.2}/batchmp.egg-info/requires.txt

@@ -2,3 +2,7 @@ mutagen>=1.27
 pygtrie>=2.3.2
 filetype>=1.0.7
 mediafile>=0.13.0
+
+[test]
+pytest
+pytest-mock

batchmp-1.4.2/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"

{batchmp-1.4 → batchmp-1.4.2}/setup.py

@@ -20,7 +20,7 @@ with open(path.join(pkg_dir, 'README.md'), encoding='utf-8') as f:
 
 setup(
     name='batchmp',
-    version='1.4',
+    version='1.4.2',
 
     url='https://github.com/akpw/batch-mp-tools',
 
@@ -38,6 +38,13 @@ setup(
 
     install_requires = ['mutagen>=1.27', 'pygtrie>=2.3.2', 'filetype>=1.0.7', 'mediafile>=0.13.0'], ##, 'profilehooks>=1.11.0'],
 
+    extras_require={
+        'test': [
+            'pytest',
+            'pytest-mock',
+        ],
+    },
+
     entry_points={'console_scripts': [
         'batchmp = batchmp.cli.base.bmp_dispatch:main',
         'renamer = batchmp.cli.renamer.renamer_dispatch:main',