def main(*args):
"""
Main function. Grab a generator and pass it to the bot to work on
"""
all = False
fix = True
create = False
for arg in pywikibot.handle_args(args):
if arg=='-all':
all = True
elif arg=='-fix':
fix = True
elif arg=='-create':
create = True
repo = pywikibot.Site().data_repository()
generator = None
if all:
query = u"""SELECT
"""
generator = pagegenerators.PreloadingEntityGenerator(pagegenerators.WikidataSPARQLPageGenerator(query, site=repo))
elif fix:
query = u"""SELECT ?item WHERE { ?item wdt:P1435 wd:Q13423591 . ?item wdt:P359 ?id } LIMIT 5000"""
generator = pagegenerators.PreloadingEntityGenerator(pagegenerators.WikidataSPARQLPageGenerator(query, site=repo))
elif create:
query = u"""SELECT """
generator = pagegenerators.PreloadingEntityGenerator(pagegenerators.WikidataSPARQLPageGenerator(query, site=repo))
if generator:
rijksmonumentenComplexBot = RijksmonumentenComplexBot(generator)
rijksmonumentenComplexBot.run()
def main(*args):
"""
Main function. Grab a generator and pass it to the bot to work on
"""
series = None
report = None
for arg in pywikibot.handle_args(args):
if arg.startswith('-series:'):
if len(arg) == 8:
series = pywikibot.input(
u'Please enter the Q id of the series to work on:')
else:
series = arg[8:]
elif arg.startswith('-report:'):
if len(arg) == 8:
report = pywikibot.input(
u'Please enter the name of the page to report on:')
else:
report = arg[8:]
basequery = u"""SELECT DISTINCT ?item WHERE {
?item wdt:P31 wd:Q21191270 .
?item wdt:P179 wd:%s .
MINUS { ?item wdt:P345 [] . ?item wdt:P1191 []}
#{ ?item wdt:P155 ?otheritem } UNION { ?item wdt:P156 ?otheritem }
#?otheritem wdt:P345 [] .
}"""
repo = pywikibot.Site().data_repository()
if series:
query = basequery % (series, )
generator = pagegenerators.PreloadingEntityGenerator(
pagegenerators.WikidataSPARQLPageGenerator(query, site=repo))
imdbFinderBot = IMDBFinderBot(generator, series)
imdbFinderBot.run()
else:
seriesquery = u"""SELECT DISTINCT ?item WHERE {
?episode wdt:P31 wd:Q21191270 .
?episode wdt:P179 ?item .
MINUS { ?episode wdt:P345 [] . ?item wdt:P1191 []}
{ ?episode wdt:P155 ?otheritem } UNION { ?episode wdt:P156 ?otheritem }
?otheritem wdt:P345 [] .
?otheritem wdt:P179 ?item .
}"""
seriesgen = pagegenerators.PreloadingEntityGenerator(
pagegenerators.WikidataSPARQLPageGenerator(seriesquery, site=repo))
for seriespage in seriesgen:
series = seriespage.title()
query = basequery % (series, )
generator = pagegenerators.PreloadingEntityGenerator(
pagegenerators.WikidataSPARQLPageGenerator(query, site=repo))
imdbFinderBot = IMDBFinderBot(generator, series)
imdbFinderBot.run()
def main():
query = u"""SELECT DISTINCT ?item WHERE {
?item wdt:P31 wd:Q3305213 .
?item wdt:P195 wd:Q28045665 .
?item wdt:P195 wd:Q18600731 .
?item p:P217 ?inv1statement .
?inv1statement ps:P217 ?inv .
?inv1statement pq:P195 wd:Q28045665 .
?item p:P217 ?inv2statement .
?inv2statement ps:P217 ?inv .
?inv2statement pq:P195 wd:Q18600731 .
MINUS {
?item wdt:P195 wd:Q28045660 .
?item wdt:P195 wd:Q28045674 .
?item wdt:P195 wd:Q2066737 .
?item p:P217 ?inv3statement .
?inv3statement ps:P217 ?inv .
?inv3statement pq:P195 wd:Q28045660 .
?item p:P217 ?inv4statement .
?inv4statement ps:P217 ?inv .
?inv4statement pq:P195 wd:Q28045674 .
?item p:P217 ?inv5statement .
?inv5statement ps:P217 ?inv .
?inv5statement pq:P195 wd:Q2066737 .
}
}"""
repo = pywikibot.Site().data_repository()
generator = pagegenerators.PreloadingEntityGenerator(
pagegenerators.WikidataSPARQLPageGenerator(query, site=repo))
provenanceBot = ProvenanceBot(generator)
provenanceBot.run()
def findPerson(self, name, yob, yod):
"""
Find a person.
:param name: Name of the person
:param yob: Year of birth of the person
:param yod: Year of death of the person
:return: ItemPage if a person is found
"""
# Search Wikidata for a suitable candidate, tell the search to only return humans
searchstring = u'"%s" haswbstatement:P31=Q5' % (name,)
persongen = pagegenerators.PreloadingEntityGenerator(pagegenerators.WikidataItemGenerator(pagegenerators.SearchPageGenerator(searchstring, step=None, total=50, namespaces=[0], site=self.repo)))
foundperson = False
for personitem in persongen:
#print (u'Possible match %s' % (personitem.title(),))
if personitem.isRedirectPage():
personitem = personitem.getRedirectTarget()
# See if the label or one of the aliases of the creatoritem matches the string we have. Only label is case insensitive.
#if (personitem.get().get('labels').get('en') and personitem.get().get('labels').get('en').lower() == name.lower()) or (personitem.get().get('aliases').get('en') and name in personitem.get().get('aliases').get('en')):
# print (u'Label match for %s' % (personitem.title(),))
# # Check of year of birth and year of death match
if u'P569' in personitem.get().get('claims') and u'P570' in personitem.get().get('claims'):
dob = personitem.get().get('claims').get('P569')[0].getTarget()
dod = personitem.get().get('claims').get('P570')[0].getTarget()
foundperson = True
if dob and dod:
#print (u'Date found dob "%s" "%s" "%s"' % (dob, dob.year, yob))
#print (u'Date found dod "%s" "%s" "%s"' % (dod, dod.year, yod))
if int(dob.year)==int(yob) and int(dod.year)==int(yod):
#print (u'maaaaaaaaaaaaaaaaaaaaaaaatcchhhhh')
return personitem
return foundperson
def add_painting_surface_qualifier(repo, materialqid):
"""
Add the missing painting surface qualifier
:param repo: The repo to work on
:param materialqid: Qid of material to work on
:return: Edit in place
"""
material = pywikibot.ItemPage(repo, materialqid)
paintingsurface = pywikibot.ItemPage(repo, 'Q861259')
query = """SELECT ?item WHERE {
?item p:P186 ?madestatement .
?madestatement ps:P186 wd:%s .
MINUS { ?madestatement pq:P518 wd:Q861259 }
?item wdt:P31 wd:Q3305213 .
} LIMIT 10000""" % (materialqid, )
generator = pagegenerators.PreloadingEntityGenerator(pagegenerators.WikidataSPARQLPageGenerator(query, site=repo))
for item in generator:
data = item.get()
claims = data.get('claims')
if 'P186' in claims:
for madeclaim in claims.get('P186'):
# Only work on the material claim if it doesn't have any qualifiers
if madeclaim.getTarget()==material and not madeclaim.qualifiers:
summary = '[[Wikidata:WikiProject sum of all paintings/Made from material#Normalization|Made from material normalization for paintings]]: Add missing painting surface qualifier'
pywikibot.output('Add missing painting surface qualifier on %s' % (item.title(),))
newqualifier = pywikibot.Claim(repo, 'P518')
newqualifier.setTarget(paintingsurface)
madeclaim.addQualifier(newqualifier, summary=summary)
def main(*args):
"""
Do a query and have the bot process the items
:param args:
:return:
"""
# The queries for paintings without a creator, all or a specific collection
query = u'SELECT ?item WHERE { ?item wdt:P31 wd:Q3305213 . MINUS { ?item wdt:P170 [] } }'
querycollection = u"""SELECT ?item WHERE { ?item wdt:P31 wd:Q3305213 .
?item wdt:P195 wd:%s .
MINUS { ?item wdt:P170 [] }
}"""
for arg in pywikibot.handle_args(args):
if arg.startswith('-collectionid'):
if len(arg) == 13:
collectionid = pywikibot.input(
u'Please enter the collectionid you want to work on:')
else:
collectionid = arg[14:]
query = querycollection % (collectionid, )
repo = pywikibot.Site().data_repository()
generator = pagegenerators.PreloadingEntityGenerator(
pagegenerators.WikidataSPARQLPageGenerator(query, site=repo))
paintingBot = PaintingBot(generator, change=False)
paintingBot.run()
def main():
repo = pywikibot.Site().data_repository()
query = u"""SELECT ?item WHERE {
?item wdt:P214 ?viafid .
{ ?item wdt:P27 wd:Q31 } UNION { ?item wdt:P27 wd:Q29999 } .
?item wdt:P31 wd:Q5 .
MINUS { ?item wdt:P1006 [] } .
} LIMIT 400000"""
# This query will get all the Qid's for which NTA has a link, but the Qid doesn't have a link
# The commented out lines will also make mismatched links visible. Too much for this bot now.
query = u"""SELECT ?item ?person {
SERVICE <http://data.bibliotheken.nl/sparql> {
SELECT ?item ?person WHERE {
?person rdf:type <http://schema.org/Person> .
?person owl:sameAs ?item .
FILTER REGEX(STR(?item), "http://www.wikidata.org/entity/") .
}
}
# The URI (wdtn) links don't seem to be fully populated
#MINUS { ?item wdtn:P1006 ?person } .
MINUS { ?item wdt:P1006 [] } .
#MINUS { ?item owl:sameAs ?item2 . ?item2 wdtn:P1006 ?person }
MINUS { ?item owl:sameAs ?item2 . ?item2 wdt:P1006 [] }
}"""
#generator = pagegenerators.PreloadingEntityGenerator(viafDumpGenerator())
generator = pagegenerators.PreloadingEntityGenerator(
ntaBacklinksGenerator())
#generator = pagegenerators.PreloadingEntityGenerator(pagegenerators.WikidataSPARQLPageGenerator(query, site=repo))
viafImportBot = ViafImportBot(generator)
viafImportBot.run()
def main(*args):
repo = pywikibot.Site("wikidata", "wikidata").data_repository()
videoQuery = u"""SELECT DISTINCT ?item
WHERE {
?item wdt:P31 wd:Q7889 .
?item wikibase:sitelinks ?sitelinks.
MINUS { ?item wdt:P7335 []}.
}"""
games = pagegenerators.PreloadingEntityGenerator(pagegenerators.WikidataSPARQLPageGenerator(videoQuery,site=repo))
vidID = ""
vidName = ""
for item in games:
claims = item.get(u'claims') #Get alle the exsisting claims
item_dict = item.get()
if u'P7335' in claims[u'claims']:
pywikibot.output(u'Error: Already have a Mixer ID (P7335)!')
continue
elif item.isRedirectPage():
pywikibot.output('{0} is a redirect page. Skipping.'.format(item))
continue
else:
try:
vidID, vidName = mixerAPI(item_dict["labels"]['en'])
if vidID:
print(u'--> {}; Adding Mixer ID (P7335) https://mixer.com/browse/games/{}'.format(item.getID(),vidID))
ref, retrieved = getRef(repo, vidID)
stringclaim = pywikibot.Claim(repo, u'P7335')
stringclaim.setTarget(str(vidID))
item.addClaim(stringclaim, summary=u'Adding Mixer ID (P7335) based on Mixer RUST API.')
stringclaim.addSources([ref, retrieved], summary=u'Adding sources to Mixer ID (P7335).')
except:
# Key is not present
pass
def main(*args):
"""
Run the bot. By default it only runs on the items changed in the last 14 days.
"""
query = u"""SELECT ?item ?urlold ?url WHERE {
?item wdt:P195 wd:Q160236 .
?item wdt:P973 ?urlold .
?item wdt:P973 ?url .
FILTER REGEX(STR(?urlold), "http://www.metmuseum.org/collection/the-collection-online/search/.+") .
FILTER REGEX(STR(?url), "http://www.metmuseum.org/art/collection/search/.+") .
}"""
repo = pywikibot.Site().data_repository()
generator = pagegenerators.PreloadingEntityGenerator(pagegenerators.WikidataSPARQLPageGenerator(query, site=repo))
summary = u'Removing redundant MET url'
for item in generator:
data = item.get()
claims = data.get('claims')
if not u'P973' in claims:
pywikibot.output(u'No url found')
continue
if not len(claims.get('P973'))>=2:
pywikibot.output(u'Not two urls')
continue
for claim in claims.get('P973'):
if claim.getTarget().startswith(u'http://www.metmuseum.org/collection/the-collection-online/search/'):
pywikibot.output(summary)
item.removeClaims(claim, summary=summary)
def replace_paint(repo, wrongqid, rightqid):
"""
Replace the wrongqid with rightqid for paint
:param repo: The repo to work on
:param wrongqid: Qid of the wrong material to replace
:param rightqid: Qid of the right material to add instead
:return: Edit in place
"""
wrongmaterial = pywikibot.ItemPage(repo, wrongqid)
rightmaterial = pywikibot.ItemPage(repo, rightqid)
query = """SELECT ?item WHERE {
?item p:P186 ?madestatement .
?madestatement ps:P186 wd:%s .
?item wdt:P31 wd:Q3305213 .
} LIMIT 10000""" % (wrongqid, )
generator = pagegenerators.PreloadingEntityGenerator(pagegenerators.WikidataSPARQLPageGenerator(query, site=repo))
for item in generator:
data = item.get()
claims = data.get('claims')
if 'P186' in claims:
for madeclaim in claims.get('P186'):
if madeclaim.getTarget()==wrongmaterial:
summary = '[[Wikidata:WikiProject sum of all paintings/Made from material#Normalization|Made from material normalization for paintings]]'
pywikibot.output('Replacing %s with %s on %s' % (wrongqid, rightqid, item.title()))
madeclaim.changeTarget(rightmaterial, summary=summary)
def main(*args):
"""
Main function. Grab a generator and pass it to the bot to work on
"""
correctlocation = False
query = u"""SELECT ?item ?collection WHERE {
?item wdt:P31 wd:Q3305213 .
?item wdt:P195 ?collection .
MINUS { ?item wdt:P276 [] } .
?collection wdt:P625 [] .
} ORDER BY ?collection"""
for arg in pywikibot.handle_args(args):
if arg.startswith('-correctlocation'):
correctlocation = True
query = """SELECT ?item ?collection ?location WHERE {
?item wdt:P31 wd:Q3305213 .
?item wdt:P276 ?location .
?item wdt:P195 ?collection . ?collection wdt:P131+ ?location ;
wdt:P625 [] .
} ORDER BY ?collection
LIMIT 5000"""
repo = pywikibot.Site().data_repository()
generator = pagegenerators.PreloadingEntityGenerator(
pagegenerators.WikidataSPARQLPageGenerator(query, site=repo))
locationFromCollectionBot = LocationFromCollectionBot(
generator, correctlocation=correctlocation)
locationFromCollectionBot.run()
def __init__(self, generator):
"""
Arguments:
* generator - A generator that yields wikidata item objects.
"""
self.repo = pywikibot.Site().data_repository()
self.generator = pagegenerators.PreloadingEntityGenerator(generator)
self.viafitem = pywikibot.ItemPage(self.repo, u'Q54919')
def main():
query = u'CLAIM[359] AND CLAIM[131:9899] AND CLAIM[969] AND NOCLAIM[669]'
pigenerator = pagegenerators.PreloadingEntityGenerator(
pagegenerators.WikidataItemGenerator(
WikidataQueryItemPageGenerator(query)))
streetBot = StreetBot(pigenerator)
streetBot.run()
def main():
repo = pywikibot.Site().data_repository()
query = u"""SELECT ?item ?viafid WHERE {
{ ?item wdt:P27 wd:Q183 } UNION { ?item wdt:P27 wd:Q40 } UNION { ?item wdt:P27 wd:Q39 } .
?item wdtn:P214 ?viafid .
MINUS { ?item wdt:P227 ?gndid }
} LIMIT 30000"""
generator = pagegenerators.PreloadingEntityGenerator(pagegenerators.WikidataSPARQLPageGenerator(query, site=repo))
viafImportBot = ViafImportBot(generator)
viafImportBot.run()
def getGenerator(self, genre):
"""
Build a SPARQL query to get interesting items to work on
:return: A generator that yields items
"""
firstfilter = True
query = """SELECT ?item WHERE {
?item wdt:P136 wd:%s .
?item wdt:P31 wd:Q3305213 .
MINUS { ?item wdt:P136 ?genre . FILTER (?genre!=wd:%s) }
} LIMIT 1000""" % (genre, genre)
return pagegenerators.PreloadingEntityGenerator(pagegenerators.WikidataSPARQLPageGenerator(query, site=self.repo))
def main():
repo = pywikibot.Site().data_repository()
query = u"""SELECT ?item WHERE {
?item wdt:P214 ?viafid .
?item wdt:P27 wd:Q45 .
?item wdt:P31 wd:Q5 .
MINUS { ?item wdt:P1005 [] } .
} LIMIT 4000"""
generator = pagegenerators.PreloadingEntityGenerator(pagegenerators.WikidataSPARQLPageGenerator(query, site=repo))
viafImportBot = ViafImportBot(generator)
viafImportBot.run()
def main():
#lang = u'en'
#templates = getTemplateClaims(lang=lang)
#print templates
repo = pywikibot.Site(u'wikidata', u'wikidata').data_repository()
namespaceclaims = {
4: u'Q14204246', # Wikipedia
10: u'Q11266439', # Template
14: u'Q4167836', # Category
100: u'Q4663903', # Portal
828: u'Q15184295', # Module
}
noclaimgen = pagegenerators.PreloadingEntityGenerator(
getNoclaimGenerator())
#repo = pywikibot.Site().data_repository()
#print templates.keys()
for itempage in noclaimgen:
pywikibot.output(itempage.title())
if not itempage.exists():
pywikibot.output(u'Deleted, skipping')
continue
if itempage.isRedirectPage():
pywikibot.output(u'Redirect, skipping')
continue
data = itempage.get()
if u'P31' not in data.get('claims'):
for page in itempage.iterlinks(family=u'wikipedia'):
pywikibot.output(page.title())
if not page.namespace() == 0 and page.namespace(
) in namespaceclaims:
pywikibot.output(u'Working on %s' % (page.title(), ))
newclaim = pywikibot.Claim(repo, u'P31')
claimtarget = pywikibot.ItemPage(
repo, namespaceclaims.get(page.namespace()))
newclaim.setTarget(claimtarget)
summary = u'Adding [[Property:%s]] -> [[%s]] based on %s' % (
u'P31', namespaceclaims.get(
page.namespace()), page.title(asLink=True))
pywikibot.output(summary)
try:
itempage.addClaim(newclaim, summary=summary)
except pywikibot.exceptions.APIError:
pywikibot.output(u'Ai, API problems. Let\'s sleep')
time.sleep(60)
break
def replace_painting_surface(repo, wrongqid, rightqid, strict=True, add_missing=False):
"""
Replace the wrongqid with rightqid for a painting surface
:param repo: The repo to work on
:param wrongqid: Qid of the wrong material to replace
:param rightqid: Qid of the right material to add instead
:param strict: If set, the wrongqid needs to have the painting surface qualifier
:param add_missing: If set, add the missing painting surface
:return: Edit in place
"""
wrongmaterial = pywikibot.ItemPage(repo, wrongqid)
rightmaterial = pywikibot.ItemPage(repo, rightqid)
paintingsurface = pywikibot.ItemPage(repo, 'Q861259')
if strict:
query = """SELECT ?item WHERE {
?item p:P186 ?madestatement .
?madestatement ps:P186 wd:%s .
?madestatement pq:P518 wd:Q861259 .
?item wdt:P31 wd:Q3305213 .
} LIMIT 10000""" % (wrongqid, )
else:
query = """SELECT ?item WHERE {
?item p:P186 ?madestatement .
?madestatement ps:P186 wd:%s .
?item wdt:P31 wd:Q3305213 .
} LIMIT 10000""" % (wrongqid, )
generator = pagegenerators.PreloadingEntityGenerator(pagegenerators.WikidataSPARQLPageGenerator(query, site=repo))
for item in generator:
data = item.get()
claims = data.get('claims')
if 'P186' in claims:
for madeclaim in claims.get('P186'):
if madeclaim.getTarget()==wrongmaterial:
if madeclaim.has_qualifier('P518', 'Q861259'):
summary = '[[Wikidata:WikiProject sum of all paintings/Made from material#Normalization|Made from material normalization for paintings]] for painting surface (qualifier [[Property:P518]] is set to [[Q861259]])'
pywikibot.output('Strict replacing %s with %s on %s' % (wrongqid, rightqid, item.title()))
madeclaim.changeTarget(rightmaterial, summary=summary)
elif not strict:
summary = '[[Wikidata:WikiProject sum of all paintings/Made from material#Normalization|Made from material normalization for paintings]] for painting surface'
pywikibot.output('Replacing %s with %s on %s' % (wrongqid, rightqid, item.title()))
madeclaim.changeTarget(rightmaterial, summary=summary)
if add_missing:
summary = 'Also adding missing painting surface'
pywikibot.output('Also adding missing painting surface on %s' % (item.title(),))
newqualifier = pywikibot.Claim(repo, 'P518')
newqualifier.setTarget(paintingsurface)
madeclaim.addQualifier(newqualifier, summary=summary)
def main():
"""
Do a query for items that do have FAST-ID (P2163), but not and VIAF ID (P214) or LCAuth ID (P244)
"""
query = u"""SELECT DISTINCT ?item WHERE {
?item wdt:P2163 [] .
MINUS { ?item wdt:P214 [] . ?item wdt:P244 [] } .
}"""
repo = pywikibot.Site().data_repository()
generator = pagegenerators.PreloadingEntityGenerator(
pagegenerators.WikidataSPARQLPageGenerator(query, site=repo))
fastImportBot = FastImportBot(generator)
fastImportBot.run()
def getGenerator(self):
"""
Get a generator of paintings that have one of the replacable genres
:return: A generator that yields ItemPages
"""
query = u'SELECT ?item WHERE { ?item wdt:P31/wdt:P279* wd:Q3305213 . ?item wdt:P136 ?genre .VALUES ?genre {'
for genre in list(self.genres.keys()):
query = query + u' wd:%s ' % (genre, )
query = query + u' } } LIMIT 1000'
generator = pagegenerators.PreloadingEntityGenerator(
pagegenerators.WikidataSPARQLPageGenerator(query, site=self.repo))
return generator
def getCreator(self, creator):
"""
Find the painter with the name in creator
First check if the name is already in the self.creators cache
Second, do a search
If a hit is found, update the cache in self.creators
"""
# First use the cache
if creator in self.creators:
return self.creators[creator]
# Search Wikidata for a suitable candidate, tell the search to only return humans
searchstring = u'%s haswbstatement:P31=Q5' % (creator, )
creategen = pagegenerators.PreloadingEntityGenerator(
pagegenerators.WikibaseItemGenerator(
pagegenerators.SearchPageGenerator(searchstring,
total=50,
namespaces=[0],
site=self.repo)))
for creatoritem in creategen:
if creatoritem.isRedirectPage():
creatoritem = creatoritem.getRedirectTarget()
# See if the label or one of the aliases of the creatoritem matches the string we have. Only label is case insensitive.
if (creatoritem.get().get('labels').get('en')
and creatoritem.get().get('labels').get('en').lower()
== creator.lower()) or (
creatoritem.get().get('aliases').get('en') and creator
in creatoritem.get().get('aliases').get('en')):
if u'P106' in creatoritem.get().get('claims'):
existing_claims = creatoritem.get().get('claims').get(
'P106')
for existing_claim in existing_claims:
if existing_claim.target_equals(u'Q1028181'):
self.creators[creator] = creatoritem
return creatoritem
# Regex that should match all the anonymous work stuff that isn't covered by the list
anonymousRegex = '^(Workshop of|Follower of|Circle of|Manner of|Forgery after|School of|After|Unidentified Artist|School of)\s.*$'
anonymousMatch = re.match(anonymousRegex, creator, flags=re.I)
if anonymousMatch:
self.creators[creator] = self.creators.get('anonymous')
return self.creators.get('anonymous')
# We don't want to do the same search over and over again
self.creators[creator] = None
return None
def main(*args):
"""
Main function does all the work.
"""
broadrfc = False
for arg in pywikibot.handle_args(args):
if arg.startswith('-broadrfc'):
broadrfc = True
repo = pywikibot.Site().data_repository()
private_collection = pywikibot.ItemPage(repo, 'Q768717')
if broadrfc:
query = """SELECT DISTINCT ?item WHERE {
?item wdt:P195 wd:Q768717 .
} LIMIT 10000"""
qualifier_summary = 'Private collection normalization, move to qualifier'
somevalue_summary = 'Private collection normalization, set to somevalue'
else:
query = """SELECT ?item WHERE {
?item p:P195/ps:P195 wd:Q768717 ;
wdt:P31 wd:Q3305213 .
} LIMIT 10000"""
qualifier_summary = '[[Wikidata:WikiProject sum of all paintings/Private collection|Private collection normalization for paintings]], move to qualifier'
somevalue_summary = '[[Wikidata:WikiProject sum of all paintings/Private collection|Private collection normalization for paintings]], set to somevalue'
generator = pagegenerators.PreloadingEntityGenerator(
pagegenerators.WikidataSPARQLPageGenerator(query, site=repo))
for item in generator:
data = item.get()
claims = data.get('claims')
if 'P195' in claims:
for collectionclaim in claims.get('P195'):
if collectionclaim.getTarget() == private_collection:
if not collectionclaim.has_qualifier('P3831', 'Q768717'):
pywikibot.output(
'Adding object has role private collection on %s' %
(item.title(), ))
newqualifier = pywikibot.Claim(repo, 'P3831')
newqualifier.setTarget(private_collection)
collectionclaim.addQualifier(newqualifier,
summary=qualifier_summary)
pywikibot.output(
'Changing target from private collection to somevalue on %s'
% (item.title(), ))
collectionclaim.changeTarget(value=None,
snaktype='somevalue',
summary=somevalue_summary)
def main(*args):
"""
Main function does all the work.
"""
broadrfc = False
for arg in pywikibot.handle_args(args):
if arg.startswith('-broadrfc'):
broadrfc = True
repo = pywikibot.Site().data_repository()
anonymous = pywikibot.ItemPage(repo, 'Q4233718')
if broadrfc:
query = """SELECT DISTINCT ?item WHERE {
?item wdt:P170 wd:Q4233718 .
} LIMIT 10000"""
qualifier_summary = '[[Wikidata:Requests for comment/Cleaning up the ontology of anonymous|Cleaning up the ontology of anonymous]], move to qualifier'
somevalue_summary = '[[Wikidata:Requests for comment/Cleaning up the ontology of anonymous|Cleaning up the ontology of anonymous]], set to somevalue'
else:
query = """SELECT ?item WHERE {
?item p:P170/ps:P170 wd:Q4233718 ;
wdt:P31 wd:Q3305213 .
} LIMIT 10000"""
qualifier_summary = '[[Wikidata:WikiProject sum of all paintings/Anonymous creator#Normalization|Anonymous creator normalization for paintings]], move to qualifier'
somevalue_summary = '[[Wikidata:WikiProject sum of all paintings/Anonymous creator#Normalization|Anonymous creator normalization for paintings]], set to somevalue'
generator = pagegenerators.PreloadingEntityGenerator(
pagegenerators.WikidataSPARQLPageGenerator(query, site=repo))
for item in generator:
data = item.get()
claims = data.get('claims')
if 'P170' in claims:
for creatorclaim in claims.get('P170'):
if creatorclaim.getTarget() == anonymous:
if not creatorclaim.has_qualifier('P3831', 'Q4233718'):
pywikibot.output(
'Adding object has role anonymous on %s' %
(item.title(), ))
newqualifier = pywikibot.Claim(repo, 'P3831')
newqualifier.setTarget(anonymous)
creatorclaim.addQualifier(newqualifier,
summary=qualifier_summary)
pywikibot.output(
'Changing target from anonymous to somevalue on %s' %
(item.title(), ))
creatorclaim.changeTarget(value=None,
snaktype='somevalue',
summary=somevalue_summary)
def main():
"""
Main function. Grab a generator and pass it to the bot to work on
"""
# Does have biografisch portaal, but no Parlement & Politiek ID
query = u"""SELECT DISTINCT ?item WHERE {
?item wdt:P651 [] .
MINUS { ?item wdt:P1749 [] }
}"""
repo = pywikibot.Site().data_repository()
generator = pagegenerators.PreloadingEntityGenerator(
pagegenerators.WikidataSPARQLPageGenerator(query, site=repo))
ppImporterBot = PPImporterBot(generator)
ppImporterBot.run()
def __init__(self):
"""
Grab generator based on SPARQL to work on.
"""
self.site = pywikibot.Site(u'commons', u'commons')
self.repo = self.site.data_repository()
query = u"""SELECT ?item ?image WHERE {
?item wdt:P105 wd:Q7432 .
?item wdt:P18 ?image .
?item wdt:P31 wd:Q16521 .
} LIMIT 200000"""
self.generator = pagegenerators.PreloadingEntityGenerator(
pagegenerators.WikidataSPARQLPageGenerator(query, site=self.repo))
def main():
"""
Do a query for items that do have RKDartists (P650) and VIAF (P214), but no ULAN (P245)
:return:
"""
query = u"""SELECT ?item WHERE {
?item wdt:P650 [] .
?item wdt:P214 [] .
MINUS { ?item wdt:P245 [] }
}"""
repo = pywikibot.Site().data_repository()
generator = pagegenerators.PreloadingEntityGenerator(pagegenerators.WikidataSPARQLPageGenerator(query, site=repo))
viafImportBot = ViafImportBot(generator)
viafImportBot.run()
def main():
query = u"""SELECT DISTINCT ?item WHERE {
?item wdt:P195 wd:Q574961 .
?item wdt:P31 wd:Q3305213 .
?item p:P217 ?invstatement .
?invstatement ps:P217 ?inv .
?invstatement pq:P195 wd:Q574961 .
FILTER regex (?inv, "^OS[- ](.*)$").
}
LIMIT 2500"""
repo = pywikibot.Site().data_repository()
generator = pagegenerators.PreloadingEntityGenerator(
pagegenerators.WikidataSPARQLPageGenerator(query, site=repo))
normalizationBot = NormalizationBot(generator)
normalizationBot.run()
def main(*args):
gen = getPaintingGenerator()
repo = pywikibot.Site().data_repository()
query = u"""SELECT ?item ?rkdid ?itemdesc WHERE {
?item wdt:P31 wd:Q3305213 .
?item wdt:P350 ?rkdid .
MINUS { ?item p:P170 [] } .
?item schema:description ?itemdesc.
FILTER(LANG(?itemdesc) = "en")
} LIMIT 1000"""
generator = pagegenerators.PreloadingEntityGenerator(
pagegenerators.WikidataSPARQLPageGenerator(query, site=repo))
imagesCreatorRobot = RKDimagesCreatorRobot(generator)
imagesCreatorRobot.run()
def getArtworks(self):
'''
Get the artworks to work on sorted by the Q id (from low to high)
'''
result = []
artdict = {}
query=u'CLAIM[608:20980830]'
generator = pagegenerators.PreloadingEntityGenerator(pagegenerators.WikidataItemGenerator(WikidataQueryItemPageGenerator(query)))
for artwork in generator:
if artwork.title() in self.officialArtworksIds:
artdict[artwork.getID(numeric=True)] = artwork
for key in sorted(artdict.keys()):
result.append(artdict[key])
return result
def generator(self):
# todo: move to store
QUERY = '''SELECT ?item WITH {
SELECT DISTINCT ?item {
?item wdt:P31 wd:%s; wikibase:sitelinks ?links .
FILTER( ?links >= %i ) .
MINUS { ?item wdt:P31 wd:Q101352 } .
} OFFSET %i LIMIT %i
} AS %%disambig WHERE {
INCLUDE %%disambig .
BIND( MD5( CONCAT( STR( ?item ), STR( RAND() ) ) ) AS ?hash ) .
} ORDER BY ?hash''' % (self.disambig_item, self.opt['min_sitelinks'],
self.opt['offset'], self.opt['limit'])
return pagegenerators.PreloadingEntityGenerator(
pagegenerators.WikidataSPARQLPageGenerator(QUERY, site=self.repo,
result_type=list))
