Module:Wikidata

 -- vim: set noexpandtab ft=lua ts=4 sw=4:
 require('strict')

 localp={}
 localdebug=false


 ------------------------------------------------------------------------------
 -- module local variables and functions

 localwiki=
 {
 langcode=mw.language.getContentLanguage().code
 }

 -- internationalisation
 locali18n=
 {
 ["errors"]=
 {
 ["property-not-found"]="Property not found.",
 ["entity-not-found"]="Wikidata entity not found.",
 ["unknown-claim-type"]="Unknown claim type.",
 ["unknown-entity-type"]="Unknown entity type.",
 ["qualifier-not-found"]="Qualifier not found.",
 ["site-not-found"]="Wikimedia project not found.",
 ["unknown-datetime-format"]="Unknown datetime format.",
 ["local-article-not-found"]="Article is not yet available in this wiki."
 },
 ["datetime"]=
 {
 -- 1ドル is a placeholder for the actual number
 [0]="1ドル billion years",-- precision: billion years
 [1]="100ドル million years",-- precision: hundred million years
 [2]="10ドル million years",-- precision: ten million years
 [3]="1ドル million years",-- precision: million years
 [4]="100,000ドル years",-- precision: hundred thousand years
 [5]="10,000ドル years",-- precision: ten thousand years
 [6]="1ドル millennium",-- precision: millennium
 [7]="1ドル century",-- precision: century
 [8]="1ドルs",-- precision: decade
 -- the following use the format of #time parser function
 [9]="Y",-- precision: year,
 [10]="F Y",-- precision: month
 [11]="F j, Y",-- precision: day
 [12]="F j, Y ga",-- precision: hour
 [13]="F j, Y g:ia",-- precision: minute
 [14]="F j, Y g:i:sa",-- precision: second
 ["beforenow"]="1ドル BCE",-- how to format negative numbers for precisions 0 to 5
 ["afternow"]="1ドル CE",-- how to format positive numbers for precisions 0 to 5
 ["bc"]='1ドル "BCE"',-- how print negative years
 ["ad"]="1ドル",-- how print positive years
 -- the following are for function getDateValue() and getQualifierDateValue()
 ["default-format"]="dmy",-- default value of the #3 (getDateValue) or
 -- #4 (getQualifierDateValue) argument
 ["default-addon"]="BC",-- default value of the #4 (getDateValue) or
 -- #5 (getQualifierDateValue) argument
 ["prefix-addon"]=false,-- set to true for languages put "BC" in front of the
 -- datetime string; or the addon will be suffixed
 ["addon-sep"]=" ",-- separator between datetime string and addon (or inverse)
 ["format"]=-- options of the 3rd argument
 {
 ["mdy"]="F j, Y",
 ["my"]="F Y",
 ["y"]="Y",
 ["dmy"]="j F Y",
 ["ymd"]="Y-m-d",
 ["ym"]="Y-m"
 }
 },
 ["monolingualtext"]='<span lang="%language">%text</span>',
 ["warnDump"]="[[Category:Called function 'Dump' from module Wikidata]]",
 ["ordinal"]=
 {
 [1]="st",
 [2]="nd",
 [3]="rd",
 ["default"]="th"
 }
 }

 ifwiki.langcode~="en"then
 --require("Module:i18n").loadI18n("Module:Wikidata/i18n", i18n)
 -- got idea from [[:w:Module:Wd]]
 localmodule_title;if...==nilthen
 module_title=mw.getCurrentFrame():getTitle()
 else
 module_title=...
 end
 require('Module:i18n').loadI18n(module_title..'/i18n',i18n)
 end

 -- this function needs to be internationalised along with the above:
 -- takes cardinal numer as a numeric and returns the ordinal as a string
 -- we need three exceptions in English for 1st, 2nd, 3rd, 21st, .. 31st, etc.
 localfunctionmakeOrdinal(cardinal)
 localordsuffix=i18n.ordinal.default
 ifcardinal%10==1then
 ordsuffix=i18n.ordinal[1]
 elseifcardinal%10==2then
 ordsuffix=i18n.ordinal[2]
 elseifcardinal%10==3then
 ordsuffix=i18n.ordinal[3]
 end
 -- In English, 1, 21, 31, etc. use 'st', but 11, 111, etc. use 'th'
 -- similarly for 12 and 13, etc.
 if(cardinal%100==11)or(cardinal%100==12)or(cardinal%100==13)then
 ordsuffix=i18n.ordinal.default
 end
 returntostring(cardinal)..ordsuffix
 end

 localfunctionprintError(code)
 return'<span class="error">'..(i18n.errors[code]orcode)..'</span>'
 end
 localfunctionparseDateFormat(f,timestamp,addon,prefix_addon,addon_sep)
 localyear_suffix
 localtstr=""
 locallang_obj=mw.language.new(wiki.langcode)
 localf_parts=mw.text.split(f,'Y',true)
 foridx,f_partinpairs(f_parts)do
 year_suffix=''
 ifstring.match(f_part,"x[mijkot]$")then
 -- for non-Gregorian year
 f_part=f_part..'Y'
 elseifidx<#f_partsthen
 -- supress leading zeros in year
 year_suffix=lang_obj:formatDate('Y',timestamp)
 year_suffix=string.gsub(year_suffix,'^0+','',1)
 end
 tstr=tstr..lang_obj:formatDate(f_part,timestamp)..year_suffix
 end
 ifaddon~=""andprefix_addonthen
 returnaddon..addon_sep..tstr
 elseifaddon~=""then
 returntstr..addon_sep..addon
 else
 returntstr
 end
 end
 localfunctionparseDateValue(timestamp,date_format,date_addon)
 localprefix_addon=i18n["datetime"]["prefix-addon"]
 localaddon_sep=i18n["datetime"]["addon-sep"]
 localaddon=""

 -- check for negative date
 ifstring.sub(timestamp,1,1)=='-'then
 timestamp='+'..string.sub(timestamp,2)
 addon=date_addon
 end
 local_date_format=i18n["datetime"]["format"][date_format]
 if_date_format~=nilthen
 returnparseDateFormat(_date_format,timestamp,addon,prefix_addon,addon_sep)
 else
 returnprintError("unknown-datetime-format")
 end
 end

 -- This local function combines the year/month/day/BC/BCE handling of parseDateValue{}
 -- with the millennium/century/decade handling of formatDate()
 localfunctionparseDateFull(timestamp,precision,date_format,date_addon)
 localprefix_addon=i18n["datetime"]["prefix-addon"]
 localaddon_sep=i18n["datetime"]["addon-sep"]
 localaddon=""

 -- check for negative date
 ifstring.sub(timestamp,1,1)=='-'then
 timestamp='+'..string.sub(timestamp,2)
 addon=date_addon
 end

 -- get the next four characters after the + (should be the year now in all cases)
 -- ok, so this is dirty, but let's get it working first
 localintyear=tonumber(string.sub(timestamp,2,5))
 ifintyear==0andprecision<=9then
 return""
 end

 -- precision is 10000 years or more
 ifprecision<=5then
 localfactor=10^((5-precision)+4)
 localy2=math.ceil(math.abs(intyear)/factor)
 localrelative=mw.ustring.gsub(i18n.datetime[precision],"1ドル",tostring(y2))
 ifaddon~=""then
 -- negative date
 relative=mw.ustring.gsub(i18n.datetime.beforenow,"1ドル",relative)
 else
 relative=mw.ustring.gsub(i18n.datetime.afternow,"1ドル",relative)
 end
 returnrelative
 end

 -- precision is decades (8), centuries (7) and millennia (6)
 localera,card
 ifprecision==6then
 card=math.floor((intyear-1)/1000)+1
 era=mw.ustring.gsub(i18n.datetime[6],"1ドル",makeOrdinal(card))
 end
 ifprecision==7then
 card=math.floor((intyear-1)/100)+1
 era=mw.ustring.gsub(i18n.datetime[7],"1ドル",makeOrdinal(card))
 end
 ifprecision==8then
 era=mw.ustring.gsub(i18n.datetime[8],"1ドル",tostring(math.floor(math.abs(intyear)/10)*10))
 end
 iferathen
 ifaddon~=""then
 era=mw.ustring.gsub(mw.ustring.gsub(i18n.datetime.bc,'"',""),"1ドル",era)
 else
 era=mw.ustring.gsub(mw.ustring.gsub(i18n.datetime.ad,'"',""),"1ドル",era)
 end
 returnera
 end

 local_date_format=i18n["datetime"]["format"][date_format]
 if_date_format~=nilthen
 -- check for precision is year and override supplied date_format
 ifprecision==9then
 _date_format=i18n["datetime"][9]
 end
 returnparseDateFormat(_date_format,timestamp,addon,prefix_addon,addon_sep)
 else
 returnprintError("unknown-datetime-format")
 end
 end

 -- the "qualifiers" and "snaks" field have a respective "qualifiers-order" and "snaks-order" field
 -- use these as the second parameter and this function instead of the built-in "pairs" function
 -- to iterate over all qualifiers and snaks in the intended order.
 localfunctionorderedpairs(array,order)
 ifnotorderthenreturnpairs(array)end

 -- return iterator function
 locali=0
 returnfunction()
 i=i+1
 iforder[i]then
 returnorder[i],array[order[i]]
 end
 end
 end

 -- precision: 0 - billion years, 1 - hundred million years, ..., 6 - millennia, 7 - century, 8 - decade, 9 - year, 10 - month, 11 - day, 12 - hour, 13 - minute, 14 - second
 localfunctionnormalizeDate(date)
 date=mw.text.trim(date,"+")
 -- extract year
 localyearstr=mw.ustring.match(date,"^\-?%d+")
 localyear=tonumber(yearstr)
 -- remove leading zeros of year
 returnyear..mw.ustring.sub(date,#yearstr+1),year
 end

 localfunctionformatDate(date,precision,timezone)
 precision=precisionor11
 localdate,year=normalizeDate(date)
 ifyear==0andprecision<=9thenreturn""end

 -- precision is 10000 years or more
 ifprecision<=5then
 localfactor=10^((5-precision)+4)
 localy2=math.ceil(math.abs(year)/factor)
 localrelative=mw.ustring.gsub(i18n.datetime[precision],"1ドル",tostring(y2))
 ifyear<0then
 relative=mw.ustring.gsub(i18n.datetime.beforenow,"1ドル",relative)
 else
 relative=mw.ustring.gsub(i18n.datetime.afternow,"1ドル",relative)
 end
 returnrelative
 end

 -- precision is decades, centuries and millennia
 localera
 ifprecision==6thenera=mw.ustring.gsub(i18n.datetime[6],"1ドル",tostring(math.floor((math.abs(year)-1)/1000)+1))end
 ifprecision==7thenera=mw.ustring.gsub(i18n.datetime[7],"1ドル",tostring(math.floor((math.abs(year)-1)/100)+1))end
 ifprecision==8thenera=mw.ustring.gsub(i18n.datetime[8],"1ドル",tostring(math.floor(math.abs(year)/10)*10))end
 iferathen
 ifyear<0thenera=mw.ustring.gsub(mw.ustring.gsub(i18n.datetime.bc,'"',""),"1ドル",era)
 elseifyear>0thenera=mw.ustring.gsub(mw.ustring.gsub(i18n.datetime.ad,'"',""),"1ドル",era)end
 returnera
 end

 -- precision is year
 ifprecision==9then
 returnyear
 end

 -- precision is less than years
 ifprecision>9then
 --[[ the following code replaces the UTC suffix with the given negated timezone to convert the global time to the given local time
 		timezone = tonumber(timezone)
 		if timezone and timezone ~= 0 then
 			timezone = -timezone
 			timezone = string.format("%.2d%.2d", timezone / 60, timezone % 60)
 			if timezone[1] ~= '-' then timezone = "+" .. timezone end
 			date = mw.text.trim(date, "Z") .. " " .. timezone
 		end
 		]]--

 localformatstr=i18n.datetime[precision]
 ifyear==0thenformatstr=mw.ustring.gsub(formatstr,i18n.datetime[9],"")
 elseifyear<0then
 -- Mediawiki formatDate doesn't support negative years
 date=mw.ustring.sub(date,2)
 formatstr=mw.ustring.gsub(formatstr,i18n.datetime[9],mw.ustring.gsub(i18n.datetime.bc,"1ドル",i18n.datetime[9]))
 elseifyear>0andi18n.datetime.ad~="1ドル"then
 formatstr=mw.ustring.gsub(formatstr,i18n.datetime[9],mw.ustring.gsub(i18n.datetime.ad,"1ドル",i18n.datetime[9]))
 end
 returnmw.language.new(wiki.langcode):formatDate(formatstr,date)
 end
 end

 localfunctionprintDatavalueEntity(data,parameter)
 -- data fields: entity-type [string], numeric-id [int, Wikidata id]
 localid

 ifdata["entity-type"]=="item"thenid="Q"..data["numeric-id"]
 elseifdata["entity-type"]=="property"thenid="P"..data["numeric-id"]
 elsereturnprintError("unknown-entity-type")
 end

 ifparameterthen
 ifparameter=="link"then
 locallinkTarget=mw.wikibase.getSitelink(id)
 locallinkName=mw.wikibase.getLabel(id)
 iflinkTargetthen
 -- if there is a local Wikipedia article link to it using the label or the article title
 return"[["..linkTarget.."|"..(linkNameorlinkTarget).."]]"
 else
 -- if there is no local Wikipedia article output the label or link to the Wikidata object to let the user input a proper label
 iflinkNamethenreturnlinkNameelsereturn"[[:d:"..id.."|"..id.."]]"end
 end
 else
 returndata[parameter]
 end
 else
 returnmw.wikibase.getLabel(id)orid
 end
 end

 localfunctionprintDatavalueTime(data,parameter)
 -- data fields: time [ISO 8601 time], timezone [int in minutes], before [int], after [int], precision [int], calendarmodel [wikidata URI]
 -- precision: 0 - billion years, 1 - hundred million years, ..., 6 - millennia, 7 - century, 8 - decade, 9 - year, 10 - month, 11 - day, 12 - hour, 13 - minute, 14 - second
 -- calendarmodel: e.g. http://www.wikidata.org/entity/Q1985727 for the proleptic Gregorian calendar or http://www.wikidata.org/wiki/Q11184 for the Julian calendar]
 ifparameterthen
 ifparameter=="calendarmodel"thendata.calendarmodel=mw.ustring.match(data.calendarmodel,"Q%d+")-- extract entity id from the calendar model URI
 elseifparameter=="time"thendata.time=normalizeDate(data.time)end
 returndata[parameter]
 else
 returnformatDate(data.time,data.precision,data.timezone)
 end
 end

 localfunctionprintDatavalueMonolingualText(data,parameter)
 -- data fields: language [string], text [string]
 ifparameterthen
 returndata[parameter]
 else
 localresult=mw.ustring.gsub(mw.ustring.gsub(i18n.monolingualtext,"%%language",data["language"]),"%%text",data["text"])
 returnresult
 end
 end

 localfunctionfindClaims(entity,property)
 ifnotpropertyornotentityornotentity.claimsthenreturnend

 ifmw.ustring.match(property,"^P%d+$")then
 -- if the property is given by an id (P..) access the claim list by this id
 returnentity.claims[property]
 else
 property=mw.wikibase.resolvePropertyId(property)
 ifnotpropertythenreturnend

 returnentity.claims[property]
 end
 end

 localfunctiongetSnakValue(snak,parameter)
 ifsnak.snaktype=="value"then
 -- call the respective snak parser
 ifsnak.datavalue.type=="string"thenreturnsnak.datavalue.value
 elseifsnak.datavalue.type=="globecoordinate"thenreturnprintDatavalueCoordinate(snak.datavalue.value,parameter)
 elseifsnak.datavalue.type=="quantity"thenreturnprintDatavalueQuantity(snak.datavalue.value,parameter)
 elseifsnak.datavalue.type=="time"thenreturnprintDatavalueTime(snak.datavalue.value,parameter)
 elseifsnak.datavalue.type=="wikibase-entityid"thenreturnprintDatavalueEntity(snak.datavalue.value,parameter)
 elseifsnak.datavalue.type=="monolingualtext"thenreturnprintDatavalueMonolingualText(snak.datavalue.value,parameter)
 end
 end
 returnmw.wikibase.renderSnak(snak)
 end

 localfunctiongetQualifierSnak(claim,qualifierId)
 -- a "snak" is Wikidata terminology for a typed key/value pair
 -- a claim consists of a main snak holding the main information of this claim,
 -- as well as a list of attribute snaks and a list of references snaks
 ifqualifierIdthen
 -- search the attribute snak with the given qualifier as key
 ifclaim.qualifiersthen
 localqualifier=claim.qualifiers[qualifierId]
 ifqualifierthenreturnqualifier[1]end
 end
 returnnil,printError("qualifier-not-found")
 else
 -- otherwise return the main snak
 returnclaim.mainsnak
 end
 end

 localfunctiongetValueOfClaim(claim,qualifierId,parameter)
 localerror
 localsnak
 snak,error=getQualifierSnak(claim,qualifierId)
 ifsnakthen
 returngetSnakValue(snak,parameter)
 else
 returnnil,error
 end
 end

 localfunctiongetReferences(frame,claim)
 localresult=""
 -- traverse through all references
 forrefinpairs(claim.referencesor{})do
 localrefparts
 -- traverse through all parts of the current reference
 forsnakkey,snakvalinorderedpairs(claim.references[ref].snaksor{},claim.references[ref]["snaks-order"])do
 ifrefpartsthenrefparts=refparts..", "elserefparts=""end
 -- output the label of the property of the reference part, e.g. "imported from" for P143
 refparts=refparts..tostring(mw.wikibase.getLabel(snakkey))..": "
 -- output all values of this reference part, e.g. "German Wikipedia" and "English Wikipedia" if the referenced claim was imported from both sites
 forsnakidx=1,#snakvaldo
 ifsnakidx>1thenrefparts=refparts..", "end
 refparts=refparts..getSnakValue(snakval[snakidx])
 end
 end
 ifrefpartsthenresult=result..frame:extensionTag("ref",refparts)end
 end
 returnresult
 end

 localfunctionparseInput(frame)
 localqid=frame.args.qid
 ifqidand(#qid==0)thenqid=nilend
 localpropertyID=mw.text.trim(frame.args[1]or"")
 localinput_parm=mw.text.trim(frame.args[2]or"")
 ifinput_parm~="FETCH_WIKIDATA"then
 returnfalse,input_parm,nil,nil
 end
 localentity=mw.wikibase.getEntity(qid)
 localclaims
 ifentityandentity.claimsthen
 claims=entity.claims[propertyID]
 ifnotclaimsthen
 returnfalse,"",nil,nil
 end
 else
 returnfalse,"",nil,nil
 end
 returntrue,entity,claims,propertyID
 end
 localfunctionisType(claims,type)
 returnclaims[1]andclaims[1].mainsnak.snaktype=="value"andclaims[1].mainsnak.datavalue.type==type
 end
 localfunctiongetValue(entity,claims,propertyID,delim,labelHook)
 iflabelHook==nilthen
 labelHook=function(qnumber)
 returnnil;
 end
 end
 ifisType(claims,"wikibase-entityid")then
 localout={}
 fork,vinpairs(claims)do
 localqnumber="Q"..v.mainsnak.datavalue.value["numeric-id"]
 localsitelink=mw.wikibase.getSitelink(qnumber)
 locallabel=labelHook(qnumber)ormw.wikibase.getLabel(qnumber)orqnumber
 ifsitelinkthen
 out[#out+1]="[["..sitelink.."|"..label.."]]"
 else
 out[#out+1]="[[:d:"..qnumber.."|"..label.."]]<abbr title='"..i18n["errors"]["local-article-not-found"].."'>[*]</abbr>"
 end
 end
 returntable.concat(out,delim)
 else
 -- just return best values
 returnentity:formatPropertyValues(propertyID).value
 end
 end

 ------------------------------------------------------------------------------
 -- module global functions

 ifdebugthen
 functionp.inspectI18n(frame)
 localval=i18n
 for_,keyinpairs(frame.args)do
 key=mw.text.trim(key)
 val=val[key]
 end
 returnval
 end
 end

 functionp.descriptionIn(frame)
 locallangcode=frame.args[1]
 localid=frame.args[2]
 -- return description of a Wikidata entity in the given language or the default language of this Wikipedia site
 returnmw.wikibase.getEntity(id):getDescription(langcodeorwiki.langcode)
 end

 functionp.labelIn(frame)
 locallangcode=frame.args[1]
 localid=frame.args[2]
 -- return label of a Wikidata entity in the given language or the default language of this Wikipedia site
 returnmw.wikibase.getEntity(id):getLabel(langcodeorwiki.langcode)
 end

 -- This is used to get a value, or a comma separated list of them if multiple values exist
 p.getValue=function(frame)
 localdelimdefault=", "-- **internationalise later**
 localdelim=frame.args.delimiteror""
 delim=string.gsub(delim,'"','')
 if#delim==0then
 delim=delimdefault
 end
 localgo,errorOrentity,claims,propertyID=parseInput(frame)
 ifnotgothen
 returnerrorOrentity
 end
 returngetValue(errorOrentity,claims,propertyID,delim)
 end

 -- Same as above, but uses the short name property for label if available.
 p.getValueShortName=function(frame)
 localgo,errorOrentity,claims,propertyID=parseInput(frame)
 ifnotgothen
 returnerrorOrentity
 end
 localentity=errorOrentity
 -- if wiki-linked value output as link if possible
 localfunctionlabelHook(qnumber)
 locallabel
 localclaimEntity=mw.wikibase.getEntity(qnumber)
 ifclaimEntity~=nilthen
 ifclaimEntity.claims.P1813then
 fork2,v2inpairs(claimEntity.claims.P1813)do
 ifv2.mainsnak.datavalue.value.language=="en"then
 label=v2.mainsnak.datavalue.value.text
 end
 end
 end
 end
 iflabel==nilorlabel==""thenreturnnilend
 returnlabel
 end
 returngetValue(errorOrentity,claims,propertyID,", ",labelHook);
 end

 -- This is used to get a value, or a comma separated list of them if multiple values exist
 -- from an arbitrary entry by using its QID.
 -- Use : {{#invoke:Wikidata|getValueFromID|<ID>|<Property>|FETCH_WIKIDATA}}
 -- E.g.: {{#invoke:Wikidata|getValueFromID|Q151973|P26|FETCH_WIKIDATA}} - to fetch value of 'spouse' (P26) from 'Richard Burton' (Q151973)
 -- Please use sparingly - this is an *expensive call*.
 p.getValueFromID=function(frame)
 localitemID=mw.text.trim(frame.args[1]or"")
 localpropertyID=mw.text.trim(frame.args[2]or"")
 localinput_parm=mw.text.trim(frame.args[3]or"")
 ifinput_parm=="FETCH_WIKIDATA"then
 localentity=mw.wikibase.getEntity(itemID)
 localclaims
 ifentityandentity.claimsthen
 claims=entity.claims[propertyID]
 end
 ifclaimsthen
 returngetValue(entity,claims,propertyID,", ")
 else
 return""
 end
 else
 returninput_parm
 end
 end
 localfunctiongetQualifier(frame,outputHook)
 localpropertyID=mw.text.trim(frame.args[1]or"")
 localqualifierID=mw.text.trim(frame.args[2]or"")
 localinput_parm=mw.text.trim(frame.args[3]or"")
 ifinput_parm=="FETCH_WIKIDATA"then
 localentity=mw.wikibase.getEntity()
 ifentity.claims[propertyID]~=nilthen
 localout={}
 fork,vinpairs(entity.claims[propertyID])do
 fork2,v2inpairs(v.qualifiers[qualifierID])do
 ifv2.snaktype=='value'then
 out[#out+1]=outputHook(v2);
 end
 end
 end
 returntable.concat(out,", "),true
 else
 return"",false
 end
 else
 returninput_parm,false
 end
 end
 p.getQualifierValue=function(frame)
 localfunctionoutputValue(value)
 localqnumber="Q"..value.datavalue.value["numeric-id"]
 if(mw.wikibase.getSitelink(qnumber))then
 return"[["..mw.wikibase.getSitelink(qnumber).."]]"
 else
 return"[[:d:"..qnumber.."|"..qnumber.."]]<abbr title='"..i18n["errors"]["local-article-not-found"].."'>[*]</abbr>"
 end
 end
 return(getQualifier(frame,outputValue))
 end

 -- This is used to get a value like 'male' (for property p21) which won't be linked and numbers without the thousand separators
 p.getRawValue=function(frame)
 localgo,errorOrentity,claims,propertyID=parseInput(frame)
 ifnotgothen
 returnerrorOrentity
 end
 localentity=errorOrentity
 localresult=entity:formatPropertyValues(propertyID,mw.wikibase.entity.claimRanks).value
 -- if number type: remove thousand separators, bounds and units
 ifisType(claims,"quantity")then
 result=mw.ustring.gsub(result,"(%d),(%d)","%1%2")
 result=mw.ustring.gsub(result,"(%d)±.*","%1")
 end
 returnresult
 end

 -- This is used to get the unit name for the numeric value returned by getRawValue
 p.getUnits=function(frame)
 localgo,errorOrentity,claims,propertyID=parseInput(frame)
 ifnotgothen
 returnerrorOrentity
 end
 localentity=errorOrentity
 localresult=entity:formatPropertyValues(propertyID,mw.wikibase.entity.claimRanks).value
 ifisType(claims,"quantity")then
 result=mw.ustring.sub(result,mw.ustring.find(result," ")+1,-1)
 end
 returnresult
 end

 -- This is used to get the unit's QID to use with the numeric value returned by getRawValue
 p.getUnitID=function(frame)
 localgo,errorOrentity,claims=parseInput(frame)
 ifnotgothen
 returnerrorOrentity
 end
 localentity=errorOrentity
 localresult
 ifisType(claims,"quantity")then
 -- get the url for the unit entry on Wikidata:
 result=claims[1].mainsnak.datavalue.value.unit
 -- and just reurn the last bit from "Q" to the end (which is the QID):
 result=mw.ustring.sub(result,mw.ustring.find(result,"Q"),-1)
 end
 returnresult
 end

 p.getRawQualifierValue=function(frame)
 localfunctionoutputHook(value)
 ifvalue.datavalue.value["numeric-id"]then
 returnmw.wikibase.getLabel("Q"..value.datavalue.value["numeric-id"])
 else
 returnvalue.datavalue.value
 end
 end
 localret,gotData=getQualifier(frame,outputHook)
 ifgotDatathen
 ret=string.upper(string.sub(ret,1,1))..string.sub(ret,2)
 end
 returnret
 end

 -- This is used to get a date value for date_of_birth (P569), etc. which won't be linked
 -- Dates and times are stored in ISO 8601 format (sort of).
 -- At present the local formatDate(date, precision, timezone) function doesn't handle timezone
 -- So I'll just supply "Z" in the call to formatDate below:
 p.getDateValue=function(frame)
 localdate_format=mw.text.trim(frame.args[3]ori18n["datetime"]["default-format"])
 localdate_addon=mw.text.trim(frame.args[4]ori18n["datetime"]["default-addon"])
 localgo,errorOrentity,claims=parseInput(frame)
 ifnotgothen
 returnerrorOrentity
 end
 localentity=errorOrentity
 localout={}
 fork,vinpairs(claims)do
 ifv.mainsnak.datavalue.type=='time'then
 localtimestamp=v.mainsnak.datavalue.value.time
 localdateprecision=v.mainsnak.datavalue.value.precision
 -- A year can be stored like this: "+1872-00-00T00:00:00Z",
 -- which is processed here as if it were the day before "+1872年01月01日T00:00:00Z",
 -- and that's the last day of 1871, so the year is wrong.
 -- So fix the month 0, day 0 timestamp to become 1 January instead:
 timestamp=timestamp:gsub("%-00%-00T","-01-01T")
 out[#out+1]=parseDateFull(timestamp,dateprecision,date_format,date_addon)
 end
 end
 returntable.concat(out,", ")
 end
 p.getQualifierDateValue=function(frame)
 localdate_format=mw.text.trim(frame.args[4]ori18n["datetime"]["default-format"])
 localdate_addon=mw.text.trim(frame.args[5]ori18n["datetime"]["default-addon"])
 localfunctionoutputHook(value)
 localtimestamp=value.datavalue.value.time
 returnparseDateValue(timestamp,date_format,date_addon)
 end
 return(getQualifier(frame,outputHook))
 end

 -- This is used to fetch all of the images with a particular property, e.g. image (P18), Gene Atlas Image (P692), etc.
 -- Parameters are | propertyID | value / FETCH_WIKIDATA / nil | separator (default=space) | size (default=frameless)
 -- It will return a standard wiki-markup [[File:Filename | size]] for each image with a selectable size and separator (which may be html)
 -- e.g. {{#invoke:Wikidata|getImages|P18|FETCH_WIKIDATA}}
 -- e.g. {{#invoke:Wikidata|getImages|P18|FETCH_WIKIDATA|<br>|250px}}
 -- If a property is chosen that is not of type "commonsMedia", it will return empty text.
 p.getImages=function(frame)
 localsep=mw.text.trim(frame.args[3]or" ")
 localimgsize=mw.text.trim(frame.args[4]or"frameless")
 localgo,errorOrentity,claims=parseInput(frame)
 ifnotgothen
 returnerrorOrentity
 end
 localentity=errorOrentity
 if(claims[1]andclaims[1].mainsnak.datatype=="commonsMedia")then
 localout={}
 fork,vinpairs(claims)do
 localfilename=v.mainsnak.datavalue.value
 out[#out+1]="[[File:"..filename.."|"..imgsize.."]]"
 end
 returntable.concat(out,sep)
 else
 return""
 end
 end

 -- This is used to get the TA98 (Terminologia Anatomica first edition 1998) values like 'A01.1.00.005' (property P1323)
 -- which are then linked to https://ifaa.unifr.ch/Public/EntryPage/TA98%20Tree/Entity%20TA98%20EN/01.1.00.005%20Entity%20TA98%20EN.htm
 -- uses the newer mw.wikibase calls instead of directly using the snaks
 -- formatPropertyValues returns a table with the P1323 values concatenated with ", " so we have to split them out into a table in order to construct the return string
 p.getTAValue=function(frame)
 localent=mw.wikibase.getEntity()
 localprops=ent:formatPropertyValues('P1323')
 localout={}
 localt={}
 fork,vinpairs(props)do
 ifk=='value'then
 t=mw.text.split(v,", ")
 fork2,v2inpairs(t)do
 out[#out+1]="[https://ifaa.unifr.ch/Public/EntryPage/TA98%20Tree/Entity%20TA98%20EN/"..string.sub(v2,2).."%20Entity%20TA98%20EN.htm "..v2.."]"
 end
 end
 end
 localret=table.concat(out,"<br> ")
 if#ret==0then
 ret="Invalid TA"
 end
 returnret
 end

 --[[
 This is used to return an image legend from Wikidata
 image is property P18
 image legend is property P2096

 Call as {{#invoke:Wikidata |getImageLegend | <PARAMETER> | lang=<ISO-639code> |id=<QID>}}
 Returns PARAMETER, unless it is equal to "FETCH_WIKIDATA", from Item QID (expensive call)
 If QID is omitted or blank, the current article is used (not an expensive call)
 If lang is omitted, it uses the local wiki language, otherwise it uses the provided ISO-639 language code
 ISO-639: https://docs.oracle.com/cd/E13214_01/wli/docs92/xref/xqisocodes.html#wp1252447

 Ranks are: 'preferred' > 'normal'
 This returns the label from the first image with 'preferred' rank
 Or the label from the first image with 'normal' rank if preferred returns nothing
 Ranks: https://www.mediawiki.org/wiki/Extension:Wikibase_Client/Lua
 ]]

 p.getImageLegend=function(frame)
 -- look for named parameter id; if it's blank make it nil
 localid=frame.args.id
 ifidand(#id==0)then
 id=nil
 end

 -- look for named parameter lang
 -- it should contain a two-character ISO-639 language code
 -- if it's blank fetch the language of the local wiki
 locallang=frame.args.lang
 if(notlang)or(#lang<2)then
 lang=mw.language.getContentLanguage().code
 end

 -- first unnamed parameter is the local parameter, if supplied
 localinput_parm=mw.text.trim(frame.args[1]or"")
 ifinput_parm=="FETCH_WIKIDATA"then
 localent=mw.wikibase.getEntity(id)
 localimgs
 ifentandent.claimsthen
 imgs=ent.claims.P18
 end
 localimglbl
 ifimgsthen
 -- look for an image with 'preferred' rank
 fork1,v1inpairs(imgs)do
 ifv1.rank=="preferred"andv1.qualifiersandv1.qualifiers.P2096then
 localimglbls=v1.qualifiers.P2096
 fork2,v2inpairs(imglbls)do
 ifv2.datavalue.value.language==langthen
 imglbl=v2.datavalue.value.text
 break
 end
 end
 end
 end
 -- if we don't find one, look for an image with 'normal' rank
 if(notimglbl)then
 fork1,v1inpairs(imgs)do
 ifv1.rank=="normal"andv1.qualifiersandv1.qualifiers.P2096then
 localimglbls=v1.qualifiers.P2096
 fork2,v2inpairs(imglbls)do
 ifv2.datavalue.value.language==langthen
 imglbl=v2.datavalue.value.text
 break
 end
 end
 end
 end
 end
 end
 returnimglbl
 else
 returninput_parm
 end
 end

 -- This is used to get the QIDs of all of the values of a property, as a comma separated list if multiple values exist
 -- Usage: {{#invoke:Wikidata |getPropertyIDs |<PropertyID> |FETCH_WIKIDATA}}
 -- Usage: {{#invoke:Wikidata |getPropertyIDs |<PropertyID> |<InputParameter> |qid=<QID>}}

 p.getPropertyIDs=function(frame)
 localgo,errorOrentity,propclaims=parseInput(frame)
 ifnotgothen
 returnerrorOrentity
 end
 localentity=errorOrentity
 -- if wiki-linked value collect the QID in a table
 if(propclaims[1]andpropclaims[1].mainsnak.snaktype=="value"andpropclaims[1].mainsnak.datavalue.type=="wikibase-entityid")then
 localout={}
 fork,vinpairs(propclaims)do
 out[#out+1]="Q"..v.mainsnak.datavalue.value["numeric-id"]
 end
 returntable.concat(out,", ")
 else
 -- not a wikibase-entityid, so return empty
 return""
 end
 end

 -- returns the page id (Q...) of the current page or nothing of the page is not connected to Wikidata
 functionp.pageId(frame)
 returnmw.wikibase.getEntityIdForCurrentPage()
 end

 functionp.claim(frame)
 localproperty=frame.args[1]or""
 localid=frame.args["id"]
 localqualifierId=frame.args["qualifier"]
 localparameter=frame.args["parameter"]
 locallist=frame.args["list"]
 localreferences=frame.args["references"]
 localshowerrors=frame.args["showerrors"]
 localdefault=frame.args["default"]
 ifdefaultthenshowerrors=nilend

 -- get wikidata entity
 localentity=mw.wikibase.getEntity(id)
 ifnotentitythen
 ifshowerrorsthenreturnprintError("entity-not-found")elsereturndefaultend
 end
 -- fetch the first claim of satisfying the given property
 localclaims=findClaims(entity,property)
 ifnotclaimsornotclaims[1]then
 ifshowerrorsthenreturnprintError("property-not-found")elsereturndefaultend
 end

 -- get initial sort indices
 localsortindices={}
 foridxinpairs(claims)do
 sortindices[#sortindices+1]=idx
 end
 -- sort by claim rank
 localcomparator=function(a,b)
 localrankmap={deprecated=2,normal=1,preferred=0}
 localranka=rankmap[claims[a].rankor"normal"]..string.format("%08d",a)
 localrankb=rankmap[claims[b].rankor"normal"]..string.format("%08d",b)
 returnranka<rankb
 end
 table.sort(sortindices,comparator)

 localresult
 localerror
 iflistthen
 localvalue
 -- iterate over all elements and return their value (if existing)
 result={}
 foridxinpairs(claims)do
 localclaim=claims[sortindices[idx]]
 value,error=getValueOfClaim(claim,qualifierId,parameter)
 ifnotvalueandshowerrorsthenvalue=errorend
 ifvalueandreferencesthenvalue=value..getReferences(frame,claim)end
 result[#result+1]=value
 end
 result=table.concat(result,list)
 else
 -- return first element
 localclaim=claims[sortindices[1]]
 result,error=getValueOfClaim(claim,qualifierId,parameter)
 ifresultandreferencesthenresult=result..getReferences(frame,claim)end
 end

 ifresultthenreturnresultelse
 ifshowerrorsthenreturnerrorelsereturndefaultend
 end
 end

 -- look into entity object
 functionp.ViewSomething(frame)
 localf=(frame.args[1]orframe.args.id)andframeorframe:getParent()
 localid=f.args.id
 ifidand(#id==0)then
 id=nil
 end
 localdata=mw.wikibase.getEntity(id)
 ifnotdatathen
 returnnil
 end

 locali=1
 whiletruedo
 localindex=f.args[i]
 ifnotindexthen
 iftype(data)=="table"then
 returnmw.text.jsonEncode(data,mw.text.JSON_PRESERVE_KEYS+mw.text.JSON_PRETTY)
 else
 returntostring(data)
 end
 end

 data=data[index]ordata[tonumber(index)]
 ifnotdatathen
 return
 end

 i=i+1
 end
 end

 -- getting sitelink of a given wiki
 -- get sitelink of current item if qid not supplied
 functionp.getSiteLink(frame)
 localqid=frame.args.qid
 ifqid==""thenqid=nilend
 localf=mw.text.trim(frame.args[1]or"")
 localentity=mw.wikibase.getEntity(qid)
 ifnotentitythen
 return
 end
 locallink=entity:getSitelink(f)
 ifnotlinkthen
 return
 end
 returnlink
 end

 functionp.Dump(frame)
 localf=(frame.args[1]orframe.args.id)andframeorframe:getParent()
 localdata=mw.wikibase.getEntity(f.args.id)
 ifnotdatathen
 returni18n.warnDump
 end

 locali=1
 whiletruedo
 localindex=f.args[i]
 ifnotindexthen
 return"<pre>"..mw.dumpObject(data).."</pre>"..i18n.warnDump
 end

 data=data[index]ordata[tonumber(index)]
 ifnotdatathen
 returni18n.warnDump
 end

 i=i+1
 end
 end

 returnp