batchmp 1.4__py3-none-any.whl

batchmp/cli/renamer/renamer_options.py

@@ -0,0 +1,355 @@
+#!/usr/bin/env python
+# 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.
+
+
+""" Batch renaming of files and directories
+      . supports source directory / source file modes
+      . visualises original / targeted folders structure before actual processing
+      . supports recursion to specified end_level
+      . supports flattening folders beyond specified end_level
+      . allows for include / exclude patterns (Unix style)
+      . allows global include/exclude of directories and folders
+      . display sorting:
+          .. by size/date, ascending/descending
+      . action commands:
+          .. print      Prints source directory
+          .. index      Adds index to files and directories names
+          .. add_date   Adds date to files and directories names
+          .. add_text   Adds text to files and directories names
+          .. remove     Removes n characters from files and directories names
+          .. replace    RegExp-based replace in files and directories names,
+                                        with support for expandable templates
+          .. capitalize Capitalizes words in files / directories names
+          .. flatten    Flatten all folders below target level, moving the files up
+                            at the target level. By default, deletes all empty flattened folders
+          .. delete     Delete selected files and directories
+
+    Usage: renamer [-h] [-d DIR] [-f FILE] [GLobal Options] {Commands}[Commands Options]
+      Input source mode:
+        [-d, --dir]                 Source directory (default is the current directory)
+        [-f, --file]                File to process
+
+      Recursion mode:
+        [-r, --recursive]           Recurse into nested folders
+        [-el, --end-level]          End level for recursion into nested folders
+
+      Filter files or folders:
+        [-in, --include]            Include: Unix-style name patterns separated by ';'
+        [-ex, --exclude]            Exclude: Unix-style name patterns separated by ';'
+                                      (excludes hidden files by default)
+        [-fd, --filter-dirs]        Enable  Include/Exclude patterns on directories
+        [-af, --all-files]          Disable Include/Exclude patterns on files
+                                      (shows hidden files excluded by default)
+      Miscellaneous:
+        [-s, --sort]{na|nd|sa|sd}   Sort order for files / folders (name | date, asc | desc)
+        [-ni, nested-indent]        Indent for printing nested directories
+        [-q, --quiet]               Do not visualise changes / show messages during processing
+
+      Commands:
+        {print, index, add_date, add_text, remove, replace, capitalize, flatten, delete, version, info}
+        $ renamer {command} -h  #run this for detailed help on individual commands
+"""
+import sys
+from batchmp.cli.base.bmp_options import BatchMPArgParser, BatchMPHelpFormatter, BatchMPBaseCommands
+
+
+class RenamerCommands(BatchMPBaseCommands):
+    INDEX = 'index'
+    ADD_DATE = 'add_date'
+    ADD_TEXT = 'add_text'
+    REMOVE = 'remove'
+    REPLACE = 'replace'
+    CAPITALIZE = 'capitalize'
+    FLATTEN = 'flatten'
+    DELETE = 'delete'
+    STATS = 'stats'
+    ORGANIZE = 'organize'
+
+    @classmethod
+    def commands_meta(cls):
+        return ''.join(('{',
+                        '{}, '.format(cls.PRINT),
+                        '{}, '.format(cls.INDEX),
+                        '{}, '.format(cls.ADD_DATE),
+                        '{}, '.format(cls.ADD_TEXT),
+                        '{}, '.format(cls.REMOVE),
+                        '{}, '.format(cls.REPLACE),
+                        '{}, '.format(cls.CAPITALIZE),
+                        '{}, '.format(cls.FLATTEN),
+                        '{}, '.format(cls.DELETE),
+                        '{}, '.format(cls.STATS),                        
+                        '{}, '.format(cls.INFO),
+                        '{}, '.format(cls.VERSION),
+                        '{}'  .format(cls.ORGANIZE),
+                        '}'))
+
+
+class RenameArgParser(BatchMPArgParser):
+    ''' Renamer commands parsing
+    '''
+    def __init__(self):
+        self._script_name = 'Renamer'
+        self._description = \
+        '''
+        Renamer is a multi-platform batch rename tool.
+        In addition to common rename operations such as
+        regexp-based replace, adding text / dates, etc.
+        it also supports multi-level indexing across
+        nested directories, flattening folders, and
+        cleaning up non-media files.
+
+        As default behavior, Renamer visualises targeted
+        changes and ask for confirmation before actually
+        changing anything.
+        '''
+    # Args Parsing
+    def parse_commands(self, parser):
+        ''' Renamer commands parsing
+        '''
+        # Commands
+        subparsers = parser.add_subparsers(dest = 'sub_cmd',
+                                                title = 'Renamer Commands',
+                                                        metavar = RenamerCommands.commands_meta())
+        self._add_version(subparsers)
+        self._add_info(subparsers)
+
+        def _add_include_mode_group(parser):
+            include_mode_group = parser.add_argument_group('Include for processing')
+            include_mode_group.add_argument("-id", "--include-dirs", dest = "include_dirs",
+                help = "Include directories for processing",
+                action = 'store_true')
+            include_mode_group.add_argument("-ef", "--exclude-files", dest = "exclude_files",
+                help = "Exclude files from processing",
+                action = 'store_true')
+
+        # Print
+        print_parser = subparsers.add_parser(RenamerCommands.PRINT,
+                                                description = 'Print source directory',
+                                                formatter_class = BatchMPHelpFormatter)
+        print_parser.add_argument('-sl', '--start-level', dest = 'start_level',
+                help = 'Initial nested level for printing (0, i.e. root source directory by default)',
+                type = int,
+                default = 0)
+        print_parser.add_argument('-ss', '--show-size', dest = 'show_size',
+                help ='Show files size',
+                action = 'store_true')
+        print_parser.add_argument('-b', '--by', dest = 'by',
+                help = 'Show organized virtual view by type or date',
+                type = str,
+                choices = ['type', 'date'])
+        print_parser.add_argument('-df', '--date-format', dest = 'date_format',
+                help = 'Date format for subdirectories when using -b date (e.g., %%Y/%%m)',
+                type = str,
+                default = '%Y-%m-%d')
+
+        # Stats
+        stats_parser = subparsers.add_parser(RenamerCommands.STATS,
+                                                description = 'Prints directory stats',
+                                                formatter_class = BatchMPHelpFormatter)
+        stats_parser.add_argument('-ss', '--show-size', dest = 'show_size',
+                help ='Show files size',
+                action = 'store_true')
+        
+
+        # Flatten
+        flatten_parser = subparsers.add_parser(RenamerCommands.FLATTEN,
+                description = 'Flatten all folders below target level, moving the files up the target level. \
+                                                  By default, all empty flattened folders will be deleted.',
+                formatter_class = BatchMPHelpFormatter)
+        flatten_parser.add_argument('-tl', '--target-level', dest = 'target_level',
+                help = 'Target level below which all folders will be flattened',
+                type = int,
+                required = True)
+        flatten_parser.add_argument('-df', '--discard-flattened', dest = 'discard_flattened',
+                help = "What to do with flattened directories: \
+                              'de' (default) will remove flattened directories if they are empty \
+                              'le' will leave flattened directories (empty or not) \
+                              'da' will discard flattened directories even if they are not empty",
+                type=str,
+                choices = ['de', 'le', 'da'],
+                default = 'de')
+        self._add_arg_display_curent_state_mode(flatten_parser)
+
+        # Add index
+        add_index_parser = subparsers.add_parser(RenamerCommands.INDEX,
+                                                 description = 'Adds index to files and directories names',
+                                                formatter_class = BatchMPHelpFormatter)
+        add_index_parser.add_argument('-sf', '--start-from', dest = 'start_from',
+                help = 'A number from which the indexing starts (1 by default)',
+                type = int,
+                default = 1)
+
+        add_index_type_group = add_index_parser.add_mutually_exclusive_group()
+        add_index_type_group.add_argument('-sq', '--sequential', dest = 'sequential',
+                help = 'Index selected files sequentially across selected directores. ' \
+                       'If omitted, the files will instead be indexed within their respective directories (multi-level indexing)',
+                action = 'store_true')
+        add_index_type_group.add_argument('-bd', '--by-directory', dest = 'by_directory',
+                help = 'Index selected files via adding their respective directory counter. ' \
+                       'If omitted, the files will instead be indexed within their respective directories (multi-level indexing)',
+                action = 'store_true')
+        add_index_parser.add_argument('-as', '--as-suffix', dest = 'as_suffix',
+                help = 'Add index at the end of file names',
+                action = 'store_true')
+        add_index_parser.add_argument('-js', '--join-string', dest = 'join_str',
+                help = "Join string for appending indices (' ' by default)",
+                type = str,
+                default = ' ')
+        add_index_parser.add_argument('-md', '--min-digits', dest = 'min_digits',
+                help = 'Minimal number of digits for indexing (2 by default, and adding leading zeros as needed)',
+                type = int,
+                default = 2)
+        _add_include_mode_group(add_index_parser)
+        self._add_arg_display_curent_state_mode(add_index_parser)
+
+        # Add Date
+        add_date_parser = subparsers.add_parser(RenamerCommands.ADD_DATE,
+                                                description = 'Adds date to files and directories names',
+                                                formatter_class = BatchMPHelpFormatter)
+        add_date_parser.add_argument('-ap', '--as-prefix', dest = 'as_prefix',
+                help = 'Add date as a prefix to file names',
+                action = 'store_true')
+        add_date_parser.add_argument('-js', '--join-string', dest = 'join_str',
+                help = "Join string for appending dates ('_' by default)",
+                type = str,
+                default = '_')
+        add_date_parser.add_argument('-fm', '--format', dest = 'format',
+                help = 'Date format',
+                type = str,
+                default = '%Y-%m-%d')
+        _add_include_mode_group(add_date_parser)
+        self._add_arg_display_curent_state_mode(add_date_parser)
+
+        # Add Text
+        add_text_parser = subparsers.add_parser(RenamerCommands.ADD_TEXT,
+                                                description = 'Adds text to files and directories names',
+                                                formatter_class = BatchMPHelpFormatter)
+        add_text_parser.add_argument('-ap', '--asprefix', dest = 'as_prefix',
+                help = 'Add text as a prefix to file names',
+                action = 'store_true')
+        add_text_parser.add_argument('-js', '--join-string', dest = 'join_str',
+                help = "Join string for appending text ('_' by default)",
+                type = str,
+                default = '_')
+        add_text_parser.add_argument('-tx', '--text', dest = 'text',
+                help = 'Text to add',
+                type = str,
+                required = True)
+        _add_include_mode_group(add_text_parser)
+        self._add_arg_display_curent_state_mode(add_text_parser)
+
+        # Remove chars
+        remove_chars_parser = subparsers.add_parser(RenamerCommands.REMOVE,
+                                            description = 'Removes n characters from files and directories names',
+                                            formatter_class = BatchMPHelpFormatter)
+        remove_chars_parser.add_argument('-nc', '--num-chars', dest = 'num_chars',
+                help = "Number of characters to remove",
+                type = int,
+                required = True)
+        remove_chars_parser.add_argument('-ft', '--from-tail', dest = 'from_tail',
+                help = 'Removes text from tail',
+                action = 'store_true')
+        _add_include_mode_group(remove_chars_parser)
+        self._add_arg_display_curent_state_mode(remove_chars_parser)
+
+        # Replace
+        replace_parser = subparsers.add_parser(RenamerCommands.REPLACE,
+                                            description = 'RegExp-based replace in files and directories names. ' \
+                                                   'Supports expandable templates, such as ' \
+                                                   '$dirname, $pardirname, $atime, $ctime, etc. ' \
+                                                   'For media files, also support tag-based templates such as ' \
+                                                   '$title, $album, $artist, $albumartist, $genre, $year, $track, etc.',
+                                            formatter_class = BatchMPHelpFormatter)
+        replace_parser.add_argument('-fs', '--find-string', dest = 'find_str',
+                help = "Find pattern to look for",
+                type = str,
+                required=True)
+        replace_parser.add_argument('-rs', '--replace-string', dest = 'replace_str',
+                help = 'Replace pattern to replace with.\
+                        If not specified and there is a match from the find pattern, \
+                        the entire string will be replaced with that match. ' \
+                        'Supports the following expandable templates: ' \
+                                                   '$dirname, $pardirname, $adtime, $cdtime, $mdtime, ' \
+                                                   '$atime, $ctime, $mtime, $adate, $cdate, $mdate. ' \
+                                                   'For media files, also support tag-based templates such as ' \
+                                                   '$title, $album, $artist, $albumartist, $genre, $year, $track, etc.',
+                        type = str)
+        replace_parser.add_argument('-ic', '--ignore-case', dest = 'ignore_case',
+                help = 'Case insensitive',
+                action = 'store_true')
+        replace_parser.add_argument('-ie', '--include-extension', dest = 'include_extension',
+                help = 'Include file extension',
+                action = 'store_true')
+        _add_include_mode_group(replace_parser)
+        self._add_arg_display_curent_state_mode(replace_parser)
+
+        # Capitalize
+        capitalize_parser = subparsers.add_parser(RenamerCommands.CAPITALIZE,
+                                                description = 'Capitalizes words in files / directories names',
+                                                formatter_class = BatchMPHelpFormatter)
+        _add_include_mode_group(capitalize_parser)
+        self._add_arg_display_curent_state_mode(capitalize_parser)
+
+        # Delete
+        delete_parser = subparsers.add_parser(RenamerCommands.DELETE,
+                                            description = 'Delete selected files and directories',
+                                            formatter_class = BatchMPHelpFormatter)
+        _add_include_mode_group(delete_parser)
+        self._add_arg_display_curent_state_mode(delete_parser)
+
+
+        # Organize
+        organize_parser = subparsers.add_parser(RenamerCommands.ORGANIZE,
+                                            description='Organize selected files into directories by specified attributes',
+                                            formatter_class=BatchMPHelpFormatter)
+        organize_parser.add_argument('-b', '--by', dest='by',
+                                     help='Organization strategy: by type or by date',
+                                     type=str,
+                                     choices=['type', 'date'],
+                                     required=True)
+        organize_parser.add_argument('-df', '--date-format', dest='date_format',
+                                     help='Date format for subdirectories (e.g., %%Y/%%m)',
+                                     type=str,
+                                     default='%Y-%m-%d')
+        organize_parser.add_argument('-td', '--target-dir', dest='target_dir',
+                                     help='Target directory to organize files into',
+                                     type=str)
+        _add_include_mode_group(organize_parser)
+        self._add_arg_display_curent_state_mode(organize_parser)
+
+
+
+    # Args Checking
+    def default_command(self, args, parser):
+        args['sub_cmd'] = RenamerCommands.PRINT
+        args['start_level'] = 0
+        args['show_size'] = False
+
+    def check_args(self, args, parser):
+        ''' Validation of supplied Renamer CLI arguments
+        '''
+        super().check_args(args, parser)
+
+        if args['sub_cmd'] == RenamerCommands.FLATTEN:
+            if args['file']:
+                parser.error('This operation requires a source directory')
+            if args['end_level'] <= args['target_level']:
+                #print ('Target Level should be greater than or equal to the End Level Global Option\n'
+                #           '... Adjusting End Level to: {}'.format(args['target_level']))
+                args['end_level'] = args['target_level']
+
+
+
+
+

batchmp/cli/tagger/tagger_dispatch.py

@@ -0,0 +1,143 @@
+#!/usr/bin/env python
+# 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.
+
+from batchmp.cli.base.bmp_dispatch import BatchMPDispatcher
+from batchmp.cli.tagger.tagger_options import TaggerArgParser, TaggerCommands
+from batchmp.commons.utils import ImageLoader
+from batchmp.tags.processors.basetp import BaseTagProcessor
+from batchmp.tags.handlers.tagsholder import TagHolder
+from batchmp.tags.output.formatters import OutputFormatType
+from batchmp.fstools.builders.fsprms import FSEntryParamsExt
+
+class TagsDispatcher(BatchMPDispatcher):
+    ''' Tagger CLI Commands Dispatcher
+    '''
+    def __init__(self):
+        self.option_parser = TaggerArgParser()
+
+    # Dispatcher
+    def dispatch(self):
+        ''' Dispatches Tagger commands
+        '''
+        if not super().dispatch():
+            args = self.option_parser.parse_options()
+            if args['sub_cmd'] == TaggerCommands.PRINT:
+                self.print_dir(args)
+
+            elif args['sub_cmd'] == TaggerCommands.SET:
+                self.set_tags(args)
+
+            elif args['sub_cmd'] == TaggerCommands.COPY:
+                self.copy_tags(args)
+
+            elif args['sub_cmd'] == TaggerCommands.INDEX:
+                self.index(args)
+
+            elif args['sub_cmd'] == TaggerCommands.REMOVE:
+                self.remove_tags(args)
+
+            elif args['sub_cmd'] == TaggerCommands.REPLACE:
+                self.replace_tags(args)
+
+            elif args['sub_cmd'] == TaggerCommands.CAPITALIZE:
+                self.capitalize_tags(args)
+
+            elif args['sub_cmd'] == TaggerCommands.DETAUCH:
+                self.detauch_art(args)
+
+            else:
+                print('Nothing to dispatch')
+                return False
+
+        return True
+
+    # Dispatched Methods
+    def print_dir(self, args):
+        fs_entry_params = FSEntryParamsExt(args)
+        BaseTagProcessor().print_dir(fs_entry_params, 
+                show_stats = args['show_stats'],
+                format = OutputFormatType.FULL if args['full_format'] else OutputFormatType.COMPACT)
+
+    def set_tags(self, args):
+        tag_holder = TagHolder(process_templates = False)
+        tag_holder.title = args['title']
+        tag_holder.album = args['album']
+        tag_holder.artist = args['artist']
+        tag_holder.albumartist = args['albumartist']
+        tag_holder.genre = args['genre']
+        tag_holder.composer = args['composer']
+        tag_holder.track = args['track']
+        tag_holder.tracktotal = args['tracktotal']
+        tag_holder.disc = args['disc']
+        tag_holder.disctotal = args['disctotal']
+        tag_holder.year = args['year']
+        tag_holder.encoder = args['encoder']
+        tag_holder.bpm = args['bpm']
+        tag_holder.comp = args['compilaton']
+        tag_holder.grouping = args['grouping']
+        tag_holder.comments = args['comments']
+        tag_holder.lyrics = args['lyrics']
+
+        art, art_path_or_url = None, args['artwork']
+        if art_path_or_url:
+            art = ImageLoader.load_image(art_path_or_url)
+        if art:
+            tag_holder.art = art
+
+        fs_entry_params = FSEntryParamsExt(args)
+        BaseTagProcessor().set_tags_visual(fs_entry_params,
+                tag_holder = tag_holder,
+                diff_tags_only = args['diff_tags_only'])
+
+    def copy_tags(self, args):
+        fs_entry_params = FSEntryParamsExt(args)
+        BaseTagProcessor().copy_tags(fs_entry_params,
+                tag_holder_path = args['tagholder'],
+                diff_tags_only = args['diff_tags_only'])
+
+    def index(self, args):
+        fs_entry_params = FSEntryParamsExt(args)
+        BaseTagProcessor().index(fs_entry_params,
+                diff_tags_only = args['diff_tags_only'], 
+                start_from = args['start_from'])
+
+    def remove_tags(self, args):
+        fs_entry_params = FSEntryParamsExt(args)
+        BaseTagProcessor().remove_tags(fs_entry_params,
+                tag_fields = args['tag_fields'],
+                diff_tags_only = args['diff_tags_only'])
+
+    def replace_tags(self, args):
+        fs_entry_params = FSEntryParamsExt(args)
+        BaseTagProcessor().replace_tags(fs_entry_params,
+                tag_fields = args['tag_fields'], ignore_case = args['ignore_case'],
+                find_str = args['find_str'], replace_str = args['replace_str'],
+                diff_tags_only = args['diff_tags_only'])
+
+    def capitalize_tags(self, args):
+        fs_entry_params = FSEntryParamsExt(args)
+        BaseTagProcessor().capitalize_tags(fs_entry_params,
+                tag_fields = args['tag_fields'],
+                diff_tags_only = args['diff_tags_only'])
+
+    def detauch_art(self, args):
+        fs_entry_params = FSEntryParamsExt(args)
+        BaseTagProcessor().detauch_art(fs_entry_params,
+                target_dir = args['target_dir'])
+
+def main():
+    ''' Tagger entry point
+    '''
+    TagsDispatcher().dispatch()
+