batchmp 1.4__py3-none-any.whl

batchmp/tags/handlers/tagsholder.py

@@ -0,0 +1,264 @@
+# 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
+from string import Template
+from batchmp.commons.utils import MiscHelpers
+from batchmp.commons.descriptors import (
+        PropertyDescriptor,
+        LazyFunctionPropertyDescriptor,
+        FunctionPropertyDescriptor,
+        WeakMethodPropertyDescriptor)
+
+
+# Tag Field Descriptors
+class TaggableMediaFieldDescriptor(PropertyDescriptor):
+    pass
+
+class TaggableMediaTrackFieldDescriptor(TaggableMediaFieldDescriptor):
+    def __get__(self, instance, owner=None):
+        if instance is None: 
+            return self
+        value = super().__get__(instance, owner = owner)      
+        if value:        
+            trt = getattr(instance, 'tracktotal', None)
+            if trt:
+                value = '{}'.format(value)
+                return value.zfill(MiscHelpers.int_num_digits(trt))
+            return value
+        else:
+            return None
+
+class ExpandableMediaFieldDescriptor(TaggableMediaFieldDescriptor):
+    def __set__(self, instance, value):
+        if value:
+            value = instance._process_value(value)
+        super().__set__(instance, value)
+
+class NullableMediaFieldDescriptor(PropertyDescriptor):
+    def __set__(self, instance, value):
+        if value is not None:
+            if not isinstance(value, list):
+                raise ValueError('{}: Nullable fields should be either None or a list of taggable fields'.format(value))
+            taggable_fields = [field for field in instance.taggable_fields()]
+            for field in value:
+                if not field in taggable_fields:
+                    raise ValueError('Field is not supported: {}'.format(field))
+        super().__set__(instance, value)
+
+class NonTaggableMediaFieldDescriptor(PropertyDescriptor):
+    pass
+
+# Art Field is a lazy property
+class ArtFieldDescriptor(LazyFunctionPropertyDescriptor):
+    pass
+
+class TagHolder:
+    ''' Tag Holder
+            Defines supported tags & the protocol
+            Supports tag templates processing
+    '''
+    title = ExpandableMediaFieldDescriptor()
+    album = ExpandableMediaFieldDescriptor()
+    artist = ExpandableMediaFieldDescriptor()
+    albumartist = ExpandableMediaFieldDescriptor()
+    genre = ExpandableMediaFieldDescriptor()
+    composer = ExpandableMediaFieldDescriptor()
+    track = TaggableMediaTrackFieldDescriptor()
+    tracktotal = TaggableMediaFieldDescriptor()
+    disc = TaggableMediaFieldDescriptor()
+    disctotal = TaggableMediaFieldDescriptor()
+    year = TaggableMediaFieldDescriptor()
+    encoder = ExpandableMediaFieldDescriptor()
+
+    bpm = TaggableMediaFieldDescriptor()
+    comp = TaggableMediaFieldDescriptor()
+    grouping = ExpandableMediaFieldDescriptor()
+    comments = ExpandableMediaFieldDescriptor()
+    lyrics = ExpandableMediaFieldDescriptor()
+
+    # non-taggable fields
+    length = NonTaggableMediaFieldDescriptor()
+    bitrate = NonTaggableMediaFieldDescriptor()
+    samplerate = NonTaggableMediaFieldDescriptor()
+    channels = NonTaggableMediaFieldDescriptor()
+    bitdepth = NonTaggableMediaFieldDescriptor()
+    format = NonTaggableMediaFieldDescriptor()
+
+    # additional non-tag properties
+    deferred_art_method = WeakMethodPropertyDescriptor()
+    filepath = PropertyDescriptor()
+    template_processor_method = FunctionPropertyDescriptor()
+    nullable_fields = NullableMediaFieldDescriptor()
+
+    def __init__(self, copy_empty_vals = False, nullable_fields = None,
+                            copy_non_taggable = False, process_templates = True):
+        self._copy_empty_vals = copy_empty_vals
+        self._copy_non_taggable = copy_non_taggable
+        self._process_templates = process_templates
+        self.nullable_fields = nullable_fields
+
+    @property
+    def copy_empty_vals(self):
+        return self._copy_empty_vals
+    @property
+    def copy_non_taggable(self):
+        return self._copy_non_taggable
+    @property
+    def process_templates(self):
+        return self._process_templates
+
+    @property
+    def has_artwork(self):
+        ''' when art retrieval is deferred,
+            provides info on art presence whithout loading into memory
+        '''
+        if self.deferred_art_method:
+            return True
+        elif self.art:
+            return True
+        return False
+
+    @ArtFieldDescriptor
+    def art(self):
+        ''' provides access on the class level
+            when art is set on the instance level, should be ignored
+        '''
+        if self.deferred_art_method:
+            return self.deferred_art_method()
+        else:
+            return None
+
+    @classmethod
+    def taggable_fields(cls):
+        ''' generates names of all writable tag fields
+        '''
+        for c in cls.__mro__:
+            for field, descr in vars(c).items():
+                if isinstance(descr, TaggableMediaFieldDescriptor):
+                    yield field
+                elif isinstance(descr, ArtFieldDescriptor):
+                    yield field
+
+    @classmethod
+    def non_taggable_fields(cls):
+        ''' generates names of non-writable tag fields
+        '''
+        for c in cls.__mro__:
+            for field, descr in vars(c).items():
+                if isinstance(descr, NonTaggableMediaFieldDescriptor):
+                    yield field
+
+    @classmethod
+    def textual_fields(cls):
+        for c in cls.__mro__:
+            for field, descr in vars(c).items():
+                if isinstance(descr, ExpandableMediaFieldDescriptor):
+                    yield field
+
+    @classmethod
+    def fields(cls):
+        ''' generates names of all tag fields
+        '''
+        yield from cls.taggable_fields
+        yield from cls.non_taggable_fields
+
+    def copy_tags(self, tag_holder = None):
+        ''' Copies tags from passed tag_holder object
+            Supports tag templates processing
+        '''
+        if not tag_holder:
+            return
+
+        fields = self.fields if tag_holder.copy_non_taggable else self.taggable_fields
+
+        if tag_holder.template_processor_method:
+            self.template_processor_method = tag_holder.template_processor_method
+
+        for field in fields():
+            value = getattr(tag_holder, field)
+            if (value is not None) or \
+                        (tag_holder.copy_empty_vals) or \
+                            (tag_holder.nullable_fields and (field in tag_holder.nullable_fields)):
+                setattr(self, field, value)
+
+    def clear_tags(self, reset_art = False):
+        ''' clears writable tags values
+        '''
+        for field in self.taggable_fields():
+            setattr(self, field, None)
+            if reset_art and hasattr(self, 'art'):
+                del self.art
+
+    def reset_tags(self):
+        ''' resets a tag holder to its initial state
+        '''
+        self.template_processor_method = None
+        self.filepath = None
+        self.clear_tags(reset_art = True)
+
+    # Internal Helpers
+    def _process_value(self, value):
+        ''' templates processing
+        '''
+        if not self.process_templates:
+            return value
+
+        if self.template_processor_method:
+            return (self.template_processor_method(self._expand_templates(value)))
+        else:
+            return self._expand_templates(value)
+
+    def _expand_templates(self, value):
+        ''' expands template values
+        '''
+        template = Template(value)
+        return template.safe_substitute(self._substitute_dictionary)
+
+    @property
+    def _substitute_dictionary(self):
+        ''' internal property for template value substitution
+        '''
+        sd = {}
+        sd['title'] = self.title if self.title else ''
+        sd['album'] = self.album if self.album else ''
+        sd['artist'] = self.artist if self.artist else ''
+        sd['albumartist'] = self.albumartist if self.albumartist else ''
+        sd['genre'] = self.genre if self.genre else ''
+        sd['composer'] = self.composer if self.composer else ''
+        sd['track'] = self.track if self.track else ''
+        sd['tracktotal'] = self.tracktotal if self.tracktotal else ''
+        sd['disc'] = self.disc if self.disc else ''
+        sd['disctotal'] = self.disctotal if self.disctotal else ''
+        sd['year'] = self.year if self.year else ''
+        sd['encoder'] = self.encoder if self.encoder else ''
+        sd['bpm'] = self.bpm if self.bpm else ''
+        sd['compilaton'] = self.comp if self.comp else ''
+        sd['grouping'] = self.grouping if self.grouping else ''
+        sd['comments'] = self.comments if self.comments else ''
+        sd['lyrics'] = self.lyrics if self.lyrics else ''
+        sd['length'] = self.length if self.length else ''
+        sd['bitrate'] = self.bitrate if self.bitrate else ''
+        sd['samplerate'] = self.samplerate if self.samplerate else ''
+        sd['channels'] = self.channels if self.channels else ''
+        sd['bitdepth'] = self.bitdepth if self.bitdepth else ''
+        sd['format'] = self.format if self.format else ''
+
+        if self.filepath:
+            sd['filename'] = os.path.splitext(os.path.basename(self.filepath))[0]
+            full_dir_name = os.path.dirname(self.filepath)
+            sd['dirname'] = os.path.basename(full_dir_name)
+            sd['pardirname'] = os.path.basename(os.path.dirname(full_dir_name))
+
+        return sd

batchmp/tags/output/formatters.py

@@ -0,0 +1,218 @@
+# 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 datetime, math
+from enum import IntEnum
+from batchmp.commons.utils import MiscHelpers
+from batchmp.fstools.builders.fsentry import FSEntry, FSEntryType
+
+
+class OutputFormatType(IntEnum):
+    COMPACT = 0
+    FULL = 1
+    STATS = 2
+
+
+class TagOutputFormatter:
+    ''' Generates output for printing tags
+    '''
+    DEFAULT_TAG_INDENT = '    '
+
+    COMPACT_FIELDS = ['title', 'album', 'artist', 'albumartist', 'genre', 'composer', 'year', 'track', 'tracktotal', 'disc', 'disctotal']
+    EXTENDED_FIELDS = ['encoder', 'bpm', 'comp', 'grouping', 'comments', 'lyrics', 'art']
+
+    @staticmethod
+    def tags_formatter(entry, *,
+                           format = None, handler = None, show_stats = False,
+                           tag_holder = None, tag_holder_builder = None,
+                           show_tag_holder_values = False,
+                           diff_tags_only = False):
+
+        ''' Tag formatting entry point
+        '''
+
+        # check inputs
+        if entry.type == FSEntryType.DIR or entry.type == FSEntryType.ROOT:
+            return entry.basename
+        if not handler or not handler.can_handle(entry.realpath):
+            return None
+
+        if tag_holder_builder:
+            tag_holder = tag_holder_builder(entry)
+
+        if not format or (format not in OutputFormatType):
+            if tag_holder:
+                format = OutputFormatType.FULL
+            else:
+                format = OutputFormatType.COMPACT
+
+        diff_fields = None
+        if tag_holder:
+            # figure out relevant fields to show
+            diff_fields = []
+            for field in tag_holder.taggable_fields():
+                value = getattr(tag_holder, field)
+                if (value is not None) or \
+                        (tag_holder.copy_empty_vals) or \
+                        (tag_holder.nullable_fields and (field in tag_holder.nullable_fields)):
+                    diff_fields.append(field)
+
+            if not diff_tags_only:
+                # if need to show the changes along with other tag fields,
+                # return a minimal set of compact fields + all changed fields (including extended)
+                diff_extended_fields = list(set(diff_fields).intersection(set(TagOutputFormatter.EXTENDED_FIELDS)))
+                diff_fields = TagOutputFormatter.COMPACT_FIELDS + diff_extended_fields
+
+        if tag_holder and show_tag_holder_values:
+            # if care for new values, copy tags / process templates
+            handler.tag_holder.copy_tags(tag_holder)
+
+        if format == OutputFormatType.COMPACT:
+            return TagOutputFormatter._formatter(entry, handler.tag_holder, show_stats = show_stats)
+        elif format == OutputFormatType.FULL:
+            return TagOutputFormatter._formatter(entry, handler.tag_holder, show_extended = True,
+                                                 show_stats = show_stats, diff_fields = diff_fields)
+        elif format == OutputFormatType.STATS:
+            return TagOutputFormatter._formatter(entry, handler.tag_holder,
+                                                    show_compact = False, show_stats = show_stats)
+        else:
+            return None
+
+    # Helpers
+    @staticmethod
+    def _formatter(entry, tag_holder,
+                    show_compact = True, show_extended = False, show_stats = False,
+                    diff_fields = None):
+        indent = entry.indent[:-3] + TagOutputFormatter.DEFAULT_TAG_INDENT
+        media_str = ''
+
+        if diff_fields is not None:
+            compact_fields = [f for f in TagOutputFormatter.COMPACT_FIELDS if f in diff_fields]
+            extended_fields = [f for f in TagOutputFormatter.EXTENDED_FIELDS if f in diff_fields]
+        else:
+            compact_fields = TagOutputFormatter.COMPACT_FIELDS
+            extended_fields = TagOutputFormatter.EXTENDED_FIELDS
+
+        if show_compact:
+            track_set = disc_set = False
+            for field in compact_fields:
+                field_val = getattr(tag_holder, field)
+                if field_val:
+                    if field in ('disc', 'disctotal'):
+                        if not disc_set:
+                            disc_set = True
+                            if tag_holder.disc or tag_holder.disctotal:
+                                media_str = TagOutputFormatter._disc_str(tag_holder, indent, media_str)
+                    elif field in ('track', 'tracktotal'):
+                        if not track_set:
+                            track_set = True
+                            if tag_holder.track or tag_holder.tracktotal:
+                                media_str = TagOutputFormatter._track_str(tag_holder, indent, media_str)
+                    else:
+                        media_str = '{0}\n{1}{2}: {3}'.format(media_str, indent,
+                                                          TagOutputFormatter._tag_display_name(field),
+                                                          field_val)
+        if show_extended:
+            for field in extended_fields:
+                field_val = getattr(tag_holder, field)
+                if field_val:
+                    if field == 'art':
+                        if tag_holder.has_artwork:
+                            media_str = '{0}\n{1}Artwork present'.format(media_str, indent)
+                    else:
+                        media_str = '{0}\n{1}{2}: {3}'.format(media_str, indent,
+                                                          TagOutputFormatter._tag_display_name(field),
+                                                          field_val)
+        # Stats
+        if show_stats:
+            media_str = TagOutputFormatter._stats_str(tag_holder, indent, media_str)
+
+        return '{0}{1}'.format(entry.basename, media_str)
+
+    @staticmethod
+    def _disc_str(tag_holder, indent, media_str):
+        disc = tag_holder.disc if tag_holder.disc else '_'
+        if tag_holder.disctotal:
+            disc_str = '{}/{}'.format(disc, tag_holder.disctotal)
+        else:
+            disc_str = tag_holder.disc
+        return '{0}\n{1}Disk: {2}'.format(media_str, indent, disc_str)
+
+    @staticmethod
+    def _track_str(tag_holder, indent, media_str, show_always = False):
+        track = tag_holder.track if tag_holder.track else '_'
+        if tag_holder.tracktotal:
+            track_str = '{}/{}'.format(track, tag_holder.tracktotal)
+        else:
+            track_str = track
+        return '{0}\n{1}Track: {2}'.format(media_str, indent, track_str)
+
+    @staticmethod
+    def _stats_str(tag_holder, indent, media_str):
+        if tag_holder.format:
+            media_str = '{0}\n{1}Format: {2}'.format(media_str, indent, tag_holder.format)
+
+        duration = datetime.timedelta(seconds = math.ceil(tag_holder.length)) if tag_holder.length else None
+        duration = 'Duration: {}'.format(duration if duration else 'n/a')
+
+        bitrate = math.ceil(tag_holder.bitrate / 1000) if tag_holder.bitrate else None
+        bitrate = 'Bit rate: {}'.format('{}kb/s'.format(bitrate) if bitrate else 'n/a')
+
+        samplerate = tag_holder.samplerate if tag_holder.samplerate else None
+        samplerate = 'Sample rate: {}'.format('{}Hz'.format(samplerate) if samplerate else 'n/a')
+
+        bitdepth = tag_holder.bitdepth if tag_holder.bitdepth else None
+        bitdepth = 'Bit depth: {}'.format(bitdepth if bitdepth else 'n/a')
+
+        return '{0}\n{1}{2}, {3}, {4}, {5}'.format(media_str, indent, duration,
+                                                                bitrate, samplerate, bitdepth)
+
+    @staticmethod
+    def _tag_display_name(field):
+        if field == 'title':
+            return 'Title'
+        elif field == 'album':
+            return 'Album'
+        elif field == 'artist':
+            return 'Artist'
+        elif field == 'albumartist':
+            return 'Album Artist'
+        elif field == 'genre':
+            return 'Genre'
+        elif field == 'composer':
+            return 'Composer'
+        elif field == 'track':
+            return 'Track'
+        elif field == 'tracktotal':
+            return 'Track Total'
+        elif field == 'disc':
+            return 'Disc'
+        elif field == 'disctotal':
+            return 'Disc Total'
+        elif field == 'year':
+            return 'Year'
+        elif field == 'encoder':
+            return 'Encoder'
+        elif field == 'bpm':
+            return 'BPM'
+        elif field == 'comp':
+            return 'Compilation'
+        elif field == 'grouping':
+            return 'Grouping'
+        elif field == 'comments':
+            return 'Comments'
+        elif field == 'lyrics':
+            return 'Lyrics'
+
+        return None