arsenetar
/
dupeguru
mirror of https://github.com/arsenetar/dupeguru.git
1
0
Fork 0
Code Releases Wiki Activity

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.
This commit is contained in:
Virgil Dupras 2013-07-14 17:43:58 -04:00
parent bdd5f0a515
commit 7891fb5396
9 changed files with 150 additions and 133 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
core/app.py
View File

@ -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()

5
core/fs.py
View File

@ -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):

26
core/tests/base.py
View File

@ -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

47
core_me/app.py
View File

@ -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)

46
core_me/fs.py
View File

@ -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)

41
core_pe/app.py
View File

@ -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)

40
core_pe/photo.py
View File

@ -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':

34
core_se/app.py
View File

@ -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()

39
core_se/fs.py Normal file
View File

@ -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),
}