Ȫ!BĢvdD//C *5)yCE'BodW~e*F/3vFU /44!nI֞z\+M%G,6TbD S`J:̚tV 1z{':OfPզ1 }
BcR!L!?)gFO7p2;/уc̫;nwpE?Nw" ; QT(<սC!,"yީj>xC`etx"SvwĬ! &y,mo Z |} v53 f^fE#]tUZ0CG
.pf)2ppRa'0zg':)7?oՊ4z0gPJQ^JQ^ɵｔMolM `۶a=/<}O5 ß@L3RˡOWp6ޫB)6ѵA ^7U5Ĕ\[Y +as#i HSܯ(} QRp$;?m=|mwWC
5'85ׇaSܰ" M @ڂ 3חCP3у3 YVgj<SL ]f-iZ?"! :R|b
ÅR'^V299-ox}v{mp*ͽxg, v 3>Y]pLò,m-㌧-t`GA3a"/$ЬlXm LWsZúUqq4]>u C ՜'Țzym"-^SN]r9WwKeE}Od4bW a `S{wu#+T x/m4 U*G0Z \1i>Ket.SmtږUeżƁ pb"Vw* y z?>q5,E&ѶmÝa}Zl6g?*_);?Yۨ%e.i8!u܉¿
t lH{uz0 !k( >:TbK<&Bفyڇe6ьq!3P-AVo87yY.~?axF#f#X~!qApaF^ +>i;
s$ Wu
MnSgmaPχ' @Z+
Qz aAG[mʋ( Enter a description for the current cover. For ID3 tags the description has to be different for each '
"cover as per the ID3 spec. If they don't differ then spaces "
'are appended to the description when the tag is saved. Select a cover type for the artwork.
modify the key sequence.'))
self.actionTable = QTableWidget(self)
self.actionTable.setSelectionBehavior(QTableWidget.SelectRows)
self.actionTable.setEditTriggers(QTableWidget.DoubleClicked)
self.actionTable.setColumnCount(2)
self.actionTable.setHorizontalHeaderLabels(
[translate("Shortcut Settings", "Description"),
translate("Shortcut Settings", "Shortcut")]
)
self.actionTable.horizontalHeader().setStretchLastSection(True)
self.actionTable.verticalHeader().hide()
self.actionTable.setItemDelegate(ActionEditorDelegate(self))
self.connect(self.actionTable, SIGNAL("cellChanged(int, int)"),
self.validateAction)
row = 0
for action in self.actions:
if action.text().isEmpty():
continue
self.actionTable.insertRow(self.actionTable.rowCount())
item = QTableWidgetItem()
item.setText(action.text())
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
self.actionTable.setItem(row, 0, item)
item = QTableWidgetItem()
item.setText(action.shortcut().toString())
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsEditable | Qt.ItemIsSelectable)
item.oldShortcutText = item.text()
self.actionTable.setItem(row, 1, item)
row += 1
self.actionTable.resizeColumnsToContents()
mainLayout = QVBoxLayout()
mainLayout.addWidget(help)
mainLayout.setMargin(8)
mainLayout.setSpacing(8)
mainLayout.addWidget(self.actionTable)
self.setLayout(mainLayout)
self._model = self.actionTable.model()
self._model.edited = False
self.actionTable.model().edited = False
self.setWindowTitle(translate("Shortcut Settings", "Edit Shortcuts"))
def applySettings(self, control=None):
if not self._model.edited:
return
row = 0
for action in self.actions:
if not action.text().isEmpty():
action.setText(self.actionTable.item(row, 0).text())
action.setShortcut(QKeySequence(self.actionTable.item(row, 1).text()))
row += 1
self.saveSettings(self.actions)
self._model.edited = False
def _loadSettings(self, actions):
cparser = PuddleConfig(os.path.join(SAVEDIR, 'user_shortcuts'))
for action in actions:
shortcut = cparser.get('shortcuts', unicode(action.text()), '')
if shortcut:
action.setShortcut(QKeySequence(shortcut))
_loadSettings = classmethod(_loadSettings)
def saveSettings(self, actions):
cparser = PuddleConfig(os.path.join(SAVEDIR, 'user_shortcuts'))
for action in actions:
shortcut = unicode(action.shortcut().toString())
cparser.set('shortcuts', unicode(action.text()), shortcut)
saveSettings = classmethod(saveSettings)
def validateAction(self, row, column):
if column != 1:
return
item = self.actionTable.item(row, column)
shortcutText = QKeySequence(item.text()).toString()
thisRow = self.actionTable.row(item)
if not shortcutText.isEmpty():
for row in range(self.actionTable.rowCount()):
if row == thisRow:
continue
other = self.actionTable.item(row, 1)
if other.text() == shortcutText:
other.setText(item.oldShortcutText)
break
item.setText(shortcutText)
item.oldShortcutText = shortcutText
self.actionTable.resizeColumnToContents(1)
if __name__ == '__main__':
app = QApplication(sys.argv)
#win = ShortcutSettings()
#win = EditShortcut('Open', 'Ctrl+O')
widget = QWidget()
actions = ls.get_actions(widget)
ActionEditorDialog._loadSettings(actions)
win = ActionEditorDialog(actions)
#win.loadSettings(actions)
win.show()
app.exec_() puddletag-1.0.2/puddlestuff/audio_filter.py 0000644 0001750 0000144 00000013576 12020617020 021315 0 ustar keith users 0000000 0000000 # -*- coding: utf-8 -*-
import pdb, sys, logging
from pyparsing import *
import puddlestuff.findfunc as findfunc
import puddlestuff.audioinfo as audioinfo
from puddlestuff.util import to_string
from puddlestuff.puddleobjects import gettaglist, timemethod
import time
def str_cmp(a, b):
if not isinstance(a, basestring):
a = u'\\'.join(a)
if not isinstance(b, basestring):
b = u'\\'.join(b)
return a.lower() == b.lower()
FIELDS = set(z.lower() for z in gettaglist()).union(audioinfo.FILETAGS)
if len(sys.argv) > 1:
logging.basicConfig(stream=sys.stderr, level=logging.DEBUG)
def parse_arg(audio, text):
if not isinstance(text, basestring):
return text
if text[0] == u'%' and text[-1] == u'%':
return to_string(audio.get(text[1:-1], u''))
elif text in FIELDS:
return to_string(audio.get(text, u''))
else:
if text[0] == u'"' and text[-1] == u'"':
text = text[1:-1]
return findfunc.parsefunc(text, audio)
return u""
def wrap_nonzero(nonzero):
def __nonzero__(self):
if hasattr(self, 'args'):
self.args = [parse_arg(self.audio, z) for z in self.args]
else:
self.arg = parse_arg(self.audio, self.arg)
return nonzero(self)
return __nonzero__
class BoolOperand(object):
def __init__(self,t):
self.args = t[0][0::2]
class BoolAnd(BoolOperand):
@wrap_nonzero
def __nonzero__(self):
logging.debug('and: ' + unicode(self.args))
for a in self.args:
if not bool(a):
return False
return True
class BoolOr(BoolOperand):
@wrap_nonzero
def __nonzero__(self):
logging.debug('or: ' + unicode(self.args))
for a in self.args:
if bool(a):
return True
return False
class BoolNot(BoolOperand):
def __init__(self,t):
self.arg = t[0][1]
@wrap_nonzero
def __nonzero__(self):
logging.debug('not: ' + unicode(self.arg))
if isinstance(self.arg, basestring):
arg = self.arg.lower()
for v in self.audio.values():
if isinstance(v, basestring):
v = [v]
v = u'\\\\'.join(v).lower()
if arg in v:
return False
return True
return not bool(self.arg)
class Greater(BoolOperand):
@wrap_nonzero
def __nonzero__(self):
logging.debug('greater: ' + unicode(self.args))
try: self.args = map(float, self.args)
except ValueError: pass
return self.args[0] > self.args[1]
class Less(BoolOperand):
@wrap_nonzero
def __nonzero__(self):
logging.debug('less: ' + unicode(self.args))
try: self.args = map(float, self.args)
except ValueError: pass
return self.args[0] < self.args[1]
class Equal(BoolOperand):
@wrap_nonzero
def __nonzero__(self):
logging.debug('equal: ' + unicode(self.args))
return str_cmp(self.args[0], self.args[1])
class Missing(BoolOperand):
def __init__(self, t):
self.arg = t[0][1]
def __nonzero__(self):
logging.debug('missing: ' + unicode(self.arg))
if getattr(self, "audio", None):
return not (self.arg in self.audio)
return False
class Present(BoolOperand):
def __init__(self, t):
self.arg = t[0][1]
def __nonzero__(self):
logging.debug('present: ' + unicode(self.arg))
if getattr(self, "audio", None):
return (self.arg in self.audio)
return False
class BoolIs(BoolOperand):
@wrap_nonzero
def __nonzero__(self):
logging.debug('is: ' + unicode(self.args))
return str_cmp(self.args[0], self.args[1])
class Has(BoolOperand):
@wrap_nonzero
def __nonzero__(self):
logging.debug('has: ' + unicode(self.args))
return self.args[1].lower() in self.args[0].lower()
bool_exprs = [
(CaselessLiteral("missing"), 1, opAssoc.RIGHT, Missing),
(CaselessLiteral("present"), 1, opAssoc.RIGHT, Present),
(CaselessLiteral("greater"), 2, opAssoc.LEFT, Greater),
(CaselessLiteral("less"), 2, opAssoc.LEFT, Less),
(CaselessLiteral("equal"), 2, opAssoc.LEFT, Equal),
(CaselessLiteral("has"), 2, opAssoc.LEFT, Has),
(CaselessLiteral("is"), 2, opAssoc.LEFT, BoolIs),
(CaselessLiteral("and"), 2, opAssoc.LEFT, BoolAnd),
(CaselessLiteral("or"), 2, opAssoc.LEFT, BoolOr),
(CaselessLiteral("not"), 1, opAssoc.RIGHT, BoolNot),
]
field_expr = Combine(u'%' + Word(alphanums + '_') + u'%')
tokens = QuotedString('"', unquoteResults=False) \
| field_expr | Word(alphanums + '_')
bool_expr = operatorPrecedence(tokens, bool_exprs)
bool_expr.enablePackrat()
def parse(audio, expr):
for i in bool_exprs:
i[3].audio = audio
res = bool_expr.parseString(expr)[0]
if isinstance(res, basestring):
res = res.lower()
for field, value in audio.items():
if isinstance(value, basestring):
value = [value]
try:
if res in u'\\\\'.join(value).lower():
return True
except TypeError:
return True
else:
return bool(res)
return False
if __name__ == '__main__':
audio = audioinfo.Tag('clen.mp3')
#parse(audio, "not p")
#parse(audio, 'not missing artist')
#parse(audio, '7 greater 6')
#parse(audio, '%track% greater 14')
#parse(audio, '%track% greater "$add($len(%artist%), 50)"')
#t = time.time()
#parse(audio, '(not missing artist) and (20 greater 19)')
#parse(audio, 'not (20 greater 19)')
#print time.time() - t
#parse(audio, 'not missing artist and 18 greater 19')
#parse(audio, 'artist is "Carl Douglas"')
#parse(audio, "artist has aarl")
#parse(audio, "artist has Carl")
import time
t = time.time()
print audio.filepath
print parse(audio, '__filename has clen')
puddletag-1.0.2/puddlestuff/puddleobjects.py 0000644 0001750 0000144 00000236343 12236751677 021527 0 ustar keith users 0000000 0000000 #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
Contains objects used throughout puddletag"""
from PyQt4.QtGui import *
from PyQt4.QtCore import *
from PyQt4.QtSvg import *
import sys, os,pdb,shutil
from itertools import groupby # for unique function.
from bisect import bisect_left, insort_left # for unique function.
from copy import copy
import audioinfo
from audioinfo import (IMAGETYPES, DESCRIPTION, DATA, IMAGETYPE, DEFAULT_COVER,
encode_fn, decode_fn, INFOTAGS)
from operator import itemgetter
path = os.path
from configobj import ConfigObj
import traceback
import time, re
from glob import glob
from constants import ACTIONDIR, SAVEDIR
from PyQt4.QtCore import QFile, QIODevice
from StringIO import StringIO
import itertools
MSGARGS = (QMessageBox.Warning, QMessageBox.Yes or QMessageBox.Default,
QMessageBox.No or QMessageBox.Escape, QMessageBox.YesAll)
from functools import partial
from puddlestuff.translations import translate
# Parameters for string distance function.
# Words that can be moved to the end of a string using a comma.
SD_END_WORDS = ['the', 'a', 'an']
# Reduced weights for certain portions of the string.
SD_PATTERNS = [
(r'^the ', 0.1),
(r'[\[\(]?(ep|single)[\]\)]?', 0.0),
(r'[\[\(]?(featuring|feat|ft)[\. :].+', 0.1),
(r'\(.*?\)', 0.3),
(r'\[.*?\]', 0.3),
(r'(, )?(pt\.|part) .+', 0.2),
]
mod_keys = {
Qt.ShiftModifier: u'Shift',
Qt.MetaModifier: u'Meta',
Qt.AltModifier: u'Alt',
Qt.ControlModifier: u'Ctrl',
Qt.NoModifier: u'',
Qt.KeypadModifier: u'',
Qt.GroupSwitchModifier: u'',}
def keycmp(a, b):
if a == b:
return 0
if a == Qt.CTRL:
return -1
elif b == Qt.CTRL:
return 1
if a == Qt.SHIFT:
return -1
elif b == Qt.SHIFT:
return 1
if a == Qt.ALT:
return -1
elif b == Qt.ALT:
return 1
if a == Qt.META:
return -1
elif b == Qt.META:
return 1
return 0
try:
permutations = itertools.permutations
except AttributeError:
#Using python < 2.6
def permutations(iterable, r=None):
# permutations('ABCD', 2) --> AB AC AD BA BC BD CA CB CD DA DB DC
# permutations(range(3)) --> 012 021 102 120 201 210
pool = tuple(iterable)
n = len(pool)
r = n if r is None else r
if r > n:
return
indices = range(n)
cycles = range(n, n-r, -1)
yield tuple(pool[i] for i in indices[:r])
while n:
for i in reversed(range(r)):
cycles[i] -= 1
if cycles[i] == 0:
indices[i:] = indices[i+1:] + indices[i:i+1]
cycles[i] = n - i
else:
j = cycles[i]
indices[i], indices[-j] = indices[-j], indices[i]
yield tuple(pool[i] for i in indices[:r])
break
else:
return
modifiers = {}
for i in range(1,len(mod_keys)):
for keys in set(permutations(mod_keys, i)):
mod = keys[0]
for key in keys[1:]:
mod = mod | key
modifiers[int(mod)] = u'+'.join(mod_keys[key] for key in sorted(keys, cmp=keycmp) if mod_keys[key])
mod_keys = set((Qt.Key_Shift, Qt.Key_Control, Qt.Key_Meta, Qt.Key_Alt))
imagetypes = [
(translate('Cover Type', 'Other'), translate("Cover Type", 'O')),
(translate('Cover Type', 'File Icon'), translate("Cover Type", 'I')),
(translate('Cover Type', 'Other File Icon'), translate("Cover Type", 'OI')),
(translate('Cover Type', 'Cover (front)'), translate("Cover Type", 'CF')),
(translate('Cover Type', 'Cover (back)'), translate("Cover Type", 'CB')),
(translate('Cover Type', 'Leaflet page'), translate("Cover Type", 'LF')),
(translate('Cover Type', 'Media (e.g. label side of CD)'), translate("Cover Type", 'M')),
(translate('Cover Type', 'Lead artist'), translate("Cover Type", 'LA')),
(translate('Cover Type', 'Artist'), translate("Cover Type", 'A')),
(translate('Cover Type', 'Conductor'), translate("Cover Type", 'C')),
(translate('Cover Type', 'Band'), translate("Cover Type", 'B')),
(translate("Cover Type", 'Composer'), translate("Cover Type", 'CP')),
(translate("Cover Type", 'Lyricist'), translate("Cover Type", 'L')),
(translate("Cover Type", 'Recording Location'), translate("Cover Type", 'RL')),
(translate("Cover Type", 'During recording'), translate("Cover Type", 'DR')),
(translate("Cover Type", 'During performance'), translate("Cover Type", 'DP')),
(translate("Cover Type", 'Movie/video screen capture'), translate("Cover Type", 'MC')),
(translate("Cover Type", 'A bright coloured fish'), translate("Cover Type", 'F')),
(translate("Cover Type", 'Illustration'), translate("Cover Type", 'P')),
(translate("Cover Type", 'Band/artist logotype'), translate("Cover Type", 'BL')),
(translate("Cover Type", 'Publisher/Studio logotype'), translate("Cover Type", 'PL'))]
def trans_imagetypes():
global imagetypes
imagetypes = [
(translate('Cover Type', 'Other'), translate("Cover Type", 'O')),
(translate('Cover Type', 'File Icon'), translate("Cover Type", 'I')),
(translate('Cover Type', 'Other File Icon'), translate("Cover Type", 'OI')),
(translate('Cover Type', 'Cover (front)'), translate("Cover Type", 'CF')),
(translate('Cover Type', 'Cover (back)'), translate("Cover Type", 'CB')),
(translate('Cover Type', 'Leaflet page'), translate("Cover Type", 'LF')),
(translate('Cover Type', 'Media (e.g. label side of CD)'), translate("Cover Type", 'M')),
(translate('Cover Type', 'Lead artist'), translate("Cover Type", 'LA')),
(translate('Cover Type', 'Artist'), translate("Cover Type", 'A')),
(translate('Cover Type', 'Conductor'), translate("Cover Type", 'C')),
(translate('Cover Type', 'Band'), translate("Cover Type", 'B')),
(translate("Cover Type", 'Composer'), translate("Cover Type", 'CP')),
(translate("Cover Type", 'Lyricist'), translate("Cover Type", 'L')),
(translate("Cover Type", 'Recording Location'), translate("Cover Type", 'RL')),
(translate("Cover Type", 'During recording'), translate("Cover Type", 'DR')),
(translate("Cover Type", 'During performance'), translate("Cover Type", 'DP')),
(translate("Cover Type", 'Movie/video screen capture'), translate("Cover Type", 'MC')),
(translate("Cover Type", 'A bright coloured fish'), translate("Cover Type", 'F')),
(translate("Cover Type", 'Illustration'), translate("Cover Type", 'P')),
(translate("Cover Type", 'Band/artist logotype'), translate("Cover Type", 'BL')),
(translate("Cover Type", 'Publisher/Studio logotype'), translate("Cover Type", 'PL'))]
class CoverButton(QPushButton):
def __init__(self, *args):
QPushButton.__init__(self, *args)
menu = QMenu(self)
triggered = SIGNAL('triggered()')
def create(title, short, index):
text = u'[%s] %s' % (short, title)
action = QAction(text, self)
self.connect(action, triggered, lambda: self.setCurrentIndex(index))
return action
actions = [create(title, short, index) for index, (title, short)
in enumerate(imagetypes)]
map(menu.addAction, actions)
self.setMenu(menu)
self.setCurrentIndex(3)
def setCurrentIndex(self, index):
try:
self.setText(imagetypes[index][1])
except IndexError:
self.setText(imagetypes[DEFAULT_COVER][1])
self.emit(SIGNAL('currentIndexChanged (int)'), index)
self._index = index
def currentIndex(self):
return self._index
class PuddleConfig(object):
"""Module that allows you to values from INI config files, similar to
Qt's Settings module (Created it because PyQt4.4.3 has problems with
saving and loading lists.
Only two functions of interest:
get -> load a key from a specified section
set -> save a key section"""
def __init__(self, filename = None):
self.settings = ConfigObj(filename, create_empty=True, encoding='utf8')
if not filename:
filename = os.path.join(os.getenv('HOME'),'.puddletag', 'puddletag.conf')
self._setFilename(filename)
#TODO: backward compatibility, remove all.
self.setSection = self.set
self.load = self.get
def get(self, section, key, default, getint = False):
settings = self.settings
try:
if isinstance(default, bool):
if self.settings[section][key] == 'True':
return True
return False
elif getint or isinstance(default, (long,int)):
try:
return int(self.settings[section][key])
except TypeError:
return [int(z) for z in self.settings[section][key]]
else:
val = self.settings[section][key]
if val is None:
return default
return val
except KeyError:
return default
def set(self, section = None, key = None, value = None):
settings = self.settings
if section in self.settings:
settings[section][key] = value
else:
settings[section] = {}
settings[section][key] = value
settings.write()
def _setFilename(self, filename):
dirname = os.path.dirname(filename)
if not os.path.exists(dirname):
os.makedirs(dirname)
self.settings.filename = filename
self.savedir = dirname
self.settings.reload()
def _getFilename(self):
return self.settings.filename
def sections(self):
return self.settings.keys()
filename = property(_getFilename, _setFilename)
def _setupsaves(func):
filename = os.path.join(PuddleConfig().savedir, 'windowsizes')
settings = QSettings(filename, QSettings.IniFormat)
return lambda x, y: func(x, y, settings)
@_setupsaves
def savewinsize(name, dialog, settings):
settings.setValue(name, QVariant(dialog.saveGeometry()))
@_setupsaves
def winsettings(name, dialog, settings):
dialog.restoreGeometry(settings.value(name).toByteArray())
cevent = dialog.closeEvent
def closeEvent(self, event=None):
savewinsize(name, dialog)
if event is None:
cevent(self)
else:
cevent(event)
setattr(dialog, 'closeEvent', closeEvent)
#Next three functions from beets: http://code.google.com/p/beets
def _levenshtein(s1, s2):
"""A nice DP edit distance implementation from Wikibooks:
http://en.wikibooks.org/wiki/Algorithm_implementation/Strings/
Levenshtein_distance#Python
"""
if len(s1) < len(s2):
return _levenshtein(s2, s1)
if not s1:
return len(s2)
previous_row = xrange(len(s2) + 1)
for i, c1 in enumerate(s1):
current_row = [i + 1]
for j, c2 in enumerate(s2):
insertions = previous_row[j + 1] + 1
deletions = current_row[j] + 1
substitutions = previous_row[j] + (c1 != c2)
current_row.append(min(insertions, deletions, substitutions))
previous_row = current_row
return previous_row[-1]
def _string_dist_basic(str1, str2):
"""Basic edit distance between two strings, ignoring
non-alphanumeric characters and case. Normalized by string length.
"""
str1 = re.sub(r'[^a-z0-9]', '', str1.lower())
str2 = re.sub(r'[^a-z0-9]', '', str2.lower())
if not str1 and not str2:
return 0.0
return _levenshtein(str1, str2) / float(max(len(str1), len(str2)))
def ratio(str1, str2):
"""Gives an "intuitive" edit distance between two strings. This is
an edit distance, normalized by the string length, with a number of
tweaks that reflect intuition about text.
"""
str1 = str1.lower()
str2 = str2.lower()
# Don't penalize strings that move certain words to the end. For
# example, "the something" should be considered equal to
# "something, the".
for word in SD_END_WORDS:
if str1.endswith(', %s' % word):
str1 = '%s %s' % (word, str1[:-len(word)-2])
if str2.endswith(', %s' % word):
str2 = '%s %s' % (word, str2[:-len(word)-2])
# Change the weight for certain string portions matched by a set
# of regular expressions. We gradually change the strings and build
# up penalties associated with parts of the string that were
# deleted.
base_dist = _string_dist_basic(str1, str2)
penalty = 0.0
for pat, weight in SD_PATTERNS:
# Get strings that drop the pattern.
case_str1 = re.sub(pat, '', str1)
case_str2 = re.sub(pat, '', str2)
if case_str1 != str1 or case_str2 != str2:
# If the pattern was present (i.e., it is deleted in the
# the current case), recalculate the distances for the
# modified strings.
case_dist = _string_dist_basic(case_str1, case_str2)
case_delta = max(0.0, base_dist - case_dist)
if case_delta == 0.0:
continue
# Shift our baseline strings down (to avoid rematching the
# same part of the string) and add a scaled distance
# amount to the penalties.
str1 = case_str1
str2 = case_str2
base_dist = case_dist
penalty += weight * case_delta
dist = base_dist + penalty
return 1 - dist
dirlevels = lambda a: len(a.split('/'))
def removeslash(x):
while x.endswith('/'):
return removeslash(x[:-1])
return x
def create_buddy(text, control, box=None):
label = QLabel(text)
label.setBuddy(control)
if not box:
box = QHBoxLayout()
elif box is True:
box = QVBoxLayout()
box.addWidget(label)
box.addWidget(control, 1)
return box
def dircmp(a, b):
"""Compare function to sort directories via parent.
So that the child is renamed before parent, thereby not
giving Permission Denied errors."""
a, b = removeslash(a), removeslash(b)
if a == b:
return 0
elif a in b and (dirlevels(a) != dirlevels(b)):
return 1
elif b in a and (dirlevels(a) != dirlevels(b)):
return -1
elif len(a) > len(b):
return 1
elif len(b) > len(a):
return -1
elif len(b) == len(a):
return 0
def dircmp1(a, b):
"""Like dircmp, but returns dirs as being in the same directory as equal."""
a,b = removeslash(a), removeslash(b)
if a == b or (dirlevels(a) == dirlevels(b)):
return 0
elif a in b:
return 1
elif b in a:
return -1
else:
return 0
def issubfolder(parent, child, level = 1):
parent, child = removeslash(parent), removeslash(child)
if isinstance(parent, unicode):
sep = unicode(os.path.sep)
else:
sep = os.path.sep
if level is not None:
if child.startswith(parent + sep) and dirlevels(parent) + level == dirlevels(child):
return True
return False
else:
if child.startswith(parent + sep) and dirlevels(parent) < dirlevels(child):
return True
return False
HORIZONTAL = 1
VERTICAL = 0
def get_icon(name, backup):
if not name and not backup:
return QIcon()
elif not name and backup:
return QIcon(backup)
try:
return QIcon.fromTheme(name, QIcon(backup))
except AttributeError:
return QIcon(backup)
def get_languages(dirs=None):
files = []
if dirs is not None:
for d in dirs:
files.extend(glob(os.path.join(d, "*.qm")))
d = QDir(':/')
if d.cd('translations'):
files.extend([os.path.join(u':/translations', t) for t in
map(unicode, d.entryList('*.qm'))])
ret = {}
get_name = lambda s: os.path.splitext(os.path.basename(s))[0]
for f in files:
ts_name = get_name(f)
if ts_name.startswith('puddletag_'):
ret[ts_name[len('puddletag_'):]] = f
else:
ret[ts_name] = f
return ret
def singleerror(parent, msg):
QMessageBox.warning(parent, 'Error', msg, QMessageBox.Ok,
QMessageBox.NoButton)
def errormsg(parent, msg, maximum):
"""Shows a messagebox containing an error message indicating that
writing to filename has failed and asks the user to continue, stop,
or continue without interruption.
error is the error that caused the disruption.
single is the number of files that are being written. If it is 1, then
just a warningMessage is shown.
Returns:
True if yes to all.
False if No.
None if just yes."""
if maximum > 1:
mb = QMessageBox(translate("Defaults", 'Error'),
msg + translate("Defaults", "
Do you want to continue?"),
*(MSGARGS + (parent, )))
ret = mb.exec_()
if ret == QMessageBox.No:
return False
elif ret == QMessageBox.YesAll:
return True
else:
singleerror(parent, msg)
def safe_name(name, chars=r'/\*?"|:', to=None):
"""Make a filename safe for use (remove some special chars)
If any special chars are found they are replaced by to."""
if not to:
to = ""
else:
to = unicode(to)
escaped = ""
for ch in name:
if ch not in chars: escaped = escaped + ch
else: escaped = escaped + to
if not escaped: return '""'
return escaped
def unique(seq, stable = False):
"""unique(seq, stable=False): return a list of the elements in seq in arbitrary
order, but without duplicates.
If stable=True it keeps the original element order (using slower algorithms)."""
# Developed from Tim Peters version:
# http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/52560
#if uniqueDebug and len(str(seq))<50: print "Input:", seq # For debugging.
# Special case of an empty s:
if not seq: return []
# if it's a set:
if isinstance(seq, set): return list(seq)
if stable:
# Try with a set:
seqSet= set()
result = []
try:
for e in seq:
if e not in seqSet:
result.append(e)
seqSet.add(e)
except TypeError:
pass # move on to the next method
else:
#if uniqueDebug: print "Stable, set."
return result
# Since you can't hash all elements, use a bisection on sorted elements
result = []
sortedElem = []
try:
for elem in seq:
pos = bisect_left(sortedElem, elem)
if pos >= len(sortedElem) or sortedElem[pos] != elem:
insort_left(sortedElem, elem)
result.append(elem)
except TypeError:
pass # Move on to the next method
else:
#if uniqueDebug: print "Stable, bisect."
return result
else: # Not stable
# Try using a set first, because it's the fastest and it usually works
try:
u = set(seq)
except TypeError:
pass # move on to the next method
else:
#if uniqueDebug: print "Unstable, set."
return list(u)
# Elements can't be hashed, so bring equal items together with a sort and
# remove them out in a single pass.
try:
t = sorted(seq)
except TypeError:
pass # Move on to the next method
else:
#if uniqueDebug: print "Unstable, sorted."
return [elem for elem,group in groupby(t)]
# Brute force:
result = []
for elem in seq:
if elem not in result:
result.append(elem)
#if uniqueDebug: print "Brute force (" + ("Unstable","Stable")[stable] + ")."
return result
class compare:
"Natural sorting class."
def try_int(self, s):
"Convert to integer if possible."
try: return int(s)
except: return s
def natsort_key(self, s):
"Used internally to get a tuple by which s is sorted."
return map(self.try_int, re.findall(r'(\d+|\D+)', s))
def natcmp(self, a, b):
"Natural string comparison, case sensitive."
return cmp(self.natsort_key(a), self.natsort_key(b))
def natcasecmp(self, a, b):
"Natural string comparison, ignores case."
return self.natcmp(u"".join(a).lower(), u"".join(b).lower())
natcasecmp = compare().natcasecmp
def dupes(l, method = None):
if method is None:
method = lambda a,b: int(a==b)
l = [{'key': z, 'index': i} for i, z in enumerate(l)]
chars = chars=r'/\*?;"|:\''
strings = sorted([(safe_name(z['key'].lower(), chars, ''), z['index'])
for z in l if z['key'] is not None])
try:
last = strings[0][0]
except IndexError:
return []
groups = [[0]]
for z, i in strings[1:]:
if z is not None:
val = method(last, z)
if val >= 0.85:
groups[-1].append(i)
else:
last = z
groups.append([i])
return [z for z in groups if len(z) > 1]
def getfiles(files, subfolders = False):
if isinstance(files, basestring):
files = [files]
isdir = os.path.isdir
join = os.path.join
temp = []
if not subfolders:
for f in files:
if not isdir(f):
yield f
else:
dirname, subs, fnames = os.walk(f).next()
for fname in fnames:
yield join(dirname, fname)
else:
for f in files:
if not isdir(f):
yield f
else:
for dirname, subs, fnames in os.walk(f):
for fname in fnames:
yield join(dirname, fname)
for sub in subs:
for fname in getfiles(join(dirname, sub), subfolders):
pass
def gettags(files):
return (gettag(audio) for audio in files)
def gettag(f):
try:
return audioinfo.Tag(f)
except:
print u'An error occured.'
print f
traceback.print_exc()
return
def translate_filename_pattern(pat):
"""Translate a shell PATTERN to a regular expression.
There is no way to quote meta-characters.
"""
#from fnmatch.py with slight modification
pat = pat.strip()
i, n = 0, len(pat)
res = ''
while i < n:
c = pat[i]
i = i+1
if c == '*':
res = res + '.*'
elif c == '?':
res = res + '.'
elif c == '[':
j = i
if j < n and pat[j] == '!':
j = j+1
if j < n and pat[j] == ']':
j = j+1
while j < n and pat[j] != ']':
j = j+1
if j >= n:
res = res + '\\['
else:
stuff = pat[i:j].replace('\\','\\\\')
i = j+1
if stuff[0] == '!':
stuff = '^' + stuff[1:]
elif stuff[0] == '^':
stuff = '\\' + stuff
res = '%s[%s]' % (res, stuff)
else:
res = res + re.escape(c)
#return res + '\Z(?ms)'
return res + '\Z'
def fnmatch(pattern, files, matchcase=False):
regexp = u'|'.join(map(translate_filename_pattern,
[z.strip() for z in pattern.split(u';')]))
if matchcase:
match = re.compile(regexp).match
else:
match = re.compile(regexp, re.I).match
return filter(match, files)
def gettaglist():
cparser = PuddleConfig()
filename = os.path.join(cparser.savedir, 'usertags')
try:
lines = sorted(set([z.strip().decode('utf8')
for z in open(filename, 'r').read().split('\n')]))
except (IOError, OSError):
lines = audioinfo.FIELDS[::]
return lines
def settaglist(tags):
cparser = PuddleConfig()
filename = os.path.join(cparser.savedir, 'usertags')
f = open(filename, 'w')
text = u'\n'.join(sorted([z for z in tags if not z.startswith('__')]))
text = text.encode('utf8')
f.write(text)
f.close()
def load_actions():
import findfunc
basename = os.path.basename
funcs = {}
cparser = PuddleConfig()
set_value = partial(cparser.set, 'puddleactions')
get_value = partial(cparser.get, 'puddleactions')
firstrun = get_value('firstrun', True)
set_value('firstrun', False)
convert = get_value('convert', True)
order = get_value('order', [])
if convert:
set_value('convert', False)
findfunc.convert_actions(SAVEDIR, ACTIONDIR)
if order:
old_order = dict([(basename(z), i) for i,z in
enumerate(order)])
files = glob(os.path.join(ACTIONDIR, u'*.action'))
order = {}
for f in files:
try:
order[old_order[basename(f)]] = f
except KeyError:
pass
order = [z[1] for z in sorted(order.items())]
set_value('order', order)
files = glob(os.path.join(ACTIONDIR, u'*.action'))
if firstrun and not files:
filenames = [':/caseconversion.action', ':/standard.action']
files = map(open_resourcefile, filenames)
set_value('firstrun', False)
for fileobj, filename in zip(files, filenames):
filename = os.path.join(ACTIONDIR, filename[2:])
f = open(filename, 'w')
f.write(fileobj.read())
f.close()
files = glob(os.path.join(ACTIONDIR, u'*.action'))
files = [z for z in order if z in files] + \
[z for z in files if z not in order]
funcs = []
for f in files:
action = findfunc.load_macro_info(f)
funcs.append([action[0], action[1], f])
return funcs
def open_resourcefile(filename):
f = QFile(filename)
f.open(QIODevice.ReadOnly)
return StringIO(f.readAll())
def progress(func, pstring, maximum, threadfin = None):
"""To be used for functions that need a threaded progressbar.
Note that this function will only (and is meant to) work on dialogs.
func is the function that will be run by the thread. It should yield None
while successful. Otherwise it should yield an errormsg and the number
of files (this'll be used when calling errormsg).
pstring is the progress message. This is shown with the number of times
func yielded a value. For instance, pstring = 'Loading... ', and maximum = 20
will show 'Loading... 1 of 20', 'Loading... 2 of 20', etc.on the progress
bar.
maximum is the maximum value of the progessbar.
threadfin is the function to run when the thread has finished. Usually
for cleanup stuff.
Note that the function returns a function that expects a parent for
the progess window as the first argument. This with the rest of the arguments
passed to the returned function are used when calling func (except in the
case where only the parent argument is passed).
"""
def s(*args):
focused = QApplication.focusWidget()
if focused:
focusedpar = focused.parentWidget()
else:
focusedpar = None
parent = args[0]
if maximum > 1:
win = ProgressWin(parent, maximum, pstring)
win.show()
if len(args) > 1:
f = func(*args)
else:
f = func()
if maximum == 1:
errors = f.next()
if errors and \
not isinstance(errors, (QString, int, long, basestring)):
errormsg(parent, errors[0], 1)
if threadfin:
threadfin()
return
parent.showmessage = True
def threadfunc():
i = 0
err = False
while not win.wasCanceled:
try:
temp = f.next()
if isinstance(temp, (QString, str, unicode)):
thread.emit(SIGNAL('message(QString)'), QString(temp))
elif isinstance(temp, (int, long)):
thread.emit(SIGNAL('set_max(int)'), temp)
elif temp is not None:
thread.emit(SIGNAL('error(QString, int)'),
temp[0], temp[1])
err = True
break
else:
thread.emit(SIGNAL('win(int)'), i)
except StopIteration:
break
i += 1
if not err:
thread.emit(SIGNAL('win(int)'), -1)
def threadexit(*args):
if args[0] == -1:
win.destroy()
QApplication.processEvents()
if threadfin:
threadfin()
if focusedpar is not None:
try: focusedpar.setFocus()
except RuntimeError: pass
return
elif isinstance(args[0], QString):
if parent.showmessage:
ret = errormsg(parent, args[0], maximum)
if ret is True:
parent.showmessage = False
elif ret is False:
thread.emit(SIGNAL('win(int)'), -1)
return
if not win.isVisible():
win.show()
while thread.isRunning():
pass
thread.start()
win.setValue(win.value + 1)
def set_message(msg):
if msg != win.label.text():
win.label.setText(msg)
QApplication.processEvents()
def set_max(value):
win.pbar.setMaximum(value)
thread = PuddleThread(threadfunc, parent)
thread.connect(thread, SIGNAL('win(int)'), threadexit)
thread.connect(thread, SIGNAL('error(QString, int)'), threadexit)
thread.connect(thread, SIGNAL('message(QString)'), set_message)
thread.connect(thread, SIGNAL('set_max(int)'), set_max)
thread.start()
return s
def timemethod(method):
def f(*args, **kwargs):
name = method.__name__
t = time.time()
ret = method(*args, **kwargs)
print name, time.time() - t
return ret
return f
class HeaderSetting(QDialog):
"""A dialog that allows you to edit the header of a TagTable widget."""
def __init__(self, tags=None, parent=None, showok=True, showedits=True):
QDialog.__init__(self, parent)
self.listbox = ListBox()
self.tags = [list(z) for z in tags]
self.listbox.addItems([z[0] for z in self.tags])
self.vbox = QVBoxLayout()
self.vboxgrid = QGridLayout()
self.textname = QLineEdit()
self.tag = QComboBox()
self.tag.addItems(sorted(INFOTAGS) + gettaglist())
self.tag.setEditable(True)
self.buttonlist = ListButtons()
self.buttonlist.edit.setVisible(False)
if showedits:
self.vboxgrid.addWidget(QLabel(translate("Column Settings", "Title")),0,0)
self.vboxgrid.addWidget(self.textname,0,1)
self.vboxgrid.addWidget(QLabel(translate("Defaults", "Field")), 1,0)
self.vboxgrid.addWidget(self.tag,1,1)
self.vboxgrid.addLayout(self.buttonlist,2,0)
else:
self.vboxgrid.addLayout(self.buttonlist,1,0)
self.vboxgrid.setColumnStretch(0,0)
self.vbox.addLayout(self.vboxgrid)
self.vbox.addStretch()
self.grid = QGridLayout()
self.grid.addWidget(self.listbox,1,0)
self.grid.addLayout(self.vbox,1,1)
self.grid.setColumnStretch(1,1)
self.grid.setColumnStretch(0,2)
self.connect(self.listbox,
SIGNAL("currentItemChanged (QListWidgetItem *,QListWidgetItem *)"),
self.fillEdits)
self.connect(self.listbox, SIGNAL("itemSelectionChanged()"),self.enableEdits)
self.okbuttons = OKCancel()
if showok is True:
self.grid.addLayout(self.okbuttons, 2,0,1,2)
self.setLayout(self.grid)
self.connect(self.okbuttons, SIGNAL("ok"), self.okClicked)
self.connect(self.okbuttons, SIGNAL("cancel"), self.close)
self.connect(self.textname, SIGNAL("textChanged (const QString&)"), self.updateList)
self.connect(self.buttonlist, SIGNAL("add"), self.add)
self.connect(self.buttonlist, SIGNAL("moveup"), self.moveup)
self.connect(self.buttonlist, SIGNAL("movedown"), self.movedown)
self.connect(self.buttonlist, SIGNAL("remove"), self.remove)
self.connect(self.buttonlist, SIGNAL("duplicate"), self.duplicate)
self.listbox.setCurrentRow(0)
def enableEdits(self):
if len(self.listbox.selectedItems()) > 1:
self.textname.setEnabled(False)
self.tag.setEnabled(False)
return
self.textname.setEnabled(True)
self.tag.setEnabled(True)
def remove(self):
if len(self.tags) == 1: return
self.disconnect(self.textname, SIGNAL("textChanged (const QString&)"), self.updateList)
self.disconnect(self.listbox, SIGNAL("currentItemChanged (QListWidgetItem *,QListWidgetItem *)"), self.fillEdits)
self.listbox.removeSelected(self.tags)
row = self.listbox.currentRow()
#self.listbox.clear()
#self.listbox.addItems([z[0] for z in self.tags])
if row == 0:
self.listbox.setCurrentRow(0)
elif row + 1 < self.listbox.count():
self.listbox.setCurrentRow(row+1)
else:
self.listbox.setCurrentRow(self.listbox.count() -1)
self.fillEdits(self.listbox.currentItem(), None)
self.connect(self.textname, SIGNAL("textChanged (const QString&)"), self.updateList)
self.connect(self.listbox, SIGNAL("currentItemChanged (QListWidgetItem *,QListWidgetItem *)"), self.fillEdits)
def moveup(self):
self.listbox.moveUp(self.tags)
def movedown(self):
self.listbox.moveDown(self.tags)
def updateList(self, text):
self.listbox.currentItem().setText(text)
def fillEdits(self, current, prev):
row = self.listbox.row(prev)
try: #An error is raised if the last item has just been removed
if row > -1:
self.tags[row][0] = unicode(self.textname.text())
self.tags[row][1] = unicode(self.tag.currentText())
except IndexError:
pass
row = self.listbox.row(current)
if row > -1:
self.textname.setText(self.tags[row][0])
self.tag.setEditText(self.tags[row][1])
def okClicked(self):
row = self.listbox.currentRow()
if row > -1:
self.tags[row][0] = unicode(self.textname.text())
self.tags[row][1] = unicode(self.tag.currentText())
self.emit(SIGNAL("headerChanged"),[z for z in self.tags])
self.close()
def add(self):
row = self.listbox.count()
self.tags.append(["",""])
self.listbox.addItem("")
self.listbox.clearSelection()
self.listbox.setCurrentRow(row)
self.textname.setFocus()
def duplicate(self):
row = self.listbox.currentRow()
if row < 0:
return
tag = self.tags[row][::]
self.tags.append(tag)
self.listbox.addItem(tag[0])
self.listbox.clearSelection()
self.listbox.setCurrentRow(self.listbox.count() - 1)
self.textname.setFocus()
class ListBox(QListWidget):
"""Puddletag's replacement of QListWidget, because
removing, moving and deleting items in a listbox
is done a lot.
First the modifier methods.
removeSelected, moveUp and moveDown each does as the
name implies. See docstrings for more info.
connectToListButtons -> connects removeSelected etc. to
the respective buttons in a ListButtons object.
Attributes:
editButton -> Set this to a button or control which will be enabled only
when a single item is selected.
yourlist -> The list that will be used in removeSelected et al, if None
is passed when calling the function.."""
def __init__(self, parent = None):
QListWidget.__init__(self, parent)
self.yourlist = None
self.editButton = None
self.setSelectionMode(self.ExtendedSelection)
def items(self):
return map(self.item, xrange(self.count()))
def selectionChanged(self, selected, deselected):
if self.editButton:
if len(self.selectedItems()) == 1:
self.editButton.setEnabled(True)
else:
self.editButton.setEnabled(False)
QListWidget.selectionChanged(self, selected, deselected)
def connectToListButtons(self, listbuttons, yourlist = None):
"""Connect the moveUp, moveDown and removeSelected to the
moveup, movedown and remove signals of listbuttons and
sets the editButton.
yourlist is used a the argument in these functions if
no other yourlist is passed."""
self.editButton = listbuttons.edit
self.connect(listbuttons, SIGNAL('moveup'), self.moveUp)
self.connect(listbuttons, SIGNAL('movedown'), self.moveDown)
self.connect(listbuttons, SIGNAL('remove'), self.removeSelected)
self.yourlist = yourlist
def removeSelected(self, yourlist = None, rows = None):
"""Removes the currently selected items.
If yourlist is not None, then the selected
items are removed for yourlist also. Note, that
the indexes of the items in yourlist and the listbox
have to correspond.
If you want to remove anything other than the selected,
just set rows to a list of integers."""
if not yourlist:
yourlist = self.yourlist
if rows:
rows = sorted(rows)
else:
rows = sorted([self.row(item) for item in self.selectedItems()])
for i in range(len(rows)):
self.takeItem(rows[i])
if yourlist:
try:
del(yourlist[rows[i]])
except (KeyError, IndexError):
"The list doesn't have enough items or something"
rows = [z - 1 for z in rows]
def moveUp(self, yourlist = None, rows = None):
"""Moves the currently selected items up one place.
If yourlist is not None, then the indexes of yourlist
are updated in tandem. Note, that
the indexes of the items in yourlist and the listbox
have to correspond."""
if not rows:
rows = [self.row(item) for item in self.selectedItems()]
rows = sorted(rows)
if not yourlist:
yourlist = self.yourlist
currentrow = self.currentRow() - 1
if 0 in rows:
return
[self.setItemSelected(item, False) for item in self.selectedItems()]
for i in range(len(rows)):
row = rows[i]
item = self.takeItem(row)
self.insertItem(row - 1, item)
if yourlist:
temp = copy(yourlist[row - 1])
yourlist[row - 1] = yourlist[row]
yourlist[row] = temp
[self.setItemSelected(self.item(row - 1), True) for row in rows]
self.setCurrentRow(currentrow)
def moveDown(self, yourlist = None, rows = None):
"""See moveup. It's exactly the opposite."""
if rows is None:
rows = [self.row(item) for item in self.selectedItems()]
if self.count() - 1 in rows:
return
[self.setItemSelected(item, False) for item in self.selectedItems()]
if not yourlist:
yourlist = self.yourlist
rows = sorted(rows)
lastindex = rows[0]
groups = {lastindex:[lastindex]}
lastrow = lastindex
for row in rows[1:]:
if row - 1 == lastindex:
groups[lastrow].append(row)
else:
groups[row] = [row]
lastrow = row
lastindex = row
for group in groups:
item = self.takeItem(group + len(groups[group]))
if yourlist:
temp = copy(yourlist[group + len(groups[group])])
for index in reversed(groups[group]):
yourlist[index + 1] = copy(yourlist[index])
yourlist[group] = temp
self.insertItem(group, item)
[self.setItemSelected(self.item(row + 1), True) for row in rows]
def selectedItems(self):
return filter(lambda item: item.isSelected(),
map(self.item, xrange(self.count())))
class ListButtons(QVBoxLayout):
"""A Layout that contains five buttons usually
associated with listboxes. They are
add, edit, movedown, moveup and remove.
Each button, when clicked sends signal with the
buttons name. e.g. add sends SIGNAL("add").
You can find them all in the widgets attribute."""
def __init__(self, parent = None):
QVBoxLayout.__init__(self, parent)
self.add = QToolButton()
self.add.setIcon(get_icon('list-add', ':/filenew.png'))
self.add.setToolTip(translate("List Buttons", 'Add'))
self.remove = QToolButton()
self.remove.setIcon(get_icon('list-remove', ':/remove.png'))
self.remove.setToolTip(translate("List Buttons", 'Remove'))
self.remove.setShortcut('Delete')
self.moveup = QToolButton()
self.moveup.setArrowType(Qt.UpArrow)
self.moveup.setToolTip(translate("List Buttons", 'Move Up'))
self.movedown = QToolButton()
self.movedown.setArrowType(Qt.DownArrow)
self.movedown.setToolTip(translate("List Buttons", 'Move Down'))
self.edit = QToolButton()
self.edit.setIcon(get_icon('document-edit', ':/edit.png'))
self.edit.setToolTip(translate("List Buttons", 'Edit'))
self.duplicate = QToolButton()
self.duplicate.setIcon(get_icon('edit-copy', ':/duplicate.png'))
self.duplicate.setToolTip(translate("List Buttons", 'Duplicate'))
self.widgets = [self.add, self.edit, self.duplicate,
self.remove, self.moveup, self.movedown]
[self.addWidget(widget) for widget in self.widgets]
self.insertStretch(4)
self.insertSpacing(4,6)
[z.setIconSize(QSize(16,16)) for z in self.widgets]
self.addStretch()
clicked = SIGNAL("clicked()")
self.connect(self.add, clicked, self.addClicked)
self.connect(self.remove, clicked, self.removeClicked)
self.connect(self.moveup, clicked, self.moveupClicked)
self.connect(self.movedown, clicked, self.movedownClicked)
self.connect(self.edit, clicked, self.editClicked)
self.connect(self.duplicate, clicked, self.duplicateClicked)
def connectToWidget(self, widget, add=None, edit=None, remove=None,
moveup=None, movedown=None, duplicate=None):
l = ['add', 'edit', 'remove']
if moveup:
l.append('moveup')
if movedown:
l.append('movedown')
if duplicate:
l.append('duplicate')
connections = dict([(z,v) for z,v in zip(l,
[add, edit, remove, moveup, movedown,
duplicate]) if v])
connect = lambda a: self.connect(self, SIGNAL(a),
connections[a] if a in connections else getattr(widget, a))
map(connect, l)
def addClicked(self):
self.emit(SIGNAL("add"))
def setEnabled(self, value):
[w.setEnabled(value) for w in self.widgets]
super(ListButtons, self).setEnabled(value)
def removeClicked(self):
self.emit(SIGNAL("remove"))
def moveupClicked(self):
self.emit(SIGNAL("moveup"))
def movedownClicked(self):
self.emit(SIGNAL("movedown"))
def editClicked(self):
self.emit(SIGNAL("edit"))
def duplicateClicked(self):
self.emit(SIGNAL('duplicate'))
class MoveButtons(QWidget):
def __init__(self, arrayname, index = 0, orientation = HORIZONTAL, parent = None):
QWidget.__init__(self, parent)
self.next = QPushButton(translate("List Buttons", '&>>'))
self.prev = QPushButton(translate("List Buttons", '&<<'))
if orientation == VERTICAL:
box = QVBoxLayout()
box.addWidget(self.next, 0)
box.addWidget(self.prev, 0)
else:
box = QHBoxLayout()
box.addWidget(self.prev)
box.addWidget(self.next)
self.arrayname = arrayname
self.setLayout(box)
self.index = index
self.connect(self.next, SIGNAL('clicked()'), self.nextClicked)
self.connect(self.prev, SIGNAL('clicked()'), self.prevClicked)
def _setCurrentIndex(self, index):
try:
if index >= len(self.arrayname) or index < 0:
return
else:
self._currentindex = index
if self._currentindex >= len(self.arrayname) - 1:
self.next.setEnabled(False)
else:
self.next.setEnabled(True)
if self._currentindex <= 0:
self.prev.setEnabled(False)
else:
self.prev.setEnabled(True)
except TypeError:
"Probably arrayname is None or something."
self.prev.setEnabled(False)
self.next.setEnabled(False)
if (not self.prev.isEnabled()) and (not self.next.isEnabled()):
self.prev.hide()
self.next.hide()
else:
self.prev.show()
self.next.show()
self.emit(SIGNAL('indexChanged'), index)
def _getCurrentIndex(self):
return self._currentindex
index = property(_getCurrentIndex, _setCurrentIndex)
def nextClicked(self):
self.index += 1
def prevClicked(self):
self.index -= 1
def updateButtons(self):
self.index = self.index
class OKCancel(QHBoxLayout):
"""Yes, I know about QDialogButtonBox, but I'm not using PyQt4.2 here."""
def __init__(self, parent = None):
QHBoxLayout.__init__(self, parent)
#QDialogButtonBox.__init__(self, parent)
#self.addStretch()
dbox = QDialogButtonBox()
self.ok = dbox.addButton(dbox.Ok)
self.cancel = dbox.addButton(dbox.Cancel)
self.addStretch()
self.addWidget(dbox)
self.ok.setText(translate('Defaults', 'OK'))
self.cancel.setText(translate('Defaults', 'Cancel'))
#self.cancel = QPushButton("&Cancel")
#self.ok.setDefault(True)
#self.addWidget(self.ok)
#self.addWidget(self.cancel)
self.connect(self.ok, SIGNAL("clicked()"), self.yes)
self.connect(self.cancel, SIGNAL("clicked()"), self.no)
def yes(self):
self.emit(SIGNAL("ok"))
def no(self):
self.emit(SIGNAL("cancel"))
class LongInfoMessage(QDialog):
def __init__(self, title, question, html, parent =None):
QDialog.__init__(self, parent)
winsettings('infomessage', self)
question = QLabel(question)
text = QTextEdit()
text.setReadOnly(True)
#text.setWordWrapMode(QTextOption.NoWrap)
text.setHtml(html)
okcancel = OKCancel()
self.connect(okcancel, SIGNAL('ok'), self._ok)
self.connect(okcancel, SIGNAL('cancel'), self.close)
vbox = QVBoxLayout()
self.setWindowTitle(title)
vbox.addWidget(question)
vbox.addWidget(text)
vbox.addLayout(okcancel)
self.setLayout(vbox)
def _ok(self):
self.close()
self.accept()
class ArtworkLabel(QGraphicsView):
def __init__(self, *args, **kwargs):
super(ArtworkLabel, self).__init__(*args, **kwargs)
pal = self.palette()
pal.setBrush(self.backgroundRole(), QBrush(QPalette.Window))
self.setAutoFillBackground(True)
self.setPalette(pal)
self._svg = QGraphicsSvgItem()
self._pixmap = QGraphicsPixmapItem()
self._pixmap.setTransformationMode(Qt.SmoothTransformation)
self._scene = QGraphicsScene()
self._scene.addItem(self._svg)
self._scene.addItem(self._pixmap)
self._shown_pixmap = None
self.setScene(self._scene)
self.setSceneRect(QRectF())
self.setAcceptDrops(True)
def dragEnterEvent(self, event):
mime = event.mimeData()
if mime.hasUrls():
event.accept()
else:
event.ignore()
def dragMoveEvent(self, event):
if event.mimeData().hasUrls():
event.accept()
else:
event.ignore()
def dropEvent(self, event):
mime = event.mimeData()
if mime.hasUrls():
filenames = [unicode(z.toString()) for z in mime.urls()]
self.emit(SIGNAL('newImages'), *filenames)
super(ArtworkLabel, self).dropEvent(event)
def mousePressEvent(self, event):
super(ArtworkLabel, self).mousePressEvent(event)
if event.buttons() == Qt.LeftButton:
self.emit(SIGNAL('clicked()'))
def resizeEvent(self, event=None):
if event is not None:
super(ArtworkLabel, self).resizeEvent(event)
if self._svg.isVisible():
item = self._svg
else:
item = self._pixmap
self.setSceneRect(item.boundingRect())
self.fitInView(item, Qt.KeepAspectRatio)
def setPixmap(self, pixmap, data=None):
if isinstance(pixmap, str):
renderer = QSvgRenderer (QByteArray(pixmap), self._svg)
self._svg.setSharedRenderer(renderer)
self._pixmap.setVisible(False)
self._svg.setVisible(True)
else:
self._data = data
self._pixmap.setPixmap(pixmap)
self._svg.setVisible(False)
self._pixmap.setVisible(True)
self.resizeEvent()
class PicWidget(QWidget):
"""A widget that shows a file's pictures.
images is a list of mutagen.id3.APIC objects.
It allows the user to edit, save and delete whichever
picture the user wants, by right-clicking on it.
In addition, there are buttons to browse through
all the pictures.
Some important attributes are:
currentImage -> The index of the current image
maxImage -> Shows the current image fullsized.
setImages -> Guess
addImage -> Guess again...but it also shows and open file dialog.
removeImage -> Removes the current image.
next and prevImage -> Moves to the next and previous image.
saveToFile -> Save the current image to file.
showbuttons -> If True, the >> and << buttons are always shown. If False,
they are shown depending on context."""
def __init__ (self, images = None, imagetags = None, parent = None,
readonly = None, buttons = False):
"""Initialises the widget.
images -> A list of images as described in the classes docstring.
parent -> Qt parent
readonly -> indexes of images that are readonly. Can be changed by modifying
the readonly attribute.
buttons -> If True, then the Add, Edit, etc. Buttons are shown.
If False, then these functions can be found by right clicking
on the picture."""
self._contextFormat = translate("Artwork Context", '%1/%2')
QWidget.__init__(self, parent)
self.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.sizePolicy().setVerticalStretch(0)
self.sizePolicy().setHorizontalStretch(3)
self.lastfilename = u'~'
self.currentFile = None
self.filePattern = u'folder.jpg'
#The picture.
self.label = ArtworkLabel()
self.label.setFrameStyle(QFrame.Box)
#self.label.setMargin(10)
self.label.setMinimumSize(200, 170)
if buttons:
self.label.setMaximumSize(200, 170)
self._itags = []
#else:
#self.setMaximumSize(400,400)
self.label.setAlignment(Qt.AlignCenter)
self.connect(self.label, SIGNAL('newImages'),
lambda *filenames: self.addImages(self.loadPics(*filenames)))
#self.label.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
#Description and picture type shit.
self._image_desc = QLineEdit(self)
self._image_desc.setPlaceholderText(translate("Artwork", 'Enter a description'))
self._image_desc.setToolTip(
translate("Artwork",
'
Features include: Batch editing of tags, renaming files using tags, retrieving tags from filenames, using Actions to automate repetitive tasks, importing your music library and loads of other awesome stuff.
Supported formats: id3v1, id3v2 (.mp3), AAC (.mp4, .m4a), VorbisComments (.ogg, .flac) and APEv2 (.ape)
< br />
Visit the puddletag website (http://puddletag.sourceforge.net) for help and updates.
© 2008-2012 concentricpuddle (concentricpuddle@gmail.com)
Licensed under GPLv3 (www.gnu.org/licenses/gpl-3.0.html).
''')
thanks = translate("About", """Evan Devetzis for his many, many awesome ideas and putting up with more bugs than humanly possible.
First off, a big thanks to **Evan Devetzis** for working tirelessly in helping me make puddletag better by contributing many, many awesome ideas and for being a great bug hunter.
Thanks to Raphaël Rochet, Fabian Bakkum, Alan Gomes and others for contributing translations.
To the writers of the libraries puddletag depends on (without which I'll probably still be writing an id3 reader).
Paul McGuire for PyParsing.
Michael Urman and Joe Wreschnig for Mutagen (It. Is. Awesome).
Phil Thomson and everyone responsible for PyQt4.
Michael Foord and Nicola Larosa for ConfigObj (seriously, they should replace ConfigParser with this).
The Oxygen team for the Oxygen icons.
""")
class ScrollLabel(QWidget):
def __init__(self, text, alignment = Qt.AlignCenter, parent=None):
QWidget.__init__(self, parent)
vbox = QVBoxLayout()
self.setLayout(vbox)
label = QLabel(text)
label.setTextFormat(Qt.RichText)
label.setAlignment(alignment)
label.setWordWrap(True)
label.setTextInteractionFlags(Qt.TextBrowserInteraction)
sa = QScrollArea()
sa.setWidget(label)
sa.setWidgetResizable(True)
vbox.addWidget(sa)
self.label = label
class AboutPuddletag(QDialog):
def __init__(self, parent=None):
QDialog.__init__(self, parent)
self.setWindowTitle(translate("About", 'About puddletag'))
icon = QLabel()
icon.setPixmap(QPixmap(':/appicon.png').scaled(48,48))
lib_versions = ', '.join(['PyQt %s' % PYQT_VERSION_STR,
'Mutagen %s' % mutagen.version_string,
'Pyparsing %s' %pyparsing.__version__])
if puddlestuff.changeset:
version = translate("About",
'puddletag %1 (Changeset %2)
%3')
version = version.arg(puddlestuff.version_string)
version = version.arg(puddlestuff.changeset).arg(lib_versions)
else:
version = translate("About",
'puddletag %1
%2')
version = version.arg(puddlestuff.version_string)
version = version.arg(lib_versions)
label = QLabel(version)
tab = QTabWidget()
tab.addTab(ScrollLabel(desc), translate('About', '&About'))
tab.addTab(ScrollLabel(thanks, Qt.AlignLeft),
translate('About', '&Thanks'))
vbox = QVBoxLayout()
version_layout = QHBoxLayout()
version_layout.addWidget(icon)
version_layout.addWidget(label, 1)
vbox.addLayout(version_layout)
vbox.addWidget(tab, 1)
ok = OKCancel()
ok.cancel.setVisible(False)
vbox.addLayout(ok)
self.connect(ok, SIGNAL('ok'), self.close)
self.setLayout(vbox)
if __name__ == '__main__':
app = QApplication([])
win = AboutPuddletag()
win.show()
app.exec_() puddletag-1.0.2/puddlestuff/libraries/ 0000755 0001750 0000144 00000000000 12236755734 020265 5 ustar keith users 0000000 0000000 puddletag-1.0.2/puddlestuff/libraries/__init__.py 0000644 0001750 0000144 00000000425 11612773575 022377 0 ustar keith users 0000000 0000000 # -*- coding: utf-8 -*-
from os.path import join, dirname
from os import listdir
from fnmatch import fnmatch
import traceback, os, imp, sys, pdb
dirpath = dirname(__file__)
__all__ = [f[:-3] for f in listdir(dirpath) if fnmatch(f, '*.py') and
f != '__init__.py']
puddletag-1.0.2/puddlestuff/libraries/quodlibetlib.py 0000755 0001750 0000144 00000032547 11627234403 023320 0 ustar keith users 0000000 0000000 # -*- coding: utf-8 -*-
import sys
import os, time, pdb, traceback
import cPickle as pickle
from collections import defaultdict
from functools import partial
from PyQt4.QtCore import *
from PyQt4.QtGui import *
import quodlibet.config
from quodlibet.parse import Query
import puddlestuff.audioinfo as audioinfo
from puddlestuff.audioinfo.tag_versions import tags_in_file
from puddlestuff.audioinfo.util import (del_deco, fn_hash, getdeco,
isempty, keys_deco, lngfrequency, lnglength, lngtime, set_total, setdeco,
stringtags, strlength, unicode_list, CaselessDict, MockTag)
from puddlestuff.constants import HOMEDIR
from puddlestuff.musiclib import MusicLibError
from puddlestuff.util import to_string, translate
model_tag = audioinfo.model_tag
ATTRIBUTES = ['length', 'accessed', 'size', 'created',
'modified', 'filetype']
def strbitrate(bitrate):
"""Returns a string representation of bitrate in kb/s."""
return unicode(bitrate/1000) + u' kb/s'
def strtime(seconds):
"""Converts UNIX time(in seconds) to more Human Readable format."""
return time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime(seconds))
time_fields = ['~#added', '~#lastplayed', '~#laststarted']
timefunc = lambda key: lambda value : {'__%s' % key[2:]: strtime(value)}
mapping = dict([(key, timefunc(key)) for key in time_fields])
mapping.update({
'tracknumber': lambda value: {'track': [value]},
'~#bitrate' : lambda value: {'__bitrate': strbitrate(value)},
'~#length': lambda value: {'__length': strlength(value)},
'~#playcount': lambda value: {'playcount': [unicode(value)]},
'~#rating': lambda value: {'rating': [unicode(value)]},
'~#skipcount': lambda value: {'__skipcount': [unicode(value)]},
'~mountpoint': lambda value: {'__mountpoint': value},
'~#mtime': lambda value : {'__modified': strtime(value)},
'~picture': lambda value: {'__picture': value},
})
time_fields = ['__added', '__lastplayed', '__laststarted',]
timefunc = lambda key: lambda value : {'~#%s' % key[2:]: lngtime(value)}
revmapping = dict([(key, timefunc(key)) for key in time_fields])
revmapping.update({
'track': lambda value: {'tracknumber': value},
'__bitrate' : lambda value: {'~#bitrate': lngfrequency(value)},
'__length': lambda value: {'~#length': lnglength(value)},
'playcount': lambda value: {'~#playcount': int(value)},
'rating': lambda value: {'~#rating': float(value)},
'__skipcount': lambda value: {'~#skipcount': int(value)},
'__mountpoint': lambda value: {'~mountpoint': value},
'__modified': lambda value : {'~#mtime': lngtime(value)},
'__picture': lambda value: {'~picture': to_string(value)},
})
class Tag(MockTag):
"""Use as base for all tag classes."""
mapping = audioinfo.mapping.get('puddletag', {})
revmapping = audioinfo.revmapping.get('puddletag', {})
IMAGETAGS = ()
def __init__(self, libclass, libtags):
MockTag.__init__(self)
self.__tags = CaselessDict()
tags = self.__tags
tags.update(self.load(libtags['~filename'])[0])
tags['__tag_read'] = u'QuodLibet'
self.library = libclass
self.remove = partial(libclass.delete, track=libtags)
self._libtags = libtags
for key, value in libtags.items():
if not value and not isinstance(value, (int, long)):
continue
if key in mapping:
tags.update(mapping[key](value))
else:
if not isinstance(value, unicode): #Strings
try: value = unicode(value, 'utf8', 'replace')
except (TypeError, ValueError):
try: value = unicode(value) #Usually numbers
except:
traceback.print_exc()
continue
tags[key] = [value]
del(tags['~filename'])
self.filepath = libtags['~filename']
self.set_attrs(ATTRIBUTES, self.__tags)
self.update_tag_list()
def get_filepath(self):
return MockTag.get_filepath(self)
def set_filepath(self, val):
self.__tags.update(MockTag.set_filepath(self, val))
filepath = property(get_filepath, set_filepath)
images = property(lambda s: [], lambda s: [])
def __contains__(self, key):
if self.revmapping:
key = self.revmapping.get(key, key)
return key in self.__tags
def __deepcopy__(self, memo=None):
tag = Tag(self._libclass, self._libtags)
tag.update(deepcopy(self.__tags))
return tag
@del_deco
def __delitem__(self, key):
if key.startswith('__'):
return
else:
if key == 'track':
del(self._libtags['tracknumber'])
del(self.__tags['track'])
else:
if key in self._libtags:
del(self._libtags[key])
del(self.__tags[key])
@getdeco
def __getitem__(self, key):
return self.__tags[key]
@setdeco
def __setitem__(self, key, value):
if key.startswith('__'):
if key == '__total':
set_total(self, value)
elif key in fn_hash:
setattr(self, fn_hash[key], value)
elif isempty(value):
if key in self:
del(self[key])
else:
return
else:
self.__tags[key] = unicode_list(value)
def delete(self):
raise NotImplementedError
@keys_deco
def keys(self):
return self.__tags.keys()
def save(self, justrename = False):
libtags = self._libtags
tags = self.__tags
newartist = to_string(tags.get('artist', [u'']))
oldartist = libtags.get('artist', u'')
newalbum = to_string(tags.get('album', [u'']))
oldalbum = libtags.get('album', u'')
self._libtags.update(self._tolibformat())
self._libtags.write()
if (newartist != oldartist) or (newalbum != oldalbum):
self.library.update(oldartist, oldalbum, libtags)
self.library.edited = True
self.update_tag_list()
def _tolibformat(self):
libtags = {}
tags = stringtags(self.__tags).items()
for key, value in tags:
if key in revmapping:
libtags.update(revmapping[key](value))
elif key.startswith('__'):
continue
else:
libtags[key] = value
libtags['~filename'] = self.filepath
return libtags
def update_tag_list(self):
l = tags_in_file(self.filepath)
if l:
self.__tags['__tag'] = u'QuodLibet, ' + u', '.join(l)
else:
self.__tags['__tag'] = u'QuodLibet'
Tag = audioinfo.model_tag(Tag)
class QuodLibet(object):
def __init__(self, filepath):
self.edited = False
self._tracks = pickle.load(open(filepath, 'rb'))
try:
quodlibet.config.init()
except ValueError:
pass
self._filepath = filepath
cached = defaultdict(lambda: defaultdict(lambda: []))
for track in self._tracks:
cached[track.get('artist', u'')][track.get('album', u'')
].append(track)
self._cached = cached
def get_tracks(self, maintag, mainval, secondary=None, secvalue=None):
exists = lambda t: os.path.exists(t['~filename'])
if secondary and secvalue:
if secondary == 'album' and maintag == 'artist':
tracks = (Tag(self, track) for track in
self._cached[mainval][secvalue] if exists(track))
return filter(None, tracks)
else:
def getvalue(track):
if (track.get(maintag) == mainval) and (
track.get(secondary) == secvalue):
return Tag(self, track)
else:
if maintag == 'artist':
tracks = []
[tracks.extend(z) for z in self._cached[mainval].values()]
return [Tag(self, track) for track in tracks if
exists(track)]
def getvalue(track):
if track.get(maintag) == mainval:
return Tag(self, track)
return filter(getvalue, self._tracks)
def distinct_values(self, field):
return set([track.get(field, u'') for track in self._tracks])
def distinct_children(self, parent, value, child):
return set([track.get(child, u'') for track in
self._tracks if track.get(parent, u'') == value])
def _artists(self):
return self._cached.keys()
artists = property(_artists)
def get_albums(self, artist):
return self._cached[artist].keys()
def save(self):
if not self.edited:
return
filepath = self._filepath + u'.puddletag'
pickle.dump(self._tracks, open(filepath, 'wb'))
os.rename(self._filepath, self._filepath + u'.bak')
os.rename(filepath, self._filepath)
def delete(self, track):
artist = to_string(track.get('artist', u''))
album = to_string(track.get('album', u''))
self._cached[artist][album].remove(track)
self._tracks.remove(track)
if not self._cached[artist][album]:
del(self._cached[artist][album])
if not self._cached[artist]:
del(self._cached[artist])
self.edited = True
def tree(self):
title = 'title'
for artist in self.artists:
print artist
albums = self.get_albums(artist)
for album in albums:
print u' ', album
tracks = self.get_tracks('artist', artist, 'album', album)
for track in tracks:
print u' ', track[title][0] if title in track else u''
def close(self):
pass
def search(self, text):
try:
filt = Query(text).search
except Query.error:
return []
else:
return [Tag(self, track) for track in filter(filt, self._tracks)]
def update(self, artist, album, track):
cached = self._cached
try:
cached[artist][album].remove(track)
except ValueError:
pass
if not cached[artist][album]:
del(cached[artist][album])
if not cached[artist]:
del(cached[artist])
trackartist = track.get('artist', u'')
trackalbum = track.get('album', u'')
cached[trackartist][trackalbum].append(track)
class DirModel(QDirModel):
def data(self, index, role=Qt.DisplayRole):
if (role == Qt.DisplayRole and index.column() == 0):
path = QDir.toNativeSeparators(self.filePath(index))
if path.endsWith(QDir.separator()):
path.chop(1)
return path
return QDirModel.data(self, index, role)
class DirLineEdit(QLineEdit):
def __init__(self, *args, **kwargs):
super(DirLineEdit, self).__init__(*args, **kwargs)
completer = QCompleter()
completer.setCompletionMode(QCompleter.PopupCompletion)
dirfilter = QDir.AllEntries | QDir.NoDotAndDotDot | QDir.Hidden
sortflags = QDir.DirsFirst | QDir.IgnoreCase
dirmodel = QDirModel(['*'], dirfilter, sortflags, completer)
completer.setModel(dirmodel)
self.setCompleter(completer)
class InitWidget(QWidget):
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.dbpath = DirLineEdit(os.path.join(HOMEDIR, u".quodlibet/songs"))
self.configpath = DirLineEdit(os.path.join(HOMEDIR, u".quodlibet/config"))
vbox = QVBoxLayout()
def label(text, control):
l = QLabel(text)
l.setBuddy(control)
return l
vbox.addWidget(label(translate("QuodLibet", '&Library Path'), self.dbpath))
hbox = QHBoxLayout()
select_db = QPushButton(translate("QuodLibet", "..."))
self.connect(select_db, SIGNAL('clicked()'), self.select_db)
hbox.addWidget(self.dbpath)
hbox.addWidget(select_db)
vbox.addLayout(hbox)
vbox.addStretch(1)
self.setLayout(vbox)
def select_db(self):
filedlg = QFileDialog()
filename = filedlg.getOpenFileName(self,
translate("QuodLibet", 'Select QuodLibet library file...'),
self.dbpath.text())
if filename:
self.dbpath.setText(filename)
def library(self):
dbpath = self.dbpath.text().toLocal8Bit()
try:
return QuodLibet(dbpath)
except (IOError, OSError), e:
raise MusicLibError(0, translate(
"QuodLibet", '%1 (%2)').arg(e.strerror).arg(e.filename))
except (pickle.UnpicklingError, EOFError):
raise MusicLibError(0, translate("QuodLibet",
'%1 is an invalid QuodLibet music library file.').arg(dbpath))
name = u'Quodlibet'
if __name__ == '__main__':
lib = QuodLibet('/home/keith/.quodlibet/songs')
artists = lib.artists
import random
d = defaultdict(lambda: defaultdict(lambda: []))
for nothing in xrange(20):
artist = artists[random.randint(0, len(artists))]
for album, tracks in lib._cached[artist].items():
d[artist][album] = [Tag(lib, t).usertags for t in tracks]
import pprint
f = {}
for z in d:
f[z] = dict(d[z])
pprint.pprint(f)
puddletag-1.0.2/puddlestuff/plugins/ 0000755 0001750 0000144 00000000000 12236755734 017772 5 ustar keith users 0000000 0000000 puddletag-1.0.2/puddlestuff/plugins/__init__.py 0000644 0001750 0000144 00000002713 11734651721 022077 0 ustar keith users 0000000 0000000 # -*- coding: utf-8 -*-
from collections import defaultdict
from puddlestuff.constants import ALWAYS, FILESLOADED, VIEWFILLED, FILESSELECTED, ENABLESIGNALS
from PyQt4.QtCore import SIGNAL
from puddlestuff.puddlesettings import add_config_widget, SettingsError
status = {}
def connect_shortcut(action, enabled, disabled=None, togglecheck=None):
controls = status['dialogs']
emits = defaultdict(lambda: [])
for c in controls.values():
[emits[sig].append(c) for sig in c.emits]
connect = action.connect
if enabled in emits:
[connect(c, ENABLESIGNALS.get(enabled, SIGNAL(enabled)),
action.setEnabled) for c in emits[enabled]]
else:
print 'No enable signal found for', action.text()
action.setEnabled(False)
if togglecheck and togglecheck in emits:
[connect(c, ENABLESIGNALS.get(togglecheck, SIGNAL(togglecheck)),
action.setEnabled) for c in emits[togglecheck]]
def connect_control(control):
controls = status['dialogs']
emits = defaultdict(lambda: [])
for c in controls.values():
[emits[sig].append(c) for sig in c.emits]
connect = control.connect
for signal, slot in control.receives:
if signal in emits:
[connect(c, SIGNAL(signal), slot) for c in emits[signal]]
for c in controls.values():
for signal, slot in c.receives:
if signal in control.emits:
connect(control, SIGNAL(signal), slot) puddletag-1.0.2/puddlestuff/functions_dialogs.py 0000644 0001750 0000144 00000004300 11612773575 022372 0 ustar keith users 0000000 0000000 # -*- coding: utf-8 -*-
from PyQt4.QtGui import (QCheckBox, QLabel, QHBoxLayout, QSpinBox,
QVBoxLayout, QWidget)
from PyQt4.QtCore import SIGNAL
from puddlestuff.translations import translate
def sanitize(type_, value, default=None):
if type_ is int:
try:
return int(value)
except (TypeError, ValueError):
return default
elif type_ is bool:
if value is True or value == 'True':
return True
else:
return False
else:
return value
class AutoNumbering(QWidget):
def __init__(self, parent = None):
QWidget.__init__(self, parent)
def hbox(*widgets):
box = QHBoxLayout()
[box.addWidget(z) for z in widgets]
box.addStretch()
return box
vbox = QVBoxLayout()
startlabel = QLabel(translate('Autonumbering Wizard', "&Start: "))
self._start = QSpinBox()
startlabel.setBuddy(self._start)
self._start.setValue(1)
self._start.setMaximum(65536)
vbox.addLayout(hbox(startlabel, self._start))
label = QLabel(translate('Autonumbering Wizard', 'Max length after padding with zeroes: '))
self._padlength = QSpinBox()
label.setBuddy(self._padlength)
self._padlength.setValue(1)
self._padlength.setMaximum(65535)
self._padlength.setMinimum(1)
vbox.addLayout(hbox(label, self._padlength))
self._restart_numbering = QCheckBox(translate('Autonumbering Wizard', "&Restart numbering at each directory."))
vbox.addWidget(self._restart_numbering)
vbox.addStretch()
self.setLayout(vbox)
def setArguments(self, *args):
minimum = sanitize(int, args[0], 0)
restart = sanitize(bool, args[1], True)
padding = sanitize(int, args[2], 1)
self._start.setValue(minimum)
self._restart_numbering.setChecked(restart)
self._padlength.setValue(padding)
def arguments(self):
x = [
self._start.value(),
self._restart_numbering.isChecked(),
self._padlength.value()]
return x
from functions import autonumbering
dialogs = {autonumbering: AutoNumbering} puddletag-1.0.2/puddlestuff/pluginloader.py 0000755 0001750 0000144 00000012051 11653274325 021344 0 ustar keith users 0000000 0000000 # -*- coding: utf-8 -*-
import os, traceback, sys
from puddlestuff.puddleobjects import PuddleConfig, winsettings
from puddlestuff.constants import (FUNCTIONS, TAGSOURCE, SAVEDIR,
DIALOGS, MUSICLIBS, MODULES)
from os.path import splitext, exists
from PyQt4.QtCore import *
from PyQt4.QtGui import *
from puddlestuff.translations import translate
NAME = 'name'
AUTHOR = 'author'
DESC = 'description'
PT_VERSION = 'puddletag_version'
VERSION = 'version'
INFO_SECTION = 'info'
MODULE_NAME = 'module'
PLUGIN_DIRS = [os.path.join(SAVEDIR, u'plugins'),
os.path.join(os.path.dirname(__file__), 'plugins')]
PROPERTIES = [NAME, AUTHOR, DESC, PT_VERSION, VERSION]
def get_plugins(plugindir):
if not os.path.exists(plugindir):
os.makedirs(plugindir)
infos = []
for module in os.listdir(plugindir):
info_path = os.path.join(plugindir, module, 'info')
if not exists(info_path):
continue
cparser = PuddleConfig(info_path)
values = [cparser.get(INFO_SECTION, prop, '') for prop in PROPERTIES]
if len(filter(None, values)) < len(PROPERTIES):
continue
d = dict(zip(PROPERTIES, values))
d[MODULE_NAME] = module
infos.append(d)
return infos
def load_plugins(plugins=None, parent=None):
[sys.path.insert(0, d) for d in PLUGIN_DIRS]
cparser = PuddleConfig()
to_load = cparser.get('plugins', 'to_load', [])
functions = {}
tagsources = []
dialogs = []
musiclibs = []
modules = []
join = os.path.join
if plugins is None:
plugins = []
[plugins.extend(get_plugins(d)) for d in PLUGIN_DIRS]
plugins.sort(key=lambda d: d.get(NAME, u''))
for plugin in plugins:
if plugin[MODULE_NAME] not in to_load:
continue
try:
module = __import__(plugin[MODULE_NAME])
except:
print u'Failed to load plugin: ', plugin['name']
traceback.print_exc()
continue
if hasattr(module, 'functions'):
functions.update(module.functions)
if hasattr(module, 'tagsources'):
tagsources.extend(module.tagsources)
if hasattr(module, 'dialogs'):
dialogs.extend(module.dialogs)
if hasattr(module, 'musiclibs'):
musiclibs.extend(module.musiclibs)
modules.append(module)
for d in PLUGIN_DIRS:
del(sys.path[0])
return {FUNCTIONS: functions, TAGSOURCE: tagsources, DIALOGS: dialogs,
MUSICLIBS: musiclibs, MODULES: modules}
class InfoWidget(QLabel):
def __init__(self, info=None, parent=None):
super(InfoWidget, self).__init__(parent)
self.setAlignment(Qt.AlignLeft | Qt.AlignTop)
self.setWordWrap(True)
if info:
self.changeInfo(info)
def changeInfo(self, info):
labels = [translate('Plugin Settings', 'Name'),
translate('Plugin Settings', 'Author'),
translate('Plugin Settings', 'Description'),
translate('Plugin Settings', 'Version')]
properties = [NAME, AUTHOR, DESC, VERSION]
text = u'
'.join([u'%s: %s' % (disp, info[prop]) for
disp, prop in zip(labels, properties)])
self.setText(text)
class PluginConfig(QDialog):
def __init__(self, parent = None):
super(PluginConfig, self).__init__(parent)
winsettings('pluginconfig', self)
self._listbox = QListWidget()
info_display = InfoWidget()
hbox = QHBoxLayout()
hbox.addWidget(self._listbox, 0)
hbox.addWidget(info_display, 1)
vbox = QVBoxLayout()
vbox.addLayout(hbox)
vbox.addWidget(
QLabel(translate("Plugin Settings",
'Loading/unloading plugins requires a restart.')))
self.setLayout(vbox)
plugins = []
[plugins.extend(get_plugins(d)) for d in PLUGIN_DIRS]
cparser = PuddleConfig()
to_load = cparser.get('plugins', 'to_load', [])
for plugin in plugins:
item = QListWidgetItem()
item.setText(plugin[NAME])
if plugin[MODULE_NAME] in to_load:
item.setCheckState(Qt.Checked)
else:
item.setCheckState(Qt.Unchecked)
item.plugin = plugin
self._listbox.addItem(item)
self.connect(self._listbox,
SIGNAL('currentItemChanged(QListWidgetItem*, QListWidgetItem *)'),
lambda item, previous: info_display.changeInfo(item.plugin))
def get_to_load(self):
to_load = []
for row in range(self._listbox.count()):
item = self._listbox.item(row)
if item.checkState() == Qt.Checked:
to_load.append(item.plugin[MODULE_NAME])
return to_load
def applySettings(self, control=None):
to_load = self.get_to_load()
cparser = PuddleConfig()
cparser.set('plugins', 'to_load', to_load)
if __name__ == '__main__':
app = QApplication([])
win = PluginConfig()
win.show()
app.exec_() puddletag-1.0.2/puddlestuff/webdb.py 0000644 0001750 0000144 00000102046 12050252313 017724 0 ustar keith users 0000000 0000000 #! /usr/bin/env python
# -*- coding: utf-8 -*-
import glob, os, pdb, sys, traceback
from collections import defaultdict
from copy import copy, deepcopy
from functools import partial
from PyQt4.QtCore import *
from PyQt4.QtGui import *
import puddlestuff
from puddlestuff.releasewidget import ReleaseWidget
import puddlestuff.audioinfo as audioinfo
from puddlestuff.constants import (TEXT, COMBO, SPINBOX,
CHECKBOX, RIGHTDOCK, SAVEDIR)
from puddlestuff.findfunc import parsefunc
from puddlestuff.functions import replace_regex
from puddleobjects import (create_buddy, unique, winsettings,
ListBox, ListButtons, OKCancel, PuddleConfig, PuddleThread)
from puddlestuff.tagsources import (tagsources, status_obj, set_useragent,
write_log, RetrievalError, mp3tag, SubmissionError)
from puddlestuff.util import (isempty, pprint_tag,
split_by_field, to_string, translate)
pyqtRemoveInputHook()
TAGSOURCE_CONFIG = os.path.join(SAVEDIR, 'tagsources.conf')
MTAG_SOURCE_DIR = os.path.join(SAVEDIR, 'mp3tag_sources')
DEFAULT_SEARCH_TIP = translate("WebDB",
"Enter search parameters here. If empty, the selected "
"files are used.
")
FIELDLIST_TIP = translate("WebDB",
'Enter a comma seperated list of fields to write. '
'
Eg. artist, album, title will only '
'write the artist, album and title fields of the '
'retrieved tags.
If you want to '
'exclude some fields, but write all others start the '
'list the tilde (~) character. Eg ~composer, '
'__image will write all fields but the '
'composer and __image fields.')
DEFAULT_REGEXP = {'album': [u'(.*?)([\(\[\{].*[\)\]\}])', u'$1']}
def apply_regexps(audio, regexps=None):
if regexps is None:
regexps = DEFAULT_REGEXP
audio = deepcopy(audio)
changed = False
for field, (regexp, output) in regexps.iteritems():
if field not in audio:
continue
text = to_string(audio[field])
try:
val = replace_regex(audio, text, regexp, output)
if val:
audio[field] = val
if not changed and val != text:
changed = val
except puddlestuff.findfunc.FuncError:
continue
return changed, audio
def display_tag(tag):
"""Used to display tags in in a human parseable format."""
tag = dict((k,v) for k,v in tag.iteritems() if
not k.startswith('#') and not isempty(v))
if not tag:
return translate("WebDB", "Nothing to display.")
fmt = u"%s: %s
"
text = pprint_tag(tag, fmt, True)
if text.endswith(u'
'):
text = text[:-len(u'
')]
return text
def load_mp3tag_sources(dirpath=MTAG_SOURCE_DIR):
"Loads Mp3tag tag sources from dirpath and return the tag source classes."
files = glob.glob(os.path.join(dirpath, '*.src'))
classes = []
for f in files:
try:
idents, search, album = mp3tag.open_script(f)
classes.append(mp3tag.Mp3TagSource(idents, search, album))
except:
print translate("WebDB", "Couldn't load Mp3tag Tag Source %s") % f
traceback.print_exc()
continue
return classes
def strip(audio, field_list, reverse = False, leave_exact=False):
'''Returns dict of key/values from audio where the key is in field_list.
If reverse is True then the dict will consist of all
fields found in audio where the key is NOT IN in field_list.
If the first field in field_list starts with '~' then reverse will be
set to True.
Any fields starting with '#' will be removed.
'''
if not field_list:
ret = dict([(key, audio[key]) for key in audio if
not key.startswith('#')])
if leave_exact and '#exact' in audio:
ret['#exact'] = audio['#exact']
return ret
tags = field_list[::]
if tags and tags[0].startswith('~'):
reverse = True
tags[0] = tags[0][1:]
else:
reverse = False
if reverse:
ret = dict([(key, audio[key]) for key in audio if key not in
tags and not key.startswith('#')])
else:
ret = dict([(key, audio[key]) for key in field_list
if not key.startswith('#') and key in audio])
if leave_exact and '#exact' in audio:
ret['#exact'] = audio['#exact']
return ret
def split_strip(stringlist):
'''Splits and strips each comma-delimited string in a list of strings.
>>> split_strip(['artist, title', 'album,genre'])
[['artist', 'title'], ['album', 'genre']]
'''
return [[field.strip() for field in s.split(u',')] for s in stringlist]
class FieldsEdit(QWidget):
def __init__(self, tags=None, parent=None):
QWidget.__init__(self, parent)
if not tags:
tags = []
label = QLabel()
label.setText(translate("Defaults", '&Fields'))
self._text = QLineEdit(u', '.join(tags))
label.setBuddy(self._text)
layout = QHBoxLayout()
layout.setMargin(0)
layout.addWidget(label, 0)
layout.addWidget(self._text, 1)
self.connect(self._text, SIGNAL('textChanged(QString)'),
self.emitTags)
self.setLayout(layout)
def emitTags(self, text=None):
self.emit(SIGNAL('fieldsChanged'), self.tags(text))
def setTags(self, tags):
self._text.setText(u', '.join(tags))
def setToolTip(self, value):
QWidget.setToolTip(self, value)
self._text.setToolTip(value)
def tags(self, text=None):
if not text:
return filter(None, [z.strip() for z in
unicode(self._text.text()).split(u',')])
else:
return filter(None,
[z.strip() for z in unicode(text).split(u',')])
class SimpleDialog(QDialog):
"""Class for simple dialog creation."""
def __init__(self, title, controls, parent = None):
"""title => Dialog's title.
controls is a list of 3-element-lists.
The three 3-element lists consist of:
description => Descriptive label for the control.
control_type => One of TEXT, COMBO, CHECKBOX corresponding
to a QLineEdit, QComboBox and QCheckBox being created
respectively.
default => Default arguments.
Can be any string for TEXT,
Must be a list of strings for COMBO as these will form the
items selectable by the combo box.
Can be either True or False for CheckBox.
A dialog will be created with vertical layout. Like so: