Python pywikibot.exception函数代码示例

    def run(self):
        """Process all pages in generator."""
        if not hasattr(self, 'generator'):
            raise NotImplementedError('Variable %s.generator not set.'
                                      % self.__class__.__name__)

        treat_missing_item = hasattr(self, 'treat_missing_item')

        try:
            for page in self.generator:
                if not page.exists():
                    pywikibot.output('%s doesn\'t exist.' % page)
                try:
                    item = pywikibot.ItemPage.fromPage(page)
                except pywikibot.NoPage:
                    item = None
                if not item:
                    if not treat_missing_item:
                        pywikibot.output(
                            '%s doesn\'t have a wikidata item.' % page)
                        #TODO FIXME: Add an option to create the item
                        continue
                self.treat(page, item)
        except QuitKeyboardInterrupt:
            pywikibot.output('\nUser quit %s bot run...' %
                             self.__class__.__name__)
        except KeyboardInterrupt:
            if config.verbose_output:
                raise
            else:
                pywikibot.output('\nKeyboardInterrupt during %s bot run...' %
                                 self.__class__.__name__)
        except Exception as e:
                pywikibot.exception(msg=e, tb=True)

 def revert(self, item):
     history = pywikibot.Page(self.site, item['title']).fullVersionHistory(
         total=2, rollback=self.rollback)
     if len(history) > 1:
         rev = history[1]
     else:
         return False
     comment = i18n.twtranslate(pywikibot.Site(), 'revertbot-revert', {'revid': rev[0], 'author': rev[2], 'timestamp': rev[1]})
     if self.comment:
         comment += ': ' + self.comment
     page = pywikibot.Page(self.site, item['title'])
     pywikibot.output(u"\n\n>>> \03{lightpurple}%s\03{default} <<<"
                      % page.title(asLink=True, forceInterwiki=True,
                                   textlink=True))
     if not self.rollback:
         old = page.text
         page.text = rev[3]
         pywikibot.showDiff(old, page.text)
         page.save(comment)
         return comment
     try:
         pywikibot.data.api.Request(action="rollback", title=page.title(), user=self.user,
                                        token=rev[4], markbot=1).submit()
     except pywikibot.data.api.APIError as e:
         if e.code == 'badtoken':
             pywikibot.error("There was an API token error rollbacking the edit")
         else:
             pywikibot.exception()
         return False
     return u"The edit(s) made in %s by %s was rollbacked" % (page.title(), self.user)

def main(*args):
    """
    Process command line arguments and invoke bot.

    If args is an empty list, sys.argv is used.

    @param args: command line arguments
    @type args: list of unicode
    """
    all = False
    new = False
    sysop = False
    for arg in pywikibot.handle_args(args):
        if arg in ('-all', '-update'):
            all = True
        elif arg == '-new':
            new = True
        elif arg == '-sysop':
            sysop = True
    if all:
        refresh_all(sysop=sysop)
    elif new:
        refresh_new(sysop=sysop)
    else:
        site = pywikibot.Site()
        watchlist = refresh(site, sysop=sysop)
        pywikibot.output(u'{0:d} pages in the watchlist.'.format(len(watchlist)))
        for page in watchlist:
            try:
                pywikibot.stdout(page.title())
            except pywikibot.InvalidTitle:
                pywikibot.exception()

    def getPDFTitle(self, ref, f):
        """Use pdfinfo to retrieve title from a PDF.

        FIXME: Unix-only, I'm afraid.

        """
        pywikibot.output(u'PDF file.')
        fd, infile = tempfile.mkstemp()
        urlobj = os.fdopen(fd, 'w+')
        urlobj.write(f.content)

        try:
            pdfinfo_out = subprocess.Popen([r"pdfinfo", "/dev/stdin"],
                                           stdin=urlobj, stdout=subprocess.PIPE,
                                           stderr=subprocess.PIPE,
                                           shell=False).communicate()[0]
            for aline in pdfinfo_out.splitlines():
                if aline.lower().startswith('title'):
                    ref.title = aline.split(None)[1:]
                    ref.title = ' '.join(ref.title)
                    if ref.title != '':
                        pywikibot.output(u'title: %s' % ref.title)
            pywikibot.output(u'PDF done.')
        except ValueError:
            pywikibot.output(u'pdfinfo value error.')
        except OSError:
            pywikibot.output(u'pdfinfo OS error.')
        except Exception:  # Ignore errors
            pywikibot.output(u'PDF processing error.')
            pywikibot.exception()
        finally:
            urlobj.close()
            os.unlink(infile)

 def revert(self, item):
     history = pywikibot.Page(self.site, item["title"]).fullVersionHistory(total=2, rollback=self.rollback)
     if len(history) > 1:
         rev = history[1]
     else:
         return False
     comment = i18n.twtranslate(
         pywikibot.Site(), "revertbot-revert", {"revid": rev[0], "author": rev[2], "timestamp": rev[1]}
     )
     if self.comment:
         comment += ": " + self.comment
     page = pywikibot.Page(self.site, item["title"])
     pywikibot.output(
         "\n\n>>> \03{lightpurple}%s\03{default} <<<" % page.title(asLink=True, forceInterwiki=True, textlink=True)
     )
     if not self.rollback:
         old = page.text
         page.text = rev[3]
         pywikibot.showDiff(old, page.text)
         page.save(comment)
         return comment
     try:
         pywikibot.data.api.Request(
             self.site,
             parameters={"action": "rollback", "title": page, "user": self.user, "token": rev[4], "markbot": True},
         ).submit()
     except pywikibot.data.api.APIError as e:
         if e.code == "badtoken":
             pywikibot.error("There was an API token error rollbacking the edit")
         else:
             pywikibot.exception()
         return False
     return "The edit(s) made in %s by %s was rollbacked" % (page.title(), self.user)

def main():
    local_args = pywikibot.handleArgs()
    cache_paths = None
    delete = False
    command = None

    for arg in local_args:
        if command == '':
            command = arg
        elif arg == '-delete':
            delete = True
        elif arg == '-password':
            command = 'has_password(entry)'
        elif arg == '-c':
            if command:
                pywikibot.error('Only one command may be executed.')
                exit(1)
            command = ''
        else:
            if not cache_paths:
                cache_paths = [arg]
            else:
                cache_paths.append(arg)

    func = None

    if not cache_paths:
        cache_paths = ['apicache', 'tests/apicache']

        # Also process the base directory, if it isnt the current directory
        if os.path.abspath(os.getcwd()) != pywikibot.config2.base_dir:
            cache_paths += [
                os.path.join(pywikibot.config2.base_dir, 'apicache')]

        # Also process the user home cache, if it isnt the config directory
        if os.path.expanduser('~/.pywikibot') != pywikibot.config2.base_dir:
            cache_paths += [
                os.path.join(os.path.expanduser('~/.pywikibot'), 'apicache')]

    if delete:
        action_func = lambda entry: entry._delete()
    else:
        action_func = lambda entry: pywikibot.output(entry)

    if command:
        try:
            command_func = eval('lambda entry: ' + command)
        except:
            pywikibot.exception()
            pywikibot.error(u'Can not compile command: %s' % command)
            exit(1)

        func = lambda entry: command_func(entry) and action_func(entry)
    else:
        func = action_func

    for cache_path in cache_paths:
        if len(cache_paths) > 1:
            pywikibot.output(u'Processing %s' % cache_path)
        process_entries(cache_path, func)

def main_script(page, rev=None, params=NotImplemented):  # pylint: disable=unused-argument
    """Main thread."""
    # http://opensourcehacker.com/2011/02/23/temporarily-capturing-python-logging-output-to-a-string-buffer/
    # https://docs.python.org/release/2.6/library/logging.html
    from io import StringIO
    import logging

    # safety; default mode is safe (no writing)
    pywikibot.config.simulate = True

    pywikibot.output(u'--- ' * 20)

    buffer = StringIO()
    rootLogger = logging.getLogger()

    logHandler = logging.StreamHandler(buffer)
    formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
    logHandler.setFormatter(formatter)
    rootLogger.addHandler(logHandler)

    sys.stdout = buffer
    sys.stderr = buffer

    # all output to logging and stdout/stderr is catched BUT NOT lua output (!)
    if rev is None:
        code = page.get()               # shell; "on demand"
    else:
        code = page.getOldVersion(rev)  # crontab; scheduled
    try:
        exec(code)
    except:
        # (done according to subster in trunk and submit in rewrite/.../data/api.py)
        pywikibot.exception(tb=True)  # secure traceback print (from api.py submit)

    sys.stdout = sys.__stdout__
    sys.stderr = sys.__stderr__

    # Remove our handler
    rootLogger.removeHandler(logHandler)

    logHandler.flush()
    buffer.flush()

    pywikibot.output(u'--- ' * 20)

    # safety; restore settings
    pywikibot.config.simulate = __simulate
    sys.argv = __sys_argv

    pywikibot.output(
        u'environment: garbage; %s / memory; %s / members; %s' % (
            gc.collect(),
            resource.getrusage(resource.RUSAGE_SELF).ru_maxrss * resource.getpagesize(),
            len(dir())))
    # 'len(dir())' is equivalent to 'len(inspect.getmembers(__main__))'

    # append result to output page
    if rev is None:
        wiki_logger(buffer.getvalue(), page, rev)

 def run(self):
     """Starts the robot."""
     self.templateTitles = self.getTemplateSynonyms(self.templateTitle)
     for page in self.generator:
         try:
             self.processPage(page)
         except Exception as e:
             pywikibot.exception(msg=e, tb=True)

def main():
    local_args = pywikibot.handleArgs()
    cache_paths = None
    delete = False
    command = None

    for arg in local_args:
        if command == "":
            command = arg
        elif arg == "-delete":
            delete = True
        elif arg == "-password":
            command = "has_password(entry)"
        elif arg == "-c":
            if command:
                pywikibot.error("Only one command may be executed.")
                exit(1)
            command = ""
        else:
            if not cache_paths:
                cache_paths = [arg]
            else:
                cache_paths.append(arg)

    func = None

    if not cache_paths:
        cache_paths = ["apicache", "tests/apicache"]

        # Also process the base directory, if it isnt the current directory
        if os.path.abspath(os.getcwd()) != pywikibot.config2.base_dir:
            cache_paths += [os.path.join(pywikibot.config2.base_dir, "apicache")]

        # Also process the user home cache, if it isnt the config directory
        if os.path.expanduser("~/.pywikibot") != pywikibot.config2.base_dir:
            cache_paths += [os.path.join(os.path.expanduser("~/.pywikibot"), "apicache")]

    if delete:
        action_func = lambda entry: entry._delete()
    else:
        action_func = lambda entry: pywikibot.output(entry)

    if command:
        try:
            command_func = eval("lambda entry: " + command)
        except:
            pywikibot.exception()
            pywikibot.error("Can not compile command: %s" % command)
            exit(1)

        func = lambda entry: command_func(entry) and action_func(entry)
    else:
        func = action_func

    for cache_path in cache_paths:
        if len(cache_paths) > 1:
            pywikibot.output("Processing %s" % cache_path)
        process_entries(cache_path, func)

 def test_exception(self):
     class TestException(Exception):
         pass
     try:
         raise TestException("Testing Exception")
     except TestException:
         pywikibot.exception("exception")
     self.assertEqual(newstdout.getvalue(), "")
     self.assertEqual(newstderr.getvalue(), "ERROR: TestException: Testing Exception\n")

    def treat(self, page):
        pywikibot.output(u'parsing {}'.format(page))
        item = pywikibot.ItemPage.fromPage(page)
        if not item.exists():
            pywikibot.warning(u'item not found for {}'.format(page))
            return
        text = page.text
        code = mwparserfromhell.parse(page.text)
        removed = []

        for template in code.ifilter_templates():
            if template.name.strip().title() != 'Autore':
                continue
            for pcode, pname in self.params.items():
                if template.has(pname, False):
                    val = template.get(pname).value.strip()
                    if val == '' or getattr(self, 'handle_' + pcode)(val, item) is True:
                        template.remove(pname, keep_field=False)
                        removed.append(pname)

        sections = {}
        sbeg = None
        elements = code.filter()
        for el in code.ifilter_tags():
            if el.tag == 'section' and el.self_closing is True:
                if el.has('begin'):
                    sbeg = el
                elif sbeg and el.has('end'):
                    sname = unicode(sbeg.get('begin').value)
                    if unicode(el.get('end').value) == sname:
                        start = elements.index(sbeg) + 2 + len(sbeg.attributes) * 2
                        sections[sname] = [sbeg] + elements[start:elements.index(el) + 1]
        for scode, sname in self.params.items():
            if sname in sections:
                val = ''.join(map(unicode, sections[sname][1:-1])).strip()
                if val == '' or getattr(self, 'handle_' + scode)(val, item) is True:
                    for el in sections[sname]:
                        code.remove(el)
                    removed.append(sname)

        if len(removed) == 6:
            remset = list(set(removed))
            if len(remset) != 3:
                return
            removed = list(remset)
            text = unicode(code)
            text = re.sub('(?<=\/\>)(\n\s*)+(?=\n\<)', '', text)
            comment = i18n.translate(page.site, wikidata_summary[1],
                                     {'counter': len(removed),
                                      'params': page.site.list_to_text(removed),
                                      'id': item.getID()
                                      })
            try:
                self.userPut(page, page.text, text, comment=comment, minor=True, botflag=True)
            except Exception as e:
                pywikibot.exception(e)

    def setUpClass(cls):
        """
        Set up the test class.

        Prevent tests running if the host is down.
        """
        super(CheckHostnameMixin, cls).setUpClass()

        if not hasattr(cls, 'sites'):
            return

        for key, data in cls.sites.items():
            if 'hostname' not in data:
                raise Exception('%s: hostname not defined for %s'
                                % (cls.__name__, key))
            hostname = data['hostname']

            if hostname in cls._checked_hostnames:
                if isinstance(cls._checked_hostnames[hostname], Exception):
                    raise unittest.SkipTest(
                        '%s: hostname %s failed (cached): %s'
                        % (cls.__name__, hostname,
                           cls._checked_hostnames[hostname]))
                elif cls._checked_hostnames[hostname] is False:
                    raise unittest.SkipTest('%s: hostname %s failed (cached)'
                                            % (cls.__name__, hostname))
                else:
                    continue

            e = None
            try:
                if '://' not in hostname:
                    hostname = 'http://' + hostname
                r = http.fetch(uri=hostname,
                               default_error_handling=False)
                if r.exception:
                    e = r.exception
                else:
                    if r.status not in [200, 301, 302, 303, 307, 308]:
                        raise ServerError('HTTP status: %d' % r.status)
                    r.content  # default decode may raise exception
            except Exception as e2:
                pywikibot.error('%s: accessing %s caused exception:'
                                % (cls.__name__, hostname))
                pywikibot.exception(e2, tb=True)
                e = e2
                pass

            if e:
                cls._checked_hostnames[hostname] = e
                raise unittest.SkipTest(
                    '%s: hostname %s failed: %s'
                    % (cls.__name__, hostname, e))

            cls._checked_hostnames[hostname] = True

    def test_exception(self):
        class TestException(Exception):

            """Test exception."""

        try:
            raise TestException('Testing Exception')
        except TestException:
            pywikibot.exception('exception')
        self.assertEqual(newstdout.getvalue(), '')
        self.assertEqual(newstderr.getvalue(), 'ERROR: TestException: Testing Exception\n')

 def safe_execute(self, method, text):
     """Execute the method and catch exceptions if enabled."""
     result = None
     try:
         result = method(text)
     except Exception as e:
         if self.ignore == CANCEL_METHOD:
             pywikibot.warning('Unable to perform "{0}" on "{1}"!'.format(method.__name__, self.title))
             pywikibot.exception(e)
         else:
             raise
     return text if result is None else result

def _parse_command(command, name):
    obj = globals().get(command)
    if callable(obj):
        return obj
    else:
        try:
            return eval('lambda entry: ' + command)
        except:
            pywikibot.exception()
            pywikibot.error(
                'Cannot compile {0} command: {1}'.format(name, command))
            return None