def make_pywikibot_item(self, value):
val_item = None
if isinstance(value, list) and len(value) == 1:
value = value[0]
if utils.string_is_q_item(value):
val_item = self.make_q_item(value)
elif value == "novalue":
val_item = value
elif isinstance(value, dict) and 'monolingual_value' in value:
text = value['monolingual_value']
language = value['lang']
val_item = pywikibot.WbMonolingualText(text=text,
language=language)
elif isinstance(value, dict) and 'quantity_value' in value:
number = value['quantity_value']
if 'unit' in value:
unit = self.wdstuff.QtoItemPage(value["unit"])
else:
unit = None
val_item = pywikibot.WbQuantity(amount=number,
unit=unit,
site=self.repo)
elif isinstance(value, dict) and 'date_value' in value:
date_dict = value["date_value"]
val_item = pywikibot.WbTime(year=date_dict.get("year"),
month=date_dict.get("month"),
day=date_dict.get("day"))
elif value == "novalue":
# raise NotImplementedError
# implement Error
print("Status: novalue will be added here")
else:
val_item = value
return val_item
def create_claim(property=None,
value=None,
item=None,
quantity=None,
repo=REPO,
site=SITE,
year=None,
month=None,
day=None,
text=None,
language=None):
claim = pywikibot.Claim(repo, property)
if item is not None:
value = pywikibot.ItemPage(repo, item)
elif quantity is not None:
value = pywikibot.WbQuantity(quantity, site=site)
elif year is not None:
value = pywikibot.WbTime(year=year, month=month, day=day)
elif text is not None:
if language is not None:
value = pywikibot.WbMonolingualText(text, language)
claim.setTarget(value)
return claim
def addTitle(self, item, metadata):
"""
Add the title (P1476) to the item. For now just skip items that already have a title
:param item: The artwork item to work on
:param metadata: All the metadata about this artwork, should contain the title field as a dict
:return:
"""
claims = item.get().get('claims')
if u'P1476' in claims:
# Already has a title. Don't care if it's the same contents and or language for now
return
if metadata.get(u'title'):
for lang in metadata.get(u'title'):
# To prevent any empty titles
if metadata.get(u'title').get(lang):
try:
newtitle = pywikibot.WbMonolingualText(text=metadata.get(u'title').get(lang).strip(),
language=lang,
)
newclaim = pywikibot.Claim(self.repo, u'P1476')
newclaim.setTarget(newtitle)
pywikibot.output('Adding title to %s' % item)
item.addClaim(newclaim)
self.addReference(item, newclaim, metadata[u'refurl'])
except pywikibot.exceptions.OtherPageSaveError:
pywikibot.output(u'The title was malformed, skipping it')
pass
def act_wd_imatge_peu(self, fitxer, peu):
if self.item == None:
print("Error, item no seleccionat")
return
print("Posant imatge a Wikidata")
nouclm = pywikibot.Claim(self.repowd, 'P18')
nouclm.setTarget(fitxer)
importatde = pywikibot.Claim(self.repowd, 'P143')
importatde.setTarget(pywikibot.ItemPage(self.repowd, 'Q199693'))
# importat de viquipèdia en català
lrefs = [importatde]
self.item.addClaim(nouclm)
nouclm.addSources(lrefs)
if peu.strip() != "":
qualif = pywikibot.Claim(self.repowd, 'P2096')
qualif.setTarget(
pywikibot.WbMonolingualText(text=peu, language='ca'))
minuts = 1
# Wikidata dóna molts timeouts, hem de posar més controls
while True:
try:
nouclm.addQualifier(qualif)
break
except pywikibot.exceptions.MaxlagTimeoutError:
time.sleep(minuts * 120)
minuts = minuts + 1
nouclm.addQualifier(qualif)
def test_set_WbMonolingualText(self):
"""Test setting claim of monolingualtext type."""
wikidata = self.get_repo()
claim = pywikibot.Claim(wikidata, 'P1450')
self.assertEqual(claim.type, 'monolingualtext')
target = pywikibot.WbMonolingualText(text='Test this!', language='en')
claim.setTarget(target)
self.assertEqual(claim.target, target)
def make_monolingual_item(self, quantity):
"""
Create claim for a monolingual text.
quantity: {'monolingual_value': 'The bestest text', 'lang': 'en'}
"""
return pywikibot.WbMonolingualText(text=quantity['monolingual_value'],
language=quantity['lang'])
def test_format_claim_value_monolingual(self):
self.set_claim_type('monolingualtext')
expected_data = pywikibot.WbMonolingualText('Foo', 'sv')
data = format_claim_value(self.mock_claim, {
'text': 'Foo',
'lang': 'sv'
})
self.assertEqual(data, expected_data)
def format_claim_value(claim, value):
"""
Reformat the internal claim as the relevant pywikibot object.
@param claim: pywikibot.Claim to which value should be added
@param value: str|dict encoding the value to be added
@return: pywikibot representation of the claim value
"""
repo = claim.repo
if claim.type == 'wikibase-item':
return pywikibot.ItemPage(repo, value)
elif claim.type == 'commonsMedia':
return pywikibot.FilePage(_get_commons(), value)
elif claim.type == 'geo-shape':
return pywikibot.WbGeoShape(
pywikibot.Page(repo.geo_shape_repository(), value))
elif claim.type == 'tabular-data':
return pywikibot.WbTabularData(
pywikibot.Page(repo.tabular_data_repository(), value))
elif claim.type == 'monolingualtext':
if common.is_str(value):
text, _, lang = value.partition('@')
value = {'text': text, 'lang': lang}
return pywikibot.WbMonolingualText(value.get('text'),
value.get('lang'))
elif claim.type == 'globe-coordinate':
if common.is_str(value):
parts = value.replace(',', '@').split('@')
value = {parts[1]: parts[0], parts[3]: parts[2]}
# set precision to the least precise of the values
precision = max(coord_precision(value.get('lat')),
coord_precision(value.get('lon')))
return pywikibot.Coordinate(float(value.get('lat')),
float(value.get('lon')),
precision=precision)
elif claim.type == 'quantity':
if common.is_str(value):
amount, _, unit = value.partition('@')
value = {'amount': amount, 'unit': unit}
if value.get('unit'):
return pywikibot.WbQuantity(value.get('amount'),
pywikibot.ItemPage(
repo, value.get('unit')),
site=repo)
return pywikibot.WbQuantity(value.get('amount'), site=repo)
elif claim.type == 'time':
# note that Wikidata only supports precision down to day
# as a result pywikibot.WbTime.fromTimestr will produce an incompatible
# result for a fully qualified timestamp/timestr
return iso_to_wbtime(value)
# simple strings
return value
def create_target(ptype, target_str):
if ptype == "item":
target = pywikibot.ItemPage(wikidata, target_str)
elif ptype == "string":
target = target_str
elif ptype == "entext":
target = pywikibot.WbMonolingualText(target_str, "en")
else:
raise NotImplementedError(ptype)
return target
def add_title_claim(self, painting_item, painting):
"""Add a title/P1476 claim based on dcTitle.
@param painting_item: item to which claim is added
@type painting_item: pywikibot.ItemPage
@param painting: information object for the painting
@type painting: dict
"""
dc_title = painting['object']['proxies'][0]['dcTitle']
titles = []
for lang, title in dc_title.iteritems():
titles.append(pywikibot.WbMonolingualText(title[0], lang))
for title in titles:
self.wd.addNewClaim(u'P1476', WD.Statement(title), painting_item,
self.make_europeana_reference(painting))
def test_WbMonolingualText_edit(self):
"""Attempt adding a monolingual text with valid input."""
# Clean the slate in preparation for test.
testsite = self.get_repo()
item = self._clean_item(testsite, 'P271')
# set new claim
claim = pywikibot.page.Claim(testsite, 'P271', datatype='monolingualtext')
target = pywikibot.WbMonolingualText(text='Test this!', language='en')
claim.setTarget(target)
item.addClaim(claim)
# confirm new claim
item.get(force=True)
claim = item.claims['P271'][0]
self.assertEqual(claim.getTarget(), target)
def addClaim(repo='', item='', claim='', value='', valuelang='', ref=''):
if repo and item and claim and value:
print("Adding claim", claim, "value", value.encode('utf-8'))
claimx = pywikibot.Claim(repo, claim)
if re.search(r'\d\d\d\d-\d\d-\d\d', value):
target = pywikibot.WbTime(year=int(value.split('-')[0]),
month=int(value.split('-')[1]),
day=int(value.split('-')[2]))
elif value.startswith('Q'):
target = pywikibot.ItemPage(repo, value)
elif valuelang:
target = pywikibot.WbMonolingualText(text=value,
language=valuelang)
else:
target = value
claimx.setTarget(target)
item.addClaim(claimx, summary='BOT - Adding 1 claim')
if ref:
addReference(repo=repo, claim=claimx, ref=ref)
def get_or_create_sources(
claim: Claim,
url: str,
retrieved,
edit_group_hash: str,
title: Optional[str] = None,
date: Optional[WbTime] = None,
):
"""
Gets or creates a `source` under the property `claim` to `url`
"""
all_sources = []
src_p = Properties.reference_url
for i in claim.sources or []:
if src_p in i:
all_sources.append(i[src_p][0])
for src_url in all_sources:
if src_url.target_equals(url):
break
else:
src_url = Claim(Settings.wikidata_repo, src_p)
src_url.setTarget(url)
src_retrieved = Claim(Settings.wikidata_repo, Properties.retrieved)
src_retrieved.setTarget(retrieved)
sources = [src_url, src_retrieved]
if title:
src_title = Claim(Settings.wikidata_repo, Properties.title)
src_title.setTarget(pywikibot.WbMonolingualText(title, "en"))
sources.append(src_title)
if date:
src_date = Claim(Settings.wikidata_repo,
Properties.publication_date)
src_date.setTarget(date)
sources.append(src_date)
claim.addSources(sources, summary=get_sumary(edit_group_hash))
return src_url
def act_wd_audio_peu(self, fitxer, peu):
if self.item == None:
print("Error, item no seleccionat")
return
print(
"********** ATENCIO Posant àudio a Wikidata **************************"
)
nouclm = pywikibot.Claim(self.repowd, 'P51')
nouclm.setTarget(fitxer)
importatde = pywikibot.Claim(self.repowd, 'P143')
importatde.setTarget(pywikibot.ItemPage(self.repowd, 'Q199693'))
# importat de viquipèdia en català
lrefs = [importatde]
self.item.addClaim(nouclm)
nouclm.addSources(lrefs)
if peu.strip() != "":
qualif = pywikibot.Claim(self.repowd, 'P2096')
qualif.setTarget(
pywikibot.WbMonolingualText(text=peu, language='ca'))
nouclm.addQualifier(qualif)
def get_or_create_sources(repo, claim, url, retrieved, title=None, date=None):
"""
Gets or creates a `source` under the property `claim` to `url`
"""
all_sources = []
src_p = Settings.properties["reference URL"]
retrieved_p = Settings.properties["retrieved"]
title_p = Settings.properties["title"]
date_p = Settings.properties["publication date"]
# We could have many sources, so let's
if claim.sources:
for i in claim.sources:
if src_p in i:
all_sources.append(i[src_p][0])
else:
all_sources = []
for src_url in all_sources:
if src_url.target_equals(url):
break
else:
src_url = pywikibot.Claim(repo, src_p)
src_url.setTarget(url)
src_retrieved = pywikibot.Claim(repo, retrieved_p)
src_retrieved.setTarget(retrieved)
sources = [src_url, src_retrieved]
if title:
src_title = pywikibot.Claim(repo, title_p)
src_title.setTarget(pywikibot.WbMonolingualText(title, "en"))
sources.append(src_title)
if date:
src_date = pywikibot.Claim(repo, date_p)
src_date.setTarget(date)
sources.append(src_date)
claim.addSources(sources)
return src_url
def act_wd_peu(self, fitxer, peu, propietat):
if len(peu) == 0:
return
if self.item == None:
print("Error, item no seleccionat")
return
#print self.item_dict
if propietat in self.item.claims: # si hi ha imatge a wikidata
clm_dict = self.item_dict["claims"]
clm_fitxer = clm_dict[propietat] # això és tot el paquet d'imatges
for clm in clm_fitxer: # pot haver-hi més d'una imatge
tg = clm.getTarget()
#print tg
#print type(tg)
#print dir(tg)
nom_fitxer = tg.title(with_ns=False)
if varglobals.comp_fitx(
nom_fitxer, fitxer): # aquest és el fitxer on hem de
# posar el peu de foto
print("Posant peu d'imatge a Wikidata")
qualif = pywikibot.Claim(self.repowd, 'P2096')
qualif.setTarget(
pywikibot.WbMonolingualText(text=peu, language='ca'))
clm.addQualifier(qualif)
def addImageSuggestion(self, item, metadata):
"""
Add Commons compatible image available at URL (P4765) to an image that can be uploaded to Commons
It will also add the suggestion if the item already has an image, but new one is of much better quality
:param item: The artwork item to work on
:param metadata: All the metadata about this artwork, should contain the imageurl field
:return: Nothing, updates item in place
"""
claims = item.get().get('claims')
if not metadata.get(u'imageurl'):
# Nothing to add
return
if u'P4765' in claims:
# Already has a suggestion
return
if u'P6500' in claims:
# Already has a non-free artwork image URL
return
if u'P18' in claims and not metadata.get(u'imageurlforce'):
if not metadata.get(u'imageupgrade'):
return
newimage = requests.get(metadata.get(u'imageurl'), stream=True)
if not newimage.headers.get('Content-length'):
return
if not newimage.headers.get('Content-length').isnumeric():
return
newimagesize = int(newimage.headers['Content-length'])
#print (u'Size of the new image is %s according to the headers' % (newimagesize,))
if newimagesize < 500000:
# Smaller than 500KB is just too small to bother check to replace
return
for imageclaim in claims.get(u'P18'):
currentsize = imageclaim.getTarget().latest_file_info.size
#print (u'Size of the current image is %s' % (currentsize,))
# New image should at least be 4 times larger
if currentsize * 4 > newimagesize:
return
newclaim = pywikibot.Claim(self.repo, u'P4765')
newclaim.setTarget(metadata[u'imageurl'])
pywikibot.output('Adding commons compatible image available at URL claim to %s' % item)
item.addClaim(newclaim)
if metadata.get(u'imageurlformat'):
newqualifier = pywikibot.Claim(self.repo, u'P2701')
newqualifier.setTarget(pywikibot.ItemPage(self.repo, metadata.get(u'imageurlformat')))
pywikibot.output('Adding new qualifier claim to %s' % item)
newclaim.addQualifier(newqualifier)
newqualifier = pywikibot.Claim(self.repo, u'P2699')
newqualifier.setTarget(metadata[u'imagesourceurl'])
pywikibot.output('Adding new qualifier claim to %s' % item)
newclaim.addQualifier(newqualifier)
if metadata.get('title'):
if metadata.get('title').get(u'en'):
title = pywikibot.WbMonolingualText(metadata.get('title').get(u'en'), u'en')
else:
lang = list(metadata.get('title').keys())[0]
title = pywikibot.WbMonolingualText(metadata.get('title').get(lang), lang)
newqualifier = pywikibot.Claim(self.repo, u'P1476')
newqualifier.setTarget(title)
pywikibot.output('Adding new qualifier claim to %s' % item)
newclaim.addQualifier(newqualifier)
if metadata.get('creatorname'):
newqualifier = pywikibot.Claim(self.repo, u'P2093')
newqualifier.setTarget(metadata.get('creatorname'))
pywikibot.output('Adding new qualifier claim to %s' % item)
newclaim.addQualifier(newqualifier)
if metadata.get(u'imageurllicense'):
newqualifier = pywikibot.Claim(self.repo, u'P275')
newqualifier.setTarget(pywikibot.ItemPage(self.repo, metadata.get(u'imageurllicense')))
pywikibot.output('Adding new qualifier claim to %s' % item)
newclaim.addQualifier(newqualifier)
if metadata.get(u'imageoperatedby'):
newqualifier = pywikibot.Claim(self.repo, u'P137')
newqualifier.setTarget(pywikibot.ItemPage(self.repo, metadata.get(u'imageoperatedby')))
pywikibot.output('Adding new qualifier claim to %s' % item)
newclaim.addQualifier(newqualifier)
def _make_WbMonolingualText_claim(self, repo, text, language):
"""Make a WbMonolingualText and set its value."""
claim = pywikibot.page.Claim(repo, 'P271', datatype='monolingualtext')
target = pywikibot.WbMonolingualText(text=text, language=language)
claim.setTarget(target)
return claim
# add source to claim
source = pywikibot.Claim(repo, url_prop_id)
source.setTarget(source_url_for_wikidata)
# add retrieved date to claim
retrieved = pywikibot.Claim(repo, retrieved_prop_id)
today = datetime.datetime.today()
retrieved_date = pywikibot.WbTime(year=today.year,
month=today.month,
day=today.day)
retrieved.setTarget(retrieved_date)
# add title source_title_text = "Statistisches Amt Basel-Stadt: Bevoelkerungsstatistik", source, retreived to claim
title = pywikibot.Claim(repo, title_prop_id)
title.setTarget(
pywikibot.WbMonolingualText(text=source_title_text, language='de'))
population_claim.addSources([source, retrieved, title])
# set preferred rank for latest date only
if (date == latest_date):
population_claim.changeRank("preferred")
else:
print("Population claim already exists on %s for year %s" %
(item_id, date.isoformat()))
# set rank to normal if not latest year
if (population_claim.getRank() == "preferred" and date != latest_date):
print(
"This is not the latest date claim, changing rank from preferred to normal"
)
population_claim.changeRank("normal")
if (population_claim.getRank() != "preferred" and date == latest_date):
def test_edit_item_1():
site = pywikibot.Site('wikidata', "wikidata")
repo = site.data_repository()
item = pywikibot.ItemPage(repo, 'Q4115189') # Wikidata Sandbox
# Crate claim
population = 'P1082' # pid: property_id
claim = pywikibot.Claim(repo, population) # , rank='preferred')
# value = to_value[insee_code]
value = 7
quantity = pywikibot.WbQuantity(value, site=site)
# print(type(quantity))
claim.setTarget(quantity)
# TODO: Remove if population is not the last one
# claim.setRank('preferred')
#item.addClaim(claim, summary="Add population 2015")
# claim.changeRank('preferred')
# Create qualifier
point_in_time = 'P585'
qualifier = pywikibot.Claim(repo, point_in_time)
date = pywikibot.WbTime(year=2015, month=1, day=1)
qualifier.setTarget(date)
# claim.addQualifier(qualifier, summary=u'Adding a qualifier.')
# set_qualifiers
qualifier.isQualifier = True
claim.qualifiers[qualifier.getID()] = [qualifier]
# Create source
stated_in = pywikibot.Claim(repo, 'P248')
insee = pywikibot.ItemPage(repo, 'Q156616')
stated_in.setTarget(insee)
title = pywikibot.Claim(repo, 'P1476')
text = pywikibot.WbMonolingualText("Recensement de la population 2015",
'fr') # monolingual text
title.setTarget(text)
publication_date = pywikibot.Claim(repo, 'P577')
date = pywikibot.WbTime(year=2017, month=12, day=27)
publication_date.setTarget(date)
# claim.addSources([statedin, publication_date], summary="Adding sources.")
# claim.addSources([statedin], summary="Adding sources.")
# claim.addSources([statedin, title, publication_date], summary="Adding sources.")
# set_source
claims = [stated_in, title, publication_date]
source = defaultdict(list)
for c in claims:
c.isReference = True
source[c.getID()].append(c)
claim.sources.append(source)
# Set rank
# claim.changeRank('preferred', summary="Add population 2015")
claim.rank = 'preferred'
identification = {'id': item.getID()}
data = {
'claims': [claim.toJSON()]
} # add the statement on property: use []
# to overwrite statement on property: do not use []
response = repo.editEntity(identification,
data,
summary="Add 2015 population")
def Wikidata_import_ratings(QId_Elo, year, month):
currentDay = datetime.now().day
currentMonth = datetime.now().month
currentYear = datetime.now().year
wikidata_site = pywikibot.Site('wikidata', 'wikidata')
repo = wikidata_site.data_repository()
with open('elo_ratings_for_import.json') as fh:
i = 0
fh.write("[ \n")
for QId, EloEntry in QId_Elo.items():
if ( i > 0 ) :
fh.write(', \n')
i = i+1
fh.write(" ")
line = {"QID": QId, "P1087": int(EloEntry["Elo"]), "P585":{ "Y":int(year) , "M":month }, "P248":"Q27038151", "P1440": EloEntry["FideID"], "P813":{ "Y":currentYear, "M":currentMonth, "D":currentDay }}
json.dump(line, fh, ensure_ascii=False)
fh.write("\n")
fh.write("]")
fh.close()
with open('elo_ratings_for_import.json') as fh:
inputdata = json.load(fh)
for i, obj in enumerate(inputdata):
random.shuffle(inputdata)
eloAlreadySet = False
Qitem = pywikibot.ItemPage(repo, obj['QID'])
while True:
try:
Qitem = pywikibot.ItemPage(repo, obj['QID'])
Qitem.get()
break
except pywikibot.exceptions.MaxlagTimeoutError as e:
print(e)
time.sleep(10)
if Qitem.claims and 'P1087' in Qitem.claims:
for eloClaim in Qitem.claims['P1087']:
if eloClaim.qualifiers and 'P585' in eloClaim.qualifiers:
for j, dummy in enumerate(eloClaim.qualifiers['P585']):
pointInTime = eloClaim.qualifiers['P585'][j].getTarget()
if pointInTime.year==obj['P585']['Y'] and pointInTime.month==obj['P585']['M']:
eloAlreadySet = True
print('{}: Elo claim for {}-{:02d} already exists with value {}; skip'.format(obj['QID'], obj['P585']['Y'], obj['P585']['M'], eloClaim.getTarget().amount))
if eloAlreadySet==False:
newElo = pywikibot.Claim(repo, 'P1087')
newElo.setTarget(value=pywikibot.WbQuantity(site=repo, amount=obj['P1087']))
Qitem.addClaim(newElo)
timestmp = pywikibot.Claim(repo, 'P585')
timestmp.setTarget(value=pywikibot.WbTime(year=obj['P585']['Y'], month=obj['P585']['M']))
newElo.addQualifier(timestmp)
if 'P1440' in obj:
statedIn = pywikibot.Claim(repo, 'P248')
statedIn.setTarget(value=pywikibot.ItemPage(repo, 'Q27038151')); # Q27038151 is ratings.fide.org
fideId = pywikibot.Claim(repo, 'P1440')
fideId.setTarget(value=obj['P1440'])
retrieved = pywikibot.Claim(repo, 'P813')
retrieved.setTarget(value=pywikibot.WbTime(year=obj['P813']['Y'], month=obj['P813']['M'], day=obj['P813']['D']))
newElo.addSources([statedIn, fideId, retrieved])
elif 'P854' in obj:
url = pywikibot.Claim(repo, 'P854')
url.setTarget(value=obj['P854'])
retrieved = pywikibot.Claim(repo, 'P813')
retrieved.setTarget(value=pywikibot.WbTime(year=obj['P813']['Y'], month=obj['P813']['M'], day=obj['P813']['D']))
if 'P1476' in obj:
title = pywikibot.Claim(repo, 'P1476')
title.setTarget(value=pywikibot.WbMonolingualText(text=obj['P1476'], language='en'))
newElo.addSources([url, retrieved, title])
else:
newElo.addSources([url, retrieved])
print('{}: Elo claim for {}-{:02d} with value {} successfully added'.format(obj['QID'], obj['P585']['Y'], obj['P585']['M'], obj['P1087']))
else:
time.sleep(1) # wait 1 second to avoid reading too fast from the API
print('All done, task finished')
def test_WbMonolingualText_unicode(self):
"""Test WbMonolingualText unicode."""
q = pywikibot.WbMonolingualText(text='Testa det här', language='sv')
q_dict = {'text': 'Testa det här', 'language': 'sv'}
self.assertEqual(q.toWikibase(), q_dict)
def test_WbMonolingualText_equality(self):
"""Test WbMonolingualText equality."""
q = pywikibot.WbMonolingualText(text='Thou shall test this!',
language='en-gb')
self.assertEqual(q, q)
def test():
# site = pywikibot.Site('test', "wikidata")
site = SITE # pywikibot.Site('wikidata', "wikidata")
repo = REPO # site.data_repository()
# item = pywikibot.ItemPage(repo, "Q121006") # test:
item = pywikibot.ItemPage(repo, 'Q4115189') # Wikidata Sandbox
# Add claim
prop = 'P1082'
claim = pywikibot.Claim(repo, prop) # , rank='preferred')
#value = to_value[insee_code]
value = 666
quantity = pywikibot.WbQuantity(value, site=site)
#print(type(quantity))
claim.setTarget(quantity)
# TODO: Remove if population is not the last one
# claim.setRank('preferred')
item.addClaim(claim, summary="Add population 2015")
#claim.changeRank('preferred')
# Create qualifier
point_in_time = 'P585'
qualifier = pywikibot.Claim(repo, point_in_time)
date = pywikibot.WbTime(year=2015) # , month=3, day=20)
qualifier.setTarget(date)
#claim.addQualifier(qualifier, summary=u'Adding a qualifier.')
# set_qualifier
qualifier.isQualifier = True
claim.qualifiers[qualifier.getID()] = [qualifier]
# Create source
statedin = pywikibot.Claim(repo, 'P248')
insee = pywikibot.ItemPage(repo, 'Q156616')
statedin.setTarget(insee)
title = pywikibot.Claim(repo, 'P1476')
text = pywikibot.WbMonolingualText("Recensement de la population 2015",
'fr') # monolingual text
title.setTarget(text)
publication_date = pywikibot.Claim(repo, 'P577')
date = pywikibot.WbTime(year=2017, month=12, day=27)
publication_date.setTarget(date)
# claim.addSources([statedin, publication_date], summary="Adding sources.")
# claim.addSources([statedin], summary="Adding sources.")
#claim.addSources([statedin, title, publication_date], summary="Adding sources.")
# set_source
claims = [statedin, title, publication_date]
source = defaultdict(list)
for c in claims:
c.isReference = True
source[c.getID()].append(c)
claim.sources.append(source)
# Set rank
#claim.changeRank('preferred', summary="Add population 2015")
claim.rank = 'preferred'
claim.repo.save_claim(claim, summary="Add population 2015")
def test_WbMonolingualText_string(self):
"""Test WbMonolingualText string."""
q = pywikibot.WbMonolingualText(text='Test that basics work',
language='en')
q_dict = {'text': 'Test that basics work', 'language': 'en'}
self.assertEqual(q.toWikibase(), q_dict)
def addname(item, repo, data):
newClaim = pywikibot.Claim(repo, 'P1705') #native label
newClaim.setTarget(pywikibot.WbMonolingualText(text=data, language='lv'))
item.addClaim(newClaim)
srcurl = row[3]
srctitle = row[4]
if doexit:
break
if selected is not None and filename != selected:
continue
if check_md5file(filename):
print("Passing {}, due to no change".format(filename))
continue
print("==", qid, filename, "==")
# Quelle – eine für alle Einträge
statedin = pywikibot.Claim(repo, 'P854')
statedin.setTarget(srcurl)
title = pywikibot.Claim(repo, 'P1476')
title.setTarget(pywikibot.WbMonolingualText(srctitle, "en"))
retrieved = pywikibot.Claim(repo, 'P813')
retrieved.setTarget(wbtoday)
# Stable Version
stablev = pywikibot.Claim(repo, 'P548')
stablev.setTarget(pywikibot.ItemPage(repo, 'Q2804309'))
# Get item
item = pywikibot.ItemPage(repo, qid)
item.get()
for line in reversed(list(open(filename))):
if doexit:
break
if len(line.split()) != 2:
def run(self):
"""
Starts the robot.
"""
for itempage in self.generator:
pywikibot.output(u'Working on %s' % (itempage.title(), ))
if not itempage.exists():
pywikibot.output(u'Item does not exist, skipping')
continue
data = itempage.get()
claims = data.get('claims')
# Do some checks so we are sure we found exactly one inventory number and one collection
if u'P350' not in claims:
pywikibot.output(u'No RKDimages found, skipping')
continue
if u'P18' in claims:
pywikibot.output(u'Already has an image, done')
continue
if u'P4765' in claims:
pywikibot.output(u'Already has an image suggestion, done')
continue
rkdimagesid = claims.get(u'P350')[0].getTarget()
rkdimagesurl = u'https://rkd.nl/nl/explore/images/%s' % (
rkdimagesid, )
imagePage = requests.get(
'https://api.rkd.nl/api/record/images/%s?format=json&language=nl'
% (rkdimagesid, ),
verify=False)
try:
imagejson = imagePage.json()
except ValueError:
pywikibot.output(u'No valid json found for %s' %
(rkdimagesurl, ))
continue
if imagejson.get('content') and imagejson.get('content').get(
'message'):
pywikibot.output(
u'Something went wrong, got "%s" for %s, skipping' %
(imagejson.get('content').get('message'), imagejson))
continue
if not imagejson.get(u'response').get(u'docs')[0].get(
u'standplaats'):
continue
# Just get the first one
standplaats = imagejson.get(u'response').get(u'docs')[0].get(
u'standplaats')[0]
if not standplaats.get('licence') or not standplaats.get(
'licence') == u'pub-dom':
pywikibot.output(u'No valid license found, skipping')
continue
afbeeldingsnummer = standplaats.get('afbeeldingsnummer')
if not imagejson.get(u'response').get(u'docs')[0].get(
u'afbeeldingsnummer_rkd_picturae_mapping'):
continue
picturae_id = imagejson.get(u'response').get(u'docs')[0].get(
u'afbeeldingsnummer_rkd_picturae_mapping').get(
afbeeldingsnummer)
if not picturae_id:
continue
imageurl = u'https://images.rkd.nl/rkd/thumb/fullsize/%s.jpg' % (
picturae_id, )
print(imageurl)
descriptioncontents = imagejson.get(u'response').get(u'docs')[
0].get(u'virtualFields').get(u'introduction').get(u'contents')
title = descriptioncontents.get(u'benaming').strip()
creator = descriptioncontents.get(u'toeschrijving').strip()
print(title)
print(creator)
newclaim = pywikibot.Claim(self.repo, u'P4765')
newclaim.setTarget(imageurl)
pywikibot.output(
'Adding commons compatible image available at URL claim to %s'
% (itempage.title(), ))
itempage.addClaim(newclaim)
# JPEG
newqualifier = pywikibot.Claim(self.repo, u'P2701')
newqualifier.setTarget(pywikibot.ItemPage(self.repo, u'Q2195'))
newclaim.addQualifier(newqualifier)
# Source link
newqualifier = pywikibot.Claim(self.repo, u'P2699')
newqualifier.setTarget(rkdimagesurl)
newclaim.addQualifier(newqualifier)
# Operated by link
newqualifier = pywikibot.Claim(self.repo, u'P137')
newqualifier.setTarget(pywikibot.ItemPage(self.repo, u'Q758610'))
newclaim.addQualifier(newqualifier)
# Title qualifier
if title:
nltitle = pywikibot.WbMonolingualText(title, u'nl')
newqualifier = pywikibot.Claim(self.repo, u'P1476')
newqualifier.setTarget(nltitle)
newclaim.addQualifier(newqualifier)
# Author name string qualifier
if creator:
newqualifier = pywikibot.Claim(self.repo, u'P2093')
newqualifier.setTarget(creator)
newclaim.addQualifier(newqualifier)
def get_address(value, repo):
address = ', '.join(value)
return pywikibot.WbMonolingualText(text=address, language='ru')
def run(self):
"""
Starts the robot.
"""
for itempage in self.generator:
pywikibot.output(u'Working on %s' % (itempage.title(),))
if not itempage.exists():
pywikibot.output(u'Item does not exist, skipping')
continue
data = itempage.get()
claims = data.get('claims')
# Do some checks so we are sure we found exactly one inventory number and one collection
if u'P1679' not in claims:
pywikibot.output(u'No Art UK artwork ID found, skipping')
continue
if u'P18' in claims:
pywikibot.output(u'Already has an image, done')
continue
if u'P4765' in claims:
pywikibot.output(u'Already has an image suggestion, done')
continue
artukid = claims.get(u'P1679')[0].getTarget()
artukidurl = 'https://artuk.org/discover/artworks/%s' % (artukid,)
imagePage = requests.get(artukidurl) #, verify=False)
# They are sending the wrong headers so I got ISO-8859-1 instead of utf-8
imagePage.encoding = imagePage.apparent_encoding
ccregex = 'id\=\"download-artwork\"[\s\t\r\n]*class\=\"btn dl toolbar_icon\"[\s\t\r\n]*title\=\"Creative Commons\"'
dlregex = '\<a href\=\"(https\:\/\/artuk\.org\/download\/[^\"]+)\" class\=\"btn btn-default\" id\=\"download-button\" data-val\=\"Downloaded\"\>Download\<\/a\>'
titleregex = '\<h1 class\=\"artwork-title\"\>([^\<]+)\s*\<\/h1\>'
creatorregex = '\<h2 class\=\"artist\"\>[\s\t\r\n]*\<a href\=\"[^\"]*\"\>\s*([^\<]+)\s*</a>'
ccmatch = re.search(ccregex, imagePage.text)
dlmatch = re.search(dlregex, imagePage.text)
titlematch = re.search(titleregex, imagePage.text)
creatormatch = re.search(creatorregex, imagePage.text)
if not ccmatch or not dlmatch or not titlematch or not creatormatch:
continue
imageurl = dlmatch.group(1)
title = titlematch.group(1).strip()
creator = " ".join(creatormatch.group(1).split()).replace('–','-')
print (imageurl)
print (title)
print (creator)
newclaim = pywikibot.Claim(self.repo, u'P4765')
newclaim.setTarget(imageurl)
pywikibot.output('Adding commons compatible image available at URL claim to %s' % (itempage.title(),))
itempage.addClaim(newclaim)
# JPEG
newqualifier = pywikibot.Claim(self.repo, u'P2701')
newqualifier.setTarget(pywikibot.ItemPage(self.repo, u'Q2195'))
newclaim.addQualifier(newqualifier)
# Source link
newqualifier = pywikibot.Claim(self.repo, u'P2699')
newqualifier.setTarget(artukidurl)
newclaim.addQualifier(newqualifier)
# Operated by link
newqualifier = pywikibot.Claim(self.repo, u'P137')
newqualifier.setTarget(pywikibot.ItemPage(self.repo, u'Q7257339'))
newclaim.addQualifier(newqualifier)
# Title qualifier
entitle = pywikibot.WbMonolingualText(title, u'en')
newqualifier = pywikibot.Claim(self.repo, u'P1476')
newqualifier.setTarget(entitle)
newclaim.addQualifier(newqualifier)
# Author name string qualifier
newqualifier = pywikibot.Claim(self.repo, u'P2093')
newqualifier.setTarget(creator)
newclaim.addQualifier(newqualifier)
