def pre(taskid=-1, lock=None, sites=[], continuous=False, main=None):
    """
    Return argument list, site object, and configuration of the script.
    This function also handles default arguments, generates lockfile
    and halt the script if lockfile exists before.
    """
    import imp

    global info
    info["main"] = main == "__main__"
    if continuous:
        lock = False
    pywikibot.handleArgs("-log")
    pywikibot.output("start task #%s at %s" % (taskid, getTime()))
    info["taskid"] = taskid
    info["lock"] = lock
    info["lockfile"] = simplifypath([os.environ["WPROBOT_DIR"], "tmp", info["basescript"] + ".lock"])
    info["continuous"] = continuous
    if os.path.exists(info["lockfile"]) and lock:
        error("lockfile found. unable to execute the script.")
        if info["main"]:
            pywikibot.stopme()
        sys.exit(ExitCode.LockFileError)

    open(info["lockfile"], "w").close()

    args = pywikibot.handleArgs()  # must be called before Site()
    site = pywikibot.Site()
    info["site"] = site

    confpath = simplifypath([os.environ["WPROBOT_DIR"], "conf", info["basescript"]])

    module = imp.load_source("conf", confpath) if os.path.exists(confpath) else None
    return args, site, module

def main():


    db = oursql.connect(db='wikidatawiki_p',
        host="wikidatawiki-p.rrdb.toolserver.org",
        read_default_file=os.path.expanduser("~/.my.cnf"),
        charset=None,
        use_unicode=False
    )


    pywikibot.handleArgs()

    cur = db.cursor()
    cur.execute(query)
    data=cur.fetchall()
    for row in data:
        check_item(row[0])
    global REPORT
    global DUPES
    rfd() #before dupes
    pg = pywikibot.Page(wikidata, 'User:Legobot/Dupes')
    pg.put(REPORT, 'Bot: Updating list of dupes')
    #save dupes locally for null edits
    fname = 'wd_null.txt'
    if os.path.exists(fname):
        with open(fname, 'r') as f:
            old = f.read()
    else:
        old = ''
    new = old + DUPES
    with open(fname, 'w') as f:
        f.write(new)
    print 'Saved dupe file'

def main():
    gen = pagegenerators.GeneratorFactory()
    commandline_claims = list()
    for arg in pywikibot.handleArgs():
        if gen.handleArg(arg):
            continue
        commandline_claims.append(arg)
    if len(commandline_claims) % 2:
        raise ValueError  # or something.
    claims = list()

    repo = pywikibot.Site().data_repository()

    for i in xrange (0, len(commandline_claims), 2):
        claim = pywikibot.Claim(repo, commandline_claims[i])
        if claim.getType() == 'wikibase-item':
            target = pywikibot.ItemPage(repo, commandline_claims[i+1])
        elif claim.getType() == 'string':
            target = commandline_claims[i+1]
        else:
            raise NotImplementedError("%s datatype is not yet supported by claimit.py" % claim.getType())
        claim.setTarget(target)
        claims.append(claim)

    generator = gen.getCombinedGenerator()
    if not generator:
        # FIXME: Should throw some help
        return
    
    bot = ClaimRobot(generator, claims)
    bot.run()

def main(*args):
    global bot
    # Disable cosmetic changes because we don't want to modify any page
    # content, so that we don't flood the histories with minor changes.
    config.cosmetic_changes = False
    #page generator
    gen = None
    genFactory = pagegenerators.GeneratorFactory()
    redirs = False
    # If the user chooses to work on a single page, this temporary array is
    # used to read the words from the page title. The words will later be
    # joined with spaces to retrieve the full title.
    pageTitle = []
    for arg in pywikibot.handleArgs(*args):
        if genFactory.handleArg(arg):
            continue
        if arg == '-redir':
            redirs = True
        else:
            pageTitle.append(arg)
    pywikibot.Site().login()
    gen = genFactory.getCombinedGenerator()
    if not gen:
        if pageTitle:
            # work on a single page
            page = pywikibot.Page(pywikibot.Link(' '.join(pageTitle)))
            gen = iter([page])
        else:
            pywikibot.showHelp()
            return
    preloadingGen = pagegenerators.PreloadingGenerator(gen)
    bot = TouchBot(preloadingGen, redirs)
    bot.run()

def main():
    featured = False
    gen = None

    # Process global args and prepare generator args parser
    local_args = pywikibot.handleArgs()
    genFactory = pagegenerators.GeneratorFactory()

    for arg in local_args:
        if arg == '-featured':
            featured = True
        else:
            genFactory.handleArg(arg)

    mysite = pywikibot.Site()
    if mysite.sitename() == 'wikipedia:nl':
        pywikibot.output(
            u'\03{lightred}There is consensus on the Dutch Wikipedia that bots should not be used to fix redirects.\03{default}')
        sys.exit()

    if featured:
        featuredList = i18n.translate(mysite, featured_articles)
        ref = pywikibot.Page(pywikibot.Site(), featuredList)
        gen = pagegenerators.ReferringPageGenerator(ref)
        gen = pagegenerators.NamespaceFilterPageGenerator(gen, [0])
    if not gen:
        gen = genFactory.getCombinedGenerator()
    if gen:
        for page in pagegenerators.PreloadingGenerator(gen):
            workon(page)
    else:
        pywikibot.showHelp('fixing_redirects')

def main():
    genFactory = pagegenerators.GeneratorFactory()
    commandline_arguments = list()
    templateTitle = u''
    for arg in pywikibot.handleArgs():
        if arg.startswith('-template'):
            if len(arg) == 9:
                templateTitle = pywikibot.input(
                    u'Please enter the template to work on:')
            else:
                templateTitle = arg[10:]
        elif genFactory.handleArg(arg):
            continue
        else:
            commandline_arguments.append(arg)

    if len(commandline_arguments) % 2 or not templateTitle:
        raise ValueError  # or something.
    fields = dict()

    for i in xrange(0, len(commandline_arguments), 2):
        fields[commandline_arguments[i]] = commandline_arguments[i + 1]
    if templateTitle:
        gen = pagegenerators.ReferringPageGenerator(
            pywikibot.Page(pywikibot.getSite(),
                           "Template:%s" % templateTitle),
            onlyTemplateInclusion=True)
    else:
        gen = genFactory.getCombinedGenerator()
    if not gen:
        # TODO: Build a transcluding generator based on templateTitle
        return

    bot = HarvestRobot(gen, templateTitle, fields)
    bot.run()

def main():
    '''
    Main loop. Get a generator and options.
    '''
    generator = None
    parent = u''
    basename = u''
    always = False

    # Process global args and prepare generator args parser
    local_args = pywikibot.handleArgs()
    genFactory = pagegenerators.GeneratorFactory()

    for arg in local_args:
        if arg == '-always':
            always = True
        elif arg.startswith('-parent:'):
            parent = arg[len('-parent:'):].strip()
        elif arg.startswith('-basename'):
            basename = arg[len('-basename:'):].strip()
        else:
            genFactory.handleArg(arg)

    generator = genFactory.getCombinedGenerator()
    if generator:
        for page in generator:
            createCategory(page, parent, basename)
    else:
        pywikibot.output(u'No pages to work on')

    pywikibot.output(u'All done')

def main():
    genFactory = pagegenerators.GeneratorFactory()
    pageName = ''
    summary = None
    always = False
    undelete = False
    generator = None

    # read command line parameters
    local_args = pywikibot.handleArgs()
    mysite = pywikibot.Site()

    for arg in local_args:
        if arg == '-always':
            always = True
        elif arg.startswith('-summary'):
            if len(arg) == len('-summary'):
                summary = pywikibot.input(u'Enter a reason for the deletion:')
            else:
                summary = arg[len('-summary:'):]
        elif arg.startswith('-images'):
            pywikibot.output('\n\03{lightred}-image option is deprecated. '
                             'Please use -imageused instead.\03{default}\n')
            local_args.append('-imageused' + arg[7:])
        elif arg.startswith('-undelete'):
            undelete = True
        else:
            genFactory.handleArg(arg)
            found = arg.find(':') + 1
            if found:
                pageName = arg[found:]

        if not summary:
            if pageName:
                if arg.startswith('-cat') or arg.startswith('-subcats'):
                    summary = i18n.twtranslate(mysite, 'delete-from-category',
                                               {'page': pageName})
                elif arg.startswith('-links'):
                    summary = i18n.twtranslate(mysite, 'delete-linked-pages',
                                               {'page': pageName})
                elif arg.startswith('-ref'):
                    summary = i18n.twtranslate(mysite, 'delete-referring-pages',
                                               {'page': pageName})
                elif arg.startswith('-imageused'):
                    summary = i18n.twtranslate(mysite, 'delete-images',
                                               {'page': pageName})
            elif arg.startswith('-file'):
                summary = i18n.twtranslate(mysite, 'delete-from-file')
    generator = genFactory.getCombinedGenerator()
    # We are just deleting pages, so we have no need of using a preloading
    # page generator to actually get the text of those pages.
    if generator:
        if summary is None:
            summary = pywikibot.input(u'Enter a reason for the %sdeletion:'
                                      % ['', 'un'][undelete])
        bot = DeletionRobot(generator, summary, always, undelete)
        bot.run()
    else:
        # Show help text from the top of this file
        pywikibot.showHelp()

def main(args):
    """
    Main loop. Get a generator and options. Work on all images in the generator.

    """
    generator = None
    onlyFilter = False
    onlyUncat = False
    genFactory = pagegenerators.GeneratorFactory()

    global search_wikis
    global hint_wiki

    site = pywikibot.getSite(u'commons', u'commons')
    pywikibot.setSite(site)
    for arg in pywikibot.handleArgs():
        if arg == '-onlyfilter':
            onlyFilter = True
        elif arg == '-onlyuncat':
            onlyUncat = True
        elif arg.startswith('-hint:'):
            hint_wiki = arg[len('-hint:'):]
        elif arg.startswith('-onlyhint'):
            search_wikis = arg[len('-onlyhint:'):]
        else:
            genFactory.handleArg(arg)

    generator = genFactory.getCombinedGenerator()
    if not generator:
        generator = pagegenerators.CategorizedPageGenerator(
            catlib.Category(site, u'Category:Media needing categories'),
            recurse=True)
    initLists()
    categorizeImages(generator, onlyFilter, onlyUncat)
    pywikibot.output(u'All done')

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():
	
	selectedSet = None
	always = False
	idProp = insertProp = filename = False
	
	# Handles command-line arguments for pywikibot.
	for arg in pywikibot.handleArgs():
		if arg.startswith('-identifier:'):
			idProp = arg.replace('-identifier:', '')
		if arg.startswith('-insert:'):
			insertProp = arg.replace('-insert:', '')
		if arg.startswith('-file:'):
			filename = arg.replace('-file:', '')
		if arg.startswith('-always'):
			always=True
	
	if idProp == None or insertProp == None or filename == None:
		pywikibot.output('All arguments are required!')
		return
	
	matchDict = {}
	with open(filename, 'r') as f:
		reader = csv.reader(f, delimiter=";")
		for row in reader:
			matchDict[row[0]] = row[1]
		
	bot = PropertyBot(always=always, idProp=idProp, insertProp=insertProp, matchDict=matchDict)
	bot.run()

def main(*args):
    gen = None
    notitle = False
    page_get = False

    # Process global args and prepare generator args parser
    local_args = pywikibot.handleArgs(*args)
    genFactory = GeneratorFactory()

    for arg in local_args:
        if arg == '-notitle':
            notitle = True
        elif arg == '-get':
            page_get = True
        else:
            genFactory.handleArg(arg)

    gen = genFactory.getCombinedGenerator()
    if gen:
        for i, page in enumerate(gen, start=1):
            if not notitle:
                pywikibot.stdout("%4d: %s" % (i, page.title()))
            if page_get:
                # TODO: catch exceptions
                pywikibot.output(page.text, toStdout=True)
    else:
        pywikibot.showHelp()

def main():
    countrycode = u''
    lang = u''
    municipality = u''
    minimum = 15
    conn = None
    cursor = None
    # Connect database, we need that
    (conn, cursor) = connect_to_monuments_database()

    for arg in pywikibot.handleArgs():
        option, sep, value = arg.partition(':')
        if option == '-countrycode':
            countrycode = value
        elif option == '-langcode':
            lang = value
        elif option == '-municipality':
            municipality = value
        elif option == '-minimum':
            minimum = int(value)
        else:
            raise Exception(
                u'Bad parameters. Expected "-countrycode", "-langcode", '
                u'"-municipality", "-minimum" or pywikibot args. '
                u'Found "{}"'.format(option))

    if countrycode and lang and municipality:
        addresses = getAddresses(countrycode, lang, municipality, conn, cursor)
        printTopStreets(addresses, minimum)
    else:
        print u'Usage'

    close_database_connection(conn, cursor)

def main():
    # This temporary array is used to read the page title if one single
    # page that should be unlinked.
    pageTitle = []
    # Which namespaces should be processed?
    # default to [] which means all namespaces will be processed
    namespaces = []
    always = False

    for arg in pywikibot.handleArgs():
        if arg.startswith('-namespace:'):
            try:
                namespaces.append(int(arg[11:]))
            except ValueError:
                namespaces.append(arg[11:])
        elif arg == '-always':
            always = True
        else:
            pageTitle.append(arg)

    if pageTitle:
        page = pywikibot.Page(pywikibot.getSite(), ' '.join(pageTitle))
        bot = UnlinkBot(page, namespaces, always)
        bot.run()
    else:
        pywikibot.showHelp('unlink')

def create(year):
    target = str(year)+' in the Palestinian territories'
    pg1 = pywikibot.Page(site, str(year)+' of the Palestinian territories')
    pg2 = pywikibot.Page(site, str(year)+' in Palestine')
    pg3 = pywikibot.Page(site, str(year)+' in the Palestinian National Authority'
    pg4 = pywikibot.Page(site, str(year)+' of the Palestinian National Authority')
    pg5 = pywikibot.Page(site, str(year)+' of Palestine')
    for page in [pg1, pg2, pg3, pg4, pg5]:
        if page.exists():
            continue
        print 'Creating %s' % page.title(asLink=True)
        page.put(REDIRECT % target, 'BOT EDIT: Creating redirect to [[%s]]' % target)
        talk = page.toggleTalkPage()
        if not talk.exists():
            print 'Creating %s' % talk.title(asLink=True)
            tag = '{{WikiProject Palestine|class=Redirect}}'
            summary = 'Bot: Tagging for [[Wikipedia:WikiProject Palestine]]'
            talk.put(tag, summary)
    
def main():
    year = 2000
    while year < 2012:
        create(year)
        year += 1
    create(1987)

if __name__ == "__main__":
    pywikibot.handleArgs()
    main()

def main():
    # This temporary string is used to read the title
    # of the page that should be unlinked.
    page_title = None
    options = {}

    for arg in pywikibot.handleArgs():
        if arg.startswith('-namespace:'):
            if 'namespaces' not in options:
                options['namespaces'] = []
            try:
                options['namespaces'].append(int(arg[11:]))
            except ValueError:
                options['namespaces'].append(arg[11:])
        elif arg == '-always':
            options['always'] = True
        else:
            page_title = arg

    if page_title:
        page = pywikibot.Page(pywikibot.Site(), page_title)
        bot = UnlinkBot(page, **options)
        bot.run()
    else:
        pywikibot.showHelp()

def main():
    always = False

    for arg in pywikibot.handleArgs():
        if arg == '-always':
            always = True

    mysite = pywikibot.Site()
    # If anything needs to be prepared, you can do it here
    template_image = i18n.translate(pywikibot.Site(),
                                    template_to_the_image)
    template_user = i18n.translate(pywikibot.Site(),
                                   template_to_the_user)
    except_text_translated = i18n.translate(pywikibot.Site(), except_text)
    if not(template_image and template_user and except_text_translated):
        pywikibot.warning(u'This script is not localized for %s site.' % mysite)
        return
    generator = pagegenerators.UnusedFilesGenerator()
    generator = pagegenerators.PreloadingGenerator(generator)
    for image in generator:
        if (except_text_translated.encode('utf-8')
                not in image.getImagePageHtml() and
                u'http://' not in image.text):
            pywikibot.output(u"\n\n>>> \03{lightpurple}%s\03{default} <<<"
                             % image.title())
            if template_image in image.text:
                pywikibot.output(u"%s done already"
                                 % image.title(asLink=True))
                continue
            appendtext(image, u"\n\n" + template_image, always)
            uploader = image.getFileVersionHistory().pop(0)['user']
            user = pywikibot.User(mysite, uploader)
            usertalkpage = user.getUserTalkPage()
            msg2uploader = template_user % {'title': image.title()}
            appendtext(usertalkpage, msg2uploader, always)

def main():
    """ Script entry point. """
    local_args = pywikibot.handleArgs()
    all = False
    new = False
    sysop = False
    for arg in local_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_all(new, sysop=sysop)
    else:
        site = pywikibot.Site()
        refresh(site, sysop=sysop)

        watchlist = get(site)
        pywikibot.output(u'%i pages in the watchlist.' % len(watchlist))
        for pageName in watchlist:
            pywikibot.output(pageName, toStdout=True)

def main(*args):
    '''
    Grab a bunch of images and tag them if they are not categorized.
    '''
    generator = None
    genFactory = pagegenerators.GeneratorFactory()

    # use the default imagerepository normally commons
    site = pywikibot.getSite().image_repository()
    site.login()
    for arg in pywikibot.handleArgs(*args):
        if arg.startswith('-yesterday'):
            generator = uploadedYesterday(site)
        elif arg.startswith('-recentchanges'):
            generator = recentChanges(site=site, delay=120)
        else:
            genFactory.handleArg(arg)
    if not generator:
        generator = genFactory.getCombinedGenerator()
    if not generator:
        pywikibot.output(
          u'You have to specify the generator you want to use for the program!')
    else:
        pregenerator = site.preloadpages(generator)
        for page in pregenerator:
            pywikibot.output(page.title())
            if page.exists() and (page.namespace() == 6) \
                   and (not page.isRedirectPage()) :
                if isUncat(page):
                    addUncat(page)

def main():
    """Main loop. Get a generator and options."""
    parent = None
    basename = None
    options = {}

    # Process global args and prepare generator args parser
    local_args = pywikibot.handleArgs()
    genFactory = pagegenerators.GeneratorFactory()

    for arg in local_args:
        if arg == '-always':
            options['always'] = True
        elif arg.startswith('-parent:'):
            parent = arg[len('-parent:'):].strip()
        elif arg.startswith('-basename'):
            basename = arg[len('-basename:'):].strip()
        else:
            genFactory.handleArg(arg)

    generator = genFactory.getCombinedGenerator()
    if generator and parent and basename:
        bot = CreateCategoriesBot(generator, parent, basename, **options)
        bot.run()
        pywikibot.output(u'All done')
    else:
        pywikibot.output(u'No pages to work on')
        pywikibot.showHelp()