From 7891fb53960f06bc6834f837440a46a887976cc5 Mon Sep 17 00:00:00 2001 From: Virgil Dupras Date: Sun, 14 Jul 2013 17:43:58 -0400 Subject: [PATCH] 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 | 5 +---- core/fs.py | 5 +++++ core/tests/base.py | 26 ++++++++++++------------- core_me/app.py | 47 +--------------------------------------------- core_me/fs.py | 46 ++++++++++++++++++++++++++++++++++++++++++++- core_pe/app.py | 41 ++-------------------------------------- core_pe/photo.py | 40 ++++++++++++++++++++++++++++++++++++++- core_se/app.py | 34 +++++---------------------------- core_se/fs.py | 39 ++++++++++++++++++++++++++++++++++++++ 9 files changed, 150 insertions(+), 133 deletions(-) create mode 100644 core_se/fs.py diff --git a/core/app.py b/core/app.py index c2f5b02d..f18bf59c 100644 --- a/core/app.py +++ b/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() diff --git a/core/fs.py b/core/fs.py index fbfaa07e..f9228ecc 100644 --- a/core/fs.py +++ b/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): diff --git a/core/tests/base.py b/core/tests/base.py index 3c44dc24..7c1f94f3 100644 --- a/core/tests/base.py +++ b/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 diff --git a/core_me/app.py b/core_me/app.py index b1c80562..eb9124da 100644 --- a/core_me/app.py +++ b/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, format_timestamp, - format_perc, format_words, format_dupe_count) +from core.app import DupeGuru as DupeGuruBase 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) diff --git a/core_me/fs.py b/core_me/fs.py index 276c18a7..528f060d 100644 --- a/core_me/fs.py +++ b/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) diff --git a/core_pe/app.py b/core_pe/app.py index 6d937022..adead631 100644 --- a/core_pe/app.py +++ b/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, format_timestamp, format_perc, - format_dupe_count, cmp_value) +from core.app import DupeGuru as DupeGuruBase, 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) diff --git a/core_pe/photo.py b/core_pe/photo.py index eb1fb635..f7352011 100644 --- a/core_pe/photo.py +++ b/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': diff --git a/core_se/app.py b/core_se/app.py index 29b52a7d..880a4b45 100644 --- a/core_se/app.py +++ b/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, format_timestamp, format_perc, - format_words, format_dupe_count) +from core.app import DupeGuru as DupeGuruBase 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): - size = dupe.size - 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 - 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 __init__(self, view, appdata): + DupeGuruBase.__init__(self, view, appdata) + self.directories.fileclasses = [fs.File] def _prioritization_categories(self): return prioritize.all_categories() diff --git a/core_se/fs.py b/core_se/fs.py new file mode 100644 index 00000000..78d0946b --- /dev/null +++ b/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), + } +