Refactoring: Moved some code from app.DupeGuru to fs.File.

Moved DupeGuru._get_display_info() to File.get_display_info().
This method used none of the app's global state or methods
and had nothing to do there.

core/app.py

@@ -128,9 +128,6 @@ class DupeGuru(RegistrableApplication, Broadcaster):
             child.connect()
     
     #--- Virtual
-    def _get_display_info(self, dupe, group, delta):
-        raise NotImplementedError()
-    
     def _prioritization_categories(self):
         raise NotImplementedError()
     
@@ -389,7 +386,7 @@ class DupeGuru(RegistrableApplication, Broadcaster):
         if (dupe is None) or (group is None):
             return empty_data()
         try:
-            return self._get_display_info(dupe, group, delta)
+            return dupe.get_display_info(group, delta)
         except Exception as e:
             logging.warning("Exception on GetDisplayInfo for %s: %s", str(dupe.path), str(e))
             return empty_data()

core/fs.py

@@ -145,6 +145,11 @@ class File:
             raise OperationError(self)
         self.path = destpath
     
+    def get_display_info(self, group, delta):
+        """Returns a display-ready dict of dupe's data.
+        """
+        raise NotImplementedError()
+    
     #--- Properties
     @property
     def extension(self):

core/tests/base.py

@@ -62,19 +62,6 @@ class DupeGuru(DupeGuruBase):
     def __init__(self):
         DupeGuruBase.__init__(self, DupeGuruView(), '/tmp')
     
-    def _get_display_info(self, dupe, group, delta):
-        size = dupe.size
-        m = group.get_match_of(dupe)
-        if m and delta:
-            r = group.ref
-            size -= r.size
-        return {
-            'name': dupe.name,
-            'folder_path': str(dupe.folder_path),
-            'size': format_size(size, 0, 1, False),
-            'extension': dupe.extension if hasattr(dupe, 'extension') else '---',
-        }
-    
     def _get_dupe_sort_key(self, dupe, get_group, key, delta):
         r = cmp_value(dupe, key)
         if delta and (key in self.result_table.DELTA_COLUMNS):
@@ -107,6 +94,19 @@ class NamedObject:
     def __bool__(self):
         return False #Make sure that operations are made correctly when the bool value of files is false.
     
+    def get_display_info(self, group, delta):
+        size = self.size
+        m = group.get_match_of(self)
+        if m and delta:
+            r = group.ref
+            size -= r.size
+        return {
+            'name': self.name,
+            'folder_path': str(self.folder_path),
+            'size': format_size(size, 0, 1, False),
+            'extension': self.extension if hasattr(self, 'extension') else '---',
+        }
+    
     @property
     def path(self):
         return self._folder + self.name

core_me/app.py

@@ -5,10 +5,7 @@
 # which should be included with this package. The terms are also available at 
 # http://www.hardcoded.net/licenses/bsd_license
 
-from hscommon.util import format_size, format_time
+from core.app import DupeGuru as DupeGuruBase
-
-from core.app import (DupeGuru as DupeGuruBase, format_timestamp,
-    format_perc, format_words, format_dupe_count)
 from . import prioritize
 from . import __appname__
 from . import scanner, fs
@@ -24,48 +21,6 @@ class DupeGuru(DupeGuruBase):
         self.scanner = scanner.ScannerME()
         self.directories.fileclasses = [fs.MusicFile]
     
-    def _get_display_info(self, dupe, group, delta):
-        size = dupe.size
-        duration = dupe.duration
-        bitrate = dupe.bitrate
-        samplerate = dupe.samplerate
-        mtime = dupe.mtime
-        m = group.get_match_of(dupe)
-        if m:
-            percentage = m.percentage
-            dupe_count = 0
-            if delta:
-                r = group.ref
-                size -= r.size
-                duration -= r.duration
-                bitrate -= r.bitrate
-                samplerate -= r.samplerate
-                mtime -= r.mtime
-        else:
-            percentage = group.percentage
-            dupe_count = len(group.dupes)
-        dupe_folder_path = getattr(dupe, 'display_folder_path', dupe.folder_path)
-        return {
-            'name': dupe.name,
-            'folder_path': str(dupe_folder_path),
-            'size': format_size(size, 2, 2, False),
-            'duration': format_time(duration, with_hours=False),
-            'bitrate': str(bitrate),
-            'samplerate': str(samplerate),
-            'extension': dupe.extension,
-            'mtime': format_timestamp(mtime,delta and m),
-            'title': dupe.title,
-            'artist': dupe.artist,
-            'album': dupe.album,
-            'genre': dupe.genre,
-            'year': dupe.year,
-            'track': str(dupe.track),
-            'comment': dupe.comment,
-            'percentage': format_perc(percentage),
-            'words': format_words(dupe.words) if hasattr(dupe, 'words') else '',
-            'dupe_count': format_dupe_count(dupe_count),
-        }
-    
     def _get_dupe_sort_key(self, dupe, get_group, key, delta):
         if key == 'folder_path':
             dupe_folder_path = getattr(dupe, 'display_folder_path', dupe.folder_path)

core_me/fs.py

@@ -7,7 +7,9 @@
 # http://www.hardcoded.net/licenses/bsd_license
 
 from hsaudiotag import auto
-from hscommon.util import get_file_ext
+from hscommon.util import get_file_ext, format_size, format_time
+
+from core.app import format_timestamp, format_perc, format_words, format_dupe_count
 from core import fs
 
 TAG_FIELDS = {'audiosize', 'duration', 'bitrate', 'samplerate', 'title', 'artist',
@@ -36,6 +38,48 @@ class MusicFile(fs.File):
             return False
         return get_file_ext(path[-1]) in auto.EXT2CLASS
     
+    def get_display_info(self, group, delta):
+        size = self.size
+        duration = self.duration
+        bitrate = self.bitrate
+        samplerate = self.samplerate
+        mtime = self.mtime
+        m = group.get_match_of(self)
+        if m:
+            percentage = m.percentage
+            dupe_count = 0
+            if delta:
+                r = group.ref
+                size -= r.size
+                duration -= r.duration
+                bitrate -= r.bitrate
+                samplerate -= r.samplerate
+                mtime -= r.mtime
+        else:
+            percentage = group.percentage
+            dupe_count = len(group.dupes)
+        dupe_folder_path = getattr(self, 'display_folder_path', self.folder_path)
+        return {
+            'name': self.name,
+            'folder_path': str(dupe_folder_path),
+            'size': format_size(size, 2, 2, False),
+            'duration': format_time(duration, with_hours=False),
+            'bitrate': str(bitrate),
+            'samplerate': str(samplerate),
+            'extension': self.extension,
+            'mtime': format_timestamp(mtime,delta and m),
+            'title': self.title,
+            'artist': self.artist,
+            'album': self.album,
+            'genre': self.genre,
+            'year': self.year,
+            'track': str(self.track),
+            'comment': self.comment,
+            'percentage': format_perc(percentage),
+            'words': format_words(self.words) if hasattr(self, 'words') else '',
+            'dupe_count': format_dupe_count(dupe_count),
+        }
+    
     def _get_md5partial_offset_and_size(self):
         f = auto.File(str(self.path))
         return (f.audio_offset, f.audio_size)

core_pe/app.py

@@ -7,21 +7,13 @@
 
 import os.path as op
 
-from hscommon.util import format_size
+from core.app import DupeGuru as DupeGuruBase, cmp_value
-
-from core.app import (DupeGuru as DupeGuruBase, format_timestamp, format_perc,
-    format_dupe_count, cmp_value)
 from .scanner import ScannerPE
 from . import prioritize
 from . import __appname__
+from .fs import get_delta_dimensions
 from .result_table import ResultTable
 
-def format_dimensions(dimensions):
-    return '%d x %d' % (dimensions[0], dimensions[1])
-
-def get_delta_dimensions(value, ref_value):
-    return (value[0]-ref_value[0], value[1]-ref_value[1])
-
 class DupeGuru(DupeGuruBase):
     NAME = __appname__
     METADATA_TO_READ = ['size', 'mtime', 'dimensions', 'exif_timestamp']
@@ -31,35 +23,6 @@ class DupeGuru(DupeGuruBase):
         self.scanner = ScannerPE()
         self.scanner.cache_path = op.join(self.appdata, 'cached_pictures.db')
     
-    def _get_display_info(self, dupe, group, delta):
-        size = dupe.size
-        mtime = dupe.mtime
-        dimensions = dupe.dimensions
-        m = group.get_match_of(dupe)
-        if m:
-            percentage = m.percentage
-            dupe_count = 0
-            if delta:
-                r = group.ref
-                size -= r.size
-                mtime -= r.mtime
-                dimensions = get_delta_dimensions(dimensions, r.dimensions)
-        else:
-            percentage = group.percentage
-            dupe_count = len(group.dupes)
-        dupe_folder_path = getattr(dupe, 'display_folder_path', dupe.folder_path)
-        return {
-            'name': dupe.name,
-            'folder_path': str(dupe_folder_path),
-            'size': format_size(size, 0, 1, False),
-            'extension': dupe.extension,
-            'dimensions': format_dimensions(dimensions),
-            'exif_timestamp': dupe.exif_timestamp,
-            'mtime': format_timestamp(mtime, delta and m),
-            'percentage': format_perc(percentage),
-            'dupe_count': format_dupe_count(dupe_count),
-        }
-    
     def _get_dupe_sort_key(self, dupe, get_group, key, delta):
         if key == 'folder_path':
             dupe_folder_path = getattr(dupe, 'display_folder_path', dupe.folder_path)

core_pe/photo.py

@@ -7,10 +7,19 @@
 # http://www.hardcoded.net/licenses/bsd_license
 
 import logging
-from hscommon.util import get_file_ext
+from hscommon.util import get_file_ext, format_size
+
+from core.app import format_timestamp, format_perc, format_dupe_count
 from core import fs
 from . import exif
 
+def format_dimensions(dimensions):
+    return '%d x %d' % (dimensions[0], dimensions[1])
+
+def get_delta_dimensions(value, ref_value):
+    return (value[0]-ref_value[0], value[1]-ref_value[1])
+
+
 class Photo(fs.File):
     INITIAL_INFO = fs.File.INITIAL_INFO.copy()
     INITIAL_INFO.update({
@@ -44,6 +53,35 @@ class Photo(fs.File):
     def can_handle(cls, path):
         return fs.File.can_handle(path) and get_file_ext(path[-1]) in cls.HANDLED_EXTS
     
+    def get_display_info(self, group, delta):
+        size = self.size
+        mtime = self.mtime
+        dimensions = self.dimensions
+        m = group.get_match_of(self)
+        if m:
+            percentage = m.percentage
+            dupe_count = 0
+            if delta:
+                r = group.ref
+                size -= r.size
+                mtime -= r.mtime
+                dimensions = get_delta_dimensions(dimensions, r.dimensions)
+        else:
+            percentage = group.percentage
+            dupe_count = len(group.dupes)
+        dupe_folder_path = getattr(self, 'display_folder_path', self.folder_path)
+        return {
+            'name': self.name,
+            'folder_path': str(dupe_folder_path),
+            'size': format_size(size, 0, 1, False),
+            'extension': self.extension,
+            'dimensions': format_dimensions(dimensions),
+            'exif_timestamp': self.exif_timestamp,
+            'mtime': format_timestamp(mtime, delta and m),
+            'percentage': format_perc(percentage),
+            'dupe_count': format_dupe_count(dupe_count),
+        }
+    
     def _read_info(self, field):
         fs.File._read_info(self, field)
         if field == 'dimensions':

core_se/app.py

@@ -5,42 +5,18 @@
 # which should be included with this package. The terms are also available at 
 # http://www.hardcoded.net/licenses/bsd_license
 
-from hscommon.util import format_size
+from core.app import DupeGuru as DupeGuruBase
-
-from core.app import (DupeGuru as DupeGuruBase, format_timestamp, format_perc,
-    format_words, format_dupe_count)
 from core import prioritize
-from . import __appname__
+from . import __appname__, fs
 from .result_table import ResultTable
 
 class DupeGuru(DupeGuruBase):
     NAME = __appname__
     METADATA_TO_READ = ['size', 'mtime']
     
-    def _get_display_info(self, dupe, group, delta):
+    def __init__(self, view, appdata):
-        size = dupe.size
+        DupeGuruBase.__init__(self, view, appdata)
-        mtime = dupe.mtime
+        self.directories.fileclasses = [fs.File]
-        m = group.get_match_of(dupe)
-        if m:
-            percentage = m.percentage
-            dupe_count = 0
-            if delta:
-                r = group.ref
-                size -= r.size
-                mtime -= r.mtime
-        else:
-            percentage = group.percentage
-            dupe_count = len(group.dupes)
-        return {
-            'name': dupe.name,
-            'folder_path': str(dupe.folder_path),
-            'size': format_size(size, 0, 1, False),
-            'extension': dupe.extension,
-            'mtime': format_timestamp(mtime, delta and m),
-            'percentage': format_perc(percentage),
-            'words': format_words(dupe.words) if hasattr(dupe, 'words') else '',
-            'dupe_count': format_dupe_count(dupe_count),
-        }
     
     def _prioritization_categories(self):
         return prioritize.all_categories()

core_se/fs.py

@@ -0,0 +1,39 @@
+# Created By: Virgil Dupras
+# Created On: 2013-07-14
+# Copyright 2013 Hardcoded Software (http://www.hardcoded.net)
+# 
+# This software is licensed under the "BSD" License as described in the "LICENSE" file, 
+# which should be included with this package. The terms are also available at 
+# http://www.hardcoded.net/licenses/bsd_license
+
+from hscommon.util import format_size
+
+from core import fs
+from core.app import format_timestamp, format_perc, format_words, format_dupe_count
+
+class File(fs.File):
+    def get_display_info(self, group, delta):
+        size = self.size
+        mtime = self.mtime
+        m = group.get_match_of(self)
+        if m:
+            percentage = m.percentage
+            dupe_count = 0
+            if delta:
+                r = group.ref
+                size -= r.size
+                mtime -= r.mtime
+        else:
+            percentage = group.percentage
+            dupe_count = len(group.dupes)
+        return {
+            'name': self.name,
+            'folder_path': str(self.folder_path),
+            'size': format_size(size, 0, 1, False),
+            'extension': self.extension,
+            'mtime': format_timestamp(mtime, delta and m),
+            'percentage': format_perc(percentage),
+            'words': format_words(self.words) if hasattr(self, 'words') else '',
+            'dupe_count': format_dupe_count(dupe_count),
+        }
+