diff --git a/couchpotato/core/_base/_core/main.py b/couchpotato/core/_base/_core/main.py index 652b2d26..7a142081 100644 --- a/couchpotato/core/_base/_core/main.py +++ b/couchpotato/core/_base/_core/main.py @@ -8,7 +8,6 @@ from couchpotato.environment import Env from flask import request from uuid import uuid4 import os -import thread import time import traceback import webbrowser @@ -32,7 +31,6 @@ class Core(Plugin): addEvent('app.crappy_shutdown', self.crappyShutdown) addEvent('app.crappy_restart', self.crappyRestart) addEvent('app.load', self.launchBrowser, priority = 1) - addEvent('app.load', self.monitorParent) addEvent('app.base_url', self.createBaseUrl) addEvent('app.api_url', self.createApiUrl) @@ -41,27 +39,6 @@ class Core(Plugin): self.removeRestartFile() - def monitorParent(self): - - def looping(): - do_shutdown = False - while 1 and not self.shuttingDown(): - if os.name == 'nt': - if os.getppid(os.getpid()) <= 1: - do_shutdown = True - break - else: - if os.getppid() <= 1: - do_shutdown = True - break - time.sleep(1) - - if do_shutdown: - log.info('Starterscript has shutdown, shutdown subprocess') - fireEvent('app.crappy_shutdown') - - thread.start_new_thread(looping, ()) - def md5Password(self, value): return md5(value) if value else '' diff --git a/couchpotato/core/_base/updater/main.py b/couchpotato/core/_base/updater/main.py index a99013cb..6e9236f6 100644 --- a/couchpotato/core/_base/updater/main.py +++ b/couchpotato/core/_base/updater/main.py @@ -64,7 +64,7 @@ class Updater(Plugin): return log.info('Checking for new version on github for %s' % self.repo_name) - if not Env.setting('development'): + if not Env.get('dev'): self.repo.fetch() current_branch = self.repo.getCurrentBranch().name @@ -135,5 +135,13 @@ class Updater(Plugin): except: log.error('Couldn\'t remove %s: %s' % (full_path, traceback.format_exc())) + for dir_name in dirs: + full_path = os.path.join(root, dir_name) + if len(os.listdir(full_path)) == 0: + try: + os.rmdir(full_path) + except: + log.error('Couldn\'t remove empty directory %s: %s' % (full_path, traceback.format_exc())) + def isEnabled(self): return super(Updater, self).isEnabled() and Env.get('uses_git') diff --git a/couchpotato/core/downloaders/base.py b/couchpotato/core/downloaders/base.py index 911ed470..e90f951a 100644 --- a/couchpotato/core/downloaders/base.py +++ b/couchpotato/core/downloaders/base.py @@ -1,8 +1,8 @@ from couchpotato.core.event import addEvent +from couchpotato.core.helpers.encoding import toSafeString from couchpotato.core.logger import CPLog from couchpotato.core.plugins.base import Plugin from couchpotato.environment import Env -from couchpotato.core.helpers.encoding import toSafeString import os log = CPLog(__name__) diff --git a/couchpotato/core/downloaders/blackhole/main.py b/couchpotato/core/downloaders/blackhole/main.py index ff96deda..9408de18 100644 --- a/couchpotato/core/downloaders/blackhole/main.py +++ b/couchpotato/core/downloaders/blackhole/main.py @@ -42,6 +42,6 @@ class Blackhole(Downloader): pass except: - log.debug('Failed to download file: %s' % data.get('name')) + log.debug('Failed to download file %s: %s' % (data.get('name'), traceback.format_exc())) return False return False diff --git a/couchpotato/core/downloaders/transmission/__init__.py b/couchpotato/core/downloaders/transmission/__init__.py index b4d986f2..34bd3c8f 100644 --- a/couchpotato/core/downloaders/transmission/__init__.py +++ b/couchpotato/core/downloaders/transmission/__init__.py @@ -29,6 +29,7 @@ config = [{ }, { 'name': 'password', + 'type': 'password', }, { 'name': 'paused', @@ -43,6 +44,7 @@ config = [{ { 'name': 'ratio', 'default': 10, + 'type': 'int', 'advanced': True, 'description': 'Stop transfer when reaching ratio', }, diff --git a/couchpotato/core/downloaders/transmission/main.py b/couchpotato/core/downloaders/transmission/main.py index 42276ddf..7677ad02 100644 --- a/couchpotato/core/downloaders/transmission/main.py +++ b/couchpotato/core/downloaders/transmission/main.py @@ -1,3 +1,4 @@ +from base64 import b64encode from couchpotato.core.downloaders.base import Downloader from couchpotato.core.helpers.encoding import isInt from couchpotato.core.logger import CPLog @@ -17,7 +18,6 @@ class Transmission(Downloader): log.info('Sending "%s" to Transmission.' % data.get('name')) - # Load host from config and split out port. host = self.conf('host').split(':') if not isInt(host[1]): @@ -26,24 +26,21 @@ class Transmission(Downloader): # Set parameters for Transmission params = { - 'paused': self.conf('paused', 0), - 'download_dir': self.conf('directory', None) - } - change_params = { - 'seedRatioLimit': self.conf('ratio'), - 'seedRatioMode': 1 if self.conf('ratio') else 0 + 'paused': self.conf('paused', default = 0), + 'download_dir': self.conf('directory', default = None) } try: tc = transmissionrpc.Client(host[0], port = host[1], user = self.conf('username'), password = self.conf('password')) - tr_id = tc.add_uri(data.get('url'), **params) + filedata = data.get('download')(url = data.get('url'), nzb_id = data.get('id')) + torrent = tc.add_torrent(b64encode(filedata), **params) # Change settings of added torrents - for item in tr_id: - try: - tc.change(item, timeout = None, **change_params) - except transmissionrpc.TransmissionError, e: - log.error('Failed to change settings for transfer in transmission: %s' % e) + try: + torrent.seed_ratio_limit = self.conf('ratio') + torrent.seed_ratio_mode = 'single' if self.conf('ratio') else 'global' + except transmissionrpc.TransmissionError, e: + log.error('Failed to change settings for transfer in transmission: %s' % e) return True diff --git a/couchpotato/core/helpers/variable.py b/couchpotato/core/helpers/variable.py index c3a9980a..f38cf39c 100644 --- a/couchpotato/core/helpers/variable.py +++ b/couchpotato/core/helpers/variable.py @@ -34,6 +34,8 @@ def mergeDicts(a, b): else: if isDict(current_src[key]) and isDict(current_dst[key]): stack.append((current_dst[key], current_src[key])) + elif isinstance(current_src[key], list) and isinstance(current_dst[key], list): + current_dst[key].extend(current_src[key]) else: current_dst[key] = current_src[key] return dst diff --git a/couchpotato/core/loader.py b/couchpotato/core/loader.py index 4092c056..a5816cc2 100644 --- a/couchpotato/core/loader.py +++ b/couchpotato/core/loader.py @@ -32,9 +32,9 @@ class Loader(object): self.paths[provider + '_provider'] = (25, 'couchpotato.core.providers.' + provider, path) - for type, tuple in self.paths.iteritems(): - priority, module, dir = tuple - self.addFromDir(type, priority, module, dir) + for plugin_type, plugin_tuple in self.paths.iteritems(): + priority, module, dir_name = plugin_tuple + self.addFromDir(plugin_type, priority, module, dir_name) def run(self): did_save = 0 @@ -51,19 +51,21 @@ class Loader(object): did_save += self.loadSettings(m, module_name, save = False) self.loadPlugins(m, plugin.get('name')) - except Exception, e: + except ImportError: + log.debug('Import error, remove the empty folder: %s' % plugin.get('module')) + except: log.error('Can\'t import %s: %s' % (module_name, traceback.format_exc())) if did_save: fireEvent('settings.save') - def addFromDir(self, type, priority, module, dir): + def addFromDir(self, plugin_type, priority, module, dir_name): - for cur_file in glob.glob(os.path.join(dir, '*')): + for cur_file in glob.glob(os.path.join(dir_name, '*')): name = os.path.basename(cur_file) - if os.path.isdir(os.path.join(dir, name)): + if os.path.isdir(os.path.join(dir_name, name)): module_name = '%s.%s' % (module, name) - self.addModule(priority, type, module_name, name) + self.addModule(priority, plugin_type, module_name, name) def loadSettings(self, module, name, save = True): try: @@ -75,7 +77,7 @@ class Loader(object): options[option['name']] = option fireEvent('settings.register', section_name = section['name'], options = options, save = save) return True - except Exception, e: + except: log.debug("Failed loading settings for '%s': %s" % (name, traceback.format_exc())) return False @@ -92,7 +94,7 @@ class Loader(object): log.error("Failed loading plugin '%s': %s" % (module.__file__, traceback.format_exc())) return False - def addModule(self, priority, type, module, name): + def addModule(self, priority, plugin_type, module, name): if not self.modules.get(priority): self.modules[priority] = {} @@ -100,7 +102,7 @@ class Loader(object): self.modules[priority][module] = { 'priority': priority, 'module': module, - 'type': type, + 'type': plugin_type, 'name': name, } diff --git a/couchpotato/core/logger.py b/couchpotato/core/logger.py index 6bfe1974..2c539060 100644 --- a/couchpotato/core/logger.py +++ b/couchpotato/core/logger.py @@ -22,6 +22,9 @@ class CPLog(object): def error(self, msg): self.logger.error(self.addContext(msg)) + def warning(self, msg): + self.logger.warning(self.addContext(msg)) + def critical(self, msg): self.logger.critical(self.addContext(msg), exc_info = 1) @@ -35,7 +38,7 @@ class CPLog(object): pass from couchpotato.environment import Env - if not Env.setting('development'): + if not Env.get('dev'): for replace in self.replace_private: msg = re.sub('(%s=)[^\&]+' % replace, '%s=xxx' % replace, msg) @@ -43,7 +46,8 @@ class CPLog(object): # Replace api key try: api_key = Env.setting('api_key') - msg = msg.replace(api_key, 'API_KEY') + if api_key: + msg = msg.replace(api_key, 'API_KEY') except: pass diff --git a/couchpotato/core/notifications/core/static/notification.js b/couchpotato/core/notifications/core/static/notification.js index 5af76570..e96fdba2 100644 --- a/couchpotato/core/notifications/core/static/notification.js +++ b/couchpotato/core/notifications/core/static/notification.js @@ -23,7 +23,7 @@ var NotificationBase = new Class({ self.request = Api.request('core_notifier.listener', { 'initialDelay': 100, 'delay': 3000, - 'onComplete': self.processData.bind(self) + 'onSuccess': self.processData.bind(self) }) self.request.startTimer() diff --git a/couchpotato/core/notifications/growl/main.py b/couchpotato/core/notifications/growl/main.py index fe339fb5..7bd6056d 100644 --- a/couchpotato/core/notifications/growl/main.py +++ b/couchpotato/core/notifications/growl/main.py @@ -3,8 +3,6 @@ from couchpotato.core.logger import CPLog from couchpotato.core.notifications.base import Notification from gntp import notifier import logging -import thread -import time import traceback log = CPLog(__name__) @@ -12,31 +10,35 @@ log = CPLog(__name__) class Growl(Notification): + registered = False + def __init__(self): super(Growl, self).__init__() logging.getLogger('gntp').setLevel(logging.WARNING) + if self.isEnabled(): + self.register() + + def register(self): + if self.registered: return try: - def startGrowl(): - time.sleep(2) - try: - self.growl = notifier.GrowlNotifier( - applicationName = 'CouchPotato', - notifications = ["Updates"], - defaultNotifications = ["Updates"], - applicationIcon = '%s/static/images/couch.png' % fireEvent('app.api_url', single = True), - ) - self.growl.register() - except: - log.error('Failed register of growl: %s' % traceback.format_exc()) - thread.start_new_thread(startGrowl, ()) + self.growl = notifier.GrowlNotifier( + applicationName = 'CouchPotato', + notifications = ["Updates"], + defaultNotifications = ["Updates"], + applicationIcon = '%s/static/images/couch.png' % fireEvent('app.api_url', single = True), + ) + self.growl.register() + self.registered = True except: - pass + log.error('Failed register of growl: %s' % traceback.format_exc()) def notify(self, type = '', message = '', data = {}): if self.isDisabled(): return + self.register() + try: self.growl.notify( noteType = "Updates", diff --git a/couchpotato/core/plugins/automation/main.py b/couchpotato/core/plugins/automation/main.py index 64a4c51d..713b97ab 100644 --- a/couchpotato/core/plugins/automation/main.py +++ b/couchpotato/core/plugins/automation/main.py @@ -10,7 +10,7 @@ class Automation(Plugin): def __init__(self): - if not Env.setting('development'): + if not Env.get('dev'): addEvent('app.load', self.addMovies) def addMovies(self): diff --git a/couchpotato/core/plugins/base.py b/couchpotato/core/plugins/base.py index 6eb1d020..49b73228 100644 --- a/couchpotato/core/plugins/base.py +++ b/couchpotato/core/plugins/base.py @@ -174,7 +174,7 @@ class Plugin(object): def getCache(self, cache_key, url = None, timeout = 300): cache = Env.get('cache').get(cache_key) if cache: - if not Env.setting('development'): log.debug('Getting cache %s' % cache_key) + if not Env.get('dev'): log.debug('Getting cache %s' % cache_key) return cache if url: diff --git a/couchpotato/core/plugins/file/main.py b/couchpotato/core/plugins/file/main.py index 099246f6..dad6bdd3 100644 --- a/couchpotato/core/plugins/file/main.py +++ b/couchpotato/core/plugins/file/main.py @@ -29,7 +29,7 @@ class FileManager(Plugin): from flask.helpers import send_from_directory return send_from_directory(cache_dir, filename) - def download(self, url = '', dest = None, overwrite = False): + def download(self, url = '', dest = None, overwrite = False, urlopen_kwargs = {}): if not dest: # to Cache dest = os.path.join(Env.get('cache_dir'), '%s.%s' % (md5(url), getExt(url))) @@ -38,14 +38,15 @@ class FileManager(Plugin): return dest try: - filedata = self.urlopen(url) + filedata = self.urlopen(url, **urlopen_kwargs) except: return False self.createFile(dest, filedata, binary = True) return dest - def add(self, path = '', part = 1, type = (), available = 1, properties = {}): + def add(self, path = '', part = 1, type_tuple = (), available = 1, properties = {}): + type_id = self.getType(type_tuple).get('id') db = get_session() f = db.query(File).filter(File.path == toUnicode(path)).first() @@ -56,7 +57,7 @@ class FileManager(Plugin): f.path = toUnicode(path) f.part = part f.available = available - f.type_id = self.getType(type).id + f.type_id = type_id db.commit() @@ -64,23 +65,24 @@ class FileManager(Plugin): return file_dict - def getType(self, type): + def getType(self, type_tuple): db = get_session() - type, identifier = type + type_type, type_identifier = type_tuple - ft = db.query(FileType).filter_by(identifier = identifier).first() + ft = db.query(FileType).filter_by(identifier = type_identifier).first() if not ft: ft = FileType( - type = toUnicode(type), - identifier = identifier, - name = toUnicode(identifier[0].capitalize() + identifier[1:]) + type = toUnicode(type_type), + identifier = type_identifier, + name = toUnicode(type_identifier[0].capitalize() + type_identifier[1:]) ) - db.add(ft) db.commit() - return ft + type_dict = ft.to_dict() + db.remove() + return type_dict def getTypes(self): @@ -89,7 +91,7 @@ class FileManager(Plugin): results = db.query(FileType).all() types = [] - for type in results: - types.append(type.to_dict()) + for type_object in results: + types.append(type_object.to_dict()) return types diff --git a/couchpotato/core/plugins/library/main.py b/couchpotato/core/plugins/library/main.py index b5d38d9a..4ceca115 100644 --- a/couchpotato/core/plugins/library/main.py +++ b/couchpotato/core/plugins/library/main.py @@ -102,7 +102,7 @@ class LibraryPlugin(Plugin): continue file_path = fireEvent('file.download', url = image, single = True) - file_obj = fireEvent('file.add', path = file_path, type = ('image', type), single = True) + file_obj = fireEvent('file.add', path = file_path, type_tuple = ('image', type), single = True) try: file_obj = db.query(File).filter_by(id = file_obj.get('id')).one() library.files.append(file_obj) diff --git a/couchpotato/core/plugins/log/static/log.js b/couchpotato/core/plugins/log/static/log.js index bc8b3955..0bbb2682 100644 --- a/couchpotato/core/plugins/log/static/log.js +++ b/couchpotato/core/plugins/log/static/log.js @@ -66,6 +66,7 @@ Page.Log = new Class({ text = text.replace(/\u001b\[31m/gi, '') text = text.replace(/\u001b\[36m/gi, '') + text = text.replace(/\u001b\[33m/gi, '') text = text.replace(/\u001b\[0m\n/gi, '') text = text.replace(/\u001b\[0m/gi, '') diff --git a/couchpotato/core/plugins/manage/main.py b/couchpotato/core/plugins/manage/main.py index 9184338d..6810199f 100644 --- a/couchpotato/core/plugins/manage/main.py +++ b/couchpotato/core/plugins/manage/main.py @@ -23,7 +23,7 @@ class Manage(Plugin): addEvent('manage.update', self.updateLibrary) addApiView('manage.update', self.updateLibraryView) - if not Env.setting('development'): + if not Env.get('dev'): addEvent('app.load', self.updateLibrary) def updateLibraryView(self): diff --git a/couchpotato/core/plugins/movie/static/search.js b/couchpotato/core/plugins/movie/static/search.js index 4dedb4c7..3f29d139 100644 --- a/couchpotato/core/plugins/movie/static/search.js +++ b/couchpotato/core/plugins/movie/static/search.js @@ -183,7 +183,7 @@ Block.Search.Item = new Class({ 'click': self.showOptions.bind(self) } }).adopt( - self.thumbnail = info.images.poster.length > 0 ? new Element('img.thumbnail', { + self.thumbnail = info.images && info.images.poster.length > 0 ? new Element('img.thumbnail', { 'src': info.images.poster[0] }) : null, new Element('div.info').adopt( @@ -288,7 +288,7 @@ Block.Search.Item = new Class({ self.options.adopt( new Element('div').adopt( - self.info.images.poster.length > 0 ? new Element('img.thumbnail', { + self.info.images && self.info.images.poster.length > 0 ? new Element('img.thumbnail', { 'src': self.info.images.poster[0] }) : null, self.info.in_wanted ? new Element('span.in_wanted', { diff --git a/couchpotato/core/plugins/release/main.py b/couchpotato/core/plugins/release/main.py index 9e92d166..9297dbb7 100644 --- a/couchpotato/core/plugins/release/main.py +++ b/couchpotato/core/plugins/release/main.py @@ -79,7 +79,7 @@ class Release(Plugin): properties = {} # Check database and update/insert if necessary - return fireEvent('file.add', path = filepath, part = fireEvent('scanner.partnumber', file, single = True), type = Scanner.file_types.get(type), properties = properties, single = True) + return fireEvent('file.add', path = filepath, part = fireEvent('scanner.partnumber', file, single = True), type_tuple = Scanner.file_types.get(type), properties = properties, single = True) def delete(self): diff --git a/couchpotato/core/plugins/renamer/main.py b/couchpotato/core/plugins/renamer/main.py index 2700dc64..b67214f7 100644 --- a/couchpotato/core/plugins/renamer/main.py +++ b/couchpotato/core/plugins/renamer/main.py @@ -3,12 +3,12 @@ from couchpotato.api import addApiView from couchpotato.core.event import addEvent, fireEvent, fireEventAsync from couchpotato.core.helpers.encoding import toUnicode from couchpotato.core.helpers.request import jsonified -from couchpotato.core.helpers.variable import getExt +from couchpotato.core.helpers.variable import getExt, mergeDicts from couchpotato.core.logger import CPLog from couchpotato.core.plugins.base import Plugin -from couchpotato.core.settings.model import Library +from couchpotato.core.settings.model import Library, File from couchpotato.environment import Env -import os.path +import os import re import shutil import traceback @@ -123,6 +123,9 @@ class Renamer(Plugin): # Move nfo depending on settings if file_type is 'nfo' and not self.conf('rename_nfo'): log.debug('Skipping, renaming of %s disabled' % file_type) + if self.conf('clean_up'): + for current_file in group['files'][file_type]: + remove_files.append(current_file) continue # Subtitle extra @@ -190,19 +193,30 @@ class Renamer(Plugin): # Check for extra subtitle files if file_type is 'subtitle': - - def test(s): - return current_file[:-len(replacements['ext'])] in s - - for subtitle_extra in set(filter(test, group['files']['subtitle_extra'])): - replacements['ext'] = getExt(subtitle_extra) - - final_folder_name = self.doReplace(folder_name, replacements) - final_file_name = self.doReplace(file_name, replacements) - rename_files[subtitle_extra] = os.path.join(destination, final_folder_name, final_file_name) + rename_extras = self.getRenameExtras( + extra_type = 'subtitle_extra', + replacements = replacements, + folder_name = folder_name, + file_name = file_name, + destination = destination, + group = group, + current_file = current_file + ) + rename_files = mergeDicts(rename_files, rename_extras) # Filename without cd etc if file_type is 'movie': + rename_extras = self.getRenameExtras( + extra_type = 'movie_extra', + replacements = replacements, + folder_name = folder_name, + file_name = file_name, + destination = destination, + group = group, + current_file = current_file + ) + rename_files = mergeDicts(rename_files, rename_extras) + group['destination_dir'] = os.path.join(destination, final_folder_name) if multiple: @@ -290,11 +304,15 @@ class Renamer(Plugin): # Remove files for src in remove_files: + + if isinstance(src, File): + src = src.path + log.info('(fake) Removing "%s"' % src) # Remove matching releases for release in remove_releases: - log.info('(fake) Removing release %s' % release) + log.info('(fake) Removing release %s' % release.identifier) # Search for trailers etc fireEventAsync('renamer.after', group) @@ -309,6 +327,22 @@ class Renamer(Plugin): self.renaming_started = False + def getRenameExtras(self, extra_type = '', replacements = {}, folder_name = '', file_name = '', destination = '', group = {}, current_file = ''): + + rename_files = {} + + def test(s): + return current_file[:-len(replacements['ext'])] in s + + for extra in set(filter(test, group['files'][extra_type])): + replacements['ext'] = getExt(extra) + + final_folder_name = self.doReplace(folder_name, replacements) + final_file_name = self.doReplace(file_name, replacements) + rename_files[extra] = os.path.join(destination, final_folder_name, final_file_name) + + return rename_files + def moveFile(self, old, dest): try: shutil.move(old, dest) diff --git a/couchpotato/core/plugins/scanner/main.py b/couchpotato/core/plugins/scanner/main.py index 5a57762a..a389bb9a 100644 --- a/couchpotato/core/plugins/scanner/main.py +++ b/couchpotato/core/plugins/scanner/main.py @@ -29,7 +29,8 @@ class Scanner(Plugin): ignored_in_path = ['_unpack', '_failed_', '_unknown_', '_exists_', '.appledouble', '.appledb', '.appledesktop', os.path.sep + '._', '.ds_store', 'cp.cpnfo'] #unpacking, smb-crap, hidden files ignore_names = ['extract', 'extracting', 'extracted', 'movie', 'movies', 'film', 'films', 'download', 'downloads', 'video_ts', 'audio_ts', 'bdmv', 'certificate'] extensions = { - 'movie': ['mkv', 'wmv', 'avi', 'mpg', 'mpeg', 'mp4', 'm2ts', 'iso', 'img'], + 'movie': ['mkv', 'wmv', 'avi', 'mpg', 'mpeg', 'mp4', 'm2ts', 'iso', 'img', 'mdf'], + 'movie_extra': ['mds'], 'dvd': ['vts_*', 'vob'], 'nfo': ['nfo', 'txt', 'tag'], 'subtitle': ['sub', 'srt', 'ssa', 'ass'], @@ -42,6 +43,7 @@ class Scanner(Plugin): 'trailer': ('video', 'trailer'), 'nfo': ('nfo', 'nfo'), 'movie': ('video', 'movie'), + 'movie': ('movie', 'movie_extra'), 'backdrop': ('image', 'backdrop'), 'leftover': ('leftover', 'leftover'), } @@ -267,6 +269,7 @@ class Scanner(Plugin): # Group extra (and easy) files first # images = self.getImages(group['unsorted_files']) group['files'] = { + 'movie_extra': self.getMovieExtras(group['unsorted_files']), 'subtitle': self.getSubtitles(group['unsorted_files']), 'subtitle_extra': self.getSubtitlesExtras(group['unsorted_files']), 'nfo': self.getNfo(group['unsorted_files']), @@ -281,6 +284,10 @@ class Scanner(Plugin): else: group['files']['movie'] = self.getMediaFiles(group['unsorted_files']) + if len(group['files']['movie']) == 0: + log.error('Couldn\t find any movie files for %s' % identifier) + continue + log.debug('Getting metadata for %s' % identifier) group['meta_data'] = self.getMetaData(group) @@ -470,6 +477,9 @@ class Scanner(Plugin): return set(filter(test, files)) + def getMovieExtras(self, files): + return set(filter(lambda s: getExt(s.lower()) in self.extensions['movie_extra'], files)) + def getDVDFiles(self, files): def test(s): return self.isDVDFile(s) diff --git a/couchpotato/core/plugins/score/main.py b/couchpotato/core/plugins/score/main.py index 8b3d267f..ee7c9806 100644 --- a/couchpotato/core/plugins/score/main.py +++ b/couchpotato/core/plugins/score/main.py @@ -23,4 +23,12 @@ class Score(Plugin): score += sizeScore(nzb['size']) + # Torrents only + if nzb.get('seeds'): + try: + score += nzb.get('seeds') / 5 + score += nzb.get('leechers') / 10 + except: + pass + return score diff --git a/couchpotato/core/plugins/searcher/__init__.py b/couchpotato/core/plugins/searcher/__init__.py index 19a1232d..14a43768 100644 --- a/couchpotato/core/plugins/searcher/__init__.py +++ b/couchpotato/core/plugins/searcher/__init__.py @@ -28,7 +28,7 @@ config = [{ { 'name': 'ignored_words', 'label': 'Ignored words', - 'default': 'german, dutch, french, danish, swedish, dubbed, swesub, korsub', + 'default': 'german, dutch, french, danish, swedish, spanish, italian, korean, dubbed, swesub, korsub', }, ], }, { diff --git a/couchpotato/core/plugins/searcher/main.py b/couchpotato/core/plugins/searcher/main.py index 34a9a7c0..4b4ee339 100644 --- a/couchpotato/core/plugins/searcher/main.py +++ b/couchpotato/core/plugins/searcher/main.py @@ -161,7 +161,7 @@ class Searcher(Plugin): single_category = kwargs.get('single_category', False) retention = Env.setting('retention', section = 'nzb') - if retention < nzb.get('age', 0): + if nzb.get('seeds') is None and retention < nzb.get('age', 0): log.info('Wrong: Outside retention, age is %s, needs %s or lower: %s' % (nzb['age'], retention, nzb['name'])) return False diff --git a/couchpotato/core/plugins/trailer/__init__.py b/couchpotato/core/plugins/trailer/__init__.py new file mode 100644 index 00000000..49b0cb9e --- /dev/null +++ b/couchpotato/core/plugins/trailer/__init__.py @@ -0,0 +1,34 @@ +from .main import Trailer + +def start(): + return Trailer() + +config = [{ + 'name': 'trailer', + 'groups': [ + { + 'tab': 'metadata', + 'name': 'trailer', + 'options': [ + { + 'name': 'enabled', + 'label': 'Search and download trailers', + 'default': False, + 'type': 'enabler', + }, + { + 'name': 'quality', + 'default': '720p', + 'type': 'dropdown', + 'values': [('1080P', '1080p'), ('720P', '720p'), ('480P', '480p')], + }, + { + 'name': 'automatic', + 'default': False, + 'type': 'bool', + 'description': 'Automaticly search & download for movies in library', + }, + ], + }, + ], +}] diff --git a/couchpotato/core/plugins/trailer/main.py b/couchpotato/core/plugins/trailer/main.py new file mode 100644 index 00000000..8f8e4ab2 --- /dev/null +++ b/couchpotato/core/plugins/trailer/main.py @@ -0,0 +1,32 @@ +from couchpotato.core.event import addEvent, fireEvent +from couchpotato.core.helpers.variable import getExt +from couchpotato.core.logger import CPLog +from couchpotato.core.plugins.base import Plugin +import os + +log = CPLog(__name__) + + +class Trailer(Plugin): + + def __init__(self): + addEvent('renamer.after', self.searchSingle) + + def searchSingle(self, group): + + if self.isDisabled() or len(group['files']['trailer']) > 0: return + + trailers = fireEvent('trailer.search', group = group, merge = True) + + for trailer in trailers.get(self.conf('quality'), []): + destination = '%s-trailer.%s' % (self.getRootName(group), getExt(trailer)) + if not os.path.isfile(destination): + fireEvent('file.download', url = trailer, dest = destination, urlopen_kwargs = {'headers': {'User-Agent': 'Quicktime'}}, single = True) + else: + log.debug('Trailer already exists: %s' % destination) + + # Download first and break + break + + def getRootName(self, data = {}): + return os.path.join(data['destination_dir'], data['filename']) diff --git a/couchpotato/core/providers/base.py b/couchpotato/core/providers/base.py index 1a2e9425..148b2e7c 100644 --- a/couchpotato/core/providers/base.py +++ b/couchpotato/core/providers/base.py @@ -48,6 +48,20 @@ class YarrProvider(Provider): def __init__(self): addEvent('provider.belongs_to', self.belongsTo) + addEvent('%s.search' % self.type, self.search) + addEvent('yarr.search', self.search) + + addEvent('nzb.feed', self.feed) + + def download(self, url = '', nzb_id = ''): + return self.urlopen(url) + + def feed(self): + return [] + + def search(self, movie, quality): + return [] + def belongsTo(self, url, host = None): try: hostname = urlparse(url).hostname diff --git a/couchpotato/core/providers/metadata/base.py b/couchpotato/core/providers/metadata/base.py index c0540262..5d99ea9b 100644 --- a/couchpotato/core/providers/metadata/base.py +++ b/couchpotato/core/providers/metadata/base.py @@ -3,7 +3,7 @@ from couchpotato.core.helpers.variable import mergeDicts from couchpotato.core.logger import CPLog from couchpotato.core.plugins.base import Plugin import json -import os.path +import os import shutil import traceback diff --git a/couchpotato/core/providers/movie/imdbapi/main.py b/couchpotato/core/providers/movie/imdbapi/main.py index c6f4555f..f238e7c4 100644 --- a/couchpotato/core/providers/movie/imdbapi/main.py +++ b/couchpotato/core/providers/movie/imdbapi/main.py @@ -30,20 +30,24 @@ class IMDBAPI(MovieProvider): cache_key = 'imdbapi.cache.%s' % q cached = self.getCache(cache_key, self.urls['search'] % urlencode({'t': name_year.get('name'), 'y': name_year.get('year')})) - result = self.parseMovie(cached) - log.info('Found: %s' % result['titles'][0] + ' (' + str(result['year']) + ')') + if cached: + result = self.parseMovie(cached) + log.info('Found: %s' % result['titles'][0] + ' (' + str(result['year']) + ')') + return [result] - return [result] + return [] def getInfo(self, identifier = None): cache_key = 'imdbapi.cache.%s' % identifier cached = self.getCache(cache_key, self.urls['info'] % identifier) - result = self.parseMovie(cached) - log.info('Found: %s' % result['titles'][0] + ' (' + str(result['year']) + ')') + if cached: + result = self.parseMovie(cached) + log.info('Found: %s' % result['titles'][0] + ' (' + str(result['year']) + ')') + return result - return result + return {} def parseMovie(self, movie): diff --git a/couchpotato/core/providers/nzb/base.py b/couchpotato/core/providers/nzb/base.py index f8c3834e..06dd2c89 100644 --- a/couchpotato/core/providers/nzb/base.py +++ b/couchpotato/core/providers/nzb/base.py @@ -6,22 +6,5 @@ import time class NZBProvider(YarrProvider): type = 'nzb' - def __init__(self): - super(NZBProvider, self).__init__() - - addEvent('nzb.search', self.search) - addEvent('yarr.search', self.search) - - addEvent('nzb.feed', self.feed) - - def download(self, url = '', nzb_id = ''): - return self.urlopen(url) - - def feed(self): - return [] - - def search(self, movie, quality): - return [] - def calculateAge(self, unix): return int(time.time() - unix) / 24 / 60 / 60 diff --git a/couchpotato/core/providers/nzb/mysterbin/main.py b/couchpotato/core/providers/nzb/mysterbin/main.py index af6c1eee..d92595f6 100644 --- a/couchpotato/core/providers/nzb/mysterbin/main.py +++ b/couchpotato/core/providers/nzb/mysterbin/main.py @@ -1,4 +1,4 @@ -from BeautifulSoup import BeautifulSoup, SoupStrainer +from BeautifulSoup import BeautifulSoup from couchpotato.core.event import fireEvent from couchpotato.core.helpers.encoding import toUnicode from couchpotato.core.helpers.variable import tryInt diff --git a/couchpotato/core/providers/nzb/nzbmatrix/main.py b/couchpotato/core/providers/nzb/nzbmatrix/main.py index e069b922..43b95873 100644 --- a/couchpotato/core/providers/nzb/nzbmatrix/main.py +++ b/couchpotato/core/providers/nzb/nzbmatrix/main.py @@ -20,6 +20,7 @@ class NZBMatrix(NZBProvider, RSS): } cat_ids = [ + ([50], ['bd50']), ([42, 53], ['720p', '1080p']), ([2], ['cam', 'ts', 'dvdrip', 'tc', 'r5', 'scr']), ([54], ['brrip']), diff --git a/couchpotato/core/providers/torrent/kickasstorrents/__init__.py b/couchpotato/core/providers/torrent/kickasstorrents/__init__.py index 7daae95f..e88ac81c 100644 --- a/couchpotato/core/providers/torrent/kickasstorrents/__init__.py +++ b/couchpotato/core/providers/torrent/kickasstorrents/__init__.py @@ -3,4 +3,19 @@ from .main import KickAssTorrents def start(): return KickAssTorrents() -config = [] +config = [{ + 'name': 'kickasstorrents', + 'groups': [ + { + 'tab': 'providers', + 'name': 'KickAssTorrents', + 'options': [ + { + 'name': 'enabled', + 'type': 'enabler', + 'default': False, + }, + ], + }, + ], +}] diff --git a/couchpotato/core/providers/torrent/kickasstorrents/main.py b/couchpotato/core/providers/torrent/kickasstorrents/main.py index 0c602fee..aff0508f 100644 --- a/couchpotato/core/providers/torrent/kickasstorrents/main.py +++ b/couchpotato/core/providers/torrent/kickasstorrents/main.py @@ -1,5 +1,12 @@ +from BeautifulSoup import BeautifulSoup +from couchpotato.core.event import fireEvent +from couchpotato.core.helpers.variable import tryInt from couchpotato.core.logger import CPLog from couchpotato.core.providers.torrent.base import TorrentProvider +import StringIO +import gzip +import re +import traceback log = CPLog(__name__) @@ -7,8 +14,124 @@ log = CPLog(__name__) class KickAssTorrents(TorrentProvider): urls = { - 'download': 'http://torrents.thepiratebay.org/%s/%s.torrent', + 'test': 'http://www.kat.ph/', 'detail': 'http://www.kat.ph/%s-t%s.html', 'search': 'http://www.kat.ph/%s-i%s/', } + cat_ids = [ + (['cam'], ['cam']), + (['telesync'], ['ts', 'tc']), + (['screener', 'tvrip'], ['screener']), + (['x264', '720p', '1080p', 'blu-ray', 'hdrip'], ['bd50', '1080p', '720p', 'brrip']), + (['dvdrip'], ['dvdrip']), + (['dvd'], ['dvdr']), + ] + + http_time_between_calls = 1 #seconds + + def search(self, movie, quality): + + results = [] + if self.isDisabled() or not self.isAvailable(self.urls['test']): + return results + + cache_key = 'kickasstorrents.%s' % movie['library']['identifier'] + data = self.getCache(cache_key, self.urls['search'] % (movie['library']['titles'][0]['title'], movie['library']['identifier'].replace('tt', ''))) + if data: + + cat_ids = self.getCatId(quality['identifier']) + table_order = ['name', 'size', None, 'age', 'seeds', 'leechers'] + + try: + html = BeautifulSoup(data) + resultdiv = html.find('div', attrs = {'class':'tabs'}) + for result in resultdiv.findAll('div', recursive = False): + if result.get('id').lower() not in cat_ids: + continue + + try: + + try: + for temp in result.findAll('tr'): + if temp['class'] is 'firstr' or not temp.get('id'): + continue + + new = { + 'type': 'torrent', + 'check_nzb': False, + 'description': '', + 'provider': self.getName(), + 'download': self.download, + 'score': 0, + } + + nr = 0 + for td in temp.findAll('td'): + column_name = table_order[nr] + if column_name: + + if column_name is 'name': + link = td.find('div', {'class': 'torrentname'}).findAll('a')[1] + new['id'] = temp.get('id')[-8:] + new['name'] = link.text + new['url'] = td.findAll('a', 'idownload')[1]['href'] + new['score'] = 20 if td.find('a', 'iverif') else 0 + elif column_name is 'size': + new['size'] = self.parseSize(td.text) + elif column_name is 'age': + new['age'] = self.ageToDays(td.text) + elif column_name is 'seeds': + new['seeds'] = tryInt(td.text) + elif column_name is 'leechers': + new['leechers'] = tryInt(td.text) + + nr += 1 + + new['score'] += fireEvent('score.calculate', new, movie, single = True) + is_correct_movie = fireEvent('searcher.correct_movie', + nzb = new, movie = movie, quality = quality, + imdb_results = True, single_category = False, single = True) + if is_correct_movie: + results.append(new) + self.found(new) + except: + log.error('Failed parsing KickAssTorrents: %s' % traceback.format_exc()) + except: + pass + + return results + except AttributeError: + log.debug('No search results found.') + + return results + + def ageToDays(self, age_str): + age = 0 + age_str = age_str.replace(' ', ' ') + + regex = '(\d*.?\d+).(sec|hour|day|week|month|year)+' + matches = re.findall(regex, age_str) + for match in matches: + nr, size = match + mult = 1 + if size == 'week': + mult = 7 + elif size == 'month': + mult = 30.5 + elif size == 'year': + mult = 365 + + age += tryInt(nr) * mult + + return tryInt(age) + + def download(self, url = '', nzb_id = ''): + compressed_data = super(KickAssTorrents, self).download(url = url, nzb_id = nzb_id) + + compressedstream = StringIO.StringIO(compressed_data) + gzipper = gzip.GzipFile(fileobj = compressedstream) + data = gzipper.read() + + return data + diff --git a/couchpotato/core/providers/trailer/base.py b/couchpotato/core/providers/trailer/base.py index 17d2e5cb..338ca9b3 100644 --- a/couchpotato/core/providers/trailer/base.py +++ b/couchpotato/core/providers/trailer/base.py @@ -1,5 +1,13 @@ +from couchpotato.core.event import addEvent +from couchpotato.core.logger import CPLog from couchpotato.core.providers.base import Provider +log = CPLog(__name__) + class TrailerProvider(Provider): + type = 'trailer' + + def __init__(self): + addEvent('trailer.search', self.search) diff --git a/couchpotato/core/providers/trailer/hdtrailers/main.py b/couchpotato/core/providers/trailer/hdtrailers/main.py index 5fe476dd..e6628760 100644 --- a/couchpotato/core/providers/trailer/hdtrailers/main.py +++ b/couchpotato/core/providers/trailer/hdtrailers/main.py @@ -1,4 +1,5 @@ from BeautifulSoup import SoupStrainer, BeautifulSoup +from couchpotato.core.helpers.variable import mergeDicts from couchpotato.core.logger import CPLog from couchpotato.core.providers.trailer.base import TrailerProvider from string import letters, digits @@ -16,47 +17,40 @@ class HDTrailers(TrailerProvider): } providers = ['apple.ico', 'yahoo.ico', 'moviefone.ico', 'myspace.ico', 'favicon.ico'] - def find(self, movie): + def search(self, group): - movie_name = movie['library']['titles'][0]['title'] + movie_name = group['library']['titles'][0]['title'] - url = self.url['api'] % self.movieUrlName(movie_name) - try: - data = self.urlopen(url) - except: - return {} + url = self.urls['api'] % self.movieUrlName(movie_name) + data = self.getCache('hdtrailers.%s' % group['library']['identifier'], url) + + result_data = {} - p480 = [] - p720 = [] - p1080 = [] did_alternative = False for provider in self.providers: results = self.findByProvider(data, provider) # Find alternative if results.get('404') and not did_alternative: - results = self.findViaAlternative(movie_name) + results = self.findViaAlternative(group) did_alternative = True - p480.extend(results.get('480p')) - p720.extend(results.get('720p')) - p1080.extend(results.get('1080p')) + result_data = mergeDicts(result_data, results) - return {'480p':p480, '720p':p720, '1080p':p1080} + return result_data - def findViaAlternative(self, movie): + def findViaAlternative(self, group): results = {'480p':[], '720p':[], '1080p':[]} - url = "%s?%s" % (self.url['backup'], urlencode({'s':movie})) - try: - data = self.urlopen(url) - except: - return results + movie_name = group['library']['titles'][0]['title'] + + url = "%s?%s" % (self.url['backup'], urlencode({'s':movie_name})) + data = self.getCache('hdtrailers.alt.%s' % group['library']['identifier'], url) try: tables = SoupStrainer('div') html = BeautifulSoup(data, parseOnlyThese = tables) - result_table = html.findAll('h2', text = re.compile(movie)) + result_table = html.findAll('h2', text = re.compile(movie_name)) for h2 in result_table: if 'trailer' in h2.lower(): @@ -88,6 +82,8 @@ class HDTrailers(TrailerProvider): break if 'trailer' in trtext and not 'clip' in trtext and provider in trtext: nr = 0 + if 'trailer' not in tr.find('span', 'standardTrailerName').text.lower(): + continue resolutions = tr.findAll('td', attrs = {'class':'bottomTableResolution'}) for res in resolutions: results[str(res.a.contents[0])].insert(0, res.a['href']) diff --git a/couchpotato/environment.py b/couchpotato/environment.py index 0b86657d..a4d50747 100644 --- a/couchpotato/environment.py +++ b/couchpotato/environment.py @@ -8,6 +8,7 @@ class Env(object): _encoding = '' _uses_git = False _debug = False + _dev = False _settings = Settings() _loader = Loader() _cache = None diff --git a/couchpotato/runner.py b/couchpotato/runner.py index 88313f2a..6b8196ea 100644 --- a/couchpotato/runner.py +++ b/couchpotato/runner.py @@ -11,7 +11,7 @@ import logging import os.path import sys import time -import traceback +import warnings def getOptions(base_path, args): @@ -46,25 +46,7 @@ def cleanup(): time.sleep(1) -def runCouchPotato(options, base_path, args, desktop = None): - - # Load settings - from couchpotato.environment import Env - settings = Env.get('settings') - settings.setFile(options.config_file) - - # Create data dir if needed - data_dir = os.path.expanduser(Env.setting('data_dir')) - if data_dir == '': - data_dir = getDataDir() - - if not os.path.isdir(data_dir): - os.makedirs(data_dir) - - # Create logging dir - log_dir = os.path.join(data_dir, 'logs'); - if not os.path.isdir(log_dir): - os.mkdir(log_dir) +def runCouchPotato(options, base_path, args, data_dir = None, log_dir = None, Env = None, desktop = None): try: locale.setlocale(locale.LC_ALL, "") @@ -95,15 +77,21 @@ def runCouchPotato(options, base_path, args, desktop = None): debug = options.debug or Env.setting('debug', default = False, type = 'bool') Env.set('debug', debug) - if not Env.setting('development'): + # Development + development = Env.setting('development', default = False, type = 'bool') + Env.set('dev', development) + if not development: atexit.register(cleanup) + # Use reloader + reloader = debug is True and development and not Env.get('desktop') and not options.daemon + # Disable server access log logging.getLogger('werkzeug').setLevel(logging.WARNING) # Only run once when debugging fire_load = False - if os.environ.get('WERKZEUG_RUN_MAIN') or not debug or Env.get('desktop') or options.daemon: + if os.environ.get('WERKZEUG_RUN_MAIN') or not reloader: # Logger logger = logging.getLogger() @@ -128,6 +116,10 @@ def runCouchPotato(options, base_path, args, desktop = None): log = CPLog(__name__) log.debug('Started with options %s' % options) + def customwarn(message, category, filename, lineno, file = None, line = None): + log.warning('%s %s %s line:%s' % (category, message, filename, lineno)) + warnings.showwarning = customwarn + # Load configs & plugins loader = Env.get('loader') @@ -168,7 +160,6 @@ def runCouchPotato(options, base_path, args, desktop = None): from couchpotato import app api_key = Env.setting('api_key') url_base = '/' + Env.setting('url_base').lstrip('/') if Env.setting('url_base') else '' - reloader = debug is True and Env.setting('development') and not Env.get('desktop') and not options.daemon # Basic config app.secret_key = api_key @@ -194,10 +185,4 @@ def runCouchPotato(options, base_path, args, desktop = None): if fire_load: fireEventAsync('app.load') # Go go go! - try: - app.run(**config) - except (KeyboardInterrupt, SystemExit): - raise - except: - log.error('Failed starting: %s' % traceback.format_exc()) - raise + app.run(**config) diff --git a/init/ubuntu b/init/ubuntu index ea6ad09d..8abc9e79 100644 --- a/init/ubuntu +++ b/init/ubuntu @@ -14,13 +14,17 @@ ############### EDIT ME ################## # path to app -APP_PATH=/usr/local/sbin/couchpotato +APP_PATH=/usr/local/sbin/CouchPotatoServer/ + +# user +RUN_AS=YOUR_USERNAME_HERE # path to python bin DAEMON=/usr/bin/python -# startup args -DAEMON_OPTS=" CouchPotato.py" +# Path to store PID file +PID_FILE=/var/run/couchpotato/server.pid +PID_PATH=$(dirname $PID_FILE) # script name NAME=couchpotato @@ -28,10 +32,8 @@ NAME=couchpotato # app name DESC=CouchPotato -# user -RUN_AS=root - -PID_FILE=/var/run/couchpotato.pid +# startup args +DAEMON_OPTS=" CouchPotato.py --daemon --pid_file=${PID_FILE}" ############### END EDIT ME ################## @@ -42,18 +44,19 @@ set -e case "$1" in start) echo "Starting $DESC" - start-stop-daemon -d $APP_PATH -c $RUN_AS --start --background --pidfile $PID_FILE --make-pidfile --exec $DAEMON -- $DAEMON_OPTS + rm -rf $PID_PATH || return 1 + install -d --mode=0755 -o $RUN_AS -g $RUN_AS $PID_PATH || return 1 + start-stop-daemon -d $APP_PATH -c $RUN_AS --start --background --pidfile $PID_FILE --exec $DAEMON -- $DAEMON_OPTS ;; stop) echo "Stopping $DESC" - start-stop-daemon --stop --pidfile $PID_FILE + start-stop-daemon --stop --pidfile $PID_FILE --retry 15 ;; restart|force-reload) echo "Restarting $DESC" - start-stop-daemon --stop --pidfile $PID_FILE - sleep 15 - start-stop-daemon -d $APP_PATH -c $RUN_AS --start --background --pidfile $PID_FILE --make-pidfile --exec $DAEMON -- $DAEMON_OPTS + start-stop-daemon --stop --pidfile $PID_FILE --retry 15 + start-stop-daemon -d $APP_PATH -c $RUN_AS --start --background --pidfile $PID_FILE --exec $DAEMON -- $DAEMON_OPTS ;; *) N=/etc/init.d/$NAME diff --git a/libs/argparse.py b/libs/argparse.py new file mode 100644 index 00000000..32d948c0 --- /dev/null +++ b/libs/argparse.py @@ -0,0 +1,2362 @@ +# Author: Steven J. Bethard . + +"""Command-line parsing library + +This module is an optparse-inspired command-line parsing library that: + + - handles both optional and positional arguments + - produces highly informative usage messages + - supports parsers that dispatch to sub-parsers + +The following is a simple usage example that sums integers from the +command-line and writes the result to a file:: + + parser = argparse.ArgumentParser( + description='sum the integers at the command line') + parser.add_argument( + 'integers', metavar='int', nargs='+', type=int, + help='an integer to be summed') + parser.add_argument( + '--log', default=sys.stdout, type=argparse.FileType('w'), + help='the file where the sum should be written') + args = parser.parse_args() + args.log.write('%s' % sum(args.integers)) + args.log.close() + +The module contains the following public classes: + + - ArgumentParser -- The main entry point for command-line parsing. As the + example above shows, the add_argument() method is used to populate + the parser with actions for optional and positional arguments. Then + the parse_args() method is invoked to convert the args at the + command-line into an object with attributes. + + - ArgumentError -- The exception raised by ArgumentParser objects when + there are errors with the parser's actions. Errors raised while + parsing the command-line are caught by ArgumentParser and emitted + as command-line messages. + + - FileType -- A factory for defining types of files to be created. As the + example above shows, instances of FileType are typically passed as + the type= argument of add_argument() calls. + + - Action -- The base class for parser actions. Typically actions are + selected by passing strings like 'store_true' or 'append_const' to + the action= argument of add_argument(). However, for greater + customization of ArgumentParser actions, subclasses of Action may + be defined and passed as the action= argument. + + - HelpFormatter, RawDescriptionHelpFormatter, RawTextHelpFormatter, + ArgumentDefaultsHelpFormatter -- Formatter classes which + may be passed as the formatter_class= argument to the + ArgumentParser constructor. HelpFormatter is the default, + RawDescriptionHelpFormatter and RawTextHelpFormatter tell the parser + not to change the formatting for help text, and + ArgumentDefaultsHelpFormatter adds information about argument defaults + to the help. + +All other classes in this module are considered implementation details. +(Also note that HelpFormatter and RawDescriptionHelpFormatter are only +considered public as object names -- the API of the formatter objects is +still considered an implementation detail.) +""" + +__version__ = '1.2.1' +__all__ = [ + 'ArgumentParser', + 'ArgumentError', + 'ArgumentTypeError', + 'FileType', + 'HelpFormatter', + 'ArgumentDefaultsHelpFormatter', + 'RawDescriptionHelpFormatter', + 'RawTextHelpFormatter', + 'Namespace', + 'Action', + 'ONE_OR_MORE', + 'OPTIONAL', + 'PARSER', + 'REMAINDER', + 'SUPPRESS', + 'ZERO_OR_MORE', +] + + +import copy as _copy +import os as _os +import re as _re +import sys as _sys +import textwrap as _textwrap + +from gettext import gettext as _ + +try: + set +except NameError: + # for python < 2.4 compatibility (sets module is there since 2.3): + from sets import Set as set + +try: + basestring +except NameError: + basestring = str + +try: + sorted +except NameError: + # for python < 2.4 compatibility: + def sorted(iterable, reverse=False): + result = list(iterable) + result.sort() + if reverse: + result.reverse() + return result + + +def _callable(obj): + return hasattr(obj, '__call__') or hasattr(obj, '__bases__') + + +SUPPRESS = '==SUPPRESS==' + +OPTIONAL = '?' +ZERO_OR_MORE = '*' +ONE_OR_MORE = '+' +PARSER = 'A...' +REMAINDER = '...' +_UNRECOGNIZED_ARGS_ATTR = '_unrecognized_args' + +# ============================= +# Utility functions and classes +# ============================= + +class _AttributeHolder(object): + """Abstract base class that provides __repr__. + + The __repr__ method returns a string in the format:: + ClassName(attr=name, attr=name, ...) + The attributes are determined either by a class-level attribute, + '_kwarg_names', or by inspecting the instance __dict__. + """ + + def __repr__(self): + type_name = type(self).__name__ + arg_strings = [] + for arg in self._get_args(): + arg_strings.append(repr(arg)) + for name, value in self._get_kwargs(): + arg_strings.append('%s=%r' % (name, value)) + return '%s(%s)' % (type_name, ', '.join(arg_strings)) + + def _get_kwargs(self): + return sorted(self.__dict__.items()) + + def _get_args(self): + return [] + + +def _ensure_value(namespace, name, value): + if getattr(namespace, name, None) is None: + setattr(namespace, name, value) + return getattr(namespace, name) + + +# =============== +# Formatting Help +# =============== + +class HelpFormatter(object): + """Formatter for generating usage messages and argument help strings. + + Only the name of this class is considered a public API. All the methods + provided by the class are considered an implementation detail. + """ + + def __init__(self, + prog, + indent_increment=2, + max_help_position=24, + width=None): + + # default setting for width + if width is None: + try: + width = int(_os.environ['COLUMNS']) + except (KeyError, ValueError): + width = 80 + width -= 2 + + self._prog = prog + self._indent_increment = indent_increment + self._max_help_position = max_help_position + self._width = width + + self._current_indent = 0 + self._level = 0 + self._action_max_length = 0 + + self._root_section = self._Section(self, None) + self._current_section = self._root_section + + self._whitespace_matcher = _re.compile(r'\s+') + self._long_break_matcher = _re.compile(r'\n\n\n+') + + # =============================== + # Section and indentation methods + # =============================== + def _indent(self): + self._current_indent += self._indent_increment + self._level += 1 + + def _dedent(self): + self._current_indent -= self._indent_increment + assert self._current_indent >= 0, 'Indent decreased below 0.' + self._level -= 1 + + class _Section(object): + + def __init__(self, formatter, parent, heading=None): + self.formatter = formatter + self.parent = parent + self.heading = heading + self.items = [] + + def format_help(self): + # format the indented section + if self.parent is not None: + self.formatter._indent() + join = self.formatter._join_parts + for func, args in self.items: + func(*args) + item_help = join([func(*args) for func, args in self.items]) + if self.parent is not None: + self.formatter._dedent() + + # return nothing if the section was empty + if not item_help: + return '' + + # add the heading if the section was non-empty + if self.heading is not SUPPRESS and self.heading is not None: + current_indent = self.formatter._current_indent + heading = '%*s%s:\n' % (current_indent, '', self.heading) + else: + heading = '' + + # join the section-initial newline, the heading and the help + return join(['\n', heading, item_help, '\n']) + + def _add_item(self, func, args): + self._current_section.items.append((func, args)) + + # ======================== + # Message building methods + # ======================== + def start_section(self, heading): + self._indent() + section = self._Section(self, self._current_section, heading) + self._add_item(section.format_help, []) + self._current_section = section + + def end_section(self): + self._current_section = self._current_section.parent + self._dedent() + + def add_text(self, text): + if text is not SUPPRESS and text is not None: + self._add_item(self._format_text, [text]) + + def add_usage(self, usage, actions, groups, prefix=None): + if usage is not SUPPRESS: + args = usage, actions, groups, prefix + self._add_item(self._format_usage, args) + + def add_argument(self, action): + if action.help is not SUPPRESS: + + # find all invocations + get_invocation = self._format_action_invocation + invocations = [get_invocation(action)] + for subaction in self._iter_indented_subactions(action): + invocations.append(get_invocation(subaction)) + + # update the maximum item length + invocation_length = max([len(s) for s in invocations]) + action_length = invocation_length + self._current_indent + self._action_max_length = max(self._action_max_length, + action_length) + + # add the item to the list + self._add_item(self._format_action, [action]) + + def add_arguments(self, actions): + for action in actions: + self.add_argument(action) + + # ======================= + # Help-formatting methods + # ======================= + def format_help(self): + help = self._root_section.format_help() + if help: + help = self._long_break_matcher.sub('\n\n', help) + help = help.strip('\n') + '\n' + return help + + def _join_parts(self, part_strings): + return ''.join([part + for part in part_strings + if part and part is not SUPPRESS]) + + def _format_usage(self, usage, actions, groups, prefix): + if prefix is None: + prefix = _('usage: ') + + # if usage is specified, use that + if usage is not None: + usage = usage % dict(prog=self._prog) + + # if no optionals or positionals are available, usage is just prog + elif usage is None and not actions: + usage = '%(prog)s' % dict(prog=self._prog) + + # if optionals and positionals are available, calculate usage + elif usage is None: + prog = '%(prog)s' % dict(prog=self._prog) + + # split optionals from positionals + optionals = [] + positionals = [] + for action in actions: + if action.option_strings: + optionals.append(action) + else: + positionals.append(action) + + # build full usage string + format = self._format_actions_usage + action_usage = format(optionals + positionals, groups) + usage = ' '.join([s for s in [prog, action_usage] if s]) + + # wrap the usage parts if it's too long + text_width = self._width - self._current_indent + if len(prefix) + len(usage) > text_width: + + # break usage into wrappable parts + part_regexp = r'\(.*?\)+|\[.*?\]+|\S+' + opt_usage = format(optionals, groups) + pos_usage = format(positionals, groups) + opt_parts = _re.findall(part_regexp, opt_usage) + pos_parts = _re.findall(part_regexp, pos_usage) + assert ' '.join(opt_parts) == opt_usage + assert ' '.join(pos_parts) == pos_usage + + # helper for wrapping lines + def get_lines(parts, indent, prefix=None): + lines = [] + line = [] + if prefix is not None: + line_len = len(prefix) - 1 + else: + line_len = len(indent) - 1 + for part in parts: + if line_len + 1 + len(part) > text_width: + lines.append(indent + ' '.join(line)) + line = [] + line_len = len(indent) - 1 + line.append(part) + line_len += len(part) + 1 + if line: + lines.append(indent + ' '.join(line)) + if prefix is not None: + lines[0] = lines[0][len(indent):] + return lines + + # if prog is short, follow it with optionals or positionals + if len(prefix) + len(prog) <= 0.75 * text_width: + indent = ' ' * (len(prefix) + len(prog) + 1) + if opt_parts: + lines = get_lines([prog] + opt_parts, indent, prefix) + lines.extend(get_lines(pos_parts, indent)) + elif pos_parts: + lines = get_lines([prog] + pos_parts, indent, prefix) + else: + lines = [prog] + + # if prog is long, put it on its own line + else: + indent = ' ' * len(prefix) + parts = opt_parts + pos_parts + lines = get_lines(parts, indent) + if len(lines) > 1: + lines = [] + lines.extend(get_lines(opt_parts, indent)) + lines.extend(get_lines(pos_parts, indent)) + lines = [prog] + lines + + # join lines into usage + usage = '\n'.join(lines) + + # prefix with 'usage:' + return '%s%s\n\n' % (prefix, usage) + + def _format_actions_usage(self, actions, groups): + # find group indices and identify actions in groups + group_actions = set() + inserts = {} + for group in groups: + try: + start = actions.index(group._group_actions[0]) + except ValueError: + continue + else: + end = start + len(group._group_actions) + if actions[start:end] == group._group_actions: + for action in group._group_actions: + group_actions.add(action) + if not group.required: + if start in inserts: + inserts[start] += ' [' + else: + inserts[start] = '[' + inserts[end] = ']' + else: + if start in inserts: + inserts[start] += ' (' + else: + inserts[start] = '(' + inserts[end] = ')' + for i in range(start + 1, end): + inserts[i] = '|' + + # collect all actions format strings + parts = [] + for i, action in enumerate(actions): + + # suppressed arguments are marked with None + # remove | separators for suppressed arguments + if action.help is SUPPRESS: + parts.append(None) + if inserts.get(i) == '|': + inserts.pop(i) + elif inserts.get(i + 1) == '|': + inserts.pop(i + 1) + + # produce all arg strings + elif not action.option_strings: + part = self._format_args(action, action.dest) + + # if it's in a group, strip the outer [] + if action in group_actions: + if part[0] == '[' and part[-1] == ']': + part = part[1:-1] + + # add the action string to the list + parts.append(part) + + # produce the first way to invoke the option in brackets + else: + option_string = action.option_strings[0] + + # if the Optional doesn't take a value, format is: + # -s or --long + if action.nargs == 0: + part = '%s' % option_string + + # if the Optional takes a value, format is: + # -s ARGS or --long ARGS + else: + default = action.dest.upper() + args_string = self._format_args(action, default) + part = '%s %s' % (option_string, args_string) + + # make it look optional if it's not required or in a group + if not action.required and action not in group_actions: + part = '[%s]' % part + + # add the action string to the list + parts.append(part) + + # insert things at the necessary indices + for i in sorted(inserts, reverse=True): + parts[i:i] = [inserts[i]] + + # join all the action items with spaces + text = ' '.join([item for item in parts if item is not None]) + + # clean up separators for mutually exclusive groups + open = r'[\[(]' + close = r'[\])]' + text = _re.sub(r'(%s) ' % open, r'\1', text) + text = _re.sub(r' (%s)' % close, r'\1', text) + text = _re.sub(r'%s *%s' % (open, close), r'', text) + text = _re.sub(r'\(([^|]*)\)', r'\1', text) + text = text.strip() + + # return the text + return text + + def _format_text(self, text): + if '%(prog)' in text: + text = text % dict(prog=self._prog) + text_width = self._width - self._current_indent + indent = ' ' * self._current_indent + return self._fill_text(text, text_width, indent) + '\n\n' + + def _format_action(self, action): + # determine the required width and the entry label + help_position = min(self._action_max_length + 2, + self._max_help_position) + help_width = self._width - help_position + action_width = help_position - self._current_indent - 2 + action_header = self._format_action_invocation(action) + + # ho nelp; start on same line and add a final newline + if not action.help: + tup = self._current_indent, '', action_header + action_header = '%*s%s\n' % tup + + # short action name; start on the same line and pad two spaces + elif len(action_header) <= action_width: + tup = self._current_indent, '', action_width, action_header + action_header = '%*s%-*s ' % tup + indent_first = 0 + + # long action name; start on the next line + else: + tup = self._current_indent, '', action_header + action_header = '%*s%s\n' % tup + indent_first = help_position + + # collect the pieces of the action help + parts = [action_header] + + # if there was help for the action, add lines of help text + if action.help: + help_text = self._expand_help(action) + help_lines = self._split_lines(help_text, help_width) + parts.append('%*s%s\n' % (indent_first, '', help_lines[0])) + for line in help_lines[1:]: + parts.append('%*s%s\n' % (help_position, '', line)) + + # or add a newline if the description doesn't end with one + elif not action_header.endswith('\n'): + parts.append('\n') + + # if there are any sub-actions, add their help as well + for subaction in self._iter_indented_subactions(action): + parts.append(self._format_action(subaction)) + + # return a single string + return self._join_parts(parts) + + def _format_action_invocation(self, action): + if not action.option_strings: + metavar, = self._metavar_formatter(action, action.dest)(1) + return metavar + + else: + parts = [] + + # if the Optional doesn't take a value, format is: + # -s, --long + if action.nargs == 0: + parts.extend(action.option_strings) + + # if the Optional takes a value, format is: + # -s ARGS, --long ARGS + else: + default = action.dest.upper() + args_string = self._format_args(action, default) + for option_string in action.option_strings: + parts.append('%s %s' % (option_string, args_string)) + + return ', '.join(parts) + + def _metavar_formatter(self, action, default_metavar): + if action.metavar is not None: + result = action.metavar + elif action.choices is not None: + choice_strs = [str(choice) for choice in action.choices] + result = '{%s}' % ','.join(choice_strs) + else: + result = default_metavar + + def format(tuple_size): + if isinstance(result, tuple): + return result + else: + return (result, ) * tuple_size + return format + + def _format_args(self, action, default_metavar): + get_metavar = self._metavar_formatter(action, default_metavar) + if action.nargs is None: + result = '%s' % get_metavar(1) + elif action.nargs == OPTIONAL: + result = '[%s]' % get_metavar(1) + elif action.nargs == ZERO_OR_MORE: + result = '[%s [%s ...]]' % get_metavar(2) + elif action.nargs == ONE_OR_MORE: + result = '%s [%s ...]' % get_metavar(2) + elif action.nargs == REMAINDER: + result = '...' + elif action.nargs == PARSER: + result = '%s ...' % get_metavar(1) + else: + formats = ['%s' for _ in range(action.nargs)] + result = ' '.join(formats) % get_metavar(action.nargs) + return result + + def _expand_help(self, action): + params = dict(vars(action), prog=self._prog) + for name in list(params): + if params[name] is SUPPRESS: + del params[name] + for name in list(params): + if hasattr(params[name], '__name__'): + params[name] = params[name].__name__ + if params.get('choices') is not None: + choices_str = ', '.join([str(c) for c in params['choices']]) + params['choices'] = choices_str + return self._get_help_string(action) % params + + def _iter_indented_subactions(self, action): + try: + get_subactions = action._get_subactions + except AttributeError: + pass + else: + self._indent() + for subaction in get_subactions(): + yield subaction + self._dedent() + + def _split_lines(self, text, width): + text = self._whitespace_matcher.sub(' ', text).strip() + return _textwrap.wrap(text, width) + + def _fill_text(self, text, width, indent): + text = self._whitespace_matcher.sub(' ', text).strip() + return _textwrap.fill(text, width, initial_indent=indent, + subsequent_indent=indent) + + def _get_help_string(self, action): + return action.help + + +class RawDescriptionHelpFormatter(HelpFormatter): + """Help message formatter which retains any formatting in descriptions. + + Only the name of this class is considered a public API. All the methods + provided by the class are considered an implementation detail. + """ + + def _fill_text(self, text, width, indent): + return ''.join([indent + line for line in text.splitlines(True)]) + + +class RawTextHelpFormatter(RawDescriptionHelpFormatter): + """Help message formatter which retains formatting of all help text. + + Only the name of this class is considered a public API. All the methods + provided by the class are considered an implementation detail. + """ + + def _split_lines(self, text, width): + return text.splitlines() + + +class ArgumentDefaultsHelpFormatter(HelpFormatter): + """Help message formatter which adds default values to argument help. + + Only the name of this class is considered a public API. All the methods + provided by the class are considered an implementation detail. + """ + + def _get_help_string(self, action): + help = action.help + if '%(default)' not in action.help: + if action.default is not SUPPRESS: + defaulting_nargs = [OPTIONAL, ZERO_OR_MORE] + if action.option_strings or action.nargs in defaulting_nargs: + help += ' (default: %(default)s)' + return help + + +# ===================== +# Options and Arguments +# ===================== + +def _get_action_name(argument): + if argument is None: + return None + elif argument.option_strings: + return '/'.join(argument.option_strings) + elif argument.metavar not in (None, SUPPRESS): + return argument.metavar + elif argument.dest not in (None, SUPPRESS): + return argument.dest + else: + return None + + +class ArgumentError(Exception): + """An error from creating or using an argument (optional or positional). + + The string value of this exception is the message, augmented with + information about the argument that caused it. + """ + + def __init__(self, argument, message): + self.argument_name = _get_action_name(argument) + self.message = message + + def __str__(self): + if self.argument_name is None: + format = '%(message)s' + else: + format = 'argument %(argument_name)s: %(message)s' + return format % dict(message=self.message, + argument_name=self.argument_name) + + +class ArgumentTypeError(Exception): + """An error from trying to convert a command line string to a type.""" + pass + + +# ============== +# Action classes +# ============== + +class Action(_AttributeHolder): + """Information about how to convert command line strings to Python objects. + + Action objects are used by an ArgumentParser to represent the information + needed to parse a single argument from one or more strings from the + command line. The keyword arguments to the Action constructor are also + all attributes of Action instances. + + Keyword Arguments: + + - option_strings -- A list of command-line option strings which + should be associated with this action. + + - dest -- The name of the attribute to hold the created object(s) + + - nargs -- The number of command-line arguments that should be + consumed. By default, one argument will be consumed and a single + value will be produced. Other values include: + - N (an integer) consumes N arguments (and produces a list) + - '?' consumes zero or one arguments + - '*' consumes zero or more arguments (and produces a list) + - '+' consumes one or more arguments (and produces a list) + Note that the difference between the default and nargs=1 is that + with the default, a single value will be produced, while with + nargs=1, a list containing a single value will be produced. + + - const -- The value to be produced if the option is specified and the + option uses an action that takes no values. + + - default -- The value to be produced if the option is not specified. + + - type -- The type which the command-line arguments should be converted + to, should be one of 'string', 'int', 'float', 'complex' or a + callable object that accepts a single string argument. If None, + 'string' is assumed. + + - choices -- A container of values that should be allowed. If not None, + after a command-line argument has been converted to the appropriate + type, an exception will be raised if it is not a member of this + collection. + + - required -- True if the action must always be specified at the + command line. This is only meaningful for optional command-line + arguments. + + - help -- The help string describing the argument. + + - metavar -- The name to be used for the option's argument with the + help string. If None, the 'dest' value will be used as the name. + """ + + def __init__(self, + option_strings, + dest, + nargs=None, + const=None, + default=None, + type=None, + choices=None, + required=False, + help=None, + metavar=None): + self.option_strings = option_strings + self.dest = dest + self.nargs = nargs + self.const = const + self.default = default + self.type = type + self.choices = choices + self.required = required + self.help = help + self.metavar = metavar + + def _get_kwargs(self): + names = [ + 'option_strings', + 'dest', + 'nargs', + 'const', + 'default', + 'type', + 'choices', + 'help', + 'metavar', + ] + return [(name, getattr(self, name)) for name in names] + + def __call__(self, parser, namespace, values, option_string=None): + raise NotImplementedError(_('.__call__() not defined')) + + +class _StoreAction(Action): + + def __init__(self, + option_strings, + dest, + nargs=None, + const=None, + default=None, + type=None, + choices=None, + required=False, + help=None, + metavar=None): + if nargs == 0: + raise ValueError('nargs for store actions must be > 0; if you ' + 'have nothing to store, actions such as store ' + 'true or store const may be more appropriate') + if const is not None and nargs != OPTIONAL: + raise ValueError('nargs must be %r to supply const' % OPTIONAL) + super(_StoreAction, self).__init__( + option_strings=option_strings, + dest=dest, + nargs=nargs, + const=const, + default=default, + type=type, + choices=choices, + required=required, + help=help, + metavar=metavar) + + def __call__(self, parser, namespace, values, option_string=None): + setattr(namespace, self.dest, values) + + +class _StoreConstAction(Action): + + def __init__(self, + option_strings, + dest, + const, + default=None, + required=False, + help=None, + metavar=None): + super(_StoreConstAction, self).__init__( + option_strings=option_strings, + dest=dest, + nargs=0, + const=const, + default=default, + required=required, + help=help) + + def __call__(self, parser, namespace, values, option_string=None): + setattr(namespace, self.dest, self.const) + + +class _StoreTrueAction(_StoreConstAction): + + def __init__(self, + option_strings, + dest, + default=False, + required=False, + help=None): + super(_StoreTrueAction, self).__init__( + option_strings=option_strings, + dest=dest, + const=True, + default=default, + required=required, + help=help) + + +class _StoreFalseAction(_StoreConstAction): + + def __init__(self, + option_strings, + dest, + default=True, + required=False, + help=None): + super(_StoreFalseAction, self).__init__( + option_strings=option_strings, + dest=dest, + const=False, + default=default, + required=required, + help=help) + + +class _AppendAction(Action): + + def __init__(self, + option_strings, + dest, + nargs=None, + const=None, + default=None, + type=None, + choices=None, + required=False, + help=None, + metavar=None): + if nargs == 0: + raise ValueError('nargs for append actions must be > 0; if arg ' + 'strings are not supplying the value to append, ' + 'the append const action may be more appropriate') + if const is not None and nargs != OPTIONAL: + raise ValueError('nargs must be %r to supply const' % OPTIONAL) + super(_AppendAction, self).__init__( + option_strings=option_strings, + dest=dest, + nargs=nargs, + const=const, + default=default, + type=type, + choices=choices, + required=required, + help=help, + metavar=metavar) + + def __call__(self, parser, namespace, values, option_string=None): + items = _copy.copy(_ensure_value(namespace, self.dest, [])) + items.append(values) + setattr(namespace, self.dest, items) + + +class _AppendConstAction(Action): + + def __init__(self, + option_strings, + dest, + const, + default=None, + required=False, + help=None, + metavar=None): + super(_AppendConstAction, self).__init__( + option_strings=option_strings, + dest=dest, + nargs=0, + const=const, + default=default, + required=required, + help=help, + metavar=metavar) + + def __call__(self, parser, namespace, values, option_string=None): + items = _copy.copy(_ensure_value(namespace, self.dest, [])) + items.append(self.const) + setattr(namespace, self.dest, items) + + +class _CountAction(Action): + + def __init__(self, + option_strings, + dest, + default=None, + required=False, + help=None): + super(_CountAction, self).__init__( + option_strings=option_strings, + dest=dest, + nargs=0, + default=default, + required=required, + help=help) + + def __call__(self, parser, namespace, values, option_string=None): + new_count = _ensure_value(namespace, self.dest, 0) + 1 + setattr(namespace, self.dest, new_count) + + +class _HelpAction(Action): + + def __init__(self, + option_strings, + dest=SUPPRESS, + default=SUPPRESS, + help=None): + super(_HelpAction, self).__init__( + option_strings=option_strings, + dest=dest, + default=default, + nargs=0, + help=help) + + def __call__(self, parser, namespace, values, option_string=None): + parser.print_help() + parser.exit() + + +class _VersionAction(Action): + + def __init__(self, + option_strings, + version=None, + dest=SUPPRESS, + default=SUPPRESS, + help="show program's version number and exit"): + super(_VersionAction, self).__init__( + option_strings=option_strings, + dest=dest, + default=default, + nargs=0, + help=help) + self.version = version + + def __call__(self, parser, namespace, values, option_string=None): + version = self.version + if version is None: + version = parser.version + formatter = parser._get_formatter() + formatter.add_text(version) + parser.exit(message=formatter.format_help()) + + +class _SubParsersAction(Action): + + class _ChoicesPseudoAction(Action): + + def __init__(self, name, help): + sup = super(_SubParsersAction._ChoicesPseudoAction, self) + sup.__init__(option_strings=[], dest=name, help=help) + + def __init__(self, + option_strings, + prog, + parser_class, + dest=SUPPRESS, + help=None, + metavar=None): + + self._prog_prefix = prog + self._parser_class = parser_class + self._name_parser_map = {} + self._choices_actions = [] + + super(_SubParsersAction, self).__init__( + option_strings=option_strings, + dest=dest, + nargs=PARSER, + choices=self._name_parser_map, + help=help, + metavar=metavar) + + def add_parser(self, name, **kwargs): + # set prog from the existing prefix + if kwargs.get('prog') is None: + kwargs['prog'] = '%s %s' % (self._prog_prefix, name) + + # create a pseudo-action to hold the choice help + if 'help' in kwargs: + help = kwargs.pop('help') + choice_action = self._ChoicesPseudoAction(name, help) + self._choices_actions.append(choice_action) + + # create the parser and add it to the map + parser = self._parser_class(**kwargs) + self._name_parser_map[name] = parser + return parser + + def _get_subactions(self): + return self._choices_actions + + def __call__(self, parser, namespace, values, option_string=None): + parser_name = values[0] + arg_strings = values[1:] + + # set the parser name if requested + if self.dest is not SUPPRESS: + setattr(namespace, self.dest, parser_name) + + # select the parser + try: + parser = self._name_parser_map[parser_name] + except KeyError: + tup = parser_name, ', '.join(self._name_parser_map) + msg = _('unknown parser %r (choices: %s)' % tup) + raise ArgumentError(self, msg) + + # parse all the remaining options into the namespace + # store any unrecognized options on the object, so that the top + # level parser can decide what to do with them + namespace, arg_strings = parser.parse_known_args(arg_strings, namespace) + if arg_strings: + vars(namespace).setdefault(_UNRECOGNIZED_ARGS_ATTR, []) + getattr(namespace, _UNRECOGNIZED_ARGS_ATTR).extend(arg_strings) + + +# ============== +# Type classes +# ============== + +class FileType(object): + """Factory for creating file object types + + Instances of FileType are typically passed as type= arguments to the + ArgumentParser add_argument() method. + + Keyword Arguments: + - mode -- A string indicating how the file is to be opened. Accepts the + same values as the builtin open() function. + - bufsize -- The file's desired buffer size. Accepts the same values as + the builtin open() function. + """ + + def __init__(self, mode='r', bufsize=None): + self._mode = mode + self._bufsize = bufsize + + def __call__(self, string): + # the special argument "-" means sys.std{in,out} + if string == '-': + if 'r' in self._mode: + return _sys.stdin + elif 'w' in self._mode: + return _sys.stdout + else: + msg = _('argument "-" with mode %r' % self._mode) + raise ValueError(msg) + + # all other arguments are used as file names + if self._bufsize: + return open(string, self._mode, self._bufsize) + else: + return open(string, self._mode) + + def __repr__(self): + args = [self._mode, self._bufsize] + args_str = ', '.join([repr(arg) for arg in args if arg is not None]) + return '%s(%s)' % (type(self).__name__, args_str) + +# =========================== +# Optional and Positional Parsing +# =========================== + +class Namespace(_AttributeHolder): + """Simple object for storing attributes. + + Implements equality by attribute names and values, and provides a simple + string representation. + """ + + def __init__(self, **kwargs): + for name in kwargs: + setattr(self, name, kwargs[name]) + + __hash__ = None + + def __eq__(self, other): + return vars(self) == vars(other) + + def __ne__(self, other): + return not (self == other) + + def __contains__(self, key): + return key in self.__dict__ + + +class _ActionsContainer(object): + + def __init__(self, + description, + prefix_chars, + argument_default, + conflict_handler): + super(_ActionsContainer, self).__init__() + + self.description = description + self.argument_default = argument_default + self.prefix_chars = prefix_chars + self.conflict_handler = conflict_handler + + # set up registries + self._registries = {} + + # register actions + self.register('action', None, _StoreAction) + self.register('action', 'store', _StoreAction) + self.register('action', 'store_const', _StoreConstAction) + self.register('action', 'store_true', _StoreTrueAction) + self.register('action', 'store_false', _StoreFalseAction) + self.register('action', 'append', _AppendAction) + self.register('action', 'append_const', _AppendConstAction) + self.register('action', 'count', _CountAction) + self.register('action', 'help', _HelpAction) + self.register('action', 'version', _VersionAction) + self.register('action', 'parsers', _SubParsersAction) + + # raise an exception if the conflict handler is invalid + self._get_handler() + + # action storage + self._actions = [] + self._option_string_actions = {} + + # groups + self._action_groups = [] + self._mutually_exclusive_groups = [] + + # defaults storage + self._defaults = {} + + # determines whether an "option" looks like a negative number + self._negative_number_matcher = _re.compile(r'^-\d+$|^-\d*\.\d+$') + + # whether or not there are any optionals that look like negative + # numbers -- uses a list so it can be shared and edited + self._has_negative_number_optionals = [] + + # ==================== + # Registration methods + # ==================== + def register(self, registry_name, value, object): + registry = self._registries.setdefault(registry_name, {}) + registry[value] = object + + def _registry_get(self, registry_name, value, default=None): + return self._registries[registry_name].get(value, default) + + # ================================== + # Namespace default accessor methods + # ================================== + def set_defaults(self, **kwargs): + self._defaults.update(kwargs) + + # if these defaults match any existing arguments, replace + # the previous default on the object with the new one + for action in self._actions: + if action.dest in kwargs: + action.default = kwargs[action.dest] + + def get_default(self, dest): + for action in self._actions: + if action.dest == dest and action.default is not None: + return action.default + return self._defaults.get(dest, None) + + + # ======================= + # Adding argument actions + # ======================= + def add_argument(self, *args, **kwargs): + """ + add_argument(dest, ..., name=value, ...) + add_argument(option_string, option_string, ..., name=value, ...) + """ + + # if no positional args are supplied or only one is supplied and + # it doesn't look like an option string, parse a positional + # argument + chars = self.prefix_chars + if not args or len(args) == 1 and args[0][0] not in chars: + if args and 'dest' in kwargs: + raise ValueError('dest supplied twice for positional argument') + kwargs = self._get_positional_kwargs(*args, **kwargs) + + # otherwise, we're adding an optional argument + else: + kwargs = self._get_optional_kwargs(*args, **kwargs) + + # if no default was supplied, use the parser-level default + if 'default' not in kwargs: + dest = kwargs['dest'] + if dest in self._defaults: + kwargs['default'] = self._defaults[dest] + elif self.argument_default is not None: + kwargs['default'] = self.argument_default + + # create the action object, and add it to the parser + action_class = self._pop_action_class(kwargs) + if not _callable(action_class): + raise ValueError('unknown action "%s"' % action_class) + action = action_class(**kwargs) + + # raise an error if the action type is not callable + type_func = self._registry_get('type', action.type, action.type) + if not _callable(type_func): + raise ValueError('%r is not callable' % type_func) + + return self._add_action(action) + + def add_argument_group(self, *args, **kwargs): + group = _ArgumentGroup(self, *args, **kwargs) + self._action_groups.append(group) + return group + + def add_mutually_exclusive_group(self, **kwargs): + group = _MutuallyExclusiveGroup(self, **kwargs) + self._mutually_exclusive_groups.append(group) + return group + + def _add_action(self, action): + # resolve any conflicts + self._check_conflict(action) + + # add to actions list + self._actions.append(action) + action.container = self + + # index the action by any option strings it has + for option_string in action.option_strings: + self._option_string_actions[option_string] = action + + # set the flag if any option strings look like negative numbers + for option_string in action.option_strings: + if self._negative_number_matcher.match(option_string): + if not self._has_negative_number_optionals: + self._has_negative_number_optionals.append(True) + + # return the created action + return action + + def _remove_action(self, action): + self._actions.remove(action) + + def _add_container_actions(self, container): + # collect groups by titles + title_group_map = {} + for group in self._action_groups: + if group.title in title_group_map: + msg = _('cannot merge actions - two groups are named %r') + raise ValueError(msg % (group.title)) + title_group_map[group.title] = group + + # map each action to its group + group_map = {} + for group in container._action_groups: + + # if a group with the title exists, use that, otherwise + # create a new group matching the container's group + if group.title not in title_group_map: + title_group_map[group.title] = self.add_argument_group( + title=group.title, + description=group.description, + conflict_handler=group.conflict_handler) + + # map the actions to their new group + for action in group._group_actions: + group_map[action] = title_group_map[group.title] + + # add container's mutually exclusive groups + # NOTE: if add_mutually_exclusive_group ever gains title= and + # description= then this code will need to be expanded as above + for group in container._mutually_exclusive_groups: + mutex_group = self.add_mutually_exclusive_group( + required=group.required) + + # map the actions to their new mutex group + for action in group._group_actions: + group_map[action] = mutex_group + + # add all actions to this container or their group + for action in container._actions: + group_map.get(action, self)._add_action(action) + + def _get_positional_kwargs(self, dest, **kwargs): + # make sure required is not specified + if 'required' in kwargs: + msg = _("'required' is an invalid argument for positionals") + raise TypeError(msg) + + # mark positional arguments as required if at least one is + # always required + if kwargs.get('nargs') not in [OPTIONAL, ZERO_OR_MORE]: + kwargs['required'] = True + if kwargs.get('nargs') == ZERO_OR_MORE and 'default' not in kwargs: + kwargs['required'] = True + + # return the keyword arguments with no option strings + return dict(kwargs, dest=dest, option_strings=[]) + + def _get_optional_kwargs(self, *args, **kwargs): + # determine short and long option strings + option_strings = [] + long_option_strings = [] + for option_string in args: + # error on strings that don't start with an appropriate prefix + if not option_string[0] in self.prefix_chars: + msg = _('invalid option string %r: ' + 'must start with a character %r') + tup = option_string, self.prefix_chars + raise ValueError(msg % tup) + + # strings starting with two prefix characters are long options + option_strings.append(option_string) + if option_string[0] in self.prefix_chars: + if len(option_string) > 1: + if option_string[1] in self.prefix_chars: + long_option_strings.append(option_string) + + # infer destination, '--foo-bar' -> 'foo_bar' and '-x' -> 'x' + dest = kwargs.pop('dest', None) + if dest is None: + if long_option_strings: + dest_option_string = long_option_strings[0] + else: + dest_option_string = option_strings[0] + dest = dest_option_string.lstrip(self.prefix_chars) + if not dest: + msg = _('dest= is required for options like %r') + raise ValueError(msg % option_string) + dest = dest.replace('-', '_') + + # return the updated keyword arguments + return dict(kwargs, dest=dest, option_strings=option_strings) + + def _pop_action_class(self, kwargs, default=None): + action = kwargs.pop('action', default) + return self._registry_get('action', action, action) + + def _get_handler(self): + # determine function from conflict handler string + handler_func_name = '_handle_conflict_%s' % self.conflict_handler + try: + return getattr(self, handler_func_name) + except AttributeError: + msg = _('invalid conflict_resolution value: %r') + raise ValueError(msg % self.conflict_handler) + + def _check_conflict(self, action): + + # find all options that conflict with this option + confl_optionals = [] + for option_string in action.option_strings: + if option_string in self._option_string_actions: + confl_optional = self._option_string_actions[option_string] + confl_optionals.append((option_string, confl_optional)) + + # resolve any conflicts + if confl_optionals: + conflict_handler = self._get_handler() + conflict_handler(action, confl_optionals) + + def _handle_conflict_error(self, action, conflicting_actions): + message = _('conflicting option string(s): %s') + conflict_string = ', '.join([option_string + for option_string, action + in conflicting_actions]) + raise ArgumentError(action, message % conflict_string) + + def _handle_conflict_resolve(self, action, conflicting_actions): + + # remove all conflicting options + for option_string, action in conflicting_actions: + + # remove the conflicting option + action.option_strings.remove(option_string) + self._option_string_actions.pop(option_string, None) + + # if the option now has no option string, remove it from the + # container holding it + if not action.option_strings: + action.container._remove_action(action) + + +class _ArgumentGroup(_ActionsContainer): + + def __init__(self, container, title=None, description=None, **kwargs): + # add any missing keyword arguments by checking the container + update = kwargs.setdefault + update('conflict_handler', container.conflict_handler) + update('prefix_chars', container.prefix_chars) + update('argument_default', container.argument_default) + super_init = super(_ArgumentGroup, self).__init__ + super_init(description=description, **kwargs) + + # group attributes + self.title = title + self._group_actions = [] + + # share most attributes with the container + self._registries = container._registries + self._actions = container._actions + self._option_string_actions = container._option_string_actions + self._defaults = container._defaults + self._has_negative_number_optionals = \ + container._has_negative_number_optionals + + def _add_action(self, action): + action = super(_ArgumentGroup, self)._add_action(action) + self._group_actions.append(action) + return action + + def _remove_action(self, action): + super(_ArgumentGroup, self)._remove_action(action) + self._group_actions.remove(action) + + +class _MutuallyExclusiveGroup(_ArgumentGroup): + + def __init__(self, container, required=False): + super(_MutuallyExclusiveGroup, self).__init__(container) + self.required = required + self._container = container + + def _add_action(self, action): + if action.required: + msg = _('mutually exclusive arguments must be optional') + raise ValueError(msg) + action = self._container._add_action(action) + self._group_actions.append(action) + return action + + def _remove_action(self, action): + self._container._remove_action(action) + self._group_actions.remove(action) + + +class ArgumentParser(_AttributeHolder, _ActionsContainer): + """Object for parsing command line strings into Python objects. + + Keyword Arguments: + - prog -- The name of the program (default: sys.argv[0]) + - usage -- A usage message (default: auto-generated from arguments) + - description -- A description of what the program does + - epilog -- Text following the argument descriptions + - parents -- Parsers whose arguments should be copied into this one + - formatter_class -- HelpFormatter class for printing help messages + - prefix_chars -- Characters that prefix optional arguments + - fromfile_prefix_chars -- Characters that prefix files containing + additional arguments + - argument_default -- The default value for all arguments + - conflict_handler -- String indicating how to handle conflicts + - add_help -- Add a -h/-help option + """ + + def __init__(self, + prog=None, + usage=None, + description=None, + epilog=None, + version=None, + parents=[], + formatter_class=HelpFormatter, + prefix_chars='-', + fromfile_prefix_chars=None, + argument_default=None, + conflict_handler='error', + add_help=True): + + if version is not None: + import warnings + warnings.warn( + """The "version" argument to ArgumentParser is deprecated. """ + """Please use """ + """"add_argument(..., action='version', version="N", ...)" """ + """instead""", DeprecationWarning) + + superinit = super(ArgumentParser, self).__init__ + superinit(description=description, + prefix_chars=prefix_chars, + argument_default=argument_default, + conflict_handler=conflict_handler) + + # default setting for prog + if prog is None: + prog = _os.path.basename(_sys.argv[0]) + + self.prog = prog + self.usage = usage + self.epilog = epilog + self.version = version + self.formatter_class = formatter_class + self.fromfile_prefix_chars = fromfile_prefix_chars + self.add_help = add_help + + add_group = self.add_argument_group + self._positionals = add_group(_('positional arguments')) + self._optionals = add_group(_('optional arguments')) + self._subparsers = None + + # register types + def identity(string): + return string + self.register('type', None, identity) + + # add help and version arguments if necessary + # (using explicit default to override global argument_default) + if '-' in prefix_chars: + default_prefix = '-' + else: + default_prefix = prefix_chars[0] + if self.add_help: + self.add_argument( + default_prefix+'h', default_prefix*2+'help', + action='help', default=SUPPRESS, + help=_('show this help message and exit')) + if self.version: + self.add_argument( + default_prefix+'v', default_prefix*2+'version', + action='version', default=SUPPRESS, + version=self.version, + help=_("show program's version number and exit")) + + # add parent arguments and defaults + for parent in parents: + self._add_container_actions(parent) + try: + defaults = parent._defaults + except AttributeError: + pass + else: + self._defaults.update(defaults) + + # ======================= + # Pretty __repr__ methods + # ======================= + def _get_kwargs(self): + names = [ + 'prog', + 'usage', + 'description', + 'version', + 'formatter_class', + 'conflict_handler', + 'add_help', + ] + return [(name, getattr(self, name)) for name in names] + + # ================================== + # Optional/Positional adding methods + # ================================== + def add_subparsers(self, **kwargs): + if self._subparsers is not None: + self.error(_('cannot have multiple subparser arguments')) + + # add the parser class to the arguments if it's not present + kwargs.setdefault('parser_class', type(self)) + + if 'title' in kwargs or 'description' in kwargs: + title = _(kwargs.pop('title', 'subcommands')) + description = _(kwargs.pop('description', None)) + self._subparsers = self.add_argument_group(title, description) + else: + self._subparsers = self._positionals + + # prog defaults to the usage message of this parser, skipping + # optional arguments and with no "usage:" prefix + if kwargs.get('prog') is None: + formatter = self._get_formatter() + positionals = self._get_positional_actions() + groups = self._mutually_exclusive_groups + formatter.add_usage(self.usage, positionals, groups, '') + kwargs['prog'] = formatter.format_help().strip() + + # create the parsers action and add it to the positionals list + parsers_class = self._pop_action_class(kwargs, 'parsers') + action = parsers_class(option_strings=[], **kwargs) + self._subparsers._add_action(action) + + # return the created parsers action + return action + + def _add_action(self, action): + if action.option_strings: + self._optionals._add_action(action) + else: + self._positionals._add_action(action) + return action + + def _get_optional_actions(self): + return [action + for action in self._actions + if action.option_strings] + + def _get_positional_actions(self): + return [action + for action in self._actions + if not action.option_strings] + + # ===================================== + # Command line argument parsing methods + # ===================================== + def parse_args(self, args=None, namespace=None): + args, argv = self.parse_known_args(args, namespace) + if argv: + msg = _('unrecognized arguments: %s') + self.error(msg % ' '.join(argv)) + return args + + def parse_known_args(self, args=None, namespace=None): + # args default to the system args + if args is None: + args = _sys.argv[1:] + + # default Namespace built from parser defaults + if namespace is None: + namespace = Namespace() + + # add any action defaults that aren't present + for action in self._actions: + if action.dest is not SUPPRESS: + if not hasattr(namespace, action.dest): + if action.default is not SUPPRESS: + default = action.default + if isinstance(action.default, basestring): + default = self._get_value(action, default) + setattr(namespace, action.dest, default) + + # add any parser defaults that aren't present + for dest in self._defaults: + if not hasattr(namespace, dest): + setattr(namespace, dest, self._defaults[dest]) + + # parse the arguments and exit if there are any errors + try: + namespace, args = self._parse_known_args(args, namespace) + if hasattr(namespace, _UNRECOGNIZED_ARGS_ATTR): + args.extend(getattr(namespace, _UNRECOGNIZED_ARGS_ATTR)) + delattr(namespace, _UNRECOGNIZED_ARGS_ATTR) + return namespace, args + except ArgumentError: + err = _sys.exc_info()[1] + self.error(str(err)) + + def _parse_known_args(self, arg_strings, namespace): + # replace arg strings that are file references + if self.fromfile_prefix_chars is not None: + arg_strings = self._read_args_from_files(arg_strings) + + # map all mutually exclusive arguments to the other arguments + # they can't occur with + action_conflicts = {} + for mutex_group in self._mutually_exclusive_groups: + group_actions = mutex_group._group_actions + for i, mutex_action in enumerate(mutex_group._group_actions): + conflicts = action_conflicts.setdefault(mutex_action, []) + conflicts.extend(group_actions[:i]) + conflicts.extend(group_actions[i + 1:]) + + # find all option indices, and determine the arg_string_pattern + # which has an 'O' if there is an option at an index, + # an 'A' if there is an argument, or a '-' if there is a '--' + option_string_indices = {} + arg_string_pattern_parts = [] + arg_strings_iter = iter(arg_strings) + for i, arg_string in enumerate(arg_strings_iter): + + # all args after -- are non-options + if arg_string == '--': + arg_string_pattern_parts.append('-') + for arg_string in arg_strings_iter: + arg_string_pattern_parts.append('A') + + # otherwise, add the arg to the arg strings + # and note the index if it was an option + else: + option_tuple = self._parse_optional(arg_string) + if option_tuple is None: + pattern = 'A' + else: + option_string_indices[i] = option_tuple + pattern = 'O' + arg_string_pattern_parts.append(pattern) + + # join the pieces together to form the pattern + arg_strings_pattern = ''.join(arg_string_pattern_parts) + + # converts arg strings to the appropriate and then takes the action + seen_actions = set() + seen_non_default_actions = set() + + def take_action(action, argument_strings, option_string=None): + seen_actions.add(action) + argument_values = self._get_values(action, argument_strings) + + # error if this argument is not allowed with other previously + # seen arguments, assuming that actions that use the default + # value don't really count as "present" + if argument_values is not action.default: + seen_non_default_actions.add(action) + for conflict_action in action_conflicts.get(action, []): + if conflict_action in seen_non_default_actions: + msg = _('not allowed with argument %s') + action_name = _get_action_name(conflict_action) + raise ArgumentError(action, msg % action_name) + + # take the action if we didn't receive a SUPPRESS value + # (e.g. from a default) + if argument_values is not SUPPRESS: + action(self, namespace, argument_values, option_string) + + # function to convert arg_strings into an optional action + def consume_optional(start_index): + + # get the optional identified at this index + option_tuple = option_string_indices[start_index] + action, option_string, explicit_arg = option_tuple + + # identify additional optionals in the same arg string + # (e.g. -xyz is the same as -x -y -z if no args are required) + match_argument = self._match_argument + action_tuples = [] + while True: + + # if we found no optional action, skip it + if action is None: + extras.append(arg_strings[start_index]) + return start_index + 1 + + # if there is an explicit argument, try to match the + # optional's string arguments to only this + if explicit_arg is not None: + arg_count = match_argument(action, 'A') + + # if the action is a single-dash option and takes no + # arguments, try to parse more single-dash options out + # of the tail of the option string + chars = self.prefix_chars + if arg_count == 0 and option_string[1] not in chars: + action_tuples.append((action, [], option_string)) + char = option_string[0] + option_string = char + explicit_arg[0] + new_explicit_arg = explicit_arg[1:] or None + optionals_map = self._option_string_actions + if option_string in optionals_map: + action = optionals_map[option_string] + explicit_arg = new_explicit_arg + else: + msg = _('ignored explicit argument %r') + raise ArgumentError(action, msg % explicit_arg) + + # if the action expect exactly one argument, we've + # successfully matched the option; exit the loop + elif arg_count == 1: + stop = start_index + 1 + args = [explicit_arg] + action_tuples.append((action, args, option_string)) + break + + # error if a double-dash option did not use the + # explicit argument + else: + msg = _('ignored explicit argument %r') + raise ArgumentError(action, msg % explicit_arg) + + # if there is no explicit argument, try to match the + # optional's string arguments with the following strings + # if successful, exit the loop + else: + start = start_index + 1 + selected_patterns = arg_strings_pattern[start:] + arg_count = match_argument(action, selected_patterns) + stop = start + arg_count + args = arg_strings[start:stop] + action_tuples.append((action, args, option_string)) + break + + # add the Optional to the list and return the index at which + # the Optional's string args stopped + assert action_tuples + for action, args, option_string in action_tuples: + take_action(action, args, option_string) + return stop + + # the list of Positionals left to be parsed; this is modified + # by consume_positionals() + positionals = self._get_positional_actions() + + # function to convert arg_strings into positional actions + def consume_positionals(start_index): + # match as many Positionals as possible + match_partial = self._match_arguments_partial + selected_pattern = arg_strings_pattern[start_index:] + arg_counts = match_partial(positionals, selected_pattern) + + # slice off the appropriate arg strings for each Positional + # and add the Positional and its args to the list + for action, arg_count in zip(positionals, arg_counts): + args = arg_strings[start_index: start_index + arg_count] + start_index += arg_count + take_action(action, args) + + # slice off the Positionals that we just parsed and return the + # index at which the Positionals' string args stopped + positionals[:] = positionals[len(arg_counts):] + return start_index + + # consume Positionals and Optionals alternately, until we have + # passed the last option string + extras = [] + start_index = 0 + if option_string_indices: + max_option_string_index = max(option_string_indices) + else: + max_option_string_index = -1 + while start_index <= max_option_string_index: + + # consume any Positionals preceding the next option + next_option_string_index = min([ + index + for index in option_string_indices + if index >= start_index]) + if start_index != next_option_string_index: + positionals_end_index = consume_positionals(start_index) + + # only try to parse the next optional if we didn't consume + # the option string during the positionals parsing + if positionals_end_index > start_index: + start_index = positionals_end_index + continue + else: + start_index = positionals_end_index + + # if we consumed all the positionals we could and we're not + # at the index of an option string, there were extra arguments + if start_index not in option_string_indices: + strings = arg_strings[start_index:next_option_string_index] + extras.extend(strings) + start_index = next_option_string_index + + # consume the next optional and any arguments for it + start_index = consume_optional(start_index) + + # consume any positionals following the last Optional + stop_index = consume_positionals(start_index) + + # if we didn't consume all the argument strings, there were extras + extras.extend(arg_strings[stop_index:]) + + # if we didn't use all the Positional objects, there were too few + # arg strings supplied. + if positionals: + self.error(_('too few arguments')) + + # make sure all required actions were present + for action in self._actions: + if action.required: + if action not in seen_actions: + name = _get_action_name(action) + self.error(_('argument %s is required') % name) + + # make sure all required groups had one option present + for group in self._mutually_exclusive_groups: + if group.required: + for action in group._group_actions: + if action in seen_non_default_actions: + break + + # if no actions were used, report the error + else: + names = [_get_action_name(action) + for action in group._group_actions + if action.help is not SUPPRESS] + msg = _('one of the arguments %s is required') + self.error(msg % ' '.join(names)) + + # return the updated namespace and the extra arguments + return namespace, extras + + def _read_args_from_files(self, arg_strings): + # expand arguments referencing files + new_arg_strings = [] + for arg_string in arg_strings: + + # for regular arguments, just add them back into the list + if arg_string[0] not in self.fromfile_prefix_chars: + new_arg_strings.append(arg_string) + + # replace arguments referencing files with the file content + else: + try: + args_file = open(arg_string[1:]) + try: + arg_strings = [] + for arg_line in args_file.read().splitlines(): + for arg in self.convert_arg_line_to_args(arg_line): + arg_strings.append(arg) + arg_strings = self._read_args_from_files(arg_strings) + new_arg_strings.extend(arg_strings) + finally: + args_file.close() + except IOError: + err = _sys.exc_info()[1] + self.error(str(err)) + + # return the modified argument list + return new_arg_strings + + def convert_arg_line_to_args(self, arg_line): + return [arg_line] + + def _match_argument(self, action, arg_strings_pattern): + # match the pattern for this action to the arg strings + nargs_pattern = self._get_nargs_pattern(action) + match = _re.match(nargs_pattern, arg_strings_pattern) + + # raise an exception if we weren't able to find a match + if match is None: + nargs_errors = { + None: _('expected one argument'), + OPTIONAL: _('expected at most one argument'), + ONE_OR_MORE: _('expected at least one argument'), + } + default = _('expected %s argument(s)') % action.nargs + msg = nargs_errors.get(action.nargs, default) + raise ArgumentError(action, msg) + + # return the number of arguments matched + return len(match.group(1)) + + def _match_arguments_partial(self, actions, arg_strings_pattern): + # progressively shorten the actions list by slicing off the + # final actions until we find a match + result = [] + for i in range(len(actions), 0, -1): + actions_slice = actions[:i] + pattern = ''.join([self._get_nargs_pattern(action) + for action in actions_slice]) + match = _re.match(pattern, arg_strings_pattern) + if match is not None: + result.extend([len(string) for string in match.groups()]) + break + + # return the list of arg string counts + return result + + def _parse_optional(self, arg_string): + # if it's an empty string, it was meant to be a positional + if not arg_string: + return None + + # if it doesn't start with a prefix, it was meant to be positional + if not arg_string[0] in self.prefix_chars: + return None + + # if the option string is present in the parser, return the action + if arg_string in self._option_string_actions: + action = self._option_string_actions[arg_string] + return action, arg_string, None + + # if it's just a single character, it was meant to be positional + if len(arg_string) == 1: + return None + + # if the option string before the "=" is present, return the action + if '=' in arg_string: + option_string, explicit_arg = arg_string.split('=', 1) + if option_string in self._option_string_actions: + action = self._option_string_actions[option_string] + return action, option_string, explicit_arg + + # search through all possible prefixes of the option string + # and all actions in the parser for possible interpretations + option_tuples = self._get_option_tuples(arg_string) + + # if multiple actions match, the option string was ambiguous + if len(option_tuples) > 1: + options = ', '.join([option_string + for action, option_string, explicit_arg in option_tuples]) + tup = arg_string, options + self.error(_('ambiguous option: %s could match %s') % tup) + + # if exactly one action matched, this segmentation is good, + # so return the parsed action + elif len(option_tuples) == 1: + option_tuple, = option_tuples + return option_tuple + + # if it was not found as an option, but it looks like a negative + # number, it was meant to be positional + # unless there are negative-number-like options + if self._negative_number_matcher.match(arg_string): + if not self._has_negative_number_optionals: + return None + + # if it contains a space, it was meant to be a positional + if ' ' in arg_string: + return None + + # it was meant to be an optional but there is no such option + # in this parser (though it might be a valid option in a subparser) + return None, arg_string, None + + def _get_option_tuples(self, option_string): + result = [] + + # option strings starting with two prefix characters are only + # split at the '=' + chars = self.prefix_chars + if option_string[0] in chars and option_string[1] in chars: + if '=' in option_string: + option_prefix, explicit_arg = option_string.split('=', 1) + else: + option_prefix = option_string + explicit_arg = None + for option_string in self._option_string_actions: + if option_string.startswith(option_prefix): + action = self._option_string_actions[option_string] + tup = action, option_string, explicit_arg + result.append(tup) + + # single character options can be concatenated with their arguments + # but multiple character options always have to have their argument + # separate + elif option_string[0] in chars and option_string[1] not in chars: + option_prefix = option_string + explicit_arg = None + short_option_prefix = option_string[:2] + short_explicit_arg = option_string[2:] + + for option_string in self._option_string_actions: + if option_string == short_option_prefix: + action = self._option_string_actions[option_string] + tup = action, option_string, short_explicit_arg + result.append(tup) + elif option_string.startswith(option_prefix): + action = self._option_string_actions[option_string] + tup = action, option_string, explicit_arg + result.append(tup) + + # shouldn't ever get here + else: + self.error(_('unexpected option string: %s') % option_string) + + # return the collected option tuples + return result + + def _get_nargs_pattern(self, action): + # in all examples below, we have to allow for '--' args + # which are represented as '-' in the pattern + nargs = action.nargs + + # the default (None) is assumed to be a single argument + if nargs is None: + nargs_pattern = '(-*A-*)' + + # allow zero or one arguments + elif nargs == OPTIONAL: + nargs_pattern = '(-*A?-*)' + + # allow zero or more arguments + elif nargs == ZERO_OR_MORE: + nargs_pattern = '(-*[A-]*)' + + # allow one or more arguments + elif nargs == ONE_OR_MORE: + nargs_pattern = '(-*A[A-]*)' + + # allow any number of options or arguments + elif nargs == REMAINDER: + nargs_pattern = '([-AO]*)' + + # allow one argument followed by any number of options or arguments + elif nargs == PARSER: + nargs_pattern = '(-*A[-AO]*)' + + # all others should be integers + else: + nargs_pattern = '(-*%s-*)' % '-*'.join('A' * nargs) + + # if this is an optional action, -- is not allowed + if action.option_strings: + nargs_pattern = nargs_pattern.replace('-*', '') + nargs_pattern = nargs_pattern.replace('-', '') + + # return the pattern + return nargs_pattern + + # ======================== + # Value conversion methods + # ======================== + def _get_values(self, action, arg_strings): + # for everything but PARSER args, strip out '--' + if action.nargs not in [PARSER, REMAINDER]: + arg_strings = [s for s in arg_strings if s != '--'] + + # optional argument produces a default when not present + if not arg_strings and action.nargs == OPTIONAL: + if action.option_strings: + value = action.const + else: + value = action.default + if isinstance(value, basestring): + value = self._get_value(action, value) + self._check_value(action, value) + + # when nargs='*' on a positional, if there were no command-line + # args, use the default if it is anything other than None + elif (not arg_strings and action.nargs == ZERO_OR_MORE and + not action.option_strings): + if action.default is not None: + value = action.default + else: + value = arg_strings + self._check_value(action, value) + + # single argument or optional argument produces a single value + elif len(arg_strings) == 1 and action.nargs in [None, OPTIONAL]: + arg_string, = arg_strings + value = self._get_value(action, arg_string) + self._check_value(action, value) + + # REMAINDER arguments convert all values, checking none + elif action.nargs == REMAINDER: + value = [self._get_value(action, v) for v in arg_strings] + + # PARSER arguments convert all values, but check only the first + elif action.nargs == PARSER: + value = [self._get_value(action, v) for v in arg_strings] + self._check_value(action, value[0]) + + # all other types of nargs produce a list + else: + value = [self._get_value(action, v) for v in arg_strings] + for v in value: + self._check_value(action, v) + + # return the converted value + return value + + def _get_value(self, action, arg_string): + type_func = self._registry_get('type', action.type, action.type) + if not _callable(type_func): + msg = _('%r is not callable') + raise ArgumentError(action, msg % type_func) + + # convert the value to the appropriate type + try: + result = type_func(arg_string) + + # ArgumentTypeErrors indicate errors + except ArgumentTypeError: + name = getattr(action.type, '__name__', repr(action.type)) + msg = str(_sys.exc_info()[1]) + raise ArgumentError(action, msg) + + # TypeErrors or ValueErrors also indicate errors + except (TypeError, ValueError): + name = getattr(action.type, '__name__', repr(action.type)) + msg = _('invalid %s value: %r') + raise ArgumentError(action, msg % (name, arg_string)) + + # return the converted value + return result + + def _check_value(self, action, value): + # converted value must be one of the choices (if specified) + if action.choices is not None and value not in action.choices: + tup = value, ', '.join(map(repr, action.choices)) + msg = _('invalid choice: %r (choose from %s)') % tup + raise ArgumentError(action, msg) + + # ======================= + # Help-formatting methods + # ======================= + def format_usage(self): + formatter = self._get_formatter() + formatter.add_usage(self.usage, self._actions, + self._mutually_exclusive_groups) + return formatter.format_help() + + def format_help(self): + formatter = self._get_formatter() + + # usage + formatter.add_usage(self.usage, self._actions, + self._mutually_exclusive_groups) + + # description + formatter.add_text(self.description) + + # positionals, optionals and user-defined groups + for action_group in self._action_groups: + formatter.start_section(action_group.title) + formatter.add_text(action_group.description) + formatter.add_arguments(action_group._group_actions) + formatter.end_section() + + # epilog + formatter.add_text(self.epilog) + + # determine help from format above + return formatter.format_help() + + def format_version(self): + import warnings + warnings.warn( + 'The format_version method is deprecated -- the "version" ' + 'argument to ArgumentParser is no longer supported.', + DeprecationWarning) + formatter = self._get_formatter() + formatter.add_text(self.version) + return formatter.format_help() + + def _get_formatter(self): + return self.formatter_class(prog=self.prog) + + # ===================== + # Help-printing methods + # ===================== + def print_usage(self, file=None): + if file is None: + file = _sys.stdout + self._print_message(self.format_usage(), file) + + def print_help(self, file=None): + if file is None: + file = _sys.stdout + self._print_message(self.format_help(), file) + + def print_version(self, file=None): + import warnings + warnings.warn( + 'The print_version method is deprecated -- the "version" ' + 'argument to ArgumentParser is no longer supported.', + DeprecationWarning) + self._print_message(self.format_version(), file) + + def _print_message(self, message, file=None): + if message: + if file is None: + file = _sys.stderr + file.write(message) + + # =============== + # Exiting methods + # =============== + def exit(self, status=0, message=None): + if message: + self._print_message(message, _sys.stderr) + _sys.exit(status) + + def error(self, message): + """error(message: string) + + Prints a usage message incorporating the message to stderr and + exits. + + If you override this in a subclass, it should not return -- it + should either exit or raise an exception. + """ + self.print_usage(_sys.stderr) + self.exit(2, _('%s: error: %s\n') % (self.prog, message)) diff --git a/libs/daemon.py b/libs/daemon.py index ed9f2d7b..0e3d0d63 100644 --- a/libs/daemon.py +++ b/libs/daemon.py @@ -64,7 +64,8 @@ class Daemon(): file(self.pidfile, 'w+').write("%s\n" % pid) def delpid(self): - os.remove(self.pidfile) + if os.path.exists(self.pidfile): + os.remove(self.pidfile) def start(self): """ @@ -112,8 +113,7 @@ class Daemon(): except OSError, err: err = str(err) if err.find("No such process") > 0: - if os.path.exists(self.pidfile): - os.remove(self.pidfile) + self.delpid() else: print str(err) sys.exit(1) diff --git a/libs/transmissionrpc/__init__.py b/libs/transmissionrpc/__init__.py index 5d3301fa..057d6784 100755 --- a/libs/transmissionrpc/__init__.py +++ b/libs/transmissionrpc/__init__.py @@ -11,6 +11,6 @@ from transmissionrpc.client import Client from transmissionrpc.utils import add_stdout_logger __author__ = u'Erik Svensson ' -__version__ = u'0.8' +__version__ = u'0.9' __copyright__ = u'Copyright (c) 2008-2011 Erik Svensson' __license__ = u'MIT' diff --git a/libs/transmissionrpc/client.py b/libs/transmissionrpc/client.py index b8f2ebba..420083b6 100755 --- a/libs/transmissionrpc/client.py +++ b/libs/transmissionrpc/client.py @@ -2,7 +2,7 @@ # Copyright (c) 2008-2011 Erik Svensson # Licensed under the MIT license. -import re, time +import re, time, operator, warnings import urllib2, urlparse, base64 try: @@ -36,7 +36,7 @@ def debug_httperror(error): 'data': data, } }, - indent=2 + indent = 2 ) ) @@ -59,7 +59,7 @@ class Client(object): Client is the class handling the Transmission JSON-RPC client protocol. """ - def __init__(self, address='localhost', port=DEFAULT_PORT, user=None, password=None, http_handler=None, timeout=None): + def __init__(self, address = 'localhost', port = DEFAULT_PORT, user = None, password = None, http_handler = None, timeout = None): if isinstance(timeout, (int, long, float)): self._query_timeout = float(timeout) else: @@ -91,7 +91,7 @@ class Client(object): elif user or password: LOGGER.warning('Either user or password missing, not using authentication.') self._sequence = 0 - self.session = Session() + self.session = None self.session_id = 0 self.server_version = None self.protocol_version = None @@ -117,9 +117,9 @@ class Client(object): """ self._query_timeout = DEFAULT_TIMEOUT - timeout = property(_get_timeout, _set_timeout, _del_timeout, doc="HTTP query timeout.") + timeout = property(_get_timeout, _set_timeout, _del_timeout, doc = "HTTP query timeout.") - def _http_query(self, query, timeout=None): + def _http_query(self, query, timeout = None): """ Query Transmission through HTTP. """ @@ -129,7 +129,7 @@ class Client(object): if timeout is None: timeout = self._query_timeout while True: - LOGGER.debug(json.dumps({'url': self.url, 'headers': headers, 'query': query, 'timeout': timeout}, indent=2)) + LOGGER.debug(json.dumps({'url': self.url, 'headers': headers, 'query': query, 'timeout': timeout}, indent = 2)) try: result = self.http_handler.request(self.url, query, headers, timeout) break @@ -150,7 +150,7 @@ class Client(object): request_count += 1 return result - def _request(self, method, arguments=None, ids=None, require_ids=False, timeout=None): + def _request(self, method, arguments = None, ids = None, require_ids = False, timeout = None): """ Send json-rpc request to Transmission using http POST """ @@ -182,7 +182,7 @@ class Client(object): LOGGER.error('HTTP data: \"%s\"' % (http_data)) raise - LOGGER.debug(json.dumps(data, indent=2)) + LOGGER.debug(json.dumps(data, indent = 2)) if 'result' in data: if data['result'] != 'success': raise TransmissionError('Query failed with result \"%s\".' % (data['result'])) @@ -264,7 +264,10 @@ class Client(object): """ Update session data. """ - self.session.update(data) + if self.session: + self.session.from_request(data) + else: + self.session = Session(self, data) def _update_server_version(self): if self.server_version is None: @@ -305,11 +308,12 @@ class Client(object): Add a warning to the log if the Transmission RPC version is lower then the provided version. """ if self.rpc_version < version: - LOGGER.warning('Using feature not supported by server. RPC version for server %d, feature introduced in %d.' % (self.rpc_version, version)) + LOGGER.warning('Using feature not supported by server. RPC version for server %d, feature introduced in %d.' + % (self.rpc_version, version)) - def add(self, data, timeout=None, **kwargs): + def add_torrent(self, torrent, timeout = None, **kwargs): """ - Add torrent to transfers list. Takes a base64 encoded .torrent file in data. + Add torrent to transfers list. Takes a uri to a torrent or base64 encoded torrent data. Additional arguments are: ===================== ===== =========== ============================================================= @@ -327,6 +331,41 @@ class Client(object): ``priority_normal`` 1 - A list of file id's that should have normal priority. ===================== ===== =========== ============================================================= + Returns a Torrent object with limited fields. + """ + if torrent is None: + raise ValueError('add_torrent requires data or a URI.') + torrent_data = None + try: + # check if this is base64 data + base64.b64decode(torrent) + torrent_data = torrent + except Exception: + torrent_data = None + if not torrent_data: + parsed_uri = urlparse.urlparse(torrent) + if parsed_uri.scheme in ['file', 'ftp', 'ftps', 'http', 'https']: + # there has been some problem with T's built in torrent fetcher, + # use a python one instead + torrent_file = urllib2.urlopen(torrent) + torrent_data = torrent_file.read() + torrent_data = base64.b64encode(torrent_data) + args = {} + if torrent_data: + args = {'metainfo': torrent_data} + else: + args = {'filename': torrent} + for key, value in kwargs.iteritems(): + argument = make_rpc_name(key) + (arg, val) = argument_value_convert('torrent-add', argument, value, self.rpc_version) + args[arg] = val + return self._request('torrent-add', args, timeout = timeout).values()[0] + + def add(self, data, timeout = None, **kwargs): + """ + + .. WARNING:: + Deprecated, please use add_torrent. """ args = {} if data: @@ -335,31 +374,16 @@ class Client(object): raise ValueError('No torrent data or torrent uri.') for key, value in kwargs.iteritems(): argument = make_rpc_name(key) - (arg, val) = argument_value_convert('torrent-add', - argument, value, self.rpc_version) + (arg, val) = argument_value_convert('torrent-add', argument, value, self.rpc_version) args[arg] = val - return self._request('torrent-add', args, timeout=timeout) + warnings.warn('add has been deprecated, please use add_torrent instead.', DeprecationWarning) + return self._request('torrent-add', args, timeout = timeout) def add_uri(self, uri, **kwargs): """ - Add torrent to transfers list. Takes a uri to a torrent, supporting - all uri's supported by Transmissions torrent-add 'filename' - argument. Additional arguments are: - ===================== ===== =========== ============================================================= - Argument RPC Replaced by Description - ===================== ===== =========== ============================================================= - ``bandwidthPriority`` 8 - Priority for this transfer. - ``cookies`` 13 - One or more HTTP cookie(s). - ``download_dir`` 1 - The directory where the downloaded contents will be saved in. - ``files_unwanted`` 1 - A list of file id's that shouldn't be downloaded. - ``files_wanted`` 1 - A list of file id's that should be downloaded. - ``paused`` 1 - If True, does not start the transfer when added. - ``peer_limit`` 1 - Maximum number of peers allowed. - ``priority_high`` 1 - A list of file id's that should have high priority. - ``priority_low`` 1 - A list of file id's that should have low priority. - ``priority_normal`` 1 - A list of file id's that should have normal priority. - ===================== ===== =========== ============================================================= + .. WARNING:: + Deprecated, please use add_torrent. """ if uri is None: raise ValueError('add_uri requires a URI.') @@ -370,47 +394,145 @@ class Client(object): if parsed_uri.scheme in ['file', 'ftp', 'ftps', 'http', 'https']: torrent_file = urllib2.urlopen(uri) torrent_data = base64.b64encode(torrent_file.read()) + warnings.warn('add_uri has been deprecated, please use add_torrent instead.', DeprecationWarning) if torrent_data: return self.add(torrent_data, **kwargs) else: - return self.add(None, filename=uri, **kwargs) + return self.add(None, filename = uri, **kwargs) - def remove(self, ids, delete_data=False, timeout=None): + def remove_torrent(self, ids, delete_data = False, timeout = None): """ remove torrent(s) with provided id(s). Local data is removed if delete_data is True, otherwise not. """ self._rpc_version_warning(3) self._request('torrent-remove', - {'delete-local-data':rpc_bool(delete_data)}, ids, True, timeout=timeout) + {'delete-local-data':rpc_bool(delete_data)}, ids, True, timeout = timeout) - def start(self, ids, bypass_queue=False, timeout=None): - """start torrent(s) with provided id(s)""" + def remove(self, ids, delete_data = False, timeout = None): + """ + + .. WARNING:: + Deprecated, please use remove_torrent. + """ + warnings.warn('remove has been deprecated, please use remove_torrent instead.', DeprecationWarning) + self.remove_torrent(ids, delete_data, timeout) + + def start_torrent(self, ids, bypass_queue = False, timeout = None): + """Start torrent(s) with provided id(s)""" method = 'torrent-start' if bypass_queue and self.rpc_version >= 14: method = 'torrent-start-now' - self._request(method, {}, ids, True, timeout=timeout) + self._request(method, {}, ids, True, timeout = timeout) - def stop(self, ids, timeout=None): + def start(self, ids, bypass_queue = False, timeout = None): + """ + + .. WARNING:: + Deprecated, please use start_torrent. + """ + warnings.warn('start has been deprecated, please use start_torrent instead.', DeprecationWarning) + self.start_torrent(ids, bypass_queue, timeout) + + def start_all(self, bypass_queue = False, timeout = None): + """Start all torrents respecting the queue order""" + torrent_list = self.get_torrents() + method = 'torrent-start' + if self.rpc_version >= 14: + if bypass_queue: + method = 'torrent-start-now' + torrent_list = sorted(torrent_list, key = operator.attrgetter('queuePosition')) + ids = [x.id for x in torrent_list] + self._request(method, {}, ids, True, timeout = timeout) + + def stop_torrent(self, ids, timeout = None): """stop torrent(s) with provided id(s)""" - self._request('torrent-stop', {}, ids, True, timeout=timeout) + self._request('torrent-stop', {}, ids, True, timeout = timeout) - def verify(self, ids, timeout=None): + def stop(self, ids, timeout = None): + """ + + .. WARNING:: + Deprecated, please use stop_torrent. + """ + warnings.warn('stop has been deprecated, please use stop_torrent instead.', DeprecationWarning) + self.stop_torrent(ids, timeout) + + def verify_torrent(self, ids, timeout = None): """verify torrent(s) with provided id(s)""" - self._request('torrent-verify', {}, ids, True, timeout=timeout) + self._request('torrent-verify', {}, ids, True, timeout = timeout) - def reannounce(self, ids, timeout=None): + def verify(self, ids, timeout = None): + """ + + .. WARNING:: + Deprecated, please use verify_torrent. + """ + warnings.warn('verify has been deprecated, please use verify_torrent instead.', DeprecationWarning) + self.verify_torrent(ids, timeout) + + def reannounce_torrent(self, ids, timeout = None): """Reannounce torrent(s) with provided id(s)""" self._rpc_version_warning(5) - self._request('torrent-reannounce', {}, ids, True, timeout=timeout) + self._request('torrent-reannounce', {}, ids, True, timeout = timeout) - def info(self, ids=None, arguments=None, timeout=None): - """Get detailed information for torrent(s) with provided id(s).""" + def reannounce(self, ids, timeout = None): + """ + + .. WARNING:: + Deprecated, please use reannounce_torrent. + """ + warnings.warn('reannounce has been deprecated, please use reannounce_torrent instead.', DeprecationWarning) + self.reannounce_torrent(ids, timeout) + + def get_torrent(self, id, arguments = None, timeout = None): + """ + Get information for torrent with provided id. + + Returns a Torrent object. + """ if not arguments: arguments = self.torrent_get_arguments - return self._request('torrent-get', {'fields': arguments}, ids, timeout=timeout) + if not isinstance(id, (int, long, str, unicode)): + raise ValueError("Invalid id") + return self._request('torrent-get', {'fields': arguments}, id, require_ids = True, timeout = timeout)[id] - def get_files(self, ids=None, timeout=None): + def get_torrents(self, ids = None, arguments = None, timeout = None): + """ + Get information for torrents with provided ids. + + Returns a list of Torrent object. + """ + if not arguments: + arguments = self.torrent_get_arguments + return self._request('torrent-get', {'fields': arguments}, ids, timeout = timeout).values() + + def info(self, ids = None, arguments = None, timeout = None): + """ + + .. WARNING:: + Deprecated, please use get_torrent or get_torrents. Please note that the return argument has changed in + the new methods. info returns a dictionary indexed by torrent id. + """ + warnings.warn('info has been deprecated, please use get_torrent or get_torrents instead.', DeprecationWarning) + if not arguments: + arguments = self.torrent_get_arguments + return self._request('torrent-get', {'fields': arguments}, ids, timeout = timeout) + + def list(self, timeout = None): + """ + + .. WARNING:: + Deprecated, please use get_torrent or get_torrents. Please note that the return argument has changed in + the new methods. list returns a dictionary indexed by torrent id. + """ + warnings.warn('list has been deprecated, please use get_torrent or get_torrents instead.', DeprecationWarning) + fields = ['id', 'hashString', 'name', 'sizeWhenDone', 'leftUntilDone' + , 'eta', 'status', 'rateUpload', 'rateDownload', 'uploadedEver' + , 'downloadedEver', 'uploadRatio', 'queuePosition'] + return self._request('torrent-get', {'fields': fields}, timeout = timeout) + + def get_files(self, ids = None, timeout = None): """ Get list of files for provided torrent id(s). If ids is empty, information for all torrents are fetched. This function returns a dictionary @@ -435,13 +557,13 @@ class Client(object): } """ fields = ['id', 'name', 'hashString', 'files', 'priorities', 'wanted'] - request_result = self._request('torrent-get', {'fields': fields}, ids, timeout=timeout) + request_result = self._request('torrent-get', {'fields': fields}, ids, timeout = timeout) result = {} for tid, torrent in request_result.iteritems(): result[tid] = torrent.files() return result - def set_files(self, items, timeout=None): + def set_files(self, items, timeout = None): """ Set file properties. Takes a dictionary with similar contents as the result of `get_files`. @@ -498,14 +620,7 @@ class Client(object): args['priority_low'] = low self.change([tid], **args) - def list(self, timeout=None): - """list all torrents""" - fields = ['id', 'hashString', 'name', 'sizeWhenDone', 'leftUntilDone' - , 'eta', 'status', 'rateUpload', 'rateDownload', 'uploadedEver' - , 'downloadedEver', 'uploadRatio'] - return self._request('torrent-get', {'fields': fields}, timeout=timeout) - - def change(self, ids, timeout=None, **kwargs): + def change_torrent(self, ids, timeout = None, **kwargs): """ Change torrent parameters for the torrent(s) with the supplied id's. The parameters are: @@ -546,54 +661,80 @@ class Client(object): args = {} for key, value in kwargs.iteritems(): argument = make_rpc_name(key) - (arg, val) = argument_value_convert('torrent-set' - , argument, value, self.rpc_version) + (arg, val) = argument_value_convert('torrent-set' , argument, value, self.rpc_version) args[arg] = val if len(args) > 0: - self._request('torrent-set', args, ids, True, timeout=timeout) + self._request('torrent-set', args, ids, True, timeout = timeout) else: ValueError("No arguments to set") - def move(self, ids, location, timeout=None): + def change(self, ids, timeout = None, **kwargs): + """ + + .. WARNING:: + Deprecated, please use change_torrent. + """ + warnings.warn('change has been deprecated, please use change_torrent instead.', DeprecationWarning) + self.change_torrent(ids, timeout, **kwargs) + + def move_torrent_data(self, ids, location, timeout = None): """Move torrent data to the new location.""" self._rpc_version_warning(6) args = {'location': location, 'move': True} - self._request('torrent-set-location', args, ids, True, timeout=timeout) + self._request('torrent-set-location', args, ids, True, timeout = timeout) - def locate(self, ids, location, timeout=None): - """Locate torrent data at the location.""" + def move(self, ids, location, timeout = None): + """ + + .. WARNING:: + Deprecated, please use move_torrent_data. + """ + warnings.warn('move has been deprecated, please use move_torrent_data instead.', DeprecationWarning) + self.move_torrent_data(ids, location, timeout) + + def locate_torrent_data(self, ids, location, timeout = None): + """Locate torrent data at the provided location.""" self._rpc_version_warning(6) args = {'location': location, 'move': False} - self._request('torrent-set-location', args, ids, True, timeout=timeout) + self._request('torrent-set-location', args, ids, True, timeout = timeout) - def queue_top(self, ids, timeout=None): + def locate(self, ids, location, timeout = None): + """ + + .. WARNING:: + Deprecated, please use locate_torrent_data. + """ + warnings.warn('locate has been deprecated, please use locate_torrent_data instead.', DeprecationWarning) + self.locate_torrent_data(ids, location, timeout) + + def queue_top(self, ids, timeout = None): """Move transfer to the top of the queue.""" self._rpc_version_warning(14) - self._request('queue-move-top', ids=ids, require_ids=True, timeout=timeout) + self._request('queue-move-top', ids = ids, require_ids = True, timeout = timeout) - def queue_bottom(self, ids, timeout=None): + def queue_bottom(self, ids, timeout = None): """Move transfer to the bottom of the queue.""" self._rpc_version_warning(14) - self._request('queue-move-bottom', ids=ids, require_ids=True, timeout=timeout) - - def queue_up(self, ids, timeout=None): + self._request('queue-move-bottom', ids = ids, require_ids = True, timeout = timeout) + + def queue_up(self, ids, timeout = None): """Move transfer up in the queue.""" self._rpc_version_warning(14) - self._request('queue-move-up', ids=ids, require_ids=True, timeout=timeout) + self._request('queue-move-up', ids = ids, require_ids = True, timeout = timeout) - def queue_down(self, ids, timeout=None): + def queue_down(self, ids, timeout = None): """Move transfer down in the queue.""" self._rpc_version_warning(14) - self._request('queue-move-down', ids=ids, require_ids=True, timeout=timeout) + self._request('queue-move-down', ids = ids, require_ids = True, timeout = timeout) - def get_session(self, timeout=None): + def get_session(self, timeout = None): """Get session parameters""" - self._request('session-get', timeout=timeout) + self._request('session-get', timeout = timeout) self._update_server_version() return self.session - def set_session(self, timeout=None, **kwargs): + def set_session(self, timeout = None, **kwargs): """ Set session parameters. The parameters are: @@ -655,32 +796,31 @@ class Client(object): if key == 'encryption' and value not in ['required', 'preferred', 'tolerated']: raise ValueError('Invalid encryption value') argument = make_rpc_name(key) - (arg, val) = argument_value_convert('session-set' - , argument, value, self.rpc_version) + (arg, val) = argument_value_convert('session-set' , argument, value, self.rpc_version) args[arg] = val if len(args) > 0: - self._request('session-set', args, timeout=timeout) + self._request('session-set', args, timeout = timeout) - def blocklist_update(self, timeout=None): + def blocklist_update(self, timeout = None): """Update block list. Returns the size of the block list.""" self._rpc_version_warning(5) - result = self._request('blocklist-update', timeout=timeout) + result = self._request('blocklist-update', timeout = timeout) if 'blocklist-size' in result: return result['blocklist-size'] return None - def port_test(self, timeout=None): + def port_test(self, timeout = None): """ Tests to see if your incoming peer port is accessible from the outside world. """ self._rpc_version_warning(5) - result = self._request('port-test', timeout=timeout) + result = self._request('port-test', timeout = timeout) if 'port-is-open' in result: return result['port-is-open'] return None - def session_stats(self, timeout=None): + def session_stats(self, timeout = None): """Get session statistics""" - self._request('session-stats', timeout=timeout) + self._request('session-stats', timeout = timeout) return self.session diff --git a/libs/transmissionrpc/error.py b/libs/transmissionrpc/error.py index 9b50e00c..5e2c1e28 100755 --- a/libs/transmissionrpc/error.py +++ b/libs/transmissionrpc/error.py @@ -15,9 +15,9 @@ class TransmissionError(Exception): def __str__(self): if self.original: original_name = type(self.original).__name__ - return '%s Original exception: %s, "%s"' % (self.message, original_name, str(self.original)) + return '%s Original exception: %s, "%s"' % (self._message, original_name, str(self.original)) else: - return self.message + return self._message class HTTPHandlerError(Exception): """ diff --git a/libs/transmissionrpc/session.py b/libs/transmissionrpc/session.py index 3f71a2ae..532553cf 100755 --- a/libs/transmissionrpc/session.py +++ b/libs/transmissionrpc/session.py @@ -2,6 +2,8 @@ # Copyright (c) 2008-2011 Erik Svensson # Licensed under the MIT license. +from transmissionrpc.utils import Field + class Session(object): """ Session is a class holding the session data for a Transmission daemon. @@ -12,33 +14,95 @@ class Session(object): ``download-dir`` -> ``download_dir``. """ - def __init__(self, fields=None): - self.fields = {} + def __init__(self, client=None, fields=None): + self._client = client + self._fields = {} if fields is not None: - self.update(fields) - - def update(self, other): - """Update the session data from a session arguments dictionary""" - - fields = None - if isinstance(other, dict): - fields = other - elif isinstance(other, Session): - fields = other.fields - else: - raise ValueError('Cannot update with supplied data') - - for key, value in fields.iteritems(): - self.fields[key.replace('-', '_')] = value + self._update_fields(fields) def __getattr__(self, name): try: - return self.fields[name] + return self._fields[name].value except KeyError: raise AttributeError('No attribute %s' % name) def __str__(self): text = '' - for key in sorted(self.fields.keys()): - text += "% 32s: %s\n" % (key[-32:], self.fields[key]) + for key in sorted(self._fields.keys()): + text += "% 32s: %s\n" % (key[-32:], self._fields[key].value) return text + + def _update_fields(self, other): + """ + Update the session data from a Transmission JSON-RPC arguments dictionary + """ + fields = None + if isinstance(other, dict): + for key, value in other.iteritems(): + self._fields[key.replace('-', '_')] = Field(value, False) + elif isinstance(other, Session): + for key in other._fields.keys(): + self._fields[key] = Field(other._fields[key].value, False) + else: + raise ValueError('Cannot update with supplied data') + + def _dirty_fields(self): + """Enumerate changed fields""" + outgoing_keys = ['peer_port', 'pex_enabled'] + fields = [] + for key in outgoing_keys: + if key in self._fields and self._fields[key].dirty: + fields.append(key) + return fields + + def _push(self): + """Push changed fields to the server""" + dirty = self._dirty_fields() + args = {} + for key in dirty: + args[key] = self._fields[key].value + self._fields[key] = self._fields[key]._replace(dirty=False) + if len(args) > 0: + self._client.set_session(**args) + + def update(self, timeout=None): + """Update the session information.""" + self._push() + session = self._client.get_session(timeout=timeout) + self._update_fields(session) + session = self._client.session_stats(timeout=timeout) + self._update_fields(session) + + def from_request(self, data): + """Update the session information.""" + self._update_fields(data) + + def _get_peer_port(self): + """ + Get the peer port. + """ + return self._fields['peer_port'].value + + def _set_peer_port(self, port): + """ + Set the peer port. + """ + if isinstance(port, (int, long)): + self._fields['peer_port'] = Field(port, True) + self._push() + else: + raise ValueError("Not a valid limit") + + peer_port = property(_get_peer_port, _set_peer_port, None, "Peer port. This is a mutator.") + + def _get_pex_enabled(self): + return self._fields['pex_enabled'].value + + def _set_pex_enabled(self, enabled): + if isinstance(enabled, bool): + self._fields['pex_enabled'] = Field(enabled, True) + self._push() + else: + raise TypeError("Not a valid type") + + pex_enabled = property(_get_pex_enabled, _set_pex_enabled, None, "Enable PEX. This is a mutator.") diff --git a/libs/transmissionrpc/torrent.py b/libs/transmissionrpc/torrent.py index 357d0a19..05008784 100755 --- a/libs/transmissionrpc/torrent.py +++ b/libs/transmissionrpc/torrent.py @@ -4,8 +4,8 @@ import sys, datetime -from transmissionrpc.constants import PRIORITY -from transmissionrpc.utils import format_timedelta +from transmissionrpc.constants import PRIORITY, RATIO_LIMIT, IDLE_LIMIT +from transmissionrpc.utils import Field, format_timedelta class Torrent(object): """ @@ -17,17 +17,19 @@ class Torrent(object): def __init__(self, client, fields): if 'id' not in fields: raise ValueError('Torrent requires an id') - self.fields = {} - self.update(fields) - self.client = client + self._fields = {} + self._update_fields(fields) + self._incoming_pending= False + self._outgoing_pending= False + self._client = client def _getNameString(self, codec=None): if codec is None: codec = sys.getdefaultencoding() name = None # try to find name - if 'name' in self.fields: - name = self.fields['name'] + if 'name' in self._fields: + name = self._fields['name'].value # if name is unicode, try to decode if isinstance(name, unicode): try: @@ -37,7 +39,7 @@ class Torrent(object): return name def __repr__(self): - tid = self.fields['id'] + tid = self._fields['id'].value name = self._getNameString() if isinstance(name, str): return '' % (tid, name) @@ -52,12 +54,53 @@ class Torrent(object): return 'Torrent' def __copy__(self): - return Torrent(self.client, self.fields) + return Torrent(self._client, self._fields) + + def __getattr__(self, name): + try: + return self._fields[name].value + except KeyError: + raise AttributeError('No attribute %s' % name) def _rpc_version(self): - if self.client: - return self.client.rpc_version + if self._client: + return self._client.rpc_version return 2 + + def _dirty_fields(self): + """Enumerate changed fields""" + outgoing_keys = ['bandwidthPriority', 'downloadLimit', 'downloadLimited', 'peer_limit', 'queuePosition' + , 'seedIdleLimit', 'seedIdleMode', 'seedRatioLimit', 'seedRatioMode', 'uploadLimit', 'uploadLimited'] + fields = [] + for key in outgoing_keys: + if key in self._fields and self._fields[key].dirty: + fields.append(key) + return fields + + def _push(self): + """Push changed fields to the server""" + dirty = self._dirty_fields() + args = {} + for key in dirty: + args[key] = self._fields[key].value + self._fields[key] = self._fields[key]._replace(dirty=False) + if len(args) > 0: + self._client.change_torrent(self.id, **args) + + def _update_fields(self, other): + """ + Update the torrent data from a Transmission JSON-RPC arguments dictionary + """ + fields = None + if isinstance(other, dict): + for key, value in other.iteritems(): + self._fields[key.replace('-', '_')] = Field(value, False) + elif isinstance(other, Torrent): + for key in other._fields.keys(): + self._fields[key] = Field(other._fields[key].value, False) + else: + raise ValueError('Cannot update with supplied data') + self._incoming_pending = False def _status_old(self, code): mapping = { @@ -82,26 +125,12 @@ class Torrent(object): return mapping[code] def _status(self): - code = self.fields['status'] + code = self._fields['status'].value if self._rpc_version() >= 14: return self._status_new(code) else: return self._status_old(code) - def update(self, other): - """ - Update the torrent data from a Transmission JSON-RPC arguments dictionary - """ - fields = None - if isinstance(other, dict): - fields = other - elif isinstance(other, Torrent): - fields = other.fields - else: - raise ValueError('Cannot update with supplied data') - for key, value in fields.iteritems(): - self.fields[key.replace('-', '_')] = value - def files(self): """ Get list of files for this torrent. @@ -122,11 +151,11 @@ class Torrent(object): } """ result = {} - if 'files' in self.fields: - indices = xrange(len(self.fields['files'])) - files = self.fields['files'] - priorities = self.fields['priorities'] - wanted = self.fields['wanted'] + if 'files' in self._fields: + files = self._fields['files'].value + indices = xrange(len(files)) + priorities = self._fields['priorities'].value + wanted = self._fields['wanted'].value for item in zip(indices, files, priorities, wanted): selected = True if item[3] else False priority = PRIORITY[item[2]] @@ -138,12 +167,6 @@ class Torrent(object): 'completed': item[1]['bytesCompleted']} return result - def __getattr__(self, name): - try: - return self.fields[name] - except KeyError: - raise AttributeError('No attribute %s' % name) - @property def status(self): """ @@ -157,19 +180,21 @@ class Torrent(object): def progress(self): """Get the download progress in percent.""" try: - return 100.0 * (self.fields['sizeWhenDone'] - self.fields['leftUntilDone']) / float(self.fields['sizeWhenDone']) + size = self._fields['sizeWhenDone'].value + left = self._fields['leftUntilDone'].value + return 100.0 * (size - left) / float(size) except ZeroDivisionError: return 0.0 @property def ratio(self): """Get the upload/download ratio.""" - return float(self.fields['uploadRatio']) + return float(self._fields['uploadRatio'].value) @property def eta(self): """Get the "eta" as datetime.timedelta.""" - eta = self.fields['eta'] + eta = self._fields['eta'].value if eta >= 0: return datetime.timedelta(seconds=eta) else: @@ -178,22 +203,22 @@ class Torrent(object): @property def date_active(self): """Get the attribute "activityDate" as datetime.datetime.""" - return datetime.datetime.fromtimestamp(self.fields['activityDate']) + return datetime.datetime.fromtimestamp(self._fields['activityDate'].value) @property def date_added(self): """Get the attribute "addedDate" as datetime.datetime.""" - return datetime.datetime.fromtimestamp(self.fields['addedDate']) + return datetime.datetime.fromtimestamp(self._fields['addedDate'].value) @property def date_started(self): """Get the attribute "startDate" as datetime.datetime.""" - return datetime.datetime.fromtimestamp(self.fields['startDate']) + return datetime.datetime.fromtimestamp(self._fields['startDate'].value) @property def date_done(self): """Get the attribute "doneDate" as datetime.datetime.""" - return datetime.datetime.fromtimestamp(self.fields['doneDate']) + return datetime.datetime.fromtimestamp(self._fields['doneDate'].value) def format_eta(self): """ @@ -203,7 +228,7 @@ class Torrent(object): * If eta is -2 the result is 'unknown' * Otherwise eta is formatted as ::. """ - eta = self.fields['eta'] + eta = self._fields['eta'].value if eta == -1: return 'not available' elif eta == -2: @@ -211,10 +236,233 @@ class Torrent(object): else: return format_timedelta(self.eta) - @property - def priority(self): + def _get_download_limit(self): + """ + Get the download limit. + Can be a number or None. + """ + if self._fields['downloadLimited'].value: + return self._fields['downloadLimit'].value + else: + return None + + def _set_download_limit(self, limit): + """ + Get the download limit. + Can be a number, 'session' or None. + """ + if isinstance(limit, (int, long)): + self._fields['downloadLimited'] = Field(True, True) + self._fields['downloadLimit'] = Field(limit, True) + self._push() + elif limit == None: + self._fields['downloadLimited'] = Field(False, True) + self._push() + else: + raise ValueError("Not a valid limit") + + download_limit = property(_get_download_limit, _set_download_limit, None, "Download limit in Kbps or None. This is a mutator.") + + def _get_peer_limit(self): + """ + Get the peer limit. + """ + return self._fields['peer_limit'].value + + def _set_peer_limit(self, limit): + """ + Set the peer limit. + """ + if isinstance(limit, (int, long)): + self._fields['peer_limit'] = Field(limit, True) + self._push() + else: + raise ValueError("Not a valid limit") + + peer_limit = property(_get_peer_limit, _set_peer_limit, None, "Peer limit. This is a mutator.") + + def _get_priority(self): """ Get the priority as string. Can be one of 'low', 'normal', 'high'. """ - return PRIORITY[self.fields['bandwidthPriority']] \ No newline at end of file + return PRIORITY[self._fields['bandwidthPriority'].value] + + def _set_priority(self, priority): + """ + Set the priority as string. + Can be one of 'low', 'normal', 'high'. + """ + if isinstance(priority, (str, unicode)): + self._fields['bandwidthPriority'] = Field(PRIORITY[priority], True) + self._push() + + priority = property(_get_priority, _set_priority, None + , "Bandwidth priority as string. Can be one of 'low', 'normal', 'high'. This is a mutator.") + + def _get_seed_idle_limit(self): + """ + Get the seed idle limit in minutes. + """ + return self._fields['seedIdleLimit'].value + + def _set_seed_idle_limit(self, limit): + """ + Set the seed idle limit in minutes. + """ + if isinstance(limit, (int, long)): + self._fields['seedIdleLimit'] = Field(limit, True) + self._push() + else: + raise ValueError("Not a valid limit") + + seed_idle_limit = property(_get_seed_idle_limit, _set_seed_idle_limit, None + , "Torrent seed idle limit in minutes. Also see seed_idle_mode. This is a mutator.") + + def _get_seed_idle_mode(self): + """ + Get the seed ratio mode as string. Can be one of 'global', 'single' or 'unlimited'. + """ + return IDLE_LIMIT[self._fields['seedIdleMode'].value] + + def _set_seed_idle_mode(self, mode): + """ + Set the seed ratio mode as string. Can be one of 'global', 'single' or 'unlimited'. + """ + if isinstance(mode, str): + self._fields['seedIdleMode'] = Field(IDLE_LIMIT[mode], True) + self._push() + else: + raise ValueError("Not a valid limit") + + seed_idle_mode = property(_get_seed_idle_mode, _set_seed_idle_mode, None, + """ + Seed idle mode as string. Can be one of 'global', 'single' or 'unlimited'. + + * global, use session seed idle limit. + * single, use torrent seed idle limit. See seed_idle_limit. + * unlimited, no seed idle limit. + + This is a mutator. + """ + ) + + def _get_seed_ratio_limit(self): + """ + Get the seed ratio limit as float. + """ + return float(self._fields['seedRatioLimit'].value) + + def _set_seed_ratio_limit(self, limit): + """ + Set the seed ratio limit as float. + """ + if isinstance(limit, (int, long, float)) and limit >= 0.0: + self._fields['seedRatioLimit'] = Field(float(limit), True) + self._push() + else: + raise ValueError("Not a valid limit") + + seed_ratio_limit = property(_get_seed_ratio_limit, _set_seed_ratio_limit, None + , "Torrent seed ratio limit as float. Also see seed_ratio_mode. This is a mutator.") + + def _get_seed_ratio_mode(self): + """ + Get the seed ratio mode as string. Can be one of 'global', 'single' or 'unlimited'. + """ + return RATIO_LIMIT[self._fields['seedRatioMode'].value] + + def _set_seed_ratio_mode(self, mode): + """ + Set the seed ratio mode as string. Can be one of 'global', 'single' or 'unlimited'. + """ + if isinstance(mode, str): + self._fields['seedRatioMode'] = Field(RATIO_LIMIT[mode], True) + self._push() + else: + raise ValueError("Not a valid limit") + + seed_ratio_mode = property(_get_seed_ratio_mode, _set_seed_ratio_mode, None, + """ + Seed ratio mode as string. Can be one of 'global', 'single' or 'unlimited'. + + * global, use session seed ratio limit. + * single, use torrent seed ratio limit. See seed_ratio_limit. + * unlimited, no seed ratio limit. + + This is a mutator. + """ + ) + + def _get_upload_limit(self): + """ + Get the upload limit. + Can be a number or None. + """ + if self._fields['uploadLimited'].value: + return self._fields['uploadLimit'].value + else: + return None + + def _set_upload_limit(self, limit): + """ + Set the upload limit. + Can be a number, 'session' or None. + """ + if isinstance(limit, (int, long)): + self._fields['uploadLimited'] = Field(True, True) + self._fields['uploadLimit'] = Field(limit, True) + self._push() + elif limit == None: + self._fields['uploadLimited'] = Field(False, True) + self._push() + else: + raise ValueError("Not a valid limit") + + upload_limit = property(_get_upload_limit, _set_upload_limit, None, "Upload limit in Kbps or None. This is a mutator.") + + def _get_queue_position(self): + if self._rpc_version() >= 14: + return self._fields['queuePosition'].value + else: + return 0 + + def _set_queue_position(self, position): + if self._rpc_version() >= 14: + if isinstance(position, (int, long)): + self._fields['queuePosition'] = Field(position, True) + self._push() + else: + raise ValueError("Not a valid position") + else: + pass + + queue_position = property(_get_queue_position, _set_queue_position, None, "Queue position") + + def update(self, timeout=None): + """Update the torrent information.""" + self._push() + torrent = self._client.get_torrent(self.id, timeout=timeout) + self._update_fields(torrent) + + def start(self, bypass_queue=False, timeout=None): + """ + Start the torrent. + """ + self._incoming_pending = True + self._client.start_torrent(self.id, bypass_queue=bypass_queue, timeout=timeout) + + def stop(self, timeout=None): + """Stop the torrent.""" + self._incoming_pending = True + self._client.stop_torrent(self.id, timeout=timeout) + + def move_data(self, location, timeout=None): + """Move torrent data to location.""" + self._incoming_pending = True + self._client.move_torrent_data(self.id, location, timeout=timeout) + + def locate_data(self, location, timeout=None): + """Locate torrent data at location.""" + self._incoming_pending = True + self._client.locate_torrent_data(self.id, location, timeout=timeout) diff --git a/libs/transmissionrpc/utils.py b/libs/transmissionrpc/utils.py index 8a74c11d..59f207a6 100755 --- a/libs/transmissionrpc/utils.py +++ b/libs/transmissionrpc/utils.py @@ -3,6 +3,7 @@ # Licensed under the MIT license. import socket, datetime, logging +from collections import namedtuple import transmissionrpc.constants as constants from transmissionrpc.constants import LOGGER @@ -186,3 +187,5 @@ def add_stdout_logger(level='debug'): trpc_logger.setLevel(loglevel) loghandler.setLevel(loglevel) trpc_logger.addHandler(loghandler) + +Field = namedtuple('Field', ['value', 'dirty']) \ No newline at end of file