From b1759bc440cd6013837697eb8de540914f693ffd Mon Sep 17 00:00:00 2001 From: Walter Purcaro Date: Tue, 7 Jul 2015 01:23:55 +0200 Subject: No camelCase style anymore --- module/plugins/internal/Account.py | 108 ++++++++++-------- module/plugins/internal/AdYouLike.py | 10 +- module/plugins/internal/AdsCaptcha.py | 10 +- module/plugins/internal/Captcha.py | 2 +- module/plugins/internal/Container.py | 2 +- module/plugins/internal/Crypter.py | 12 +- module/plugins/internal/DeadCrypter.py | 6 +- module/plugins/internal/DeadHoster.py | 6 +- module/plugins/internal/Extractor.py | 14 +-- module/plugins/internal/Hook.py | 60 +++++----- module/plugins/internal/Hoster.py | 138 +++++++++++------------ module/plugins/internal/MultiHook.py | 68 +++++------ module/plugins/internal/MultiHoster.py | 58 +++++----- module/plugins/internal/OCR.py | 4 +- module/plugins/internal/Plugin.py | 58 ++++++---- module/plugins/internal/ReCaptcha.py | 40 +++---- module/plugins/internal/SevenZip.py | 8 +- module/plugins/internal/SimpleCrypter.py | 42 +++---- module/plugins/internal/SimpleHoster.py | 188 +++++++++++++++---------------- module/plugins/internal/SolveMedia.py | 18 +-- module/plugins/internal/UnRar.py | 12 +- module/plugins/internal/UnZip.py | 4 +- module/plugins/internal/XFSAccount.py | 28 ++--- module/plugins/internal/XFSCrypter.py | 2 +- module/plugins/internal/XFSHoster.py | 70 ++++++------ 25 files changed, 498 insertions(+), 470 deletions(-) (limited to 'module/plugins/internal') diff --git a/module/plugins/internal/Account.py b/module/plugins/internal/Account.py index d2efe7996..9e0efaee6 100644 --- a/module/plugins/internal/Account.py +++ b/module/plugins/internal/Account.py @@ -16,7 +16,7 @@ class WrongPassword(Exception): class Account(Plugin): __name__ = "Account" __type__ = "account" - __version__ = "0.03" + __version__ = "0.04" __description__ = """Base account plugin""" __license__ = "GPLv3" @@ -37,7 +37,7 @@ class Account(Plugin): self.init() - self.setAccounts(accounts) + self.set_accounts(accounts) def init(self): @@ -60,18 +60,18 @@ class Account(Plugin): #: set timestamp for login self.timestamps[user] = time.time() - req = self.getAccountRequest(user) + req = self.get_account_request(user) try: self.login(user, data, req) except WrongPassword: - self.logWarning( + self.log_warning( _("Could not login with account %(user)s | %(msg)s") % {"user": user, "msg": _("Wrong Password")}) success = data['valid'] = False except Exception, e: - self.logWarning( + self.log_warning( _("Could not login with account %(user)s | %(msg)s") % {"user": user, "msg": e}) success = data['valid'] = False @@ -88,7 +88,7 @@ class Account(Plugin): def relogin(self, user): - req = self.getAccountRequest(user) + req = self.get_account_request(user) if req: req.cj.clear() req.close() @@ -98,14 +98,14 @@ class Account(Plugin): return self._login(user, self.accounts[user]) - def setAccounts(self, accounts): + def set_accounts(self, accounts): self.accounts = accounts for user, data in self.accounts.iteritems(): self._login(user, data) self.infos[user] = {} - def updateAccounts(self, user, password=None, options={}): + def update_accounts(self, user, password=None, options={}): """ Updates account and return true if anything changed """ @@ -125,7 +125,12 @@ class Account(Plugin): return True - def removeAccount(self, user): + #: Deprecated method, use `update_accounts` instead + def updateAccounts(self, *args, **kwargs): + return self.update_accounts(*args, **kwargs) + + + def remove_account(self, user): if user in self.accounts: del self.accounts[user] if user in self.infos: @@ -134,28 +139,33 @@ class Account(Plugin): del self.timestamps[user] + #: Deprecated method, use `remove_account` instead + def removeAccount(self, *args, **kwargs): + return self.remove_account(*args, **kwargs) + + @lock - def getAccountInfo(self, name, force=False): + def get_account_info(self, name, force=False): """ Retrieve account infos for an user, do **not** overwrite this method!\\ - just use it to retrieve infos in hoster plugins. see `loadAccountInfo` + just use it to retrieve infos in hoster plugins. see `load_account_info` :param name: username :param force: reloads cached account information :return: dictionary with information """ - data = Account.loadAccountInfo(self, name) + data = Account.load_account_info(self, name) if force or name not in self.infos: - self.logDebug("Get Account Info for %s" % name) - req = self.getAccountRequest(name) + self.log_debug("Get Account Info for %s" % name) + req = self.get_account_request(name) try: - infos = self.loadAccountInfo(name, req) + infos = self.load_account_info(name, req) if not type(infos) == dict: raise Exception("Wrong return format") except Exception, e: - infos = super(self.__class__, self).loadAccountInfo(name, req) + infos = super(self.__class__, self).load_account_info(name, req) infos['error'] = str(e) if self.core.debug: @@ -164,24 +174,24 @@ class Account(Plugin): if req: req.close() - self.logDebug("Account Info: %s" % infos) + self.log_debug("Account Info: %s" % infos) infos['timestamp'] = time.time() self.infos[name] = infos elif "timestamp" in self.infos[name] and self.infos[name]['timestamp'] + self.info_threshold * 60 < time.time(): - self.logDebug("Reached timeout for account data") - self.scheduleRefresh(name) + self.log_debug("Reached timeout for account data") + self.schedule_refresh(name) data.update(self.infos[name]) return data - def isPremium(self, user): - info = self.getAccountInfo(user) + def is_premium(self, user): + info = self.get_account_info(user) return info['premium'] - def loadAccountInfo(self, name, req=None): + def load_account_info(self, name, req=None): """ This should be overwritten in account plugin,\ and retrieving account information for user @@ -202,20 +212,25 @@ class Account(Plugin): "type" : self.__name__} - def getAllAccounts(self, force=False): - return [self.getAccountInfo(user, force) for user, data in self.accounts.iteritems()] + def get_all_accounts(self, force=False): + return [self.get_account_info(user, force) for user, data in self.accounts.iteritems()] - def getAccountRequest(self, user=None): + #: Deprecated method, use `get_all_accounts` instead + def getAllAccounts(self, *args, **kwargs): + return self.get_all_accounts(*args, **kwargs) + + + def get_account_request(self, user=None): if not user: - user, data = self.selectAccount() + user, data = self.select_account() return self.core.requestFactory.getRequest(self.__name__, user) - def getAccountCookies(self, user=None): + def get_account_cookies(self, user=None): if not user: - user, data = self.selectAccount() + user, data = self.select_account() if not user: return None @@ -223,11 +238,11 @@ class Account(Plugin): return cj - def getAccountData(self, user): + def get_account_data(self, user): return self.accounts[user] - def selectAccount(self): + def select_account(self): """ Returns an valid account name and data """ @@ -244,7 +259,7 @@ class Account(Plugin): if not compare_time(start.split(":"), end.split(":")): continue except Exception: - self.logWarning(_("Your Time %s has wrong format, use: 1:22-3:44") % time_data) + self.log_warning(_("Your Time %s has wrong format, use: 1:22-3:44") % time_data) if user in self.infos: if "validuntil" in self.infos[user]: @@ -262,52 +277,57 @@ class Account(Plugin): return random.choice(usable) - def canUse(self): - return self.selectAccount() != (None, None) + def can_use(self): + return self.select_account() != (None, None) - def parseTraffic(self, value, unit=None): #: return kilobytes + def parse_traffic(self, value, unit=None): #: return kilobytes if not unit and not isinstance(value, basestring): unit = "KB" return parseFileSize(value, unit) - def wrongPassword(self): + def wrong_password(self): raise WrongPassword def empty(self, user): if user in self.infos: - self.logWarning(_("Account %s has not enough traffic, checking again in 30min") % user) + self.log_warning(_("Account %s has not enough traffic, checking again in 30min") % user) self.infos[user].update({"trafficleft": 0}) - self.scheduleRefresh(user, 30 * 60) + self.schedule_refresh(user, 30 * 60) def expired(self, user): if user in self.infos: - self.logWarning(_("Account %s is expired, checking again in 1h") % user) + self.log_warning(_("Account %s is expired, checking again in 1h") % user) self.infos[user].update({"validuntil": time.time() - 1}) - self.scheduleRefresh(user, 60 * 60) + self.schedule_refresh(user, 60 * 60) - def scheduleRefresh(self, user, time=0, force=True): + def schedule_refresh(self, user, time=0, force=True): """ Add task to refresh account info to sheduler """ - self.logDebug("Scheduled Account refresh for %s in %s seconds." % (user, time)) - self.core.scheduler.addJob(time, self.getAccountInfo, [user, force]) + self.log_debug("Scheduled Account refresh for %s in %s seconds." % (user, time)) + self.core.scheduler.addJob(time, self.get_account_info, [user, force]) + + + #: Deprecated method, use `schedule_refresh` instead + def scheduleRefresh(self, *args, **kwargs): + return self.schedule_refresh(*args, **kwargs) @lock - def checkLogin(self, user): + def check_login(self, user): """ Checks if user is still logged in """ if user in self.timestamps: if self.login_timeout > 0 and self.timestamps[user] + self.login_timeout * 60 < time.time(): - self.logDebug("Reached login timeout for %s" % user) + self.log_debug("Reached login timeout for %s" % user) return self.relogin(user) else: return True diff --git a/module/plugins/internal/AdYouLike.py b/module/plugins/internal/AdYouLike.py index f623ed268..07e7e4d17 100644 --- a/module/plugins/internal/AdYouLike.py +++ b/module/plugins/internal/AdYouLike.py @@ -9,7 +9,7 @@ from module.plugins.internal.Captcha import Captcha class AdYouLike(Captcha): __name__ = "AdYouLike" __type__ = "captcha" - __version__ = "0.06" + __version__ = "0.07" __description__ = """AdYouLike captcha service plugin""" __license__ = "GPLv3" @@ -27,10 +27,10 @@ class AdYouLike(Captcha): n = re.search(self.CALLBACK_PATTERN, html) if m and n: self.key = (m.group(1).strip(), n.group(1).strip()) - self.logDebug("Ayl: %s | Callback: %s" % self.key) + self.log_debug("Ayl: %s | Callback: %s" % self.key) return self.key #: key is the tuple(ayl, callback) else: - self.logWarning("Ayl or callback pattern not found") + self.log_warning("Ayl or callback pattern not found") return None @@ -51,7 +51,7 @@ class AdYouLike(Captcha): except AttributeError: self.fail(_("AdYouLike challenge pattern not found")) - self.logDebug("Challenge: %s" % challenge) + self.log_debug("Challenge: %s" % challenge) return self.result(ayl, challenge), challenge @@ -86,6 +86,6 @@ class AdYouLike(Captcha): '_ayl_token_challenge': challenge['token'], '_ayl_response' : response} - self.logDebug("Result: %s" % result) + self.log_debug("Result: %s" % result) return result diff --git a/module/plugins/internal/AdsCaptcha.py b/module/plugins/internal/AdsCaptcha.py index e058352dd..b45a6dfda 100644 --- a/module/plugins/internal/AdsCaptcha.py +++ b/module/plugins/internal/AdsCaptcha.py @@ -9,7 +9,7 @@ from module.plugins.internal.Captcha import Captcha class AdsCaptcha(Captcha): __name__ = "AdsCaptcha" __type__ = "captcha" - __version__ = "0.09" + __version__ = "0.10" __description__ = """AdsCaptcha captcha service plugin""" __license__ = "GPLv3" @@ -27,10 +27,10 @@ class AdsCaptcha(Captcha): n = re.search(self.CAPTCHAID_PATTERN, html) if m and n: self.key = (m.group(1).strip(), n.group(1).strip()) #: key is the tuple(PublicKey, CaptchaId) - self.logDebug("Key: %s | ID: %s" % self.key) + self.log_debug("Key: %s | ID: %s" % self.key) return self.key else: - self.logWarning("Key or id pattern not found") + self.log_warning("Key or id pattern not found") return None @@ -47,7 +47,7 @@ class AdsCaptcha(Captcha): except AttributeError: self.fail(_("AdsCaptcha challenge pattern not found")) - self.logDebug("Challenge: %s" % challenge) + self.log_debug("Challenge: %s" % challenge) return self.result(server, challenge), challenge @@ -58,6 +58,6 @@ class AdsCaptcha(Captcha): cookies=True, imgtype="jpg") - self.logDebug("Result: %s" % result) + self.log_debug("Result: %s" % result) return result diff --git a/module/plugins/internal/Captcha.py b/module/plugins/internal/Captcha.py index 4629c9522..50ebea89c 100644 --- a/module/plugins/internal/Captcha.py +++ b/module/plugins/internal/Captcha.py @@ -6,7 +6,7 @@ from module.plugins.internal.Plugin import Plugin class Captcha(Plugin): __name__ = "Captcha" __type__ = "captcha" - __version__ = "0.30" + __version__ = "0.31" __description__ = """Base captcha service plugin""" __license__ = "GPLv3" diff --git a/module/plugins/internal/Container.py b/module/plugins/internal/Container.py index fc1a93606..91b5a6f76 100644 --- a/module/plugins/internal/Container.py +++ b/module/plugins/internal/Container.py @@ -12,7 +12,7 @@ from module.utils import save_join as fs_join class Container(Crypter): __name__ = "Container" __type__ = "container" - __version__ = "0.04" + __version__ = "0.05" __pattern__ = r'^unmatchable$' __config__ = [] #: [("name", "type", "desc", "default")] diff --git a/module/plugins/internal/Crypter.py b/module/plugins/internal/Crypter.py index d8cda17d4..f6d3528fd 100644 --- a/module/plugins/internal/Crypter.py +++ b/module/plugins/internal/Crypter.py @@ -9,7 +9,7 @@ from module.utils import save_path as safe_filename class Crypter(Hoster): __name__ = "Crypter" __type__ = "crypter" - __version__ = "0.04" + __version__ = "0.05" __pattern__ = r'^unmatchable$' __config__ = [("use_subfolder", "bool", "Save package to subfolder", True), #: Overrides core.config.get("general", "folder_per_package") @@ -69,11 +69,11 @@ class Crypter(Hoster): package_queue = self.pyfile.package().queue folder_per_package = self.core.config.get("general", "folder_per_package") - use_subfolder = self.getConfig('use_subfolder', folder_per_package) - subfolder_per_package = self.getConfig('subfolder_per_package', True) + use_subfolder = self.get_config('use_subfolder', folder_per_package) + subfolder_per_package = self.get_config('subfolder_per_package', True) for name, links, folder in self.packages: - self.logDebug("Parsed package: %s" % name, + self.log_debug("Parsed package: %s" % name, "%d links" % len(links), "Saved to folder: %s" % folder if folder else "Saved to download folder") @@ -88,14 +88,14 @@ class Crypter(Hoster): if use_subfolder: if not subfolder_per_package: setFolder(package_folder) - self.logDebug("Set package %(name)s folder to: %(folder)s" % {"name": name, "folder": folder}) + self.log_debug("Set package %(name)s folder to: %(folder)s" % {"name": name, "folder": folder}) elif not folder_per_package or name != folder: if not folder: folder = urlparse.urlparse(name).path.split("/")[-1] setFolder(safe_filename(folder)) - self.logDebug("Set package %(name)s folder to: %(folder)s" % {"name": name, "folder": folder}) + self.log_debug("Set package %(name)s folder to: %(folder)s" % {"name": name, "folder": folder}) elif folder_per_package: setFolder(None) diff --git a/module/plugins/internal/DeadCrypter.py b/module/plugins/internal/DeadCrypter.py index ef0d12b91..d79551b52 100644 --- a/module/plugins/internal/DeadCrypter.py +++ b/module/plugins/internal/DeadCrypter.py @@ -7,7 +7,7 @@ from module.plugins.internal.SimpleCrypter import create_getInfo class DeadCrypter(Crypter): __name__ = "DeadCrypter" __type__ = "crypter" - __version__ = "0.06" + __version__ = "0.07" __pattern__ = r'^unmatchable$' @@ -17,8 +17,8 @@ class DeadCrypter(Crypter): @classmethod - def apiInfo(cls, *args, **kwargs): - api = super(DeadCrypter, cls).apiInfo(*args, **kwargs) + def api_info(cls, *args, **kwargs): + api = super(DeadCrypter, cls).api_info(*args, **kwargs) api['status'] = 1 return api diff --git a/module/plugins/internal/DeadHoster.py b/module/plugins/internal/DeadHoster.py index accb15a78..86f4381a3 100644 --- a/module/plugins/internal/DeadHoster.py +++ b/module/plugins/internal/DeadHoster.py @@ -7,7 +7,7 @@ from module.plugins.internal.SimpleHoster import create_getInfo class DeadHoster(Hoster): __name__ = "DeadHoster" __type__ = "hoster" - __version__ = "0.16" + __version__ = "0.17" __pattern__ = r'^unmatchable$' @@ -17,8 +17,8 @@ class DeadHoster(Hoster): @classmethod - def apiInfo(cls, *args, **kwargs): - api = super(DeadHoster, cls).apiInfo(*args, **kwargs) + def api_info(cls, *args, **kwargs): + api = super(DeadHoster, cls).api_info(*args, **kwargs) api['status'] = 1 return api diff --git a/module/plugins/internal/Extractor.py b/module/plugins/internal/Extractor.py index f73388d8c..60d8b3b3b 100644 --- a/module/plugins/internal/Extractor.py +++ b/module/plugins/internal/Extractor.py @@ -22,7 +22,7 @@ class PasswordError(Exception): class Extractor(Plugin): __name__ = "Extractor" __type__ = "extractor" - __version__ = "0.24" + __version__ = "0.25" __description__ = """Base extractor plugin""" __license__ = "GPLv3" @@ -36,18 +36,18 @@ class Extractor(Plugin): @classmethod - def isArchive(cls, filename): + def is_archive(cls, filename): name = os.path.basename(filename).lower() return any(name.endswith(ext) for ext in cls.EXTENSIONS) @classmethod - def isMultipart(cls, filename): + def is_multipart(cls, filename): return False @classmethod - def isUsable(cls): + def is_usable(cls): """ Check if system statisfy dependencies :return: boolean @@ -56,7 +56,7 @@ class Extractor(Plugin): @classmethod - def getTargets(cls, files_ids): + def get_targets(cls, files_ids): """ Filter suited targets from list of filename id tuple list :param files_ids: List of filepathes @@ -97,7 +97,7 @@ class Extractor(Plugin): self.files = [] #: Store extracted files here pyfile = self.manager.core.files.getFile(fid) if fid else None - self.notifyProgress = lambda x: pyfile.setProgress(x) if pyfile else lambda x: None + self.notify_progress = lambda x: pyfile.setProgress(x) if pyfile else lambda x: None def init(self): @@ -149,7 +149,7 @@ class Extractor(Plugin): raise NotImplementedError - def getDeleteFiles(self): + def get_delete_files(self): """ Return list of files to delete, do *not* delete them here. diff --git a/module/plugins/internal/Hook.py b/module/plugins/internal/Hook.py index 5959089b5..7ef8f0189 100644 --- a/module/plugins/internal/Hook.py +++ b/module/plugins/internal/Hook.py @@ -25,7 +25,7 @@ def threaded(fn): class Hook(Plugin): __name__ = "Hook" __type__ = "hook" - __version__ = "0.08" + __version__ = "0.09" __config__ = [] #: [("name", "type", "desc", "default")] __threaded__ = [] #@TODO: Remove in 0.4.10 @@ -72,7 +72,7 @@ class Hook(Plugin): self.event_map = None if self.event_list: - self.logDebug("Deprecated method `event_list`, use `event_map` instead") + self.log_debug("Deprecated method `event_list`, use `event_map` instead") for f in self.event_list: self.manager.addEvent(f, getattr(self, f)) @@ -85,8 +85,8 @@ class Hook(Plugin): #: Deprecated method, use `init_periodical` instead - def initPeriodical(self): - return self.init_periodical() + def initPeriodical(self, *args, **kwargs): + return self.init_periodical(*args, **kwargs) def _periodical(self, threaded): @@ -98,7 +98,7 @@ class Hook(Plugin): self.periodical() except Exception, e: - self.logError(_("Error executing hook: %s") % e) + self.log_error(_("Error executing hook: %s") % e) if self.core.debug: traceback.print_exc() @@ -124,12 +124,12 @@ class Hook(Plugin): """ Checks if hook is activated """ - return self.getConfig("activated") + return self.get_config("activated") #: Deprecated method, use `is_activated` instead - def isActivated(self): - return self.is_activated() + def isActivated(self, *args, **kwargs): + return self.is_activated(*args, **kwargs) def deactivate(self): @@ -140,8 +140,8 @@ class Hook(Plugin): #: Deprecated method, use `deactivate` instead - def unload(self): - return self.deactivate() + def unload(self, *args, **kwargs): + return self.deactivate(*args, **kwargs) def activate(self): @@ -152,8 +152,8 @@ class Hook(Plugin): #: Deprecated method, use `activate` instead - def coreReady(self): - return self.activate() + def coreReady(self, *args, **kwargs): + return self.activate(*args, **kwargs) def exit(self): @@ -164,8 +164,8 @@ class Hook(Plugin): #: Deprecated method, use `exit` instead - def coreExiting(self): - return self.exit() + def coreExiting(self, *args, **kwargs): + return self.exit(*args, **kwargs) def download_preparing(self, pyfile): @@ -173,8 +173,8 @@ class Hook(Plugin): #: Deprecated method, use `download_preparing` instead - def downloadPreparing(self, pyfile): - return self.download_preparing(pyfile) + def downloadPreparing(self, *args, **kwargs): + return self.download_preparing(*args, **kwargs) def download_finished(self, pyfile): @@ -182,8 +182,8 @@ class Hook(Plugin): #: Deprecated method, use `download_finished` instead - def downloadFinished(self, pyfile): - return self.download_finished(pyfile) + def downloadFinished(self, *args, **kwargs): + return self.download_finished(*args, **kwargs) def download_failed(self, pyfile): @@ -191,8 +191,8 @@ class Hook(Plugin): #: Deprecated method, use `download_failed` instead - def downloadFailed(self, pyfile): - return self.download_failed(pyfile) + def downloadFailed(self, *args, **kwargs): + return self.download_failed(*args, **kwargs) def package_finished(self, pypack): @@ -200,8 +200,8 @@ class Hook(Plugin): #: Deprecated method, use `package_finished` instead - def packageFinished(self, pypack): - return self.package_finished(pypack) + def packageFinished(self, *args, **kwargs): + return self.package_finished(*args, **kwargs) def before_reconnect(self, ip): @@ -209,8 +209,8 @@ class Hook(Plugin): #: Deprecated method, use `before_reconnect` instead - def beforeReconnecting(self, ip): - return self.before_reconnect(ip) + def beforeReconnecting(self, *args, **kwargs): + return self.before_reconnect(*args, **kwargs) def after_reconnect(self, ip, oldip): @@ -230,8 +230,8 @@ class Hook(Plugin): #: Deprecated method, use `captcha_task` instead - def newCaptchaTask(self, task): - return self.captcha_task(task) + def newCaptchaTask(self, *args, **kwargs): + return self.captcha_task(*args, **kwargs) def captcha_correct(self, task): @@ -239,8 +239,8 @@ class Hook(Plugin): #: Deprecated method, use `captcha_correct` instead - def captchaCorrect(self, task): - return self.captcha_correct(task) + def captchaCorrect(self, *args, **kwargs): + return self.captcha_correct(*args, **kwargs) def captcha_invalid(self, task): @@ -248,5 +248,5 @@ class Hook(Plugin): #: Deprecated method, use `captcha_invalid` instead - def captchaInvalid(self, task): - return self.captcha_invalid(task) + def captchaInvalid(self, *args, **kwargs): + return self.captcha_invalid(*args, **kwargs) diff --git a/module/plugins/internal/Hoster.py b/module/plugins/internal/Hoster.py index 92cb476ea..09672f6f0 100644 --- a/module/plugins/internal/Hoster.py +++ b/module/plugins/internal/Hoster.py @@ -16,15 +16,15 @@ from module.plugins.internal.Plugin import Plugin, Abort, Fail, Reconnect, Retry from module.utils import fs_decode, fs_encode, save_join as fs_join -def getInfo(urls): - #result = [ .. (name, size, status, url) .. ] +def get_info(urls): + # result = [ .. (name, size, status, url) .. ] pass class Hoster(Plugin): __name__ = "Hoster" __type__ = "hoster" - __version__ = "0.03" + __version__ = "0.04" __pattern__ = r'^unmatchable$' __config__ = [] #: [("name", "type", "desc", "default")] @@ -41,18 +41,18 @@ class Hoster(Plugin): super(Hoster, self).__init__(pyfile.m.core) #: engage wan reconnection - self.wantReconnect = False + self.want_reconnect = False #: enable simultaneous processing of multiple downloads - self.multiDL = True - self.limitDL = 0 + self.multi_dl = True + self.limit_dl = 0 #: chunk limit - self.chunkLimit = 1 - self.resumeDownload = False + self.chunk_limit = 1 + self.resume_download = False #: time.time() + wait in seconds - self.waitUntil = 0 + self.wait_until = 0 self.waiting = False #: captcha reader instance @@ -75,10 +75,10 @@ class Hoster(Plugin): #: Browser instance, see `network.Browser` self.req = self.account.getAccountRequest(self.user) - self.chunkLimit = -1 #: chunk limit, -1 for unlimited + self.chunk_limit = -1 #: chunk limit, -1 for unlimited #: enables resume (will be ignored if server dont accept chunks) - self.resumeDownload = True + self.resume_download = True #: premium status self.premium = self.account.isPremium(self.user) @@ -91,16 +91,16 @@ class Hoster(Plugin): self.thread = None #: holds thread in future #: location where the last call to download was saved - self.lastDownload = "" + self.last_download = "" #: re match of the last call to `checkDownload` - self.lastCheck = None + self.last_check = None #: js engine, see `JsEngine` self.js = self.core.js #: captcha task - self.cTask = None + self.c_task = None #: some plugins store html code here self.html = None @@ -150,13 +150,13 @@ class Hoster(Plugin): raise NotImplementedError - def getChunkCount(self): - if self.chunkLimit <= 0: + def get_chunk_count(self): + if self.chunk_limit <= 0: return self.core.config.get("download", "chunks") - return min(self.core.config.get("download", "chunks"), self.chunkLimit) + return min(self.core.config.get("download", "chunks"), self.chunk_limit) - def resetAccount(self): + def reset_account(self): """ Don't use account and retry download """ @@ -165,13 +165,13 @@ class Hoster(Plugin): self.retry() - def setReconnect(self, reconnect): + def set_reconnect(self, reconnect): reconnect = bool(reconnect) - self.logDebug("Set wantReconnect to: %s (previous: %s)" % (reconnect, self.wantReconnect)) - self.wantReconnect = reconnect + self.log_debug("Set wantReconnect to: %s (previous: %s)" % (reconnect, self.want_reconnect)) + self.want_reconnect = reconnect - def setWait(self, seconds, reconnect=None): + def set_wait(self, seconds, reconnect=None): """ Set a specific wait time later used with `wait` @@ -181,13 +181,13 @@ class Hoster(Plugin): wait_time = max(int(seconds), 1) wait_until = time.time() + wait_time + 1 - self.logDebug("Set waitUntil to: %f (previous: %f)" % (wait_until, self.pyfile.waitUntil), + self.log_debug("Set waitUntil to: %f (previous: %f)" % (wait_until, self.pyfile.waitUntil), "Wait: %d+1 seconds" % wait_time) self.pyfile.waitUntil = wait_until if reconnect is not None: - self.setReconnect(reconnect) + self.set_reconnect(reconnect) def wait(self, seconds=0, reconnect=None): @@ -197,21 +197,21 @@ class Hoster(Plugin): pyfile = self.pyfile if seconds > 0: - self.setWait(seconds) + self.set_wait(seconds) if reconnect is not None: - self.setReconnect(reconnect) + self.set_reconnect(reconnect) self.waiting = True status = pyfile.status pyfile.setStatus("waiting") - self.logInfo(_("Wait: %d seconds") % (pyfile.waitUntil - time.time()), - _("Reconnect: %s") % self.wantReconnect) + self.log_info(_("Wait: %d seconds") % (pyfile.waitUntil - time.time()), + _("Reconnect: %s") % self.want_reconnect) if self.account: - self.logDebug("Ignore reconnection due account logged") + self.log_debug("Ignore reconnection due account logged") while pyfile.waitUntil > time.time(): if pyfile.abort: @@ -227,7 +227,7 @@ class Hoster(Plugin): if self.thread.m.reconnecting.isSet(): self.waiting = False - self.wantReconnect = False + self.want_reconnect = False raise Reconnect time.sleep(1) @@ -262,7 +262,7 @@ class Hoster(Plugin): raise Fail("offline") - def tempOffline(self, reason=""): + def temp_offline(self, reason=""): """ Fail and indicates file ist temporary offline, the core may take consequences """ @@ -292,19 +292,19 @@ class Hoster(Plugin): raise Retry(reason) - def invalidCaptcha(self): - self.logError(_("Invalid captcha")) - if self.cTask: - self.cTask.invalid() + def invalid_captcha(self): + self.log_error(_("Invalid captcha")) + if self.c_task: + self.c_task.invalid() - def correctCaptcha(self): - self.logInfo(_("Correct captcha")) - if self.cTask: - self.cTask.correct() + def correct_captcha(self): + self.log_info(_("Correct captcha")) + if self.c_task: + self.c_task.correct() - def decryptCaptcha(self, url, get={}, post={}, cookies=False, forceUser=False, + def decrypt_captcha(self, url, get={}, post={}, cookies=False, forceUser=False, imgtype='jpg', result_type='textual'): """ Loads a captcha and decrypts it with ocr, plugin, user input @@ -345,7 +345,7 @@ class Hoster(Plugin): else: captchaManager = self.core.captchaManager task = captchaManager.newTask(img, imgtype, tmpCaptcha.name, result_type) - self.cTask = task + self.c_task = task captchaManager.handleCaptcha(task) while task.isWaiting(): @@ -364,7 +364,7 @@ class Hoster(Plugin): self.fail(_("No captcha result obtained in appropiate time by any of the plugins")) result = task.result - self.logDebug("Received captcha result: %s" % result) + self.log_debug("Received captcha result: %s" % result) if not self.core.debug: try: @@ -409,10 +409,10 @@ class Hoster(Plugin): self.fail(_("No url given")) if self.core.debug: - self.logDebug("Download url: " + url, *["%s=%s" % (key, val) for key, val in locals().iteritems() if key not in ("self", "url")]) + self.log_debug("Download url: " + url, *["%s=%s" % (key, val) for key, val in locals().iteritems() if key not in ("self", "url")]) - self.correctCaptcha() - self.checkForSameFiles() + self.correct_captcha() + self.check_for_same_files() self.pyfile.setStatus("downloading") @@ -445,7 +445,7 @@ class Hoster(Plugin): try: newname = self.req.httpDownload(url, filename, get=get, post=post, ref=ref, cookies=cookies, - chunks=self.getChunkCount(), resume=self.resumeDownload, + chunks=self.get_chunk_count(), resume=self.resume_download, progressNotify=self.pyfile.setProgress, disposition=disposition) finally: self.pyfile.size = self.req.size @@ -454,7 +454,7 @@ class Hoster(Plugin): newname = urlparse.urlparse(newname).path.split('/')[-1] if disposition and newname != name: - self.logInfo(_("%(name)s saved as %(newname)s") % {"name": name, "newname": newname}) + self.log_info(_("%(name)s saved as %(newname)s") % {"name": name, "newname": newname}) self.pyfile.name = newname filename = os.path.join(location, newname) @@ -464,7 +464,7 @@ class Hoster(Plugin): try: os.chmod(fs_filename, int(self.core.config.get("permission", "file"), 8)) except Exception, e: - self.logWarning(_("Setting file mode failed"), e) + self.log_warning(_("Setting file mode failed"), e) if self.core.config.get("permission", "change_dl") and os.name != "nt": try: @@ -473,13 +473,13 @@ class Hoster(Plugin): os.chown(fs_filename, uid, gid) except Exception, e: - self.logWarning(_("Setting User and Group failed"), e) + self.log_warning(_("Setting User and Group failed"), e) - self.lastDownload = filename - return self.lastDownload + self.last_download = filename + return self.last_download - def checkDownload(self, rules, delete=True, file_size=0, size_tolerance=1000, read_size=100000): + def check_download(self, rules, delete=True, file_size=0, size_tolerance=1000, read_size=100000): """ Checks the content of the last downloaded file, re match is saved to `lastCheck` @@ -491,10 +491,10 @@ class Hoster(Plugin): :return: dictionary key of the first rule that matched """ do_delete = False - lastDownload = fs_encode(self.lastDownload) + lastDownload = fs_encode(self.last_download) - if not self.lastDownload or not os.path.exists(lastDownload): - self.lastDownload = "" + if not self.last_download or not os.path.exists(lastDownload): + self.last_download = "" self.fail(self.pyfile.error or _("No file downloaded")) try: @@ -512,15 +512,15 @@ class Hoster(Plugin): self.fail(_("File size mismatch")) elif diff != 0: - self.logWarning(_("File size is not equal to expected size")) + self.log_warning(_("File size is not equal to expected size")) - self.logDebug("Download Check triggered") + self.log_debug("Download Check triggered") with open(lastDownload, "rb") as f: content = f.read(read_size) #: produces encoding errors, better log to other file in the future? - #: self.logDebug("Content: %s" % content) + #: self.log_debug("Content: %s" % content) for name, rule in rules.iteritems(): if isinstance(rule, basestring): if rule in content: @@ -531,14 +531,14 @@ class Hoster(Plugin): m = rule.search(content) if m: do_delete = True - self.lastCheck = m + self.last_check = m return name finally: if delete and do_delete: os.remove(lastDownload) - def directLink(self, url, follow_location=None): + def direct_link(self, url, follow_location=None): link = "" if follow_location is None: @@ -548,11 +548,11 @@ class Hoster(Plugin): redirect = max(follow_location, 1) else: - redirect = self.getConfig("maxredirs", plugin="UserAgentSwitcher") + redirect = self.get_config("maxredirs", plugin="UserAgentSwitcher") for i in xrange(redirect): try: - self.logDebug("Redirect #%d to: %s" % (i, url)) + self.log_debug("Redirect #%d to: %s" % (i, url)) header = self.load(url, just_header=True) except Exception: #: Bad bad bad... rewrite this part in 0.4.10 @@ -618,18 +618,18 @@ class Hoster(Plugin): else: try: - self.logError(_("Too many redirects")) + self.log_error(_("Too many redirects")) except Exception: pass return link - def parseHtmlForm(self, attr_str="", input_names={}): + def parse_html_form(self, attr_str="", input_names={}): return parseHtmlForm(attr_str, self.html, input_names) - def checkTrafficLeft(self): + def check_traffic_left(self): if not self.account: return True @@ -641,18 +641,18 @@ class Hoster(Plugin): return True else: size = self.pyfile.size / 1024 - self.logInfo(_("Filesize: %s KiB, Traffic left for user %s: %s KiB") % (size, self.user, traffic)) + self.log_info(_("Filesize: %s KiB, Traffic left for user %s: %s KiB") % (size, self.user, traffic)) return size <= traffic - def getPassword(self): + def get_password(self): """ Get the password the user provided in the package """ return self.pyfile.package().password or "" - def checkForSameFiles(self, starting=False): + def check_for_same_files(self, starting=False): """ Checks if same file was/is downloaded within same package @@ -681,7 +681,7 @@ class Hoster(Plugin): if os.path.exists(location): self.skip(pyfile[0]) - self.logDebug("File %s not skipped, because it does not exists." % self.pyfile.name) + self.log_debug("File %s not skipped, because it does not exists." % self.pyfile.name) def clean(self): diff --git a/module/plugins/internal/MultiHook.py b/module/plugins/internal/MultiHook.py index 22b0fd7c6..623836cdc 100644 --- a/module/plugins/internal/MultiHook.py +++ b/module/plugins/internal/MultiHook.py @@ -11,7 +11,7 @@ from module.utils import decode, remove_chars class MultiHook(Hook): __name__ = "MultiHook" __type__ = "hook" - __version__ = "0.49" + __version__ = "0.50" __config__ = [("pluginmode" , "all;listed;unlisted", "Use for plugins" , "all"), ("pluginlist" , "str" , "Plugin list (comma separated)", "" ), @@ -65,10 +65,10 @@ class MultiHook(Hook): self.pluginname = None self.plugintype = None - self.initPlugin() + self.init_plugin() - def initPlugin(self): + def init_plugin(self): self.pluginname = self.__name__.rsplit("Hook", 1)[0] plugin, self.plugintype = self.core.pluginManager.findPlugin(self.pluginname) @@ -76,47 +76,47 @@ class MultiHook(Hook): self.pluginmodule = self.core.pluginManager.loadModule(self.plugintype, self.pluginname) self.pluginclass = getattr(self.pluginmodule, self.pluginname) else: - self.logWarning("Hook plugin will be deactivated due missing plugin reference") - self.setConfig('activated', False) + self.log_warning("Hook plugin will be deactivated due missing plugin reference") + self.set_config('activated', False) - def loadAccount(self): + def load_account(self): self.account = self.core.accountManager.getAccountPlugin(self.pluginname) if self.account and not self.account.canUse(): self.account = None if not self.account and hasattr(self.pluginclass, "LOGIN_ACCOUNT") and self.pluginclass.LOGIN_ACCOUNT: - self.logWarning("Hook plugin will be deactivated due missing account reference") - self.setConfig('activated', False) + self.log_warning("Hook plugin will be deactivated due missing account reference") + self.set_config('activated', False) def activate(self): self.init_periodical(threaded=True) - def pluginsCached(self): + def plugins_cached(self): if self.plugins: return self.plugins for _i in xrange(2): try: - pluginset = self._pluginSet(self.getHosters()) + pluginset = self._plugin_set(self.get_hosters()) break except Exception, e: - self.logDebug(e, "Waiting 1 minute and retry") + self.log_debug(e, "Waiting 1 minute and retry") time.sleep(60) else: - self.logWarning(_("Fallback to default reload interval due plugin parse error")) + self.log_warning(_("Fallback to default reload interval due plugin parse error")) self.interval = self.MIN_RELOAD_INTERVAL return list() try: - configmode = self.getConfig('pluginmode', 'all') + configmode = self.get_config('pluginmode', 'all') if configmode in ("listed", "unlisted"): - pluginlist = self.getConfig('pluginlist', '').replace('|', ',').replace(';', ',').split(',') - configset = self._pluginSet(pluginlist) + pluginlist = self.get_config('pluginlist', '').replace('|', ',').replace(';', ',').split(',') + configset = self._plugin_set(pluginlist) if configmode == "listed": pluginset &= configset @@ -124,14 +124,14 @@ class MultiHook(Hook): pluginset -= configset except Exception, e: - self.logError(e) + self.log_error(e) self.plugins = list(pluginset) return self.plugins - def _pluginSet(self, plugins): + def _plugin_set(self, plugins): regexp = re.compile(r'^[\w\-.^_]{3,63}\.[a-zA-Z]{2,}$', re.U) plugins = [decode(p.strip()).lower() for p in plugins if regexp.match(p.strip())] @@ -143,7 +143,7 @@ class MultiHook(Hook): return set(plugins) - def getHosters(self): + def get_hosters(self): """ Load list of supported hoster @@ -156,15 +156,15 @@ class MultiHook(Hook): """ Reload plugin list periodically """ - self.loadAccount() + self.load_account() - if self.getConfig('reload', True): - self.interval = max(self.getConfig('reloadinterval', 12) * 60 * 60, self.MIN_RELOAD_INTERVAL) + if self.get_config('reload', True): + self.interval = max(self.get_config('reloadinterval', 12) * 60 * 60, self.MIN_RELOAD_INTERVAL) else: self.core.scheduler.removeJob(self.cb) self.cb = None - self.logInfo(_("Reloading supported %s list") % self.plugintype) + self.log_info(_("Reloading supported %s list") % self.plugintype) old_supported = self.supported @@ -172,17 +172,17 @@ class MultiHook(Hook): self.new_supported = [] self.plugins = [] - self.overridePlugins() + self.override_plugins() old_supported = [plugin for plugin in old_supported if plugin not in self.supported] if old_supported: - self.logDebug("Unload: %s" % ", ".join(old_supported)) + self.log_debug("Unload: %s" % ", ".join(old_supported)) for plugin in old_supported: - self.unloadPlugin(plugin) + self.unload_plugin(plugin) - def overridePlugins(self): + def override_plugins(self): excludedList = [] if self.plugintype == "hoster": @@ -192,7 +192,7 @@ class MultiHook(Hook): pluginMap = {} accountList = [name[::-1].replace("Folder"[::-1], "", 1).lower()[::-1] for name in self.core.pluginManager.crypterPlugins.iterkeys()] - for plugin in self.pluginsCached(): + for plugin in self.plugins_cached(): name = remove_chars(plugin, "-.") if name in accountList: @@ -204,11 +204,11 @@ class MultiHook(Hook): self.new_supported.append(plugin) if not self.supported and not self.new_supported: - self.logError(_("No %s loaded") % self.plugintype) + self.log_error(_("No %s loaded") % self.plugintype) return #: inject plugin plugin - self.logDebug("Overwritten %ss: %s" % (self.plugintype, ", ".join(sorted(self.supported)))) + self.log_debug("Overwritten %ss: %s" % (self.plugintype, ", ".join(sorted(self.supported)))) for plugin in self.supported: hdict = self.core.pluginManager.plugins[self.plugintype][plugin] @@ -216,26 +216,26 @@ class MultiHook(Hook): hdict['new_name'] = self.pluginname if excludedList: - self.logInfo(_("%ss not overwritten: %s") % (self.plugintype.capitalize(), ", ".join(sorted(excludedList)))) + self.log_info(_("%ss not overwritten: %s") % (self.plugintype.capitalize(), ", ".join(sorted(excludedList)))) if self.new_supported: plugins = sorted(self.new_supported) - self.logDebug("New %ss: %s" % (self.plugintype, ", ".join(plugins))) + self.log_debug("New %ss: %s" % (self.plugintype, ", ".join(plugins))) #: create new regexp regexp = r'.*(?P%s).*' % "|".join(x.replace('.', '\.') for x in plugins) if hasattr(self.pluginclass, "__pattern__") and isinstance(self.pluginclass.__pattern__, basestring) and "://" in self.pluginclass.__pattern__: regexp = r'%s|%s' % (self.pluginclass.__pattern__, regexp) - self.logDebug("Regexp: %s" % regexp) + self.log_debug("Regexp: %s" % regexp) hdict = self.core.pluginManager.plugins[self.plugintype][self.pluginname] hdict['pattern'] = regexp hdict['re'] = re.compile(regexp) - def unloadPlugin(self, plugin): + def unload_plugin(self, plugin): hdict = self.core.pluginManager.plugins[self.plugintype][plugin] if "module" in hdict: hdict.pop('module', None) @@ -250,7 +250,7 @@ class MultiHook(Hook): Remove override for all plugins. Scheduler job is removed by hookmanager """ for plugin in self.supported: - self.unloadPlugin(plugin) + self.unload_plugin(plugin) #: reset pattern hdict = self.core.pluginManager.plugins[self.plugintype][self.pluginname] diff --git a/module/plugins/internal/MultiHoster.py b/module/plugins/internal/MultiHoster.py index 2b3eb8941..8360d871e 100644 --- a/module/plugins/internal/MultiHoster.py +++ b/module/plugins/internal/MultiHoster.py @@ -9,7 +9,7 @@ from module.plugins.internal.SimpleHoster import SimpleHoster, create_getInfo, r class MultiHoster(SimpleHoster): __name__ = "MultiHoster" __type__ = "hoster" - __version__ = "0.42" + __version__ = "0.43" __pattern__ = r'^unmatchable$' __config__ = [("use_premium" , "bool", "Use premium account if available" , True), @@ -24,19 +24,19 @@ class MultiHoster(SimpleHoster): def setup(self): - self.chunkLimit = 1 - self.multiDL = bool(self.account) - self.resumeDownload = self.premium + self.chunk_limit = 1 + self.multi_dl = bool(self.account) + self.resume_download = self.premium def prepare(self): self.info = {} self.html = "" self.link = "" #@TODO: Move to Hoster in 0.4.10 - self.directDL = False #@TODO: Move to Hoster in 0.4.10 + self.direct_d_l = False #@TODO: Move to Hoster in 0.4.10 - if not self.getConfig('use_premium', True): - self.retryFree() + if not self.get_config('use_premium', True): + self.retry_free() if self.LOGIN_ACCOUNT and not self.account: self.fail(_("Required account not found")) @@ -47,9 +47,9 @@ class MultiHoster(SimpleHoster): set_cookies(self.req.cj, self.COOKIES) if self.DIRECT_LINK is None: - self.directDL = self.__pattern__ != r'^unmatchable$' and re.match(self.__pattern__, self.pyfile.url) + self.direct_d_l = self.__pattern__ != r'^unmatchable$' and re.match(self.__pattern__, self.pyfile.url) else: - self.directDL = self.DIRECT_LINK + self.direct_d_l = self.DIRECT_LINK self.pyfile.url = replace_patterns(self.pyfile.url, self.URL_REPLACEMENTS) @@ -58,36 +58,36 @@ class MultiHoster(SimpleHoster): try: self.prepare() - if self.directDL: - self.checkInfo() - self.logDebug("Looking for direct download link...") - self.handleDirect(pyfile) + if self.direct_d_l: + self.check_info() + self.log_debug("Looking for direct download link...") + self.handle_direct(pyfile) - if not self.link and not self.lastDownload: + if not self.link and not self.last_download: self.preload() - self.checkErrors() - self.checkStatus(getinfo=False) + self.check_errors() + self.check_status(getinfo=False) - if self.premium and (not self.CHECK_TRAFFIC or self.checkTrafficLeft()): - self.logDebug("Handled as premium download") - self.handlePremium(pyfile) + if self.premium and (not self.CHECK_TRAFFIC or self.check_traffic_left()): + self.log_debug("Handled as premium download") + self.handle_premium(pyfile) - elif not self.LOGIN_ACCOUNT or (not self.CHECK_TRAFFIC or self.checkTrafficLeft()): - self.logDebug("Handled as free download") - self.handleFree(pyfile) + elif not self.LOGIN_ACCOUNT or (not self.CHECK_TRAFFIC or self.check_traffic_left()): + self.log_debug("Handled as free download") + self.handle_free(pyfile) self.download(self.link, ref=False, disposition=True) - self.checkFile() + self.check_file() except Fail, e: #@TODO: Move to PluginThread in 0.4.10 err = str(e) #@TODO: Recheck in 0.4.10 if self.premium: - self.logWarning(_("Premium download failed")) - self.retryFree() + self.log_warning(_("Premium download failed")) + self.retry_free() - elif self.getConfig("revertfailed", True) \ + elif self.get_config("revertfailed", True) \ and "new_module" in self.core.pluginManager.hosterPlugins[self.__name__]: hdict = self.core.pluginManager.hosterPlugins[self.__name__] @@ -107,11 +107,11 @@ class MultiHoster(SimpleHoster): raise Fail(err) - def handlePremium(self, pyfile): - return self.handleFree(pyfile) + def handle_premium(self, pyfile): + return self.handle_free(pyfile) - def handleFree(self, pyfile): + def handle_free(self, pyfile): if self.premium: raise NotImplementedError else: diff --git a/module/plugins/internal/OCR.py b/module/plugins/internal/OCR.py index 0191a4938..880f8b570 100644 --- a/module/plugins/internal/OCR.py +++ b/module/plugins/internal/OCR.py @@ -20,7 +20,7 @@ from module.utils import save_join as fs_join class OCR(Plugin): __name__ = "OCR" __type__ = "ocr" - __version__ = "0.11" + __version__ = "0.12" __description__ = """OCR base plugin""" __license__ = "GPLv3" @@ -71,7 +71,7 @@ class OCR(Plugin): tmpTxt.close() except IOError, e: - self.logError(e) + self.log_error(e) return self.logger.debug("save tiff") diff --git a/module/plugins/internal/Plugin.py b/module/plugins/internal/Plugin.py index 9b110280e..0b08858f3 100644 --- a/module/plugins/internal/Plugin.py +++ b/module/plugins/internal/Plugin.py @@ -25,12 +25,12 @@ def set_cookies(cj, cookies): cj.setCookie(domain, name, value) -def parseHtmlTagAttrValue(attr_name, tag): +def parse_html_tag_attr_value(attr_name, tag): m = re.search(r"%s\s*=\s*([\"']?)((?<=\")[^\"]+|(?<=')[^']+|[^>\s\"'][^>\s]*)\1" % attr_name, tag, re.I) return m.group(2) if m else None -def parseHtmlForm(attr_str, html, input_names={}): +def parse_html_form(attr_str, html, input_names={}): for form in re.finditer(r"(?P]*%s[^>]*>)(?P.*?)]*>" % attr_str, html, re.S | re.I): inputs = {} @@ -78,7 +78,7 @@ def chunks(iterable, size): class Plugin(object): __name__ = "Plugin" __type__ = "hoster" - __version__ = "0.11" + __version__ = "0.12" __pattern__ = r'^unmatchable$' __config__ = [] #: [("name", "type", "desc", "default")] @@ -106,28 +106,28 @@ class Plugin(object): 'msg' : msg or _(level.upper() + " MARK")}) - def logDebug(self, *args): + def log_debug(self, *args): if self.core.debug: return self._log("debug", args) - def logInfo(self, *args): + def log_info(self, *args): return self._log("info", args) - def logWarning(self, *args): + def log_warning(self, *args): return self._log("warning", args) - def logError(self, *args): + def log_error(self, *args): return self._log("error", args) - def logCritical(self, *args): + def log_critical(self, *args): return self._log("critical", args) - def setConfig(self, option, value): + def set_config(self, option, value): """ Set config value for current plugin @@ -138,15 +138,15 @@ class Plugin(object): self.core.config.setPlugin(self.__name__, option, value) - #: Deprecated method + #: Deprecated method, use `set_config` instead def setConf(self, *args, **kwargs): """ - See `setConfig` + See `set_config` """ - return self.setConfig(*args, **kwargs) + return self.set_config(*args, **kwargs) - def getConfig(self, option, default="", plugin=None): + def get_config(self, option, default="", plugin=None): """ Returns config value for current plugin @@ -157,16 +157,16 @@ class Plugin(object): return self.core.config.getPlugin(plugin or self.__name__, option) except KeyError: - self.logWarning(_("Config option or plugin not found")) + self.log_warning(_("Config option or plugin not found")) return default - #: Deprecated method + #: Deprecated method, use `get_config` instead def getConf(self, *args, **kwargs): """ - See `getConfig` + See `get_config` """ - return self.getConfig(*args, **kwargs) + return self.get_config(*args, **kwargs) def store(self, key, value): @@ -176,10 +176,10 @@ class Plugin(object): self.core.db.setStorage(self.__name__, key, value) - #: Deprecated method + #: Deprecated method, use `store` instead def setStorage(self, *args, **kwargs): """ - Same as `setStorage` + Same as `store` """ return self.store(*args, **kwargs) @@ -191,21 +191,29 @@ class Plugin(object): return self.core.db.getStorage(self.__name__, key) or default - #: Deprecated method + #: Deprecated method, use `retrieve` instead def getStorage(self, *args, **kwargs): """ - Same as `getStorage` + Same as `retrieve` """ return self.retrieve(*args, **kwargs) - def delStorage(self, key): + def delete(self, key): """ Delete entry in db """ self.core.db.delStorage(self.__name__, key) + #: Deprecated method, use `delete` instead + def delStorage(self, *args, **kwargs): + """ + Same as `delete` + """ + return self.delete(*args, **kwargs) + + def fail(self, reason): """ Fail and give reason @@ -250,7 +258,7 @@ class Plugin(object): self.fail(_("No url given")) if self.core.debug: - self.logDebug("Load url: " + url, *["%s=%s" % (key, val) for key, val in locals().iteritems() if key not in ("self", "url")]) + self.log_debug("Load url: " + url, *["%s=%s" % (key, val) for key, val in locals().iteritems() if key not in ("self", "url")]) if req is None: if hasattr(self, "req"): @@ -274,7 +282,7 @@ class Plugin(object): del frame #: delete the frame or it wont be cleaned f.write(res.encode('utf8')) except IOError, e: - self.logError(e) + self.log_error(e) if just_header: #: parse header @@ -297,4 +305,4 @@ class Plugin(object): header[key] = value res = header - return res \ No newline at end of file + return res diff --git a/module/plugins/internal/ReCaptcha.py b/module/plugins/internal/ReCaptcha.py index 40faff5f0..79bda9051 100644 --- a/module/plugins/internal/ReCaptcha.py +++ b/module/plugins/internal/ReCaptcha.py @@ -13,7 +13,7 @@ from module.plugins.internal.Captcha import Captcha class ReCaptcha(Captcha): __name__ = "ReCaptcha" __type__ = "captcha" - __version__ = "0.17" + __version__ = "0.18" __description__ = """ReCaptcha captcha service plugin""" __license__ = "GPLv3" @@ -32,10 +32,10 @@ class ReCaptcha(Captcha): m = re.search(self.KEY_V2_PATTERN, html) or re.search(self.KEY_V1_PATTERN, html) if m: self.key = m.group(1).strip() - self.logDebug("Key: %s" % self.key) + self.log_debug("Key: %s" % self.key) return self.key else: - self.logWarning("Key pattern not found") + self.log_warning("Key pattern not found") return None @@ -60,7 +60,7 @@ class ReCaptcha(Captcha): except AttributeError: self.fail(_("ReCaptcha challenge pattern not found")) - self.logDebug("Challenge: %s" % challenge) + self.log_debug("Challenge: %s" % challenge) return self.result(server, challenge, key) @@ -79,50 +79,50 @@ class ReCaptcha(Captcha): except AttributeError: self.fail(_("ReCaptcha second challenge pattern not found")) - self.logDebug("Second challenge: %s" % challenge) + self.log_debug("Second challenge: %s" % challenge) result = self.plugin.decryptCaptcha("%simage" % server, get={'c': challenge}, cookies=True, forceUser=True, imgtype="jpg") - self.logDebug("Result: %s" % result) + self.log_debug("Result: %s" % result) return result, challenge - def _collectApiInfo(self): + def _collect_api_info(self): html = self.plugin.load("http://www.google.com/recaptcha/api.js") a = re.search(r'po.src = \'(.*?)\';', html).group(1) vers = a.split("/")[5] - self.logDebug("API version: %s" % vers) + self.log_debug("API version: %s" % vers) language = a.split("__")[1].split(".")[0] - self.logDebug("API language: %s" % language) + self.log_debug("API language: %s" % language) html = self.plugin.load("https://apis.google.com/js/api.js") b = re.search(r'"h":"(.*?)","', html).group(1) jsh = b.decode('unicode-escape') - self.logDebug("API jsh-string: %s" % jsh) + self.log_debug("API jsh-string: %s" % jsh) return vers, language, jsh - def _prepareTimeAndRpc(self): + def _prepare_time_and_rpc(self): self.plugin.load("http://www.google.com/recaptcha/api2/demo") millis = int(round(time.time() * 1000)) - self.logDebug("Time: %s" % millis) + self.log_debug("Time: %s" % millis) rand = random.randint(1, 99999999) a = "0.%s" % str(rand * 2147483647) rpc = int(100000000 * float(a)) - self.logDebug("Rpc-token: %s" % rpc) + self.log_debug("Rpc-token: %s" % rpc) return millis, rpc @@ -136,8 +136,8 @@ class ReCaptcha(Captcha): parent = "" botguardstring = "!A" - vers, language, jsh = self._collectApiInfo() - millis, rpc = self._prepareTimeAndRpc() + vers, language, jsh = self._collect_api_info() + millis, rpc = self._prepare_time_and_rpc() html = self.plugin.load("https://www.google.com/recaptcha/api2/anchor", get={'k' : key, @@ -150,7 +150,7 @@ class ReCaptcha(Captcha): 'rpctoken': rpc}) token1 = re.search(r'id="recaptcha-token" value="(.*?)">', html) - self.logDebug("Token #1: %s" % token1.group(1)) + self.log_debug("Token #1: %s" % token1.group(1)) html = self.plugin.load("https://www.google.com/recaptcha/api2/frame", get={'c' : token1.group(1), @@ -163,10 +163,10 @@ class ReCaptcha(Captcha): decode="unicode-escape") token2 = re.search(r'"finput","(.*?)",', html) - self.logDebug("Token #2: %s" % token2.group(1)) + self.log_debug("Token #2: %s" % token2.group(1)) token3 = re.search(r'"rresp","(.*?)",', html) - self.logDebug("Token #3: %s" % token3.group(1)) + self.log_debug("Token #3: %s" % token3.group(1)) millis_captcha_loading = int(round(time.time() * 1000)) captcha_response = self.plugin.decryptCaptcha("https://www.google.com/recaptcha/api2/payload", @@ -175,7 +175,7 @@ class ReCaptcha(Captcha): forceUser=True) response = b64encode('{"response":"%s"}' % captcha_response) - self.logDebug("Result: %s" % response) + self.log_debug("Result: %s" % response) timeToSolve = int(round(time.time() * 1000)) - millis_captcha_loading timeToSolveMore = timeToSolve + int(float("0." + str(random.randint(1, 99999999))) * 500) @@ -189,7 +189,7 @@ class ReCaptcha(Captcha): 'bg' : botguardstring}) token4 = re.search(r'"uvresp","(.*?)",', html) - self.logDebug("Token #4: %s" % token4.group(1)) + self.log_debug("Token #4: %s" % token4.group(1)) result = token4.group(1) diff --git a/module/plugins/internal/SevenZip.py b/module/plugins/internal/SevenZip.py index 147ac6bd4..86ff5156e 100644 --- a/module/plugins/internal/SevenZip.py +++ b/module/plugins/internal/SevenZip.py @@ -10,7 +10,7 @@ from module.utils import fs_encode, save_join as fs_join class SevenZip(UnRar): __name__ = "SevenZip" - __version__ = "0.11" + __version__ = "0.12" __description__ = """7-Zip extractor plugin""" __license__ = "GPLv3" @@ -37,7 +37,7 @@ class SevenZip(UnRar): @classmethod - def isUsable(cls): + def is_usable(cls): if os.name == "nt": cls.CMD = os.path.join(pypath, "7z.exe") p = subprocess.Popen([cls.CMD], stdout=subprocess.PIPE, stderr=subprocess.PIPE) @@ -134,11 +134,11 @@ class SevenZip(UnRar): def call_cmd(self, command, *xargs, **kwargs): args = [] - #overwrite flag + # overwrite flag if self.overwrite: args.append("-y") - #set a password + # set a password if "password" in kwargs and kwargs['password']: args.append("-p%s" % kwargs['password']) else: diff --git a/module/plugins/internal/SimpleCrypter.py b/module/plugins/internal/SimpleCrypter.py index 7685be55a..fe47178e3 100644 --- a/module/plugins/internal/SimpleCrypter.py +++ b/module/plugins/internal/SimpleCrypter.py @@ -10,7 +10,7 @@ from module.utils import fixup, html_unescape class SimpleCrypter(Crypter, SimpleHoster): __name__ = "SimpleCrypter" __type__ = "crypter" - __version__ = "0.55" + __version__ = "0.56" __pattern__ = r'^unmatchable$' __config__ = [("use_subfolder" , "bool", "Save package to subfolder" , True), #: Overrides core.config['general']['folder_per_package'] @@ -47,7 +47,7 @@ class SimpleCrypter(Crypter, SimpleHoster): and its loadPage method: - def loadPage(self, page_n): + def load_page(self, page_n): return the html of the page number page_n """ #@TODO: Remove in 0.4.10 @@ -85,10 +85,10 @@ class SimpleCrypter(Crypter, SimpleHoster): self.pyfile.url = replace_patterns(self.pyfile.url, self.URL_REPLACEMENTS) - def handleDirect(self, pyfile): - for i in xrange(self.getConfig("maxredirs", plugin="UserAgentSwitcher")): + def handle_direct(self, pyfile): + for i in xrange(self.get_config("maxredirs", plugin="UserAgentSwitcher")): redirect = self.link or pyfile.url - self.logDebug("Redirect #%d to: %s" % (i, redirect)) + self.log_debug("Redirect #%d to: %s" % (i, redirect)) header = self.load(redirect, just_header=True) if 'location' in header and header['location']: @@ -96,38 +96,38 @@ class SimpleCrypter(Crypter, SimpleHoster): else: break else: - self.logError(_("Too many redirects")) + self.log_error(_("Too many redirects")) def decrypt(self, pyfile): self.prepare() - self.logDebug("Looking for link redirect...") - self.handleDirect(pyfile) + self.log_debug("Looking for link redirect...") + self.handle_direct(pyfile) if self.link: self.urls = [self.link] else: self.preload() - self.checkInfo() + self.check_info() - self.links = self.getLinks() or list() + self.links = self.get_links() or list() if hasattr(self, 'PAGES_PATTERN') and hasattr(self, 'loadPage'): - self.handlePages(pyfile) + self.handle_pages(pyfile) - self.logDebug("Package has %d links" % len(self.links)) + self.log_debug("Package has %d links" % len(self.links)) if self.links: self.packages = [(self.info['name'], self.links, self.info['folder'])] - def checkNameSize(self, getinfo=True): + def check_name_size(self, getinfo=True): if not self.info or getinfo: - self.logDebug("File info (BEFORE): %s" % self.info) - self.info.update(self.getInfo(self.pyfile.url, self.html)) - self.logDebug("File info (AFTER): %s" % self.info) + self.log_debug("File info (BEFORE): %s" % self.info) + self.info.update(self.get_info(self.pyfile.url, self.html)) + self.log_debug("File info (AFTER): %s" % self.info) try: url = self.info['url'].strip() @@ -144,11 +144,11 @@ class SimpleCrypter(Crypter, SimpleHoster): except Exception: pass - self.logDebug("File name: %s" % self.pyfile.name, + self.log_debug("File name: %s" % self.pyfile.name, "File folder: %s" % self.pyfile.name) - def getLinks(self): + def get_links(self): """ Returns the links extracted from self.html You should override this only if it's impossible to extract links using only the LINK_PATTERN. @@ -156,12 +156,12 @@ class SimpleCrypter(Crypter, SimpleHoster): return re.findall(self.LINK_PATTERN, self.html) - def handlePages(self, pyfile): + def handle_pages(self, pyfile): try: pages = int(re.search(self.PAGES_PATTERN, self.html).group(1)) except Exception: pages = 1 for p in xrange(2, pages + 1): - self.html = self.loadPage(p) - self.links += self.getLinks() + self.html = self.load_page(p) + self.links += self.get_links() diff --git a/module/plugins/internal/SimpleHoster.py b/module/plugins/internal/SimpleHoster.py index 067b97747..2e31c1176 100644 --- a/module/plugins/internal/SimpleHoster.py +++ b/module/plugins/internal/SimpleHoster.py @@ -25,7 +25,7 @@ statusMap = dict((v, k) for k, v in _statusMap.iteritems()) #@TODO: Remove in 0.4.10 def parseFileInfo(plugin, url="", html=""): if hasattr(plugin, "getInfo"): - info = plugin.getInfo(url, html) + info = plugin.get_info(url, html) res = info['name'], info['size'], info['status'], info['url'] else: url = urllib.unquote(url) @@ -42,7 +42,7 @@ def parseFileInfo(plugin, url="", html=""): #@TODO: Remove in 0.4.10 def create_getInfo(plugin): - def getInfo(urls): + def get_info(urls): for url in urls: if hasattr(plugin, "URL_REPLACEMENTS"): url = replace_patterns(url, plugin.URL_REPLACEMENTS) @@ -55,7 +55,7 @@ def timestamp(): return int(time.time() * 1000) -def secondsToMidnight(gmt=0): +def seconds_to_midnight(gmt=0): now = datetime.datetime.utcnow() + datetime.timedelta(hours=gmt) if now.hour is 0 and now.minute < 10: @@ -76,7 +76,7 @@ def secondsToMidnight(gmt=0): class SimpleHoster(Hoster): __name__ = "SimpleHoster" __type__ = "hoster" - __version__ = "1.69" + __version__ = "1.70" __pattern__ = r'^unmatchable$' __config__ = [("use_premium", "bool", "Use premium account if available" , True), @@ -132,7 +132,7 @@ class SimpleHoster(Hoster): example: ERROR_PATTERN = r'' - Instead overriding handleFree and handlePremium methods you may define the following patterns for basic link handling: + Instead overriding handle_free and handle_premium methods you may define the following patterns for basic link handling: LINK_PATTERN: (optional) group(1) should be the direct link for free and premium download example: LINK_PATTERN = r'
', " ", errmsg) - self.logWarning(self.info['error']) + self.log_warning(self.info['error']) if re.search('da(il)?y|today', errmsg, re.I): - wait_time = secondsToMidnight(gmt=2) + wait_time = seconds_to_midnight(gmt=2) else: wait_time = sum(int(v) * {"hr": 3600, "hour": 3600, "min": 60, "sec": 1, "": 1}[u.lower()] for v, u in re.findall(r'(\d+)\s*(hr|hour|min|sec|)', errmsg, re.I)) - self.wantReconnect = wait_time > 300 + self.want_reconnect = wait_time > 300 self.retry(1, wait_time, _("Download limit exceeded")) if hasattr(self, 'HAPPY_HOUR_PATTERN') and re.search(self.HAPPY_HOUR_PATTERN, self.html): - self.multiDL = True + self.multi_dl = True if hasattr(self, 'ERROR_PATTERN'): m = re.search(self.ERROR_PATTERN, self.html) @@ -438,30 +438,30 @@ class SimpleHoster(Hoster): errmsg = m.group(0).strip() self.info['error'] = re.sub(r'<.*?>', " ", errmsg) - self.logWarning(self.info['error']) + self.log_warning(self.info['error']) if re.search('limit|wait|slot', errmsg, re.I): if re.search("da(il)?y|today", errmsg): - wait_time = secondsToMidnight(gmt=2) + wait_time = seconds_to_midnight(gmt=2) else: wait_time = sum(int(v) * {"hr": 3600, "hour": 3600, "min": 60, "sec": 1, "": 1}[u.lower()] for v, u in re.findall(r'(\d+)\s*(hr|hour|min|sec|)', errmsg, re.I)) - self.wantReconnect = wait_time > 300 + self.want_reconnect = wait_time > 300 self.retry(1, wait_time, _("Download limit exceeded")) elif re.search('country|ip|region|nation', errmsg, re.I): self.fail(_("Connection from your current IP address is not allowed")) elif re.search('captcha|code', errmsg, re.I): - self.invalidCaptcha() + self.invalid_captcha() self.retry(10, reason=_("Wrong captcha")) elif re.search('countdown|expired', errmsg, re.I): self.retry(10, 60, _("Link expired")) elif re.search('maintenance|maintainance|temp', errmsg, re.I): - self.tempOffline() + self.temp_offline() elif re.search('up to|size', errmsg, re.I): self.fail(_("File too large for free download")) @@ -478,7 +478,7 @@ class SimpleHoster(Hoster): self.fail(_("File can be downloaded by premium users only")) else: - self.wantReconnect = True + self.want_reconnect = True self.retry(wait_time=60, reason=errmsg) elif hasattr(self, 'WAIT_PATTERN'): @@ -496,12 +496,12 @@ class SimpleHoster(Hoster): self.info.pop('error', None) - def checkStatus(self, getinfo=True): + def check_status(self, getinfo=True): if not self.info or getinfo: - self.logDebug("Update file info...") - self.logDebug("Previous file info: %s" % self.info) - self.info.update(self.getInfo(self.pyfile.url, self.html)) - self.logDebug("Current file info: %s" % self.info) + self.log_debug("Update file info...") + self.log_debug("Previous file info: %s" % self.info) + self.info.update(self.get_info(self.pyfile.url, self.html)) + self.log_debug("Current file info: %s" % self.info) try: status = self.info['status'] @@ -510,21 +510,21 @@ class SimpleHoster(Hoster): self.offline() elif status is 6: - self.tempOffline() + self.temp_offline() elif status is 8: self.fail(self.info['error'] if 'error' in self.info else _("Failed")) finally: - self.logDebug("File status: %s" % statusMap[status]) + self.log_debug("File status: %s" % statusMap[status]) - def checkNameSize(self, getinfo=True): + def check_name_size(self, getinfo=True): if not self.info or getinfo: - self.logDebug("Update file info...") - self.logDebug("Previous file info: %s" % self.info) - self.info.update(self.getInfo(self.pyfile.url, self.html)) - self.logDebug("Current file info: %s" % self.info) + self.log_debug("Update file info...") + self.log_debug("Previous file info: %s" % self.info) + self.info.update(self.get_info(self.pyfile.url, self.html)) + self.log_debug("Current file info: %s" % self.info) try: url = self.info['url'].strip() @@ -543,44 +543,44 @@ class SimpleHoster(Hoster): except Exception: pass - self.logDebug("File name: %s" % self.pyfile.name, + self.log_debug("File name: %s" % self.pyfile.name, "File size: %s byte" % self.pyfile.size if self.pyfile.size > 0 else "File size: Unknown") - def checkInfo(self): - self.checkNameSize() + def check_info(self): + self.check_name_size() if self.html: - self.checkErrors() - self.checkNameSize() + self.check_errors() + self.check_name_size() - self.checkStatus(getinfo=False) + self.check_status(getinfo=False) - #: Deprecated + #: Deprecated method def getFileInfo(self): self.info = {} - self.checkInfo() + self.check_info() return self.info - def handleDirect(self, pyfile): - link = self.directLink(pyfile.url, self.resumeDownload) + def handle_direct(self, pyfile): + link = self.direct_link(pyfile.url, self.resume_download) if link: - self.logInfo(_("Direct download link detected")) + self.log_info(_("Direct download link detected")) self.link = link else: - self.logDebug("Direct download link not found") + self.log_debug("Direct download link not found") - def handleMulti(self, pyfile): #: Multi-hoster handler + def handle_multi(self, pyfile): #: Multi-hoster handler pass - def handleFree(self, pyfile): + def handle_free(self, pyfile): if not hasattr(self, 'LINK_FREE_PATTERN'): - self.logError(_("Free download not implemented")) + self.log_error(_("Free download not implemented")) m = re.search(self.LINK_FREE_PATTERN, self.html) if m is None: @@ -589,11 +589,11 @@ class SimpleHoster(Hoster): self.link = m.group(1) - def handlePremium(self, pyfile): + def handle_premium(self, pyfile): if not hasattr(self, 'LINK_PREMIUM_PATTERN'): - self.logError(_("Premium download not implemented")) - self.logDebug("Handled as free download") - self.handleFree(pyfile) + self.log_error(_("Premium download not implemented")) + self.log_debug("Handled as free download") + self.handle_free(pyfile) m = re.search(self.LINK_PREMIUM_PATTERN, self.html) if m is None: @@ -602,7 +602,7 @@ class SimpleHoster(Hoster): self.link = m.group(1) - def retryFree(self): + def retry_free(self): if not self.premium: return self.premium = False diff --git a/module/plugins/internal/SolveMedia.py b/module/plugins/internal/SolveMedia.py index dde6223ed..927d4e536 100644 --- a/module/plugins/internal/SolveMedia.py +++ b/module/plugins/internal/SolveMedia.py @@ -9,7 +9,7 @@ from module.plugins.internal.Captcha import Captcha class SolveMedia(Captcha): __name__ = "SolveMedia" __type__ = "captcha" - __version__ = "0.14" + __version__ = "0.15" __description__ = """SolveMedia captcha service plugin""" __license__ = "GPLv3" @@ -25,10 +25,10 @@ class SolveMedia(Captcha): m = re.search(self.KEY_PATTERN, html) if m: self.key = m.group(1).strip() - self.logDebug("Key: %s" % self.key) + self.log_debug("Key: %s" % self.key) return self.key else: - self.logWarning("Key pattern not found") + self.log_warning("Key pattern not found") return None @@ -43,7 +43,7 @@ class SolveMedia(Captcha): magic = re.search(r'name="magic" value="(.+?)"', html).group(1) except AttributeError: - self.logWarning("Magic pattern not found") + self.log_warning("Magic pattern not found") magic = None try: @@ -54,13 +54,13 @@ class SolveMedia(Captcha): self.fail(_("SolveMedia challenge pattern not found")) else: - self.logDebug("Challenge: %s" % challenge) + self.log_debug("Challenge: %s" % challenge) try: result = self.result("http://api.solvemedia.com/papi/media", challenge) except Fail, e: - self.logWarning(e) + self.log_warning(e) self.plugin.invalidCaptcha() result = None @@ -81,8 +81,8 @@ class SolveMedia(Captcha): else: if "error" in html: - self.logWarning("Captcha code was invalid") - self.logDebug("Retry #%d" % i) + self.log_warning("Captcha code was invalid") + self.log_debug("Retry #%d" % i) html = self.plugin.load(redirect) else: break @@ -99,6 +99,6 @@ class SolveMedia(Captcha): cookies=True, imgtype="gif") - self.logDebug("Result: %s" % result) + self.log_debug("Result: %s" % result) return result diff --git a/module/plugins/internal/UnRar.py b/module/plugins/internal/UnRar.py index 25a8a52de..4494b98c6 100644 --- a/module/plugins/internal/UnRar.py +++ b/module/plugins/internal/UnRar.py @@ -22,7 +22,7 @@ def renice(pid, value): class UnRar(Extractor): __name__ = "UnRar" - __version__ = "1.20" + __version__ = "1.21" __description__ = """Rar extractor plugin""" __license__ = "GPLv3" @@ -48,7 +48,7 @@ class UnRar(Extractor): @classmethod - def isUsable(cls): + def is_usable(cls): if os.name == "nt": try: cls.CMD = os.path.join(pypath, "RAR.exe") @@ -79,7 +79,7 @@ class UnRar(Extractor): @classmethod - def isMultipart(cls, filename): + def is_multipart(cls, filename): return True if cls.re_multipart.search(filename) else False @@ -131,7 +131,7 @@ class UnRar(Extractor): break #: reading a percentage sign -> set progress and restart if c == '%': - self.notifyProgress(int(s)) + self.notify_progress(int(s)) s = "" #: not reading a digit -> therefore restart elif c not in digits: @@ -168,14 +168,14 @@ class UnRar(Extractor): self.files = self.list(password) - def getDeleteFiles(self): + def get_delete_files(self): dir, name = os.path.split(self.filename) #: actually extracted file files = [self.filename] #: eventually Multipart Files - files.extend(fs_join(dir, os.path.basename(file)) for file in filter(self.isMultipart, os.listdir(dir)) + files.extend(fs_join(dir, os.path.basename(file)) for file in filter(self.is_multipart, os.listdir(dir)) if re.sub(self.re_multipart,".rar",name) == re.sub(self.re_multipart,".rar",file)) return files diff --git a/module/plugins/internal/UnZip.py b/module/plugins/internal/UnZip.py index 4c18a0e35..c2eb522a8 100644 --- a/module/plugins/internal/UnZip.py +++ b/module/plugins/internal/UnZip.py @@ -12,7 +12,7 @@ from module.utils import fs_encode class UnZip(Extractor): __name__ = "UnZip" - __version__ = "1.12" + __version__ = "1.13" __description__ = """Zip extractor plugin""" __license__ = "GPLv3" @@ -24,7 +24,7 @@ class UnZip(Extractor): @classmethod - def isUsable(cls): + def is_usable(cls): return sys.version_info[:2] >= (2, 6) diff --git a/module/plugins/internal/XFSAccount.py b/module/plugins/internal/XFSAccount.py index c26a91775..fb2302f4c 100644 --- a/module/plugins/internal/XFSAccount.py +++ b/module/plugins/internal/XFSAccount.py @@ -11,7 +11,7 @@ from module.plugins.internal.Plugin import parseHtmlForm, set_cookies class XFSAccount(Account): __name__ = "XFSAccount" __type__ = "account" - __version__ = "0.38" + __version__ = "0.39" __description__ = """XFileSharing account plugin""" __license__ = "GPLv3" @@ -40,7 +40,7 @@ class XFSAccount(Account): def init(self): if not self.HOSTER_DOMAIN: - self.logError(_("Missing HOSTER_DOMAIN")) + self.log_error(_("Missing HOSTER_DOMAIN")) self.COOKIES = False else: @@ -52,7 +52,7 @@ class XFSAccount(Account): set_cookies(req.cj, self.COOKIES) - def loadAccountInfo(self, user, req): + def load_account_info(self, user, req): validuntil = None trafficleft = None leechtraffic = None @@ -71,16 +71,16 @@ class XFSAccount(Account): m = re.search(self.VALID_UNTIL_PATTERN, html) if m: expiredate = m.group(1).strip() - self.logDebug("Expire date: " + expiredate) + self.log_debug("Expire date: " + expiredate) try: validuntil = time.mktime(time.strptime(expiredate, "%d %B %Y")) except Exception, e: - self.logError(e) + self.log_error(e) else: - self.logDebug("Valid until: %s" % validuntil) + self.log_debug("Valid until: %s" % validuntil) if validuntil > time.mktime(time.gmtime()): premium = True @@ -89,7 +89,7 @@ class XFSAccount(Account): premium = False validuntil = None #: registered account type (not premium) else: - self.logDebug("VALID_UNTIL_PATTERN not found") + self.log_debug("VALID_UNTIL_PATTERN not found") m = re.search(self.TRAFFIC_LEFT_PATTERN, html) if m: @@ -109,12 +109,12 @@ class XFSAccount(Account): else: unit = "" - trafficleft = self.parseTraffic(size + unit) + trafficleft = self.parse_traffic(size + unit) except Exception, e: - self.logError(e) + self.log_error(e) else: - self.logDebug("TRAFFIC_LEFT_PATTERN not found") + self.log_debug("TRAFFIC_LEFT_PATTERN not found") leech = [m.groupdict() for m in re.finditer(self.LEECH_TRAFFIC_PATTERN, html)] if leech: @@ -136,12 +136,12 @@ class XFSAccount(Account): else: unit = "" - leechtraffic += self.parseTraffic(size + unit) + leechtraffic += self.parse_traffic(size + unit) except Exception, e: - self.logError(e) + self.log_error(e) else: - self.logDebug("LEECH_TRAFFIC_PATTERN not found") + self.log_debug("LEECH_TRAFFIC_PATTERN not found") return {'validuntil' : validuntil, 'trafficleft' : trafficleft, @@ -173,4 +173,4 @@ class XFSAccount(Account): html = self.load(url, post=inputs, req=req) if re.search(self.LOGIN_FAIL_PATTERN, html): - self.wrongPassword() + self.wrong_password() diff --git a/module/plugins/internal/XFSCrypter.py b/module/plugins/internal/XFSCrypter.py index 0f5bfd5d7..c371e97f5 100644 --- a/module/plugins/internal/XFSCrypter.py +++ b/module/plugins/internal/XFSCrypter.py @@ -6,7 +6,7 @@ from module.plugins.internal.SimpleCrypter import SimpleCrypter, create_getInfo class XFSCrypter(SimpleCrypter): __name__ = "XFSCrypter" __type__ = "crypter" - __version__ = "0.10" + __version__ = "0.11" __pattern__ = r'^unmatchable$' diff --git a/module/plugins/internal/XFSHoster.py b/module/plugins/internal/XFSHoster.py index 0f4f90128..68cf25f14 100644 --- a/module/plugins/internal/XFSHoster.py +++ b/module/plugins/internal/XFSHoster.py @@ -6,14 +6,14 @@ import re from module.plugins.internal.ReCaptcha import ReCaptcha from module.plugins.internal.SolveMedia import SolveMedia -from module.plugins.internal.SimpleHoster import SimpleHoster, create_getInfo, secondsToMidnight +from module.plugins.internal.SimpleHoster import SimpleHoster, create_getInfo, seconds_to_midnight from module.utils import html_unescape class XFSHoster(SimpleHoster): __name__ = "XFSHoster" __type__ = "hoster" - __version__ = "0.53" + __version__ = "0.54" __pattern__ = r'^unmatchable$' @@ -51,8 +51,8 @@ class XFSHoster(SimpleHoster): def setup(self): - self.chunkLimit = -1 if self.premium else 1 - self.resumeDownload = self.multiDL = self.premium + self.chunk_limit = -1 if self.premium else 1 + self.resume_download = self.multi_dl = self.premium def prepare(self): @@ -80,20 +80,20 @@ class XFSHoster(SimpleHoster): super(XFSHoster, self).prepare() if self.DIRECT_LINK is None: - self.directDL = self.premium + self.direct_d_l = self.premium - def handleFree(self, pyfile): + def handle_free(self, pyfile): for i in xrange(1, 6): - self.logDebug("Getting download link #%d" % i) + self.log_debug("Getting download link #%d" % i) - self.checkErrors() + self.check_errors() m = re.search(self.LINK_PATTERN, self.html, re.S) if m: break - data = self.getPostParameters() + data = self.get_post_parameters() self.req.http.c.setopt(pycurl.FOLLOWLOCATION, 0) @@ -109,24 +109,24 @@ class XFSHoster(SimpleHoster): if m: break else: - self.logError(data['op'] if 'op' in data else _("UNKNOWN")) + self.log_error(data['op'] if 'op' in data else _("UNKNOWN")) return "" self.link = m.group(1) - def handlePremium(self, pyfile): - return self.handleFree(pyfile) + def handle_premium(self, pyfile): + return self.handle_free(pyfile) - def handleMulti(self, pyfile): + def handle_multi(self, pyfile): if not self.account: self.fail(_("Only registered or premium users can use url leech feature")) - #only tested with easybytez.com + # only tested with easybytez.com self.html = self.load("http://www.%s/" % self.HOSTER_DOMAIN) - action, inputs = self.parseHtmlForm() + action, inputs = self.parse_html_form() upload_id = "%012d" % int(random.random() * 10 ** 12) action += upload_id + "&js_on=1&utype=prem&upload_type=url" @@ -135,19 +135,19 @@ class XFSHoster(SimpleHoster): inputs['url_mass'] = pyfile.url inputs['up1oad_type'] = 'url' - self.logDebug(action, inputs) + self.log_debug(action, inputs) self.req.setOption("timeout", 600) #: wait for file to upload to easybytez.com self.html = self.load(action, post=inputs) - self.checkErrors() + self.check_errors() - action, inputs = self.parseHtmlForm('F1') + action, inputs = self.parse_html_form('F1') if not inputs: self.retry(reason=self.info['error'] if 'error' in self.info else _("TEXTAREA F1 not found")) - self.logDebug(inputs) + self.log_debug(inputs) stmsg = inputs['st'] @@ -158,12 +158,12 @@ class XFSHoster(SimpleHoster): self.retry(20, 3 * 60, _("Can not leech file")) elif 'today' in stmsg: - self.retry(wait_time=secondsToMidnight(gmt=2), reason=_("You've used all Leech traffic today")) + self.retry(wait_time=seconds_to_midnight(gmt=2), reason=_("You've used all Leech traffic today")) else: self.fail(stmsg) - #get easybytez.com link for uploaded file + # get easybytez.com link for uploaded file m = re.search(self.LINK_LEECH_PATTERN, self.html) if m is None: self.error(_("LINK_LEECH_PATTERN not found")) @@ -174,22 +174,22 @@ class XFSHoster(SimpleHoster): self.link = header['location'] - def getPostParameters(self): + def get_post_parameters(self): if self.FORM_PATTERN or self.FORM_INPUTS_MAP: - action, inputs = self.parseHtmlForm(self.FORM_PATTERN or "", self.FORM_INPUTS_MAP or {}) + action, inputs = self.parse_html_form(self.FORM_PATTERN or "", self.FORM_INPUTS_MAP or {}) else: - action, inputs = self.parseHtmlForm(input_names={'op': re.compile(r'^download')}) + action, inputs = self.parse_html_form(input_names={'op': re.compile(r'^download')}) if not inputs: - action, inputs = self.parseHtmlForm('F1') + action, inputs = self.parse_html_form('F1') if not inputs: self.retry(reason=self.info['error'] if 'error' in self.info else _("TEXTAREA F1 not found")) - self.logDebug(inputs) + self.log_debug(inputs) if 'op' in inputs: if "password" in inputs: - password = self.getPassword() + password = self.get_password() if password: inputs['password'] = password else: @@ -199,9 +199,9 @@ class XFSHoster(SimpleHoster): m = re.search(self.WAIT_PATTERN, self.html) if m: wait_time = int(m.group(1)) - self.setWait(wait_time, False) + self.set_wait(wait_time, False) - self.handleCaptcha(inputs) + self.handle_captcha(inputs) self.wait() else: inputs['referer'] = self.pyfile.url @@ -216,11 +216,11 @@ class XFSHoster(SimpleHoster): return inputs - def handleCaptcha(self, inputs): + def handle_captcha(self, inputs): m = re.search(self.CAPTCHA_PATTERN, self.html) if m: captcha_url = m.group(1) - inputs['code'] = self.decryptCaptcha(captcha_url) + inputs['code'] = self.decrypt_captcha(captcha_url) return m = re.search(self.CAPTCHA_BLOCK_PATTERN, self.html, re.S) @@ -228,11 +228,11 @@ class XFSHoster(SimpleHoster): captcha_div = m.group(1) numerals = re.findall(r'(\d)', html_unescape(captcha_div)) - self.logDebug(captcha_div) + self.log_debug(captcha_div) inputs['code'] = "".join(a[1] for a in sorted(numerals, key=lambda num: int(num[0]))) - self.logDebug("Captcha code: %s" % inputs['code'], numerals) + self.log_debug("Captcha code: %s" % inputs['code'], numerals) return recaptcha = ReCaptcha(self) @@ -243,7 +243,7 @@ class XFSHoster(SimpleHoster): captcha_key = recaptcha.detect_key() else: - self.logDebug("ReCaptcha key: %s" % captcha_key) + self.log_debug("ReCaptcha key: %s" % captcha_key) if captcha_key: inputs['recaptcha_response_field'], inputs['recaptcha_challenge_field'] = recaptcha.challenge(captcha_key) @@ -257,7 +257,7 @@ class XFSHoster(SimpleHoster): captcha_key = solvemedia.detect_key() else: - self.logDebug("SolveMedia key: %s" % captcha_key) + self.log_debug("SolveMedia key: %s" % captcha_key) if captcha_key: inputs['adcopy_response'], inputs['adcopy_challenge'] = solvemedia.challenge(captcha_key) -- cgit v1.2.3