added base class for editmeta

Author: sudormrfbin

clid/_const.py

@@ -213,3 +213,26 @@
 }
 
 FORMAT_PAT = re.compile(r'%.')
+
+TAG_FIELDS = {
+    'tit': 'title',
+    'alb': 'album',
+    'gen': 'genre',
+    'tno': 'track',
+    'art': 'artist',
+    'com': 'comment',
+    'ala': 'album_artist'
+}
+
+ 
+DATE_PATTERN = re.compile(r"""(?x)\s*
+                ((?P<year>[0-9]{4})       # YYYY
+                (-(?P<month>[01][0-9])    # -MM
+                (-(?P<day>[0-3][0-9])     # -DD
+                )?)?)?
+                [ T]?
+                ((?P<hour>[0-2][0-9])     #  HH
+                (:(?P<min>[0-6][0-9])     # :MM
+                (:(?P<sec>[0-6][0-9])     # :SS
+                )?)?)?\s*
+                """)

clid/base.py

@@ -4,8 +4,11 @@
 
 import curses
 
+import stagger
 import npyscreen as npy
 
+from . import _const
+
 class ClidActionController(npy.ActionControllerSimple):
     """Base class for the command line at the bottom of the screen"""
 
@@ -30,10 +33,10 @@ def set_up_handlers(self):
         self.handlers[curses.KEY_END] = self.h_end
         self.handlers[curses.KEY_HOME] = self.h_home
 
-    def h_home(self, input):
+    def h_home(self, char):
         self.cursor_position = 0
 
-    def h_end(self, input):
+    def h_end(self, char):
         self.cursor_position = len(self.value)
 
 
@@ -75,30 +78,30 @@ def set_up_handlers(self):
         self.vim_add_handlers()
         self.handlers[curses.ascii.ESC] = self.h_vim_normal_mode   # is a bit slow
 
-    def h_addch(self, input):
+    def h_addch(self, char):
         if self.parent.in_insert_mode:   # add characters only if in insert mode
-            super().h_addch(input)
+            super().h_addch(char)
 
-    def h_vim_insert_mode(self, input):
+    def h_vim_insert_mode(self, char):
         """Enter insert mode"""
         self.parent.in_insert_mode = True
         self.vim_remove_handlers()   # else `k`, j`, etc will not be added to text(will still act as keybindings)
 
-    def h_vim_normal_mode(self, input):
+    def h_vim_normal_mode(self, char):
         """Exit insert mode by pressing Esc"""
         self.parent.in_insert_mode = False
         self.cursor_position -= 1   # just like in vim
         self.vim_add_handlers()   # removed earlier when going to insert mode
 
-    def h_vim_append_char(self, input):
+    def h_vim_append_char(self, char):
         """Append characters, like `a` in vim"""
-        self.h_vim_insert_mode(input)
+        self.h_vim_insert_mode(char)
         self.cursor_position += 1
 
-    def h_vim_append_char_at_end(self, input):
+    def h_vim_append_char_at_end(self, char):
         """Add characters to the end of the line, like `A` in vim"""
-        self.h_vim_insert_mode(input)
-        self.h_end(input)   # go to the end
+        self.h_vim_insert_mode(char)
+        self.h_end(char)   # go to the end
 
 class ClidVimTitleText(npy.TitleText):
     _entry_type = ClidVimTextfield
@@ -122,3 +125,122 @@ class ClidCommandLine(npy.fmFormMuttActive.TextCommandBoxTraditional, ClidTextfi
     #     # self.color = 'DEFAULT'
     #     # self.show_bold = False
     pass
+
+
+class ClidEditMeta(npy.ActionFormV2):
+    """Edit the metadata of a track.
+
+       Attributes:
+            files(list): List of files whose tags are being edited.
+            _label_textbox(ClidTextfield):  
+                Text box which acts like a label(cannot be edited).
+            _title_textbox(ClidTextfield):
+                Text box with a title, to be used as input field for tags.
+            in_insert_mode(bool):
+                Used to decide whether the form is in insert/normal
+                mode(if vi_keybindings are enabled). This is actually
+                set as an attribute of the parent form so that all
+                text boxes in the form are in the same mode.
+    """
+    def __init__(self, *args, **kwags):
+        super().__init__(*args, **kwags)
+        self.handlers.update({
+            '^S': self.h_ok,
+            '^Q': self.h_cancel
+        })
+        self.in_insert_mode = False
+        self.files = self.parentApp.current_file
+
+    def set_textbox(self):
+        """Set the text boxes to be used(with or without vim-bindings).
+           Called by child classes.
+        """
+        if self.parentApp.settings['vim_mode'] == 'true':
+            self._title_textbox = ClidVimTitleText   # vim keybindings if enabled
+            self._label_textbox = ClidVimTextfield
+        else:
+            self._title_textbox = ClidTitleText
+            self._label_textbox = ClidTextfield
+
+    def create(self):
+        self.set_textbox()
+        self.tit = self.add(self._title_textbox, name='Title')
+        self.nextrely += 1
+        self.alb = self.add(self._title_textbox, name='Album')
+        self.nextrely += 1
+        self.art = self.add(self._title_textbox, name='Artist')
+        self.nextrely += 1
+        self.ala = self.add(self._title_textbox, name='Album Artist')
+        self.nextrely += 2
+        self.gen = self.add(self._title_textbox, name='Genre')
+        self.nextrely += 1
+        self.dat = self.add(self._title_textbox, name='Date/Year')
+        self.nextrely += 1
+        self.tno = self.add(self._title_textbox, name='Track Number')
+        self.nextrely += 2
+        self.com = self.add(self._title_textbox, name='Comment')
+
+    def resolve_genre(self, num_gen):
+        """Convert numerical genre values to readable values. Genre may be
+           saved as a str of the format '(int)' by applications like EasyTag.
+
+           Args:
+                num_gen (str): str representing the genre.
+
+           Returns:
+                str: Name of the genre (Electronic, Blues, etc). Returns
+                num_gen itself if it doesn't match the format.
+        """
+        match = _const.GENRE_PAT.findall(num_gen)
+
+        if match:
+            try:
+                return _const.GENRES[int(match[0])]
+            except IndexError:
+                return ''
+        else:
+            return num_gen
+
+    def h_ok(self, char):
+        """Handler to save the tags"""
+        self.on_ok()
+
+    def h_cancel(self, char):
+        """Handler to cancel the operation"""
+        self.on_cancel()
+
+    def on_cancel(self):   # char is for handlers
+        """Switch to standard view at once without saving"""
+        self.editing = False
+        self.parentApp.switchForm("MAIN")
+
+    def on_ok(self):   # char is for handlers
+        """Save and switch to standard view"""
+        # date format check
+        m = _const.DATE_PATTERN.match(self.dat.value)
+        if m is None or m.end() != len(self.dat.value):
+            npy.notify_confirm(message='Date should be of the form YYYY-MM-DD HH:MM:SS',
+                               title='Invalid Date Format', editw=1)
+            return None
+        # track number check
+        track = self.tno.value or '0'   # automatically converted to int by stagger
+        if not track.isnumeric():
+            npy.notify_confirm(message='Track number can only take integer values',
+                               title='Invalid Track Number', editw=1)
+            return None
+        # FIXME: values of tags are reset to initial when ok is pressed(no prob with ^S)
+
+        for mp3 in self.files:
+            meta = stagger.read_tag(mp3)
+            for tbox, field in _const.TAG_FIELDS:
+                # equivalent to `meta.title = self.tit.value`...
+                tag = getattr(self, tbox).value   # get value to be written to file
+                setattr(meta, field, tag)
+            meta.write()
+
+        main_form = self.parentApp.getForm("MAIN")
+        # show the new tags in the status line
+        main_form.wMain.set_status(filename=main_form.wMain.get_selected(), force=True)   
+
+        self.editing = False
+        self.parentApp.switchForm("MAIN")

clid/database.py

@@ -74,15 +74,16 @@ def load_files_and_set_values(self):
         self.meta_cache = dict()
 
 
-    def parse_meta_for_status(self, filename):
+    def parse_meta_for_status(self, filename, force=False):
         """Make a string like 'artist - album - track_number. title' from a filename
            (using file_dict and data[attributes])
 
            Args:
                 filename: the filename(*not* the absolute path)
+                force: reconstruct the string even if it has already been made
         """
         temp = self.pre_format   # make a copy of format and replace specifiers with tags
-        if not filename in self.meta_cache:
+        if not filename in self.meta_cache or force:
             try:
                 meta = stagger.read_tag(self.file_dict[filename])
                 for spec in self.specifiers:   # str to convert track number to str if given

clid/main.py

@@ -55,10 +55,16 @@ class ClidMultiline(npy.MultiLine):
     """MultiLine class to be used by clid. `Esc` has been modified to revert
        the screen back to the normal view after a searh has been performed
        (the search results will be shown; blank if no matches are found)
+       or if files have been selected. If files are selected *and* search
+       has been performed, selected files will be kept intact and search will
+       be reverted
 
        Attributes:
             space_selected_values(list):
                 Stores list of files which was selected for batch tagging using <Space>
+            _space_selected_values(list):
+                (property) List of indexes of space selected files *in context with
+                self.parent.wMain.values*
 
        Note:
             self.parent refers to ClidInterface -> class
@@ -73,16 +79,20 @@ def __init__(self, *args, **kwargs):
             curses.ascii.SP:  self.h_multi_select,
             curses.ascii.ESC: self.h_revert_escape,
         })
-        
+
         self.allow_filtering = False   # does NOT refer to search invoked with '/'
         self.space_selected_values = []
-        
+
         smooth = self.parent.parentApp.settings['smooth_scroll']   # is smooth scroll enabled ?
         self.slow_scroll = True if smooth == 'true' else False
 
-    def set_status(self, filename):
+    @property
+    def _space_selected_values(self):
+        return [self.values.index(file) for file in self.space_selected_values if file in self.values]
+
+    def set_status(self, filename, **kwargs):
         """Set the the value of self.parent.wStatus2 with metadata of file under cursor."""
-        self.parent.wStatus2.value = self.parent.value.parse_meta_for_status(filename=filename)
+        self.parent.wStatus2.value = self.parent.value.parse_meta_for_status(filename=filename, **kwargs)
         self.parent.display()
 
     def get_selected(self):
@@ -101,16 +111,15 @@ def h_revert_escape(self, char):
         if self.parent.after_search_now_filter_view:   # if screen is showing search results
             self.values = self.parent.value.get_all_values()   # revert
             self.parent.after_search_now_filter_view = False
+        elif len(self.space_selected_values):
+            self.space_selected_values = []
 
             self.display()
 
 # TODO: make it faster
 
     def filter_value(self, index):
-        if self._filter in self.display_value(self.values[index]).lower():   # ignore case
-            return True
-        else:
-            return False
+        return self._filter in self.display_value(self.values[index]).lower   # ignore case
 
     def h_switch_to_settings(self, char):
         self.parent.parentApp.switchForm("SETTINGS")
@@ -149,17 +158,22 @@ def h_cursor_page_up(self, char):
             self.set_status(self.get_selected())
 
     def h_select(self, char):
-        self.parent.parentApp.current_file = self.parent.value.file_dict[self.get_selected()]
+        self.parent.parentApp.current_file = [self.parent.value.file_dict[self.get_selected()]]
         self.parent.parentApp.switchForm("EDIT")
 
     def h_multi_select(self, char):
-        if self.cursor_line in self.space_selected_values:
-            self.space_selected_values.remove(self.cursor_line)
+        """Add or remove current line from list of lines
+           to be highlighted, when <Space> is pressed.
+        """
+        current = self.get_selected()
+        if current in self.space_selected_values:
+            self.space_selected_values.remove(current)
         else:
-            self.space_selected_values.append(self.cursor_line)
+            self.space_selected_values.append(current)
 
     def _set_line_highlighting(self, line, value_indexer):
-        if value_indexer in self.space_selected_values:
+        """Highlight files which were selected with <Space>"""
+        if value_indexer in self._space_selected_values:
             self.set_is_line_important(line, True)   # mark as important
         else:
             self.set_is_line_important(line, False)