def __init__(self,
name=None,
description=None,
epilog=None,
debug_flag=True):
self.db = ConfigDB()
self.name = os.path.basename(sys.argv[0])
reload(sys)
sys.setdefaultencoding('utf-8')
setproctitle('%s %s' % (self.name, ' '.join(sys.argv[1:])))
signal.signal(signal.SIGINT, self.SIGINT)
if name is None:
name = self.name
self.logger = SoundforestLogger()
self.log = self.logger.default_stream
self.parser = argparse.ArgumentParser(
prog=name,
description=description,
epilog=epilog,
add_help=True,
conflict_handler='resolve',
)
self.subcommand_parser = None
self.subcommands = None
if debug_flag:
self.parser.add_argument('--debug',
action='store_true',
help='Show debug messages')
class ScriptCommand(argparse.ArgumentParser):
"""
Parent class for cli subcommands
"""
def __init__(self, name, description='', epilog='', mode_flags=[]):
self.script = None
self.name = name
self.description = description
self.epilog = epilog
self.logger = SoundforestLogger()
self.log = self.logger.default_stream
if not isinstance(mode_flags, list):
raise ScriptError('Mode flags must be a list')
self.mode_flags = mode_flags
self.selected_mode_flags = []
@property
def db(self):
return self.script.db
def exit(self, *args, **kwargs):
self.script.exit(*args, **kwargs)
def message(self, *args, **kwargs):
self.script.message(*args, **kwargs)
def parse_args(self, args):
if hasattr(args, 'debug') and getattr(args, 'debug'):
self.logger.set_level('DEBUG')
self.selected_mode_flags = []
for flag in self.mode_flags:
if not hasattr(args, flag):
continue
if getattr(self, flag) not in ( None, False, [], ):
self.selected_mode_flags.append(flag)
xterm_title('soundforest %s' % (self.name))
return args
def match_path(self, path, matches=[]):
for m in matches:
m_realpath = os.path.realpath(m)
t_realpath = os.path.realpath(path)
if fnmatch.fnmatch(path, m):
return True
if path[:len(m)] == m:
return True
if t_realpath[:len(m_realpath)] == m_realpath:
return True
return False
def __init__(self, threads=None, delete=False, debug=False):
MusaThreadManager.__init__(self, 'sync', threads)
self.delete = delete
self.debug = debug
if not debug:
self.log = SoundforestLogger('sync').register_file_handler(
'sync', MUSA_USER_DIR)
SoundforestLogger('sync').set_level('INFO')
else:
self.log = SoundforestLogger().default_stream
def __init__(self, name, description='', epilog='', mode_flags=[]):
self.script = None
self.name = name
self.description = description
self.epilog = epilog
self.logger = SoundforestLogger()
self.log = self.logger.default_stream
if not isinstance(mode_flags, list):
raise ScriptError('Mode flags must be a list')
self.mode_flags = mode_flags
self.selected_mode_flags = []
def __init__(self, name=None, description=None, epilog=None, debug_flag=True):
self.db = ConfigDB()
self.name = os.path.basename(sys.argv[0])
reload(sys)
sys.setdefaultencoding('utf-8')
setproctitle('%s %s' % (self.name, ' '.join(sys.argv[1:])))
signal.signal(signal.SIGINT, self.SIGINT)
if name is None:
name = self.name
self.logger = SoundforestLogger()
self.log = self.logger.default_stream
self.parser = argparse.ArgumentParser(
prog=name,
description=description,
epilog=epilog,
add_help=True,
conflict_handler='resolve',
)
self.subcommand_parser = None
self.subcommands = None
if debug_flag:
self.parser.add_argument('--debug', action='store_true', help='Show debug messages')
def __init__(self, name, threads=None):
self.log = SoundforestLogger().default_stream
self.db = ConfigDB()
if threads is None:
threads = self.db.get('threads')
if threads is None:
threads = 1
else:
threads = int(threads)
self.threads = threads
def __init__(self):
self.log = SoundforestLogger().default_stream
list.__init__(self)
self.db = ConfigDB()
common_prefixes = set(DEFAULT_PATHS + [prefix.path for prefix in self.db.prefixes])
for path in common_prefixes:
for name, codec in self.db.codecs.items():
prefix_path = os.path.join(path, name)
prefix = MusicTreePrefix(prefix_path, [codec.name] + codec.extensions)
self.register_prefix(prefix)
if 'm4a' in self.db.codecs.keys():
prefix_path = os.path.join(path, 'm4a')
prefix = MusicTreePrefix(prefix_path, self.db.codecs.extensions('m4a'))
self.register_prefix(prefix)
itunes_prefix = MusicTreePrefix(ITUNES_MUSIC, self.db.codecs.extensions('m4a'))
self.register_prefix(itunes_prefix)
self.load_user_config()
def __init__(self, name, description='', epilog='', mode_flags=[]):
self.script = None
self.name = name
self.description = description
self.epilog = epilog
self.logger = SoundforestLogger()
self.log = self.logger.default_stream
if not isinstance(mode_flags, list):
raise ScriptError('Mode flags must be a list')
self.mode_flags = mode_flags
self.selected_mode_flags = []
def __init__(self, path):
self.log = SoundforestLogger().default_stream
models.SoundforestDB.__init__(self, path=path)
treetypes = self.session.query(models.TreeTypeModel).all()
if not treetypes:
treetypes = []
for name, description in DEFAULT_TREE_TYPES.items():
treetypes.append(
models.TreeTypeModel(name=name,
description=description))
self.add(treetypes)
self.commit()
self.codecs = CodecConfiguration(db=self)
self.sync = SyncConfiguration(db=self)
def __init__(self):
self.log = SoundforestLogger().default_stream
self.db = ConfigDB()
common_prefixes = set(DEFAULT_PATHS + [prefix.path for prefix in self.db.tree_prefixes])
for path in common_prefixes:
for name, codec in self.db.codec_configuration.items():
prefix_path = os.path.join(path, name)
prefix = MusicTreePrefix(prefix_path, [codec.name] + codec.extensions)
self.add_prefix(prefix)
if 'm4a' in self.db.codec_configuration.keys():
prefix_path = os.path.join(path, 'm4a')
prefix = MusicTreePrefix(prefix_path, self.db.codec_configuration.extensions('m4a'))
self.add_prefix(prefix)
itunes_prefix = MusicTreePrefix(ITUNES_MUSIC, self.db.codec_configuration.extensions('m4a'))
self.add_prefix(itunes_prefix)
self.load_user_config()
def __init__(self, path, extensions=[]):
self.log = SoundforestLogger().default_stream
self.path = path.rstrip(os.sep)
if not isinstance(extensions, list):
raise PrefixError('Extensions must be a list')
self.extensions = []
for ext in extensions:
if hasattr(ext, 'extension'):
ext = ext.extension
elif not isinstance(ext, basestring):
raise PrefixError('Extensions must be a list of strings')
if not isinstance(ext, unicode):
ext = unicode(ext, 'utf-8')
if self.extensions.count(ext)==0:
self.extensions.append(ext)
def __init__(self, path):
self.log = SoundforestLogger().default_stream
self.path = path_string(path)
self.codec = None
self.description = None
self.is_metadata = False
self.codec = match_codec(path)
if self.codec is not None:
self.description = self.codec.description.lower()
else:
m = match_metadata(path)
if m:
self.is_metadata = True
self.description = m.description.lower()
elif os.path.isdir(path):
self.description = 'unknown directory'
else:
self.description = 'unknown file format'
def __init__(self, path):
self.log = SoundforestLogger().default_stream
self.path = path_string(path)
self.codec = None
self.description = None
self.is_metadata = False
self.codec = match_codec(path)
if self.codec is not None:
self.description = self.codec.description.lower()
else:
m = match_metadata(path)
if m:
self.is_metadata = True
self.description = m.description.lower()
elif os.path.isdir(path):
self.description = 'unknown directory'
else:
self.description = 'unknown file format'
def __init__(self, db):
self.log = SoundforestLogger().default_stream
self.db = db
class Script(object):
"""
Common CLI tool setup class
"""
def __init__(self, name=None, description=None, epilog=None, debug_flag=True):
self.db = ConfigDB()
self.name = os.path.basename(sys.argv[0])
reload(sys)
sys.setdefaultencoding('utf-8')
setproctitle('%s %s' % (self.name, ' '.join(sys.argv[1:])))
signal.signal(signal.SIGINT, self.SIGINT)
if name is None:
name = self.name
self.logger = SoundforestLogger()
self.log = self.logger.default_stream
self.parser = argparse.ArgumentParser(
prog=name,
description=description,
epilog=epilog,
add_help=True,
conflict_handler='resolve',
)
self.subcommand_parser = None
self.subcommands = None
if debug_flag:
self.parser.add_argument('--debug', action='store_true', help='Show debug messages')
def SIGINT(self, signum, frame):
"""
Parse SIGINT signal by quitting the program cleanly with exit code 1
"""
for t in filter(lambda t: t.name!='MainThread', threading.enumerate()):
t.join()
self.exit(1)
def wait(self, poll_interval=1):
"""
Wait for running threads to finish.
Poll interval is time to wait between checks for threads
"""
while True:
active = filter(lambda t: t.name!='MainThread', threading.enumerate())
if not len(active):
break
time.sleep(poll_interval)
def exit(self, value=0, message=None):
"""
Exit the script with given exit value.
If message is not None, it is printed on screen.
"""
if message is not None:
self.message(message)
while True:
active = filter(lambda t: t.name!='MainThread', threading.enumerate())
if not len(active):
break
time.sleep(1)
sys.exit(value)
def message(self, message):
sys.stdout.write('%s\n' % message)
sys.stdout.flush()
def error(self, message):
sys.stderr.write('%s\n' % message)
sys.stdout.flush()
def add_subcommand(self, command):
if self.subcommand_parser is None:
self.subcommand_parser = self.parser.add_subparsers(
dest='command',
help='Please select one command mode below',
title='Command modes'
)
self.subcommands = {}
if not isinstance(command, ScriptCommand):
raise ScriptError('Subcommand must be a ScriptCommand instance')
parser = self.subcommand_parser.add_parser(
command.name,
help=command.description,
description=command.description,
epilog=command.epilog
)
self.subcommands[command.name] = command
command.script = self
return parser
def add_argument(self, *args, **kwargs):
"""
Shortcut to add argument to main argumentparser instance
"""
self.parser.add_argument(*args, **kwargs)
def parse_args(self):
"""
Call parse_args for parser and check for default logging flags
"""
args = self.parser.parse_args()
if hasattr(args, 'debug') and getattr(args, 'debug'):
self.logger.set_level('DEBUG')
return args
def run(self):
args = self.parse_args()
if self.subcommand_parser is not None:
self.subcommands[args.command].run(args)
class TreePrefixInstance(list):
def __init__(self):
self.log = SoundforestLogger().default_stream
list.__init__(self)
self.db = ConfigDB()
common_prefixes = set(DEFAULT_PATHS + [prefix.path for prefix in self.db.prefixes])
for path in common_prefixes:
for name, codec in self.db.codecs.items():
prefix_path = os.path.join(path, name)
prefix = MusicTreePrefix(prefix_path, [codec.name] + codec.extensions)
self.register_prefix(prefix)
if 'm4a' in self.db.codecs.keys():
prefix_path = os.path.join(path, 'm4a')
prefix = MusicTreePrefix(prefix_path, self.db.codecs.extensions('m4a'))
self.register_prefix(prefix)
itunes_prefix = MusicTreePrefix(ITUNES_MUSIC, self.db.codecs.extensions('m4a'))
self.register_prefix(itunes_prefix)
self.load_user_config()
def load_user_config(self):
if not os.path.isfile(USER_PATH_CONFIG):
return
try:
with open(USER_PATH_CONFIG, 'r') as config:
user_codecs = {}
for line in config:
try:
if line.strip() == '' or line[:1] == '#':
continue
(codec_name, paths) = [x.strip() for x in line.split('=', 1)]
paths = [x.strip() for x in paths.split(',')]
except ValueError:
self.log.debug('Error parsing line: %s' % line)
continue
user_codecs[codec_name] = paths
for codec_name in reversed(sorted(user_codecs.keys())):
paths = user_codecs[codec_name]
if codec_name == 'itunes':
codec = match_codec('m4a')
else:
codec = match_codec(codec_name)
if not codec:
continue
for path in reversed(paths):
prefix = MusicTreePrefix(path, self.db.codecs.extensions('aac'))
if codec_name == 'itunes':
self.register_prefix(prefix, prepend=False)
else:
self.register_prefix(prefix, prepend=True)
except IOError, (ecode, emsg):
raise PrefixError('Error reading %s: %s' % (USER_PATH_CONFIG, emsg))
class AudioFileFormat(object):
"""AudioFileFormat
Common file format wrapper for various codecs
"""
def __init__(self, path):
self.log = SoundforestLogger().default_stream
self.path = path_string(path)
self.codec = None
self.description = None
self.is_metadata = False
self.codec = match_codec(path)
if self.codec is not None:
self.description = self.codec.description.lower()
else:
m = match_metadata(path)
if m:
self.is_metadata = True
self.description = m.description.lower()
elif os.path.isdir(path):
self.description = 'unknown directory'
else:
self.description = 'unknown file format'
def __repr__(self):
return '{0} {1}'.format(self.codec, self.path)
@property
def directory(self):
return os.path.dirname(self.path)
@property
def filename(self):
return os.path.basename(self.path)
@property
def extension(self):
return os.path.splitext(self.path)[1][1:]
@property
def size(self):
if not self.path.isfile:
return None
return os.stat(self.path).st_size
@property
def ctime(self):
if not self.path.isfile:
return None
return os.stat(self.path).st_ctime
@property
def mtime(self):
if not self.path.isfile:
return None
return os.stat(self.path).st_mtime
def get_temporary_file(self, dir=SOUNDFOREST_CACHE_DIR, prefix='tmp', suffix=''):
if not os.path.isdir(dir):
try:
os.makedirs(dir)
except IOError as e:
raise SoundforestError('Error creating directory {0}: {1}'.format(SOUNDFOREST_CACHE_DIR, e))
except OSError as e:
raise SoundforestError('Error creating directory {0}: {1}'.format(SOUNDFOREST_CACHE_DIR, e))
return tempfile.mktemp(dir=dir, prefix=prefix, suffix=suffix)
def get_tag_parser(self):
if self.codec is None:
return None
if self.codec.name in TAG_PARSERS.keys():
classpath = TAG_PARSERS[self.codec.name]
else:
try:
classpath = TAG_PARSERS[TAG_EXTENSION_ALIASES[self.codec.name]]
except KeyError:
return None
module_path = '.'.join(classpath.split('.')[:-1])
class_name = classpath.split('.')[-1]
m = __import__(module_path, globals(), fromlist=[class_name])
return getattr(m, class_name)
def get_available_encoders(self):
if self.codec is None or not self.codec.encoders:
return []
return filter_available_command_list(self.codec.encoders)
def get_available_decoders(self):
if self.codec is None or not self.codec.decoders:
return []
return filter_available_command_list(self.codec.decoders)
def get_available_testers(self):
if self.codec is None or not self.codec.testers:
return []
return filter_available_command_list(self.codec.testers)
def execute(self, args):
self.log.debug('running: {0}'.format(' '.join(args)))
p = Popen(args, stdin=PIPE, stdout=PIPE, stderr=PIPE)
(stdout, stderr) = p.communicate()
if stdout:
self.log.debug('output:\n{0}'.format(stdout))
if stderr:
self.log.debug('errors:\n{0}'.format(stderr))
return p.returncode, stdout, stderr
class TreePrefixInstance(list):
def __init__(self):
self.log = SoundforestLogger().default_stream
self.db = ConfigDB()
common_prefixes = set(DEFAULT_PATHS + [prefix.path for prefix in self.db.tree_prefixes])
for path in common_prefixes:
for name, codec in self.db.codec_configuration.items():
prefix_path = os.path.join(path, name)
prefix = MusicTreePrefix(prefix_path, [codec.name] + codec.extensions)
self.add_prefix(prefix)
if 'm4a' in self.db.codec_configuration.keys():
prefix_path = os.path.join(path, 'm4a')
prefix = MusicTreePrefix(prefix_path, self.db.codec_configuration.extensions('m4a'))
self.add_prefix(prefix)
itunes_prefix = MusicTreePrefix(ITUNES_MUSIC, self.db.codec_configuration.extensions('m4a'))
self.add_prefix(itunes_prefix)
self.load_user_config()
def load_user_config(self):
if not os.path.isfile(USER_PATH_CONFIG):
return
try:
with open(USER_PATH_CONFIG, 'r') as config:
user_codecs = {}
for line in config:
try:
if line.strip() == '' or line[:1] == '#':
continue
(codec_name, paths) = [x.strip() for x in line.split('=', 1)]
paths = [x.strip() for x in paths.split(',')]
except ValueError:
self.log.debug('Error parsing line: {}'.format(line))
continue
user_codecs[codec_name] = paths
for codec_name in reversed(sorted(user_codecs.keys())):
paths = user_codecs[codec_name]
if codec_name == 'itunes':
codec = match_codec('m4a')
else:
codec = match_codec(codec_name)
if not codec:
continue
for path in reversed(paths):
prefix = MusicTreePrefix(path, self.db.codec_configuration.extensions('aac'))
if codec_name == 'itunes':
self.add_prefix(prefix, prepend=False)
else:
self.add_prefix(prefix, prepend=True)
except IOError as e:
raise PrefixError('Error reading {}: {}'.format(
USER_PATH_CONFIG,
e,
))
def index(self, prefix):
if not isinstance(prefix, MusicTreePrefix):
raise PrefixError('Prefix must be MusicTreePrefix instance')
for index, existing in enumerate(self):
if prefix.realpath == existing.realpath:
return index
raise IndexError('Prefix is not registered')
def add_prefix(self, prefix, extensions=[], prepend=False):
if isinstance(prefix, str):
prefix = MusicTreePrefix(prefix, extensions)
if not isinstance(prefix, MusicTreePrefix):
raise PrefixError('prefix must be string or MusicTreePrefix instance')
try:
index = self.index(prefix)
if prepend and index != 0:
prefix = self.pop(index)
self.insert(0, prefix)
except IndexError:
if prepend:
self.insert(0, prefix)
else:
self.append(prefix)
return prefix
def match_extension(self, extension, match_existing=False):
for prefix in self:
if match_existing and not os.path.isdir(prefix.path):
continue
if prefix.match_extension(extension):
return prefix
return None
def match(self, path, match_existing=False):
for prefix in self:
if match_existing and not os.path.isdir(prefix.path):
continue
if prefix.match(path):
return prefix
return None
def relative_path(self, path):
prefix = self.match(path)
if not prefix:
return path
return prefix.relative_path(path)
class Script(object):
"""
Common CLI tool setup class
"""
def __init__(self,
name=None,
description=None,
epilog=None,
debug_flag=True):
self.db = ConfigDB()
self.name = os.path.basename(sys.argv[0])
reload(sys)
sys.setdefaultencoding('utf-8')
setproctitle('%s %s' % (self.name, ' '.join(sys.argv[1:])))
signal.signal(signal.SIGINT, self.SIGINT)
if name is None:
name = self.name
self.logger = SoundforestLogger()
self.log = self.logger.default_stream
self.parser = argparse.ArgumentParser(
prog=name,
description=description,
epilog=epilog,
add_help=True,
conflict_handler='resolve',
)
self.subcommand_parser = None
self.subcommands = None
if debug_flag:
self.parser.add_argument('--debug',
action='store_true',
help='Show debug messages')
def SIGINT(self, signum, frame):
"""
Parse SIGINT signal by quitting the program cleanly with exit code 1
"""
for t in filter(lambda t: t.name != 'MainThread',
threading.enumerate()):
t.join()
self.exit(1)
def wait(self, poll_interval=1):
"""
Wait for running threads to finish.
Poll interval is time to wait between checks for threads
"""
while True:
active = filter(lambda t: t.name != 'MainThread',
threading.enumerate())
if not len(active):
break
time.sleep(poll_interval)
def exit(self, value=0, message=None):
"""
Exit the script with given exit value.
If message is not None, it is printed on screen.
"""
if message is not None:
self.message(message)
while True:
active = filter(lambda t: t.name != 'MainThread',
threading.enumerate())
if not len(active):
break
time.sleep(1)
sys.exit(value)
def message(self, message):
sys.stdout.write('%s\n' % message)
sys.stdout.flush()
def error(self, message):
sys.stderr.write('%s\n' % message)
sys.stdout.flush()
def add_subcommand(self, command):
if self.subcommand_parser is None:
self.subcommand_parser = self.parser.add_subparsers(
dest='command',
help='Please select one command mode below',
title='Command modes')
self.subcommands = {}
if not isinstance(command, ScriptCommand):
raise ScriptError('Subcommand must be a ScriptCommand instance')
parser = self.subcommand_parser.add_parser(
command.name,
help=command.description,
description=command.description,
epilog=command.epilog)
self.subcommands[command.name] = command
command.script = self
return parser
def add_argument(self, *args, **kwargs):
"""
Shortcut to add argument to main argumentparser instance
"""
self.parser.add_argument(*args, **kwargs)
def parse_args(self):
"""
Call parse_args for parser and check for default logging flags
"""
args = self.parser.parse_args()
if hasattr(args, 'debug') and getattr(args, 'debug'):
self.logger.set_level('DEBUG')
return args
def run(self):
args = self.parse_args()
if self.subcommand_parser is not None:
self.subcommands[args.command].run(args)
def __init__(self, name):
threading.Thread.__init__(self)
self.log = SoundforestLogger().default_stream
self.status = 'not running'
self.setDaemon(True)
self.setName(name)
class ScriptCommand(argparse.ArgumentParser):
"""
Parent class for cli subcommands
"""
def __init__(self, name, description='', epilog='', mode_flags=[]):
self.script = None
self.name = name
self.description = description
self.epilog = epilog
self.logger = SoundforestLogger()
self.log = self.logger.default_stream
if not isinstance(mode_flags, list):
raise ScriptError('Mode flags must be a list')
self.mode_flags = mode_flags
self.selected_mode_flags = []
@property
def db(self):
return self.script.db
def exit(self, *args, **kwargs):
self.script.exit(*args, **kwargs)
def message(self, *args, **kwargs):
self.script.message(*args, **kwargs)
def parse_args(self, args):
if hasattr(args, 'debug') and getattr(args, 'debug'):
self.logger.set_level('DEBUG')
self.selected_mode_flags = []
for flag in self.mode_flags:
if not hasattr(args, flag):
continue
if getattr(self, flag) not in (
None,
False,
[],
):
self.selected_mode_flags.append(flag)
xterm_title('soundforest %s' % (self.name))
return args
def match_path(self, path, matches=[]):
for m in matches:
m_realpath = os.path.realpath(m)
t_realpath = os.path.realpath(path)
if fnmatch.fnmatch(path, m):
return True
if path[:len(m)] == m:
return True
if t_realpath[:len(m_realpath)] == m_realpath:
return True
return False
Guessing of supported file formats and codecs based on extensions
"""
import os
import tempfile
from subprocess import Popen, PIPE
from soundforest import normalized, SoundforestError, CommandPathCache
from soundforest.config import ConfigDB
from soundforest.defaults import SOUNDFOREST_CACHE_DIR
from soundforest.log import SoundforestLogger
from soundforest.metadata import Metadata
logger = SoundforestLogger().default_stream
TAG_PARSERS = {
'm4a': 'soundforest.tags.formats.aac.aac',
'm4r': 'soundforest.tags.formats.aac.aac',
'mp3': 'soundforest.tags.formats.mp3.mp3',
'flac': 'soundforest.tags.formats.flac.flac',
'vorbis': 'soundforest.tags.formats.vorbis.vorbis',
}
PATH_CACHE = CommandPathCache()
PATH_CACHE.update()
db = ConfigDB()
def filter_available_command_list(commands):
