batchmp 1.4__py3-none-any.whl

batchmp/ffmptools/utils/cueparse.py

@@ -0,0 +1,227 @@
+#!/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.
+
+
+import os, re
+from batchmp.ffmptools.utils.cuesheet import CueSheet, CueTrack
+
+class CueParseReadDataEncodingError(Exception):
+    def __init__(self, message = None):
+        super().__init__(message if message is not None else self.default_message)
+
+    @property
+    def default_message(self):
+        return '\n\tUnable to read data from the .cue file' \
+               '\n\tProvide correct encoding argument when parsing files, e.g.:' \
+               '\n\t\tcue_parser = CueParser()' \
+               '\n\t\tcue_parser.parse(cue_filepath, encoding = "latin-1")'
+
+class CueLineParser:
+    ''' Cue Lines Parser
+    '''
+    def __init__(self):
+        self._line_matcher = re.compile(r'^([A-Z]+)\s+(.*)$')
+
+    def parse_line(self, line):
+        ''' Parses a line read from a *.cue file
+        '''
+        line = line.strip()
+
+        command = params = None
+        match = self._line_matcher.match(line)
+        if match and len(match.groups()) >= 2:
+            command = match.group(1)
+            params = self._parse_params(match.group(2))
+
+        return command, params
+
+    def _parse_params(self, params):
+        res = []
+        params = params.strip()
+        if params:
+            quote_idx = params.find('"')
+            if quote_idx < 0:
+                for param in params.split():
+                    res.append(param)
+            elif quote_idx == 0:
+                if len(params) > 1:
+                    res = self._parse_params(params[quote_idx + 1:])
+            elif quote_idx > 0:
+                res.append(params[:quote_idx])
+                if len(params) > 1:
+                    res = res + self._parse_params(params[quote_idx + 1:])
+        return res
+
+class CueParser:
+    ''' Cue files parser
+    '''
+    def __init__(self):
+        self._commands_map = {
+                            'CATALOG':    self._parse_catalog,
+                            'CDTEXTFILE': self._parse_cdtextfile,
+                            'FILE':       self._parse_file,
+                            'FLAGS':      self._parse_flags,
+                            'INDEX':      self._parse_index,
+                            'ISRC':       self._parse_isrc,
+                            'PERFORMER':  self._parse_performer,
+                            'POSTGAP':    self._parse_postgap,
+                            'PREGAP':     self._parse_pregap,
+                            'REM':        self._parse_rem,
+                            'SONGWRITER': self._parse_songwriter,
+                            'TITLE':      self._parse_title,
+                            'TRACK':      self._parse_track
+                            }
+
+        self._time_offset_matcher = re.compile(r'^(\d{1,3}):(\d{1,2}):(\d{1,2})$')
+        self._line_parser = CueLineParser()
+        self._lines = None
+        self._cuesheet = None
+
+    def parse(self, filepath, encoding = 'utf-8'):
+        try:
+            self._read_data(filepath, encoding = encoding)
+        except CueParseReadDataEncodingError:
+            raise
+        self._cuesheet = CueSheet()
+
+        for line in self._lines:
+            command, params = self._line_parser.parse_line(line)
+            if command:
+                self._commands_map[command](params)
+
+        return self._cuesheet
+
+
+    # Internal processing
+    #####################
+    def _read_data(self, filepath, encoding):
+        if not os.path.isfile(filepath):
+            print('Cannot open file: {}'.format(filepath))
+            exit(2)
+        try:
+            with open(filepath, encoding = encoding) as f:
+                lines = f.read()
+        except UnicodeDecodeError:
+            raise CueParseReadDataEncodingError
+        self._lines = lines.splitlines()
+
+    def _parse_catalog(self, params):
+        self._cuesheet.catalog = params[0];
+
+    def _parse_cdtextfile(self, params):
+        self._cuesheet.cdtextfile = params[0];
+
+    def _parse_file(self, params):
+        self._cuesheet.add_file()
+        self._cuesheet.last_file.name = params[0];
+        self._cuesheet.last_file.type = params[1];
+
+    def _parse_flags(self, params):
+        track = _cuesheet.last_track()
+        if track:
+            track.flags = params[0]
+
+    def _parse_index(self, params):
+        number = int(params[0])
+        time_offset = self._parse_time_offset(params[1])
+
+        track = self._cuesheet.last_track
+        if track:
+            index = CueTrack.Index(number, time_offset)
+            track.indexes.append(index)
+
+            # for the first index, look to calculate previous track duration
+            if len(track.indexes) == 1:
+                penultimate_track = self._cuesheet.penultimate_track
+                if penultimate_track and penultimate_track.indexes:
+                    time_offset = track.indexes[0].time_offset_timedelta
+                    previosOffset = penultimate_track.indexes[0].time_offset_timedelta
+                    penultimate_track.duration = time_offset - previosOffset
+
+    def _parse_isrc(self, params):
+        track = self._cuesheet.last_track
+        if track:
+            track.isrc = params[0]
+
+    def _parse_performer(self, params):
+        track = self._cuesheet.last_track
+        if not track:
+            self._cuesheet.performer = params[0]
+        else:
+            track.performer = params[0]
+
+    def _parse_postgap(self, params):
+        track = self._cuesheet.last_track
+        if track:
+            track.postgap = self._parse_time_offset(params[0])
+
+    def _parse_pregap(self, params):
+        track = self._cuesheet.last_track
+        if track:
+            track.pregap = self._parse_time_offset(params[0])
+
+    def _parse_rem(self, params):
+        self._cuesheet.rem.append(' '.join(params))
+
+    def _parse_songwriter(self, params):
+        track = self._cuesheet.last_track
+        if not track:
+            self._cuesheet.songWriter = params[0]
+        else:
+            track.songWriter = params[0]
+
+    def _parse_title(self, params):
+        track = self._cuesheet.last_track
+        if not track:
+            self._cuesheet.title = params[0]
+        else:
+            track.title = params[0]
+
+    def _parse_track(self, params):
+        number = int(params[0])
+        type = params[1]
+        self._cuesheet.add_track(number, type)
+
+    def _parse_time_offset(self, time_offset_str):
+        mins = secs = frames = 0
+        match = self._time_offset_matcher.match(time_offset_str)
+        if match:
+            mins = int(match.group(1))
+            secs = int(match.group(2))
+            frames = int(match.group(3))
+        time_offset = CueTrack.TimeOffset(mins, secs, frames)
+        return time_offset
+
+from datetime import timedelta
+if __name__ == '__main__':
+    cue_filepath = os.path.expanduser('~/_Dev/GitHub/batch-mp-tools/tests/ffmp/.data/bmfp_a/noise.cue')
+
+    line_parser = CueLineParser()
+    param_dict = ['TRACK 01 AUDIO',
+              'INDEX 01 00:00:00',
+              'TITLE "BMFP Noisy Classical"',
+              'FILE "01 background noise.aiff" AIFF',
+              'REM GENRE "NOISY CLASSICAL"','REM DATE "2016"']
+
+    for params in param_dict:
+        param = line_parser.parse_line(params)
+        print(param)
+    print()
+
+    parser = CueParser()
+    cuesheet = parser.parse(cue_filepath)
+    print(cuesheet)
+
+
+

batchmp/ffmptools/utils/cuesheet.py

@@ -0,0 +1,239 @@
+#!/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.
+
+
+import sys, os, re, math
+from collections import namedtuple
+from enum import Enum
+from datetime import timedelta
+from string import Template
+from batchmp.commons.descriptors import PropertyDescriptor
+
+
+class CueDefaultOutputDescriptor(PropertyDescriptor):
+    ''' Output format property descriptor, with support for default values
+    '''
+    def __init__(self, func_name):
+        self._func_name = func_name
+
+    def __get__(self, instance, type=None):
+        value = super().__get__(instance, type = type)
+        if not value:
+            value = getattr(instance, self._func_name)()
+        return value
+
+class TimeOffsetPropertyDescriptor(PropertyDescriptor):
+    ''' Named tuple type property descriptor
+        or, "typing like a duck rhymes with ..."
+    '''
+    def __set__(self, instance, value):
+        if isinstance(value, tuple): #and hasattr ...
+            super().__set__(instance, value)
+        else:
+            raise TypeError("Not a Tuple Type: {}".format(value))
+
+class CueBase:
+    ''' Base cue sheet / track stuff
+    '''
+    performer = PropertyDescriptor()
+    songwriter = PropertyDescriptor()
+    title = PropertyDescriptor()
+    outputformat = CueDefaultOutputDescriptor("default_output_format")
+    substitute_dictionary = CueDefaultOutputDescriptor("default_substitute_dictionary")
+
+    # Internal methods
+    ###################
+    def __repr__(self):
+        template = Template(self.default_output_format)
+        return template.safe_substitute(self.default_substitute_dictionary)
+
+    @property
+    def default_output_format(self):
+        return None
+
+    @property
+    def default_substitute_dictionary(self):
+        ''' common default output-related template processing
+            subclasses can extend this via adding ther specific stuff to process
+        '''
+        sd = {}
+        sd['performer'] = self.performer if self.performer else ''
+        sd['songwriter'] = self.songwriter if self.songwriter else ''
+        sd['title'] = self.title if self.title else ''
+
+        return sd
+
+class CueTrack(CueBase):
+    ''' Cue track attributes / processing
+    '''
+    TimeOffset = namedtuple('TimeOffset', ['mins', 'secs', 'frames'])
+    class Index:
+        number = PropertyDescriptor()
+        time_offset = TimeOffsetPropertyDescriptor()
+
+        def __init__(self, number, time_offset):
+            self.number = number
+            self.time_offset = time_offset
+
+        @property
+        def time_offset_str(self):
+            return '{0:02d}:{1:02d}:{2:02d}'.format(self.time_offset.mins, self.time_offset.secs, self.time_offset.frames)
+
+        @property
+        def time_offset_timedelta(self):
+            ''' time_offset is specified as mm:ss:ff (minute-second-frame) format,
+                where there are 75 such frames per second of audio
+            '''
+            seconds = self.time_offset.secs + self.time_offset.frames / 75
+            return timedelta(minutes = self.time_offset.mins, seconds = seconds)
+
+        @property
+        def time_offset_in_seconds(self):
+            return self.time_offset_timedelta.total_seconds()
+
+    number = PropertyDescriptor()
+    type =  PropertyDescriptor()
+    flags = PropertyDescriptor()
+    isrc = PropertyDescriptor()
+    pregap  = TimeOffsetPropertyDescriptor()
+    postgap = TimeOffsetPropertyDescriptor()
+    duration = PropertyDescriptor()
+
+    def __init__(self, number, type):
+        self.number = number
+        self.type = type
+        self.indexes = []
+
+    @property
+    def offset_in_seconds(self):
+        offset_in_seconds = 0
+        if len(self.indexes) > 0:
+            offset_in_seconds = self.indexes[0].time_offset_in_seconds
+        return offset_in_seconds
+
+    @property
+    def duration_in_seconds(self):
+        return self.duration.total_seconds() if self.duration else 0
+
+    # Internal methods
+    ###################
+    @property
+    def default_output_format(self):
+        return '  $number\t$time_offset\t$duration\t$title'
+
+    @property
+    def default_substitute_dictionary(self):
+        ''' cue track default output template processing
+        '''
+        sd = super().default_substitute_dictionary
+        if len(self.indexes) > 0:
+            sd['time_offset'] = self.indexes[0].time_offset_str
+        else:
+            sd['time_offset'] = ''
+
+        sd['number'] = '{0:02d}'.format(self.number) if self.number else ''
+        if self.duration:
+            minutes = math.floor(self.duration.total_seconds() / 60)
+            sd['duration'] = '{0:02d}:{1:02d}'.format(minutes, self.duration.seconds - 60 * minutes)
+        else:
+            sd['duration'] = '  :  '
+        return sd
+
+class CueSheet(CueBase):
+    ''' Cue sheet processing
+    '''
+    class File:
+        name = PropertyDescriptor()
+        format = PropertyDescriptor()
+
+        def __init__(self):
+            self.tracks = []
+
+    catalog = PropertyDescriptor()
+    cdtextfile = PropertyDescriptor()
+
+    def __init__(self):
+        self.files = []
+        self.rem = []
+
+    @property
+    def last_file(self):
+        files_cnt = len(self.files)
+        if files_cnt > 0:
+            return self.files[files_cnt - 1]
+        return None
+
+    @property
+    def last_track(self):
+        file = self.last_file
+        if file and file.tracks:
+            tracks_cnt = len(file.tracks)
+            if tracks_cnt > 0:
+                return file.tracks[tracks_cnt - 1]
+        return None
+
+    @property
+    def penultimate_track(self):
+        file = self.last_file
+        if file and file.tracks:
+            tracks_cnt = len(file.tracks)
+            if tracks_cnt > 1:
+                return file.tracks[tracks_cnt - 2]
+        return None
+
+    def add_file(self):
+        file = CueSheet.File()
+        self.files.append(file)
+
+    def add_track(self, number, type):
+        file = self.last_file
+        if file:
+            file.tracks.append(CueTrack(number, type))
+
+    # Internal methods
+    ###################
+    @property
+    def default_output_format(self):
+        return 'Performer: $performer\nTitle: $title\nRem: $rem\nFiles: $files\nTracks: $tracks'
+
+    @property
+    def default_substitute_dictionary(self):
+        ''' cue sheet default output template processing
+        '''
+        sd = super().default_substitute_dictionary
+
+        if self.rem:
+            rem_output = '\n'
+            for rem in self.rem:
+                if rem == self.rem[-1]:
+                    rem_output += ' {}'.format(rem)
+                else:
+                    rem_output += ' {}\n'.format(rem)
+            sd['rem'] = rem_output
+
+        files_output = '\n'
+        tracks_output = '\n'
+        for file in self.files:
+            if file == self.files[-1]:
+                files_output += ' {0} ({1})'.format(file.name, file.type)
+            else:
+                files_output += ' {0} ({1})\n'.format(file.name, file.type)
+            for track in file.tracks:
+                tracks_output += '{}\n'.format(str(track))
+
+        sd['files'] = files_output
+        sd['tracks'] = tracks_output
+
+        return sd
+

batchmp/fstools/builders/fsb.py

@@ -0,0 +1,221 @@
+# 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, sys
+from abc import ABCMeta, abstractmethod
+from batchmp.fstools.fsutils import FSH
+from batchmp.fstools.builders.fsentry import FSEntry, FSEntryType, FSMediaEntryGroupType
+
+
+class FSEntryBuilder(metaclass = ABCMeta):
+    ''' root entry builder
+    '''
+    @staticmethod
+    def build_root_entry(fs_entry_params):
+        # yield the current folder
+        if fs_entry_params.current_level == 0:
+            # src dir goes in full and without indent
+            entry = FSEntry(type = FSEntryType.ROOT,
+                                basename = os.path.basename(fs_entry_params.rpath), 
+                                realpath = fs_entry_params.rpath,
+                                indent = os.path.dirname(fs_entry_params.rpath) + os.path.sep,
+                                isEnclosingEntry = True,
+                                isEnclosingFilesContainterEntry = True)
+        else:
+            entry = FSEntry(FSEntryType.DIR,
+                                basename = os.path.basename(fs_entry_params.rpath), 
+                                realpath = fs_entry_params.rpath,
+                                indent = fs_entry_params.current_indent[:-1] + os.path.sep,
+                                isEnclosingEntry = fs_entry_params.isEnclosingEntry,
+                                isEnclosingFilesContainterEntry = fs_entry_params.isEnclosingFilesContainterEntry,
+                                isScopeSwitchingEntry = True)
+        # debug
+        # print("{}cur level:{}".format(fs_entry_params.current_indent, fs_entry_params.current_level))
+        # print("{}end level:{}".format(fs_entry_params.current_indent, fs_entry_params.end_level))              
+        yield entry        
+
+    ''' Abstract builder method
+    '''
+    @staticmethod
+    @abstractmethod
+    def build_entry(fs_entry_params):
+        yield None
+
+
+class FSEntryBuilderBase(FSEntryBuilder):
+    ''' File System Processing
+    '''
+    @staticmethod
+    def build_entry(fs_entry_params):
+        ## not much there for enclosing entries 
+        if fs_entry_params.isEnclosingEntry and not fs_entry_params.isEnclosingFilesContainterEntry: 
+            return
+
+        ## Files processing ##        
+        for fname in fs_entry_params.fnames:
+            fpath = os.path.join(fs_entry_params.rpath, fname)
+            entry = FSEntry(type = FSEntryType.FILE,
+                                basename = fname, 
+                                realpath = fpath,
+                                indent = fs_entry_params.siblings_indent)
+            yield entry
+
+        ## Directories processing ##
+        for dname in fs_entry_params.dnames.passed:
+           dpath = os.path.join(fs_entry_params.rpath, dname)
+
+           # check the current_level from root
+           if fs_entry_params.current_level == fs_entry_params.end_level:
+               # not going any deeper
+               # yield the dir
+               entry = FSEntry(type = FSEntryType.DIR,
+                                basename = dname, 
+                                realpath = dpath, 
+                                indent = fs_entry_params.siblings_indent[:-1] + os.path.sep)
+               #print('from build_entry!\n')
+               yield entry
+
+
+
+class FSEntryBuilderFlatten(FSEntryBuilder):
+    @staticmethod
+    def build_root_entry(fs_entry_params):
+        if fs_entry_params.current_level <= fs_entry_params.target_level:
+            yield from FSEntryBuilderBase.build_root_entry(fs_entry_params)
+
+
+    @staticmethod
+    def build_entry(fs_entry_params):
+        if fs_entry_params.current_level < fs_entry_params.target_level:
+            yield from FSEntryBuilderBase.build_entry(fs_entry_params)
+        else: 
+            if fs_entry_params.current_level > fs_entry_params.target_level:
+                return
+
+            flattens = []
+            unique_fname = fs_entry_params.unique_fnames()
+
+            ## Files processing ##        
+            for fname in fs_entry_params.fnames:
+                fpath = os.path.join(fs_entry_params.rpath, fname)
+                entry = FSEntry(type = FSEntryType.FILE, 
+                                    basename = fname, 
+                                    realpath = fpath, 
+                                    indent = fs_entry_params.siblings_indent)
+                flattens.append(entry)
+
+                # store the name generator init values
+                next(unique_fname)
+                unique_fname.send(fname)
+            
+            ## Directories processing ##
+            # remove non-matching
+            for dname in fs_entry_params.merged_dnames:
+                dpath = os.path.join(fs_entry_params.rpath, dname)
+
+                # flattening, yield the underlying files 
+                for dr, _, dfnames in os.walk(dpath):
+                    dr_path = FSH.full_path(dr)
+                    df_path = lambda fname: os.path.join(dr_path, fname)
+
+                    # filter non-matching files
+                    if fs_entry_params.filter_files:
+                        dfnames = (fname for fname in dfnames if fs_entry_params.passed_filters(fname))
+
+                    # file types
+                    if fs_entry_params.file_type != FSMediaEntryGroupType.ANY:
+                        dfnames = [fname for fname in dfnames if fs_entry_params.is_of_required_type(df_path(fname))]
+
+
+                    for fname in dfnames:
+                        fpath = df_path(fname)
+                        next(unique_fname)
+                        fname = unique_fname.send(fname)
+
+                        entry = FSEntry(FSEntryType.FILE, fname, fpath, fs_entry_params.siblings_indent)
+                        flattens.append(entry)
+
+            # OK to sort now
+            if fs_entry_params.by_size:
+                sort_key = lambda entry: os.path.getsize(entry.realpath)
+            else:
+                # for sorting need to still derive basename from realpath
+                # as for flattened it might be different from entry.basename
+                sort_key = lambda entry: os.path.basename(entry.realpath).lower()
+
+            for entry in sorted(flattens, key = sort_key, reverse = fs_entry_params.descending):
+                yield entry
+
+
+
+from batchmp.ffmptools.ffutils import FFH
+import datetime
+
+class FSEntryBuilderOrganize(FSEntryBuilderBase):
+    @staticmethod
+    def build_entry(fs_entry_params):
+        """ Build entries for virtual directory preview """
+        # not much there for enclosing entries 
+        if fs_entry_params.isEnclosingEntry and not fs_entry_params.isEnclosingFilesContainterEntry: 
+            return
+
+        ## Files processing - for virtual preview, just show the files ##        
+        for fname in fs_entry_params.fnames:
+            entry = FSEntry(type = FSEntryType.FILE,
+                                basename = fname, 
+                                realpath = os.path.join(fs_entry_params.rpath, fname),  # Virtual path for display
+                                indent = fs_entry_params.siblings_indent)
+            yield entry
+
+        ## Directories processing ##
+        for dname in fs_entry_params.dnames.passed:
+           dpath = os.path.join(fs_entry_params.rpath, dname)
+
+           # check the current_level from root
+           if fs_entry_params.current_level == fs_entry_params.end_level:
+               # not going any deeper
+               # yield the dir
+               entry = FSEntry(type = FSEntryType.DIR,
+                                basename = dname, 
+                                realpath = dpath, 
+                                indent = fs_entry_params.siblings_indent[:-1] + os.path.sep)
+               yield entry
+
+
+class FSEntryBuilderOrganizeWorker(FSEntryBuilder):
+    @staticmethod
+    def build_entry(fs_entry_params):
+        base_target_dir = fs_entry_params.target_dir if fs_entry_params.target_dir else fs_entry_params.src_dir
+
+        for fname in fs_entry_params.fnames:
+            fpath = os.path.join(fs_entry_params.rpath, fname)
+            entry = FSEntry(type=FSEntryType.FILE,
+                            basename=fname,
+                            realpath=fpath,
+                            indent=fs_entry_params.siblings_indent)
+
+            if fs_entry_params.by == 'type':
+                media_type = FFH.media_type(fpath=fpath, fast_scan=fs_entry_params.fast_scan)
+                subdir = str(media_type.name).lower()
+                target_dir = os.path.join(base_target_dir, subdir)
+            elif fs_entry_params.by == 'date':
+                mtime = os.path.getmtime(fpath)
+                date = datetime.datetime.fromtimestamp(mtime)
+                subdir = date.strftime(fs_entry_params.date_format)
+                target_dir = os.path.join(base_target_dir, subdir)
+            else:
+                # Should not happen if arguments are parsed correctly
+                target_dir = base_target_dir
+
+            entry.target_path = os.path.join(target_dir, fname)
+            yield entry