Module:WikidataIB: Difference between revisions

From Random Island Wiki
Jump to navigation Jump to search
>RexxS
(trap zero in rounding function)
>RexxS
(add min as abbreviation)
Line 1: Line 1:
-- Module to implement use of a blacklist and whitelist for infobox fields
-- Module to implement use of a blacklist and whitelist for infobox fields
-- can take a named parameter |qid which is the Wikidata ID for the article. This will not normally be used
-- Can take a named parameter |qid which is the Wikidata ID for the article
-- (this will not normally be used because it's an expensive call)
-- Fields in blacklist are never to be displayed, i.e. module must return nil in all circumstances
-- Fields in blacklist are never to be displayed, i.e. module must return nil in all circumstances
-- Fields in whitelist return local value if it exists or the Wikidata value otherwise
-- Fields in whitelist return local value if it exists or the Wikidata value otherwise
-- The name of the field that this function is called from is passed in named parameter |name
-- The name of the field that this function is called from is passed in named parameter |name
-- The name is compulsory when blacklist or whitelist is used, so the module returns nil if it is not supplied
-- The name is compulsory when blacklist or whitelist is used,
-- blacklist is passed in named parameter |suppressfields
-- so the module returns nil if it is not supplied.
-- whitelist is passed in named parameter |fetchwikidata
-- blacklist is passed in named parameter |suppressfields (or |spf)
-- whitelist is passed in named parameter |fetchwikidata (or |fwd)


local p = {}
local p = {}
Line 15: Line 17:
{
{
["property-not-found"] = "Property not found.",
["property-not-found"] = "Property not found.",
["No property supplied"] = "No property supplied",
["entity-not-found"] = "Wikidata entity not found.",
["entity-not-found"] = "Wikidata entity not found.",
["unknown-claim-type"] = "Unknown claim type.",
["unknown-claim-type"] = "Unknown claim type.",
Line 25: Line 28:
["months"] =
["months"] =
{
{
"January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"
"January", "February", "March", "April", "May", "June", "July",
"August", "September", "October", "November", "December"
},
},
["century"] = "century",
["century"] = "century",
Line 38: Line 42:
},
},
["filespace"] = "File",
["filespace"] = "File",
["Unknown"] = "Unknown",
["NaN"] = "Not a number",
["editonwikidata"] = "Edit this on Wikidata",
["editonwikidata"] = "Edit this on Wikidata",
["latestdatequalifier"] = function (date) return "before " .. date end,
["latestdatequalifier"] = function (date) return "before " .. date end,
-- some languages, e.g. Bosnian use a period as a suffix after each number in a date
-- some languages, e.g. Bosnian use a period as a suffix after each number in a date
["datenumbersuffix"] = "",
["datenumbersuffix"] = "",
["list separator"] = ", ",
["abbr"] =
["abbr"] =
{
{
["Q828224"] = "km",
["Q828224"]   = "km",
["Q11573"]   = "m",
["Q11573"]   = "m",
["Q174728"] = "cm",
["Q174728"]   = "cm",
["Q174789"] = "mm",
["Q174789"]   = "mm",
["Q712226"] = "sq km",
["Q11570"]   = "kg",
["Q11570"]   = "kg",
["Q41803"]   = "g",
["Q41803"]   = "g",
["Q3241121"] = "mg",
["Q3241121"] = "mg",
["Q2332346"] = "ml",
["Q2332346"] = "ml",
["Q7727"]     = "min",
},
},
}
}
Line 67: Line 74:
-- takes cardinal numer as a numeric and returns the ordinal as a string
-- 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.
-- we need three exceptions in English for 1st, 2nd, 3rd, 21st, .. 31st, etc.
local function makeOrdinal (cardinal)
local function makeOrdinal(cardinal)
local ordsuffix = i18n.ordinal.default
local ordsuffix = i18n.ordinal.default
if cardinal % 10 == 1 then
if cardinal % 10 == 1 then
Line 103: Line 110:
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
-- formatDate takes a datetime of the usual format from mw.wikibase.entity:formatPropertyValues
-- formatDate takes a datetime of the usual format from mw.wikibase.entity:formatPropertyValues
-- like "1 August 30 BCE" as parameter 1 and formats it according to the df (date format) and bc parameters
-- like "1 August 30 BCE" as parameter 1
-- and formats it according to the df (date format) and bc parameters
-- df = ["dmy" / "mdy" / "y"] default will be "dmy"
-- df = ["dmy" / "mdy" / "y"] default will be "dmy"
-- bc = ["BC" / "BCE"] default will be "BCE"
-- bc = ["BC" / "BCE"] default will be "BCE"
Line 136: Line 144:


local sep = " " -- separator is nbsp
local sep = " " -- separator is nbsp
local fdate = table.concat(dateparts, " ") -- formatted date defaults to same order as input
local fdate = table.concat(dateparts, " ") -- set formatted date to same order as input


-- if we have day month year, check dateformat
-- if we have day month year, check dateformat
Line 189: Line 197:
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
-- sourced takes a table representing a statement that may or may not have references
-- sourced takes a table representing a statement that may or may not have references
-- it counts how many references are sourced to something not contianing the word "wikipedia"
-- it counts how many references are sourced to something not containing the word "wikipedia"
-- the reference string "ref" is available for debugging
-- the reference string "ref" is available for debugging
-- it returns a boolean = true if there are any sourced references.
-- it returns a boolean = true if there are any sourced references.
Line 204: Line 212:




-------------------------------------------------------------------------------
-- parseInput processes the Q-id , the blacklist and the whitelist
-- parseInput processes the Q-id , the blacklist and the whitelist
-- if an input parameter is supplied, it returns that and ends the call.
-- if an input parameter is supplied, it returns that and ends the call.
Line 212: Line 221:
local input_parm = mw.text.trim(input_parm or "")
local input_parm = mw.text.trim(input_parm or "")
if input_parm == "" then input_parm = nil end
if input_parm == "" then input_parm = nil end
local args = frame.args


-- can take a named parameter |qid which is the Wikidata ID for the article.
-- can take a named parameter |qid which is the Wikidata ID for the article.
-- This will not normally be used because it's an expensive call.
-- This will not normally be used because it's an expensive call.
local args = frame.args
local qid = args.qid
local qid = args.qid
if qid == "" then qid = nil end
if qid == "" then qid = nil end
Line 224: Line 234:
-- The whitelist is passed in named parameter |fetchwikidata
-- The whitelist is passed in named parameter |fetchwikidata
local whitelist = args.fetchwikidata or args.fwd
local whitelist = args.fetchwikidata or args.fwd
if not whitelist or whitelist == "" then whitelist = "NONE" end


-- The name of the field that this function is called from is passed in named parameter |name
-- The name of the field that this function is called from is passed in named parameter |name
local fieldname = args.name
local fieldname = args.name or ""
 
if blacklist then
if blacklist then
-- The name is compulsory when blacklist is used, so return nil if it is not supplied
-- The name is compulsory when blacklist is used, so return nil if it is not supplied
Line 240: Line 252:


-- Otherwise see if this field is on the whitelist:
-- Otherwise see if this field is on the whitelist:
if not (whitelist and (whitelist == 'ALL' or whitelist:find(fieldname))) then
-- needs a bit more logic because find will return its second value = 0 if fieldname=""
-- not on the whitelist so just return what should be a nil input parameter
-- but nil if fieldname not found on whitelist
return false, input_parm, nil
local _, found = whitelist:find(fieldname)
found = ((found or 0) > 0)
if whitelist ~= 'ALL' and (whitelist:upper() == "NONE" or not found) then
return false, nil, nil
end
end


Line 258: Line 273:




local function _getvalue(frame, entity, props, filter, propertyID)
-------------------------------------------------------------------------------
-- onlysourced is a boolean passed to return only values sourced to other than Wikipedia
-- assembleoutput takes the sequence table containing the property values
-- if nothing or an empty string is passed set it true
-- and formats it according to switches given
local function assembleoutput(out, args, entityID, propertyID)
 
-- sorted is a boolean passed to enable sorting of the values returned
-- if nothing or an empty string is passed set it false
-- if "false" or "no" or "0" is passed set it false
-- if "false" or "no" or "0" is passed set it false
local args = frame.args
local sorted = parseParam(args.sorted, false)
local onlysrc = parseParam(args.onlysourced or args.osd, true)


-- noicon is a boolean passed to suppress the trailing "edit at Wikidata" icon
-- noicon is a boolean passed to suppress the trailing "edit at Wikidata" icon
Line 271: Line 289:
local noic = parseParam(args.noicon, false)
local noic = parseParam(args.noicon, false)


-- wdlinks is a boolean passed to enable links to Wikidata when no article exists
-- list is the name of a template that a list of multiple values is passed through
-- if nothing or an empty string is passed set it false
-- examples include "hlist" and "ubl"
-- if "false" or "no" or "0" is passed set it false
-- setting it to "prose" produces something like "1, 2, 3, and 4"
local wdl = parseParam(args.wdlinks or args.wdl, false)
local list = args.list or ""
 
-- sorted is a boolean passed to enable sorting of the values returned
-- if nothing or an empty string is passed set it false
-- if "false" or "no" or "0" is passed set it false
local sorted = parseParam(args.sorted, false)


-- sep is a string that is used to separate multiple returned values
-- sep is a string that is used to separate multiple returned values
Line 285: Line 298:
-- any double-quotes " are stripped out, so that spaces may be passed
-- any double-quotes " are stripped out, so that spaces may be passed
-- e.g. |sep=" - "
-- e.g. |sep=" - "
local sepdefault = ", " -- **internationalise later**
local sepdefault = i18n["list separator"]
local separator = args.sep or ""
local separator = args.sep or ""
separator = string.gsub(separator, '"', '')
separator = string.gsub(separator, '"', '')
if #separator == 0 then
if separator == "" then
separator = sepdefault
separator = sepdefault
end
end


-- list is the name of a template that a list of multiple values is passed through
-- if there's anything to return, then return a list
-- examples include "hlist" and "ubl"
-- comma-separated by default, but may be specified by the sep parameter
local list = args.list or ""
-- optionally specify a hlist or ubl or a prose list, etc.
local strout
if #out > 0 then
if sorted then table.sort(out) end
-- if a pen icon is wanted add it the end of the last value
if not noic then
local icon = " [[" .. i18n["filespace"]
icon = icon .. ":Blue pencil.svg |frameless |text-top |10px |alt="
icon = icon .. i18n["editonwikidata"]
icon = icon .. "|link=https://www.wikidata.org/wiki/" .. entityID
icon = icon .. "?uselang=" .. mw.language.getContentLanguage().code
icon = icon .. "#" .. propertyID .. "|" .. i18n["editonwikidata"] .. "]]"
out[#out] = out[#out] .. icon
end
if list == "" then
strout = table.concat(out, separator)
elseif list:lower() == "prose" then
strout = mw.text.listToText( out )
else
strout = mw.getCurrentFrame():expandTemplate{title = list, args = out}
end
else
strout = nil -- no items had valid reference
end
return strout
end
 
 
-------------------------------------------------------------------------------
-- propertyvalueandquals takes a property object, the arguments passed from frame,
-- the prefered/normal filter function, and a qualifier propertyID.
-- It returns a sequence (table) of values representing the values of that property
-- and qualifiers that match the qualifierID if supplied.
--
local function propertyvalueandquals(objproperty, args, filter, qualID)
 
-- onlysourced is a boolean passed to return only values sourced to other than Wikipedia
-- if nothing or an empty string is passed set it true
local onlysrc = parseParam(args.onlysourced or args.osd, true)
 
-- linked is a a boolean that enables the link to a local page via sitelink
-- if nothing or an empty string is passed set it true
local linked = parseParam(args.linked, true)


-- prefix is a string that may be nil, empty (""), or a string of characters
-- prefix is a string that may be nil, empty (""), or a string of characters
Line 324: Line 379:
lpostfix = string.gsub(lpostfix, '"', '')
lpostfix = string.gsub(lpostfix, '"', '')


-- maxvals is a string that may be nil, empty (""), or a number
-- wdlinks is a boolean passed to enable links to Wikidata when no article exists
-- this determines how many items may be returned when multiple values are available
-- if nothing or an empty string is passed set it false
-- setting it = 1 is useful where the returned string is used within another call, e.g. image
local wdl = parseParam(args.wdlinks or args.wdl, false)
local maxvals = tonumber(args.maxvals) or 0


-- unitabbr is a boolean passed to enable unit abbreviations for common units
-- unitabbr is a boolean passed to enable unit abbreviations for common units
-- if nothing or an empty string is passed set it false
-- if nothing or an empty string is passed set it false
-- if "false" or "no" or "0" is passed set it false
local uabbr = parseParam(args.unitabbr, false)
local uabbr = parseParam(args.unitabbr, false)


-- So now we have something to return: deal with:
-- maxvals is a string that may be nil, empty (""), or a number
-- (1) ["datatype"] = "wikibase-item";
-- this determines how many items may be returned when multiple values are available
-- (2) ["datatype"] = "time";
-- setting it = 1 is useful where the returned string is used within another call, e.g. image
-- (3) ["datatype"] = "commonsMedia",
local maxvals = tonumber(args.maxvals) or 0
--     ["datatype"] = "external-id",
--     ["datatype"] = "string",
--    ["datatype"] = "url"
-- (4) ["datatype"] = "globe-coordinate", or anything else


local lang = mw.language.getContentLanguage().code
-- all proper values of a Wikidata property will be the same type as the first
local thisQid = entity.id
-- qualifiers don't have a mainsnak, properties do
-- table 'out' is going to to store the return value(s):
local datatype = objproperty[1].datatype or objproperty[1].mainsnak.datatype
local out = {}
local out = {}
local icon = " [[" .. i18n["filespace"] .. ":Blue pencil.svg |frameless |text-top |10px |alt=" .. i18n["editonwikidata"] .. "|link=https://www.wikidata.org/wiki/" .. thisQid .. "?uselang=" .. lang .. "#" .. propertyID .. "|" .. i18n["editonwikidata"] .. "]]"
for k, v in pairs(objproperty) do
local datatype = props[1].mainsnak.datatype
local snak = v.mainsnak or v
for k, v in pairs(props) do
local datavalue = snak.datavalue
local datavalue = v.mainsnak.datavalue
datavalue = datavalue and datavalue.value
datavalue = datavalue and datavalue.value
if (not filter(v)) or (onlysrc and not sourced(v)) then
if (not filter(v)) or (onlysrc and not sourced(v)) then
-- do nothing; either isn't preferred when prefered values are requested, or isn't sourced when onlysourced=true
-- nothing added to 'out'  -- debug: out[#out + 1] = "nosrc"
elseif v.mainsnak.snaktype == "somevalue" then -- check for value is unknown
-- either isn't preferred when prefered values are requested
out[#out + 1] = "Unknown"
-- or isn't sourced when onlysourced=true
elseif v.mainsnak.snaktype == "novalue" then -- check for value is none
------------------------------------
-- out[#out + 1] = "No value" -- don't return a value for this
elseif snak.snaktype == "somevalue" then -- value is unknown
-- data type is a wikibase item:
out[#out + 1] = i18n["Unknown"]
elseif datatype == "wikibase-item" then
------------------------------------
-- it's wiki-linked value, so output as link if possible
elseif snak.snaktype == "novalue" then -- value is none
local qnumber = "Q" .. datavalue["numeric-id"]
-- out[#out + 1] = "No value" -- don't return anything
------------------------------------
elseif datatype == "wikibase-item" then -- data type is a wikibase item:
-- it's wiki-linked value, so output as link if enabled and possible
local qnumber = datavalue.id
local sitelink = mw.wikibase.sitelink(qnumber)
local sitelink = mw.wikibase.sitelink(qnumber)
local label = labelOrId(qnumber)
local label = labelOrId(qnumber)
if sitelink then
if linked then
out[#out + 1] = "[[" .. lprefix .. sitelink .. lpostfix .. "|" .. label .. "]]"
if sitelink then
else
out[#out + 1] = "[[" .. lprefix .. sitelink .. lpostfix .. "|" .. label .. "]]"
-- no sitelink, so check first for a redirect with that label
local artitle = mw.title.new(label, 0)
if artitle.id > 0 then
if artitle.isRedirect then
-- no sitelink, but there's a redirect with the same title as the label
-- let's link to that
out[#out + 1] = "[[".. lprefix .. label .. lpostfix .. "|" .. label .. "]]"
else
-- no sitelink and not a redirect but an article exists with the same title as the label
-- that's probably a dab page, so output the plain label
out[#out + 1] = label
end
else
else
-- no article or redirect with the same title as the label
-- no sitelink, so check first for a redirect with that label
if wdl then
local artitle = mw.title.new(label, 0)
-- show that there's a Wikidata entry available
if artitle.id > 0 then
out[#out + 1] = "[[:d:Q" .. datavalue["numeric-id"] .. "|" .. label .. "]]&nbsp;<span title='" .. i18n["errors"]["local-article-not-found"] .. "'>[[File:Wikidata-logo.svg|16px|alt=|link=]]</span>"
if artitle.isRedirect then
-- no sitelink, but there's a redirect with the same title as the label
-- let's link to that
out[#out + 1] = "[[".. lprefix .. label .. lpostfix
out[#out] = out[#out] .. "|" .. label .. "]]"
else
-- no sitelink and not a redirect
-- but an article exists with the same title as the label
-- that's probably a dab page, so output the plain label
out[#out + 1] = label
end
else
else
-- no wikidata links required, so just give the plain label
-- no article or redirect with the same title as the label
out[#out + 1] = label
if wdl then
end
-- show that there's a Wikidata entry available
end
local wd = "[[:d:" .. qnumber .. "|" .. label
end
wd = wd .. "]]&nbsp;<span title='"
wd = wd .. i18n["errors"]["local-article-not-found"]
wd = wd .. "'>[[File:Wikidata-logo.svg|16px|alt=|link=]]</span>"
out[#out + 1] = wd
else
-- no wikidata links required, so just give the plain label
out[#out + 1] = label
end -- test if wikdata link display required
end -- test if article exists
end -- test for sitelink exists
else -- no link wanted so just give the plain label:
out[#out + 1] = label
end -- test for link required
-- If the property has a qualifier of latest date, add that in all cases:
-- If the property has a qualifier of latest date, add that in all cases:
if v.qualifiers then
if v.qualifiers then
local quals = v.qualifiers["P1326"] -- latest date qualifier
local quals = v.qualifiers["P1326"] -- latest date qualifier
if quals then
if quals then
out[#out] = out[#out] .. " (" .. i18n.latestdatequalifier(mw.wikibase.renderSnaks(quals)) .. ")"
local ldq = i18n.latestdatequalifier(mw.wikibase.renderSnaks(quals))
out[#out] = out[#out] .. " (" .. ldq .. ")"
end
end
end
end
-- data type is time:
------------------------------------
elseif datatype == "time" then
elseif datatype == "time" then -- data type is time:
-- it's a date value, so output according to formatting preferences
-- it's a date value, so output according to formatting preferences
local timestamp = datavalue.time
local timestamp = datavalue.time
Line 409: Line 472:
local fpvdate = tonumber(timestamp:sub(2, 5))
local fpvdate = tonumber(timestamp:sub(2, 5))
local fdate
local fdate
if dateprecision >= 9 then -- 9 is year precision
if dateprecision >= 9 then -- precision is year or shorter
local dateformat = "y"
local dateformat = "y"
if dateprecision >= 10 then -- prepend month
if dateprecision >= 10 then -- prepend month
Line 439: Line 502:
end
end
out[#out+1] = fdate
out[#out+1] = fdate
------------------------------------
-- data types which are strings:
-- data types which are strings:
elseif datatype == "commonsMedia" or datatype == "external-id" or datatype == "string" or datatype == "url" then
elseif datatype == "commonsMedia" or datatype == "external-id" or datatype == "string" or datatype == "url" then
-- commonsMedia or external-id or string or url
-- commonsMedia or external-id or string or url
-- all have mainsnak.datavalue.value as string
-- all have mainsnak.datavalue.value as string
if lprefix ~= "" then
if lprefix == "" and lpostfix == "" then
out[#out+1] = "[[" .. lprefix .. datavalue .. lpostfix .. "|" .. prefix .. datavalue .. postfix .. "]]"
out[#out+1] = prefix .. datavalue .. postfix
else
else
out[#out+1] = prefix .. datavalue .. postfix
out[#out+1] = "[[" .. lprefix .. datavalue .. lpostfix
end -- check for link requested
out[#out] = out[#out] .. "|" .. prefix .. datavalue .. postfix .. "]]"
end -- check for link requested (i.e. either linkprefix or linkpostfix exists)
------------------------------------
-- data types which are quantities:
-- data types which are quantities:
elseif datatype == "quantity" then
elseif datatype == "quantity" then
Line 453: Line 519:
-- the unit is of the form http://www.wikidata.org/entity/Q829073
-- the unit is of the form http://www.wikidata.org/entity/Q829073
-- convert amount to a number
-- convert amount to a number
local amount = tonumber(datavalue.amount) or "Not a number"
local amount = tonumber(datavalue.amount) or i18n["NaN"]
-- check if upper and/or lower bounds are given and significant
-- check if upper and/or lower bounds are given and significant
local upb = tonumber(datavalue.upperBound)
local upb = tonumber(datavalue.upperBound)
Line 470: Line 536:
-- otherwise range is zero, so leave it off: amount = amount
-- otherwise range is zero, so leave it off: amount = amount
end
end
-- extract the qid in the form 'Qnnn' from the value.unit url and then fetch the label from that
-- extract the qid in the form 'Qnnn' from the value.unit url
-- and then fetch the label from that
local unit = ""
local unit = ""
local unitqid = string.match( datavalue.unit, "(Q%d+)" )
local unitqid = string.match( datavalue.unit, "(Q%d+)" )
Line 484: Line 551:
end
end
out[#out+1] = amount .. unit
out[#out+1] = amount .. unit
------------------------------------
-- datatypes which are global coordinates:
elseif datatype == "globe-coordinate" then
local display = args.display or ""
local format = args.format or ""
if display=="decimal" then
local latdecimal = 0
local longdecimal = 0
local coords = entity:formatPropertyValues(propertyID).value
-- the latitude and longitude are returned like this: nn°nn&#39;nn.n&#34;
-- using html entities with hex values really screws up parsing the numbers
local lat = mw.ustring.match(coords, "^[^,]*")  -- everything from the start to before the comma
local long = mw.ustring.match(coords, "[^ ]*$") -- everything from after the space to the end
lat = lat:gsub("&#%d%d;", ":")                  -- clean out the html entities
long = long:gsub("&#%d%d;", ":")                -- clean out the html entities
-- read the latitude numbers into a table
local newlat = {}
for num in mw.ustring.gmatch(lat, "%d+%.?%d*") do
newlat[#newlat + 1] = num
end
if #newlat==3 then
latdecimal = newlat[1] + newlat[2]/60 + newlat[3]/3600
elseif #newlat==2 then
latdecimal = newlat[1] + newlat[2]/60
else
latdecimal = newlat[1]
end
if lat:sub(-1)=="S" then
latdecimal = -latdecimal
end
local newlong = {}
for num in mw.ustring.gmatch(long, "%d+%.?%d*") do
newlong[#newlong + 1] = num
end
if #newlong==3 then
longdecimal = newlong[1] + newlong[2]/60 + newlong[3]/3600
elseif #newlat==2 then
longdecimal = newlong[1] + newlong[2]/60
else
longdecimal = newlong[1]
end
if long:sub(-1)=="W" then
longdecimal = -longdecimal
end
if format == "longlat" then
out[#out+1] = longdecimal .. ", " .. latdecimal
elseif format == "lat" then
out[#out+1] = latdecimal
elseif format == "long" then
out[#out+1] = longdecimal
else
out[#out+1] = latdecimal .. ", " .. longdecimal
end
else
out[#out+1] = entity:formatPropertyValues(propertyID).value
end
else
else
-- some other data type
-- some other data type
-- e.g. globe-coordinate where mainsnak.datavalue.value is a table
-- either write a specific handler
-- either write a specific handler
-- or we can use formatPropertyValues() as a temporary measure. This won't work with multiple valid values.
-- or we can use formatPropertyValues() as a temporary measure.
-- This won't work with multiple valid values.
out[#out+1] = entity:formatPropertyValues(propertyID).value
out[#out+1] = entity:formatPropertyValues(propertyID).value
break
break
end -- of datatype/unknown value/sourced check
end -- of datatype/unknown value/sourced check
-- See if qualifiers are to be returned:
if v.qualifiers and qualID and snak.snaktype=="value" then
local qsep = args.qsep or ""
qsep = string.gsub(qsep, '"', '')
local qargs = {
["osd"]      = "false",
["linked"]  = tostring(linked),
["prefix"]  = "",
["postfix"]  = "",
["lprefix"]  = "",
["lpostfix"] = "",
["wdl"]      = "false",
["unitabbr"] = tostring(uabbr),
["maxvals"]  = 0,
["sorted"]  = parseParam(args.qsorted, false),
["noicon"]  = "true",
["list"]    = "",
["sep"]      = qsep
}
if qualID == "DATES" then qargs.maxvals = 1 end
local function qf(dummy)
return true
end
local qlist = {}
local t1, t2, dsep = "", "", ""
for k1, v1 in pairs(v.qualifiers) do
-- look for date range:
if qualID == "DATES" then
if k1 == "P580" then -- P580 is "start time"
t1 = propertyvalueandquals(v1, qargs, qf)[1]
elseif k1 == "P582" then -- P582 is "end time"
t2 = propertyvalueandquals(v1, qargs, qf)[1]
end
-- check for latest date qualifier:
elseif k1 == "P1326" then
-- do nothing - this is handled already
-- otherwise see if we want this qualifier:
elseif qualID == "ALL" or qualID == k1 then
local ql = propertyvalueandquals(v1, qargs, qf)
for k2, v2 in ipairs(ql) do
qlist[#qlist + 1] = v2
end
end
end -- of loop through qualifiers
local t = t1 .. t2
-- *** internationalise date separators later ***
if t:find("%s") or t:find("&nbsp;") then dsep = "  &ndash; " else dsep = "&ndash;" end
if #qlist > 0 then
local qstr = assembleoutput(qlist, qargs)
out[#out] = out[#out] .. " (" .. qstr .. ")"
elseif t > "" then
out[#out] = out[#out] .. " (" .. t1 .. dsep .. t2 .. ")"
end
end -- of test for qualifiers wanted
if maxvals > 0 and #out >= maxvals then break end
if maxvals > 0 and #out >= maxvals then break end
end -- of for each value loop
end -- of for each value loop
return out
end
-------------------------------------------------------------------------------
-- _getvalue is the common function for getValue, getPreferredValue, and getNormalValue
--
local function _getvalue(frame, entity, props, propertyID)
-- qual is a string containing the property ID of the qualifier(s) to be returned
-- if qual == "ALL" then all qualifiers returned
-- if qual == "DATES" then qualifiers P580 (start time) and P582 (end time) returned
-- if nothing or an empty string is passed set it nil -> no qualifiers returned
local qualID = mw.text.trim(frame.args.qual or ""):upper()
if qualID == "" then qualID = nil end
-- create a filter function
--
-- rank is a parameter passed, which indicates "preferred" or "normal"
--
local rank = (frame.args.rank or ""):lower()
if rank:sub(1,1) == "p" then
rank = "preferred"
elseif rank:sub(1,1) == "n" then
rank = "normal"
else
rank = ""
end


-- if there's anything to return, then return a list
local function filter(claim)
-- comma-separated by default, but may be specified by the sep parameter
return true
-- optionally specify a hlist or ubl
end
if #out > 0 then
 
if sorted then table.sort(out) end
if rank > "" then
-- if there's a pen icon add it the end of the last value
local rankflag = false
if not noic then
for k, v in pairs(props) do
out[#out] = out[#out] .. icon
if v.rank == rank then
rankflag = true
break
end
end
end
if list == "" then
function filter(claim)
return table.concat(out, separator)
return claim.rank == rank or rankflag == false
else
return frame:expandTemplate{title = list, args = out}
end
end
else
return nil -- no items had valid reference
end
end
-- table 'out' stores the return value(s):
local out = propertyvalueandquals(props, frame.args, filter, qualID)
-- format the table of values and return it as a string:
return assembleoutput(out, frame.args, entity.id, propertyID)
end
end




 
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
-- Public functions
-- Public functions
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--
--
-- getValue is used to get a value, or a comma separated list of them if multiple values exist
-- getValue is used to get the value(s) of a property
-- The property ID is passed as the first unnamed parameter and is required.
-- A locally supplied parameter may optionaly be supplied as the second unnamed parameter.
-- The function will now also return qualifiers if parameter qual is supplied
--
--
p.getValue = function(frame)
p.getValue = function(frame)
if not frame.args[1] then
frame.args = frame:getParent().args
if not frame.args[1] then return i18n.errors["No property supplied"] end
end
local propertyID = mw.text.trim(frame.args[1] or "")
local propertyID = mw.text.trim(frame.args[1] or "")


Line 530: Line 748:
return errorOrEntity
return errorOrEntity
end
end
local function filter(claim)
local function filter(claim)
return true
return true
end
end
return _getvalue(frame, errorOrEntity, props, filter, propertyID)
return _getvalue(frame, errorOrEntity, props, propertyID)
end
end




-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
-- getPreferredValue is used to get a value, or a comma separated list of them if multiple values exist
-- getPreferredValue is used to get a value,
-- (or a comma separated list of them if multiple values exist).
-- If preferred ranks are set, it will return those values, otherwise values with normal ranks
-- If preferred ranks are set, it will return those values, otherwise values with normal ranks
--
--
p.getPreferredValue = function(frame)
p.getPreferredValue = function(frame)
local propertyID = mw.text.trim(frame.args[1] or "")
frame.args.rank = "preferred"
 
return p.getValue(frame)
local success, errorOrEntity, props = parseInput(frame, frame.args[2], propertyID)
if not success then
return errorOrEntity
end
local prefflag = false
for k, v in pairs(props) do
if v.rank == "preferred" then
prefflag = true
break
end
end
local function filter(claim)
return claim.rank == "preferred" or prefflag == false
end
return _getvalue(frame, errorOrEntity, props, filter, propertyID)
end
end




-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
-- getNormalValue is used to get a value, or a comma separated list of them if multiple values exist
-- getNormalValue is used to get a value,
-- (or a comma separated list of them if multiple values exist).
-- If normal ranks are set, it will return those values, otherwise all values
-- If normal ranks are set, it will return those values, otherwise all values
--
--
p.getNormalValue = function(frame)
p.getNormalValue = function(frame)
local propertyID = mw.text.trim(frame.args[1] or "")
frame.args.rank = "normal"
return p.getValue(frame)
end


local success, errorOrEntity, props = parseInput(frame, frame.args[2], propertyID)
if not success then
return errorOrEntity
end
local normflag = false
for k, v in pairs(props) do
if v.rank == "normal" then
normflag = true
break
end
end
local function filter(claim)
return claim.rank == "normal" or normflag == false
end
return _getvalue(frame, errorOrEntity, props, filter, propertyID)
end


-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
Line 610: Line 802:
-- the latitude and longitude are returned like this: nn°nn&#39;nn.n&#34;
-- the latitude and longitude are returned like this: nn°nn&#39;nn.n&#34;
-- using html entities with hex values really screws up parsing the numbers - thanks devs
-- using html entities with hex values really screws up parsing the numbers - thanks devs
local lat = mw.ustring.match(coords, "^[^,]*")  -- everything from the start to before the comma
local lat = mw.ustring.match(coords, "^[^,]*")  -- everything from start to before comma
local long = mw.ustring.match(coords, "[^ ]*$") -- everything from after the space to the end
local long = mw.ustring.match(coords, "[^ ]*$") -- everything from after space to the end
lat = lat:gsub("&#%d%d;", ":")                  -- clean out the html entities
lat = lat:gsub("&#%d%d;", ":")                  -- replace the html entities with colon
long = long:gsub("&#%d%d;", ":")                -- clean out the html entities
long = long:gsub("&#%d%d;", ":")                -- replace the html entities with colon
-- read the latitude numbers into a table
-- read the latitude numbers into a table
for num in mw.ustring.gmatch(lat, "%d+%.?%d*") do
for num in mw.ustring.gmatch(lat, "%d+%.?%d*") do
Line 645: Line 837:
--
--
p.getQualifierValue = function(frame)
p.getQualifierValue = function(frame)
local args = frame.args
local propertyID = mw.text.trim(args[1] or "")


-- The PropertyID of the target value of the property
-- The property ID that will have a qualifier is the first unnamed parameter
-- whose qualifier is to be returned is passed in named parameter |pval=
local propertyID = mw.text.trim(frame.args[1] or "")
local propvalue = args.pval
 
-- The value of the property we want to match whose qualifier value is to be returned
-- is passed in named parameter |pval=
local propvalue = frame.args.pval


-- The PropertyID of the qualifier
-- The property ID of the qualifier
-- whose value is to be returned is passed in named parameter |qual=
-- whose value is to be returned is passed in named parameter |qual=
local qualifierID = args.qual
local qualifierID = frame.args.qual


-- onlysourced is a boolean passed to return qualifiers
-- onlysourced is a boolean passed to return qualifiers
-- only when property values are sourced to something other than Wikipedia
-- only when property values are sourced to something other than Wikipedia
-- if nothing or an empty string is passed set it false
-- if nothing or an empty string is passed set it true
-- if "false" or "no" or 0 is passed set it false
-- if "false" or "no" or 0 is passed set it false
local onlysrc = parseParam(args.onlysourced, false)
local onlysrc = parseParam(frame.args.onlysourced or frame.args.osd, true)


 
-- check for locally supplied parameter in second unnamed parameter
local success, errorOrEntity, props = parseInput(frame, args[2], propertyID)
-- success means no local parameter and the property exists
if not success then
local success, errorOrEntity, props = parseInput(frame, frame.args[2], propertyID)
return errorOrEntity
if success then
else
local entity = errorOrEntity
local entity = errorOrEntity
local out = {}
-- Scan through the values of the property
-- Scan through the values of the property
-- we want something like property is P793, significant event (in propertyID)
-- we want something like property is P793, significant event (in propertyID)
Line 677: Line 870:
-- and if it has qualifiers
-- and if it has qualifiers
if v1.mainsnak.datavalue.value.id == propvalue and v1.qualifiers then
if v1.mainsnak.datavalue.value.id == propvalue and v1.qualifiers then
if (onlysrc == true) and not sourced(v1) then
if onlysrc == false or sourced(v1) then
return
-- if we've got this far, we have a (sourced) claim with qualifiers
end
-- which matches the target, so find the value(s) of the qualifier we want
-- if we've got this far, we have a (sourced) claim with qualifiers
local quals = v1.qualifiers[qualifierID]
-- which matches the target, so find the value(s) of the qualifier we want
if quals then
local quals = v1.qualifiers[qualifierID]
local function filter(claim)
local out = {}
return true
if quals then
end
if quals[1].datatype == "wikibase-item" then
local vals = propertyvalueandquals(quals, frame.args, filter)
for k2, v2 in pairs(quals) do
for k, v in pairs(vals) do
local valueID = v2.datavalue.value.id
out[#out + 1] = v
local sitelink = mw.wikibase.sitelink(valueID)
local label = labelOrId(valueID)
if sitelink then
out[#out + 1] = "[[" .. sitelink .. "|" .. label .. "]]"
else
out[#out + 1] = "[[:d:" .. valueID .. "|" .. label .. "]]&nbsp;<span title='" .. i18n["errors"]["local-article-not-found"] .. "'>[[File:Wikidata-logo.svg|16px|alt=|link=]]</span>"
end
end
end
return table.concat(out, ", ")
else
return mw.wikibase.renderSnaks(quals)
end
end
end
end -- of check for sourced
end
end -- of check for matching required value and has qualifiers
end -- of loop through values of propertyID
end -- of check for wikibase entity
end
end -- of loop through values of propertyID
end
return assembleoutput(out, frame.args, entity.id, propertyID)
else
return errorOrEntity
end -- of test for success
return nil
return nil
end
end
Line 809: Line 995:
end
end
end
end
-------------------------------------------------------------------------------
-- labelorid is a public function to expose the output of labelOrId()
-- pass the Q-number as |qid= or as an unnamed parameter
p.labelorid = function(frame)
local id = frame.args.qid or frame.args[1]
return labelOrId(id)
end


return p
return p

Revision as of 11:46, 3 May 2018

Documentation for this module may be created at Module:WikidataIB/doc

-- Module to implement use of a blacklist and whitelist for infobox fields
-- Can take a named parameter |qid which is the Wikidata ID for the article
-- (this will not normally be used because it's an expensive call)
-- Fields in blacklist are never to be displayed, i.e. module must return nil in all circumstances
-- Fields in whitelist return local value if it exists or the Wikidata value otherwise
-- The name of the field that this function is called from is passed in named parameter |name
-- The name is compulsory when blacklist or whitelist is used,
-- so the module returns nil if it is not supplied.
-- blacklist is passed in named parameter |suppressfields (or |spf)
-- whitelist is passed in named parameter |fetchwikidata (or |fwd)

local p = {}

local i18n =
{
	["errors"] =
	{
		["property-not-found"] = "Property not found.",
		["No property supplied"] = "No property supplied",
		["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 available on Wikidata, but not on Wikipedia"
	},
	["months"] =
	{
		"January", "February", "March", "April", "May", "June", "July",
		"August", "September", "October", "November", "December"
	},
	["century"] = "century",
	["BC"] = "BC",
	["BCE"] = "BCE",
	["ordinal"] =
	{
		[1] = "st",
		[2] = "nd",
		[3] = "rd",
		["default"] = "th"
	},
	["filespace"] = "File",
	["Unknown"] = "Unknown",
	["NaN"] = "Not a number",
	["editonwikidata"] = "Edit this on Wikidata",
	["latestdatequalifier"] = function (date) return "before " .. date end,
	-- some languages, e.g. Bosnian use a period as a suffix after each number in a date
	["datenumbersuffix"] = "",
	["list separator"] = ", ",
	["abbr"] =
	{
		["Q828224"]   = "km",
		["Q11573"]    = "m",
		["Q174728"]   = "cm",
		["Q174789"]   = "mm",
		["Q11570"]    = "kg",
		["Q41803"]    = "g",
		["Q3241121"]  = "mg",
		["Q2332346"]  = "ml",
		["Q7727"]     = "min",
	},
}

require("Module:i18n").loadI18n("Module:WikidataIB/i18n", i18n)


-------------------------------------------------------------------------------
-- Private functions
-------------------------------------------------------------------------------
--
-------------------------------------------------------------------------------
-- makeOrdinal 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.
local function makeOrdinal(cardinal)
	local ordsuffix = i18n.ordinal.default
	if cardinal % 10 == 1 then
		ordsuffix = i18n.ordinal[1]
	elseif cardinal % 10 == 2 then
		ordsuffix = i18n.ordinal[2]
	elseif cardinal % 10 == 3 then
		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
	return tostring(cardinal) .. ordsuffix
end


-------------------------------------------------------------------------------
-- roundto takes a positive number (x)
-- and returns it rounded to (sf) significant figures
local function roundto(x, sf)
	if x == 0 then return 0 end
	x = math.abs(x)
	if sf < 1 then sf = 1 end
	local e = math.floor(math.log10(x)) - sf + 1
	local m = math.floor(x / 10^e + 0.5)
	x = m * 10^e
	-- if it's integral, cast to an integer:
	if  x == math.floor(x) then x = math.floor(x) end
	return x
end


-------------------------------------------------------------------------------
-- formatDate takes a datetime of the usual format from mw.wikibase.entity:formatPropertyValues
-- like "1 August 30 BCE" as parameter 1
-- and formats it according to the df (date format) and bc parameters
-- df = ["dmy" / "mdy" / "y"] default will be "dmy"
-- bc = ["BC" / "BCE"] default will be "BCE"
-- first the local version
local format_Date = function(datetime, dateformat, bc)
	local datetime = datetime or "1 August 30 BCE" -- in case of nil value
	-- chop off multiple vales and/or any hours, mins, etc.
	-- keep anything before punctuation - we just want a single date:
	local dateval = string.match( datetime, "[%w ]+")

	local dateformat = string.lower(dateformat or "dmy") -- default to dmy

	local bc = string.upper(bc or "") -- can't use nil for bc
	-- we only want to accept two possibilities: BC or default to BCE
	if bc == "BC" then
		bc = "&nbsp;" .. i18n["BC"] -- prepend a non-breaking space.
	else
		bc = "&nbsp;" .. i18n["BCE"]
	end

	local postchrist = true -- start by assuming no BCE
	local dateparts = {}
	for word in string.gmatch(dateval, "%w+") do
		if word == "BCE" or word == "BC" then -- **internationalise later**
			postchrist = false
		else
			-- we'll keep the parts that are not 'BCE' in a table
			dateparts[#dateparts + 1] = word
		end
	end
	if postchrist then bc = "" end -- set AD dates to no suffix **internationalise later**

	local sep = "&nbsp;" -- separator is nbsp
	local fdate = table.concat(dateparts, "&nbsp;") -- set formatted date to same order as input

	-- if we have day month year, check dateformat
	if #dateparts == 3 then
		if dateformat == "y" then
			fdate = dateparts[3]
		elseif dateformat == "mdy" then
			fdate = dateparts[2] .. sep .. dateparts[1] .. "," .. sep .. dateparts[3]
		end
	elseif #dateparts == 2 and dateformat == "y" then
		fdate = dateparts[2]
	end

	return fdate .. bc
end


-------------------------------------------------------------------------------
-- parseParam takes a (string) parameter, e.g. from the list of frame arguments,
-- and makes "false", "no", and "0" into the (boolean) false
-- it makes the empty string and nil into the (boolean) value passed as default
-- allowing the parameter to be true or false by default.
local parseParam = function(param, default)
	if param and param ~= "" then
		param = param:lower()
		if (param == "false") or (param == "no") or (param == "0") then
			return false
		else
			return true
		end
	else
		return default
	end
end


-------------------------------------------------------------------------------
-- The label in a Wikidata item is subject to vulnerabilities
-- that an attacker might try to exploit.
-- It needs to be 'sanitised' by removing any wikitext before use.
-- If it doesn't exist, just return the id for the item
local labelOrId = function (id)
	local label = mw.wikibase.label(id)
	if label then
		return mw.text.nowiki(label)
	else
		return id
	end
end


-------------------------------------------------------------------------------
-- sourced takes a table representing a statement that may or may not have references
-- it counts how many references are sourced to something not containing the word "wikipedia"
-- the reference string "ref" is available for debugging
-- it returns a boolean = true if there are any sourced references.
local sourced = function(claim)
	local refs = 0
	if claim.references then
		for kr, vr in pairs(claim.references) do
			local ref = mw.wikibase.renderSnaks(vr.snaks)
			if not ref:find("Wikipedia") then refs = refs + 1 end
		end
	end
	return refs > 0
end


-------------------------------------------------------------------------------
-- parseInput processes the Q-id , the blacklist and the whitelist
-- if an input parameter is supplied, it returns that and ends the call.
-- it returns a boolean indicating whether or not the call should continue
-- and an object containing all of the Wikidata for the Qid supplied or the current page
local parseInput = function(frame, input_parm, property_id)
	-- There may be a local parameter supplied, if it's blank, set it to nil
	local input_parm = mw.text.trim(input_parm or "")
	if input_parm == "" then input_parm = nil end

	local args = frame.args

	-- can take a named parameter |qid which is the Wikidata ID for the article.
	-- This will not normally be used because it's an expensive call.
	local qid = args.qid
	if qid == "" then qid = nil end

	-- The blacklist is passed in named parameter |suppressfields
	local blacklist = args.suppressfields or args.spf

	-- The whitelist is passed in named parameter |fetchwikidata
	local whitelist = args.fetchwikidata or args.fwd
	if not whitelist or whitelist == "" then whitelist = "NONE" end

	-- The name of the field that this function is called from is passed in named parameter |name
	local fieldname = args.name or ""

	if blacklist then
		-- The name is compulsory when blacklist is used, so return nil if it is not supplied
		if not fieldname or fieldname == "" then return false, nil, nil end
		-- If this field is on the blacklist, then return nil
		if blacklist:find(fieldname) then return false, nil, nil end
	end

	-- If we got this far then we're not on the blacklist
	-- The blacklist overrides any locally supplied parameter as well
	-- If a non-blank input parameter was supplied return it
	if input_parm then return false, input_parm, nil end

	-- Otherwise see if this field is on the whitelist:
	-- needs a bit more logic because find will return its second value = 0 if fieldname=""
	-- but nil if fieldname not found on whitelist
	local _, found = whitelist:find(fieldname)
	found = ((found or 0) > 0)
	if whitelist ~= 'ALL' and (whitelist:upper() == "NONE" or not found) then
		return false, nil, nil
	end

	-- See what's on Wikidata:
	local entity = mw.wikibase.getEntityObject(qid)
	if entity and entity.claims then
		local props = entity.claims[property_id]
		if props and props[1] then
			return true, entity, props
		end
	end
	-- no property on Wikidata
	return false, input_parm, nil
end


-------------------------------------------------------------------------------
-- assembleoutput takes the sequence table containing the property values
-- and formats it according to switches given
local function assembleoutput(out, args, entityID, propertyID)

	-- sorted is a boolean passed to enable sorting of the values returned
	-- if nothing or an empty string is passed set it false
	-- if "false" or "no" or "0" is passed set it false
	local sorted = parseParam(args.sorted, false)

	-- noicon is a boolean passed to suppress the trailing "edit at Wikidata" icon
	-- for use when the value is processed further by the infobox
	-- if nothing or an empty string is passed set it false
	-- if "false" or "no" or "0" is passed set it false
	local noic = parseParam(args.noicon, false)

	-- list is the name of a template that a list of multiple values is passed through
	-- examples include "hlist" and "ubl"
	-- setting it to "prose" produces something like "1, 2, 3, and 4"
	local list = args.list or ""

	-- sep is a string that is used to separate multiple returned values
	-- if nothing or an empty string is passed set it to the default
	-- any double-quotes " are stripped out, so that spaces may be passed
	-- e.g. |sep=" - "
	local sepdefault = i18n["list separator"]
	local separator = args.sep or ""
	separator = string.gsub(separator, '"', '')
	if separator == "" then
		separator = sepdefault
	end

	-- if there's anything to return, then return a list
	-- comma-separated by default, but may be specified by the sep parameter
	-- optionally specify a hlist or ubl or a prose list, etc.
	local strout
	if #out > 0 then
		if sorted then table.sort(out) end
		-- if a pen icon is wanted add it the end of the last value
		if not noic then
			local icon = "&nbsp;[[" .. i18n["filespace"]
			icon = icon .. ":Blue pencil.svg |frameless |text-top |10px |alt="
			icon = icon .. i18n["editonwikidata"]
			icon = icon .. "|link=https://www.wikidata.org/wiki/" .. entityID
			icon = icon .. "?uselang=" .. mw.language.getContentLanguage().code
			icon = icon .. "#" .. propertyID .. "|" .. i18n["editonwikidata"] .. "]]"
			out[#out] = out[#out] .. icon
		end
		if list == "" then
			strout = table.concat(out, separator)
		elseif list:lower() == "prose" then
			strout = mw.text.listToText( out )
		else
			strout = mw.getCurrentFrame():expandTemplate{title = list, args = out}
		end
	else
		strout = nil -- no items had valid reference
	end
	return strout
end


-------------------------------------------------------------------------------
-- propertyvalueandquals takes a property object, the arguments passed from frame,
-- the prefered/normal filter function, and a qualifier propertyID.
-- It returns a sequence (table) of values representing the values of that property
-- and qualifiers that match the qualifierID if supplied.
--
local function propertyvalueandquals(objproperty, args, filter, qualID)

	-- onlysourced is a boolean passed to return only values sourced to other than Wikipedia
	-- if nothing or an empty string is passed set it true
	local onlysrc = parseParam(args.onlysourced or args.osd, true)

	-- linked is a a boolean that enables the link to a local page via sitelink
	-- if nothing or an empty string is passed set it true
	local linked = parseParam(args.linked, true)

	-- prefix is a string that may be nil, empty (""), or a string of characters
	-- this is prefixed to each value
	-- useful when when multiple values are returned
	-- any double-quotes " are stripped out, so that spaces may be passed
	local prefix = args.prefix or ""
	prefix = string.gsub(prefix, '"', '')

	-- postfix is a string that may be nil, empty (""), or a string of characters
	-- this is postfixed to each value
	-- useful when when multiple values are returned
	-- any double-quotes " are stripped out, so that spaces may be passed
	local postfix = args.postfix or ""
	postfix = string.gsub(postfix, '"', '')

	-- linkprefix is a string that may be nil, empty (""), or a string of characters
	-- this creates a link and is then prefixed to each value
	-- useful when when multiple values are returned and indirect links are needed
	-- any double-quotes " are stripped out, so that spaces may be passed
	local lprefix = args.linkprefix or ""
	lprefix = string.gsub(lprefix, '"', '')

	-- linkpostfix is a string that may be nil, empty (""), or a string of characters
	-- this is postfixed to each value when linking is enabled with lprefix
	-- useful when when multiple values are returned
	-- any double-quotes " are stripped out, so that spaces may be passed
	local lpostfix = args.linkpostfix or ""
	lpostfix = string.gsub(lpostfix, '"', '')

	-- wdlinks is a boolean passed to enable links to Wikidata when no article exists
	-- if nothing or an empty string is passed set it false
	local wdl = parseParam(args.wdlinks or args.wdl, false)

	-- unitabbr is a boolean passed to enable unit abbreviations for common units
	-- if nothing or an empty string is passed set it false
	local uabbr = parseParam(args.unitabbr, false)

	-- maxvals is a string that may be nil, empty (""), or a number
	-- this determines how many items may be returned when multiple values are available
	-- setting it = 1 is useful where the returned string is used within another call, e.g. image
	local maxvals = tonumber(args.maxvals) or 0

	-- all proper values of a Wikidata property will be the same type as the first
	-- qualifiers don't have a mainsnak, properties do
	local datatype = objproperty[1].datatype or objproperty[1].mainsnak.datatype
	local out = {}
	for k, v in pairs(objproperty) do
		local snak = v.mainsnak or v
		local datavalue = snak.datavalue
		datavalue = datavalue and datavalue.value
		if (not filter(v)) or (onlysrc and not sourced(v)) then
			-- nothing added to 'out'  -- debug: out[#out + 1] = "nosrc"
			-- either isn't preferred when prefered values are requested
			-- or isn't sourced when onlysourced=true
			------------------------------------
		elseif snak.snaktype == "somevalue" then -- value is unknown
			out[#out + 1] = i18n["Unknown"]
			------------------------------------
		elseif snak.snaktype == "novalue" then -- value is none
			-- out[#out + 1] = "No value" -- don't return anything
			------------------------------------
		elseif datatype == "wikibase-item" then -- data type is a wikibase item:
			-- it's wiki-linked value, so output as link if enabled and possible
			local qnumber = datavalue.id
			local sitelink = mw.wikibase.sitelink(qnumber)
			local label = labelOrId(qnumber)
			if linked then
				if sitelink then
					out[#out + 1] = "[[" .. lprefix .. sitelink .. lpostfix .. "|" .. label .. "]]"
				else
					-- no sitelink, so check first for a redirect with that label
					local artitle = mw.title.new(label, 0)
					if artitle.id > 0 then
						if artitle.isRedirect then
							-- no sitelink, but there's a redirect with the same title as the label
							-- let's link to that
							out[#out + 1] = "[[".. lprefix .. label .. lpostfix
							out[#out] = out[#out] .. "|" .. label .. "]]"
						else
							-- no sitelink and not a redirect
							-- but an article exists with the same title as the label
							-- that's probably a dab page, so output the plain label
							out[#out + 1] = label
						end
					else
						-- no article or redirect with the same title as the label
						if wdl then
							-- show that there's a Wikidata entry available
							local wd = "[[:d:" .. qnumber .. "|" .. label
							wd = wd .. "]]&nbsp;<span title='"
							wd = wd .. i18n["errors"]["local-article-not-found"]
							wd = wd .. "'>[[File:Wikidata-logo.svg|16px|alt=|link=]]</span>"
							out[#out + 1] = wd
						else
							-- no wikidata links required, so just give the plain label
							out[#out + 1] = label
						end -- test if wikdata link display required
					end -- test if article exists
				end -- test for sitelink exists
			else -- no link wanted so just give the plain label:
				out[#out + 1] = label
			end -- test for link required
			-- If the property has a qualifier of latest date, add that in all cases:
			if v.qualifiers then
				local quals = v.qualifiers["P1326"] -- latest date qualifier
				if quals then
					local ldq = i18n.latestdatequalifier(mw.wikibase.renderSnaks(quals))
					out[#out] = out[#out] .. " (" .. ldq .. ")"
				end
			end
			------------------------------------
		elseif datatype == "time" then -- data type is time:
			-- it's a date value, so output according to formatting preferences
			local timestamp = datavalue.time
			-- 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-01T00: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")
			local dateprecision = datavalue.precision
			local fpvdate = tonumber(timestamp:sub(2, 5))
			local fdate
			if dateprecision >= 9 then -- precision is year or shorter
				local dateformat = "y"
				if dateprecision >= 10 then -- prepend month
					fpvdate = i18n.months[tonumber(timestamp:sub(7, 8))] .. " " .. fpvdate
					dateformat = args.df
					if dateprecision >= 11 then -- prepend day
							fpvdate = tonumber(timestamp:sub(10, 11)) .. " " .. fpvdate
					end
					if timestamp:sub(1, 1) == "-" then
						fpvdate = fpvdate .. " BCE"
					end
				end
				fdate = format_Date(fpvdate, dateformat, args.bc)
			elseif dateprecision == 7 then -- century
				local century = math.floor((fpvdate - 1) / 100) + 1
				fdate = makeOrdinal(century) .. "&nbsp;" .. i18n["century"]
				if timestamp:sub(1, 1) == "-" then -- date is BC
					local bc = string.upper(args.bc or "") -- can't use nil for bc
					-- we only want to accept two possibilities: BC or default to BCE
					if bc == "BC" then
						fdate = fdate .. "&nbsp;" .. i18n["BC"] -- use non-breaking space.
					else
						fdate = fdate .. "&nbsp;" .. i18n["BCE"]
					end
				end
			else
				-- date precisions 0 to 6 (billion years to millenium) TODO:
				--
			end
			out[#out+1] = fdate
			------------------------------------
		-- data types which are strings:
		elseif datatype == "commonsMedia" or datatype == "external-id" or datatype == "string" or datatype == "url" then
			-- commonsMedia or external-id or string or url
			-- all have mainsnak.datavalue.value as string
			if lprefix == "" and lpostfix == "" then
				out[#out+1] = prefix .. datavalue .. postfix
			else
				out[#out+1] = "[[" .. lprefix .. datavalue .. lpostfix
				out[#out] = out[#out] .. "|" .. prefix .. datavalue .. postfix .. "]]"
			end -- check for link requested (i.e. either linkprefix or linkpostfix exists)
			------------------------------------
		-- data types which are quantities:
		elseif datatype == "quantity" then
			-- quantities have mainsnak.datavalue.value.amount and mainsnak.datavalue.value.unit
			-- the unit is of the form http://www.wikidata.org/entity/Q829073
			-- convert amount to a number
			local amount = tonumber(datavalue.amount) or i18n["NaN"]
			-- check if upper and/or lower bounds are given and significant
			local upb = tonumber(datavalue.upperBound)
			local lowb = tonumber(datavalue.lowerBound)
			if upb and lowb then
				-- differences rounded to 2 sig fig:
				local posdif = roundto(upb - amount, 2)
				local negdif = roundto(amount - lowb, 2)
				if posdif ~= negdif then
					-- non-symmetrical
					amount = amount .. " +" .. posdif .. " -" .. negdif
				elseif posdif ~= 0 then
					-- symmetrical and significant
					amount = amount .. " ±" .. posdif
				end
				-- otherwise range is zero, so leave it off: amount = amount
			end
			-- extract the qid in the form 'Qnnn' from the value.unit url
			-- and then fetch the label from that
			local unit = ""
			local unitqid = string.match( datavalue.unit, "(Q%d+)" )
			if unitqid then
				if uabbr and i18n.abbr[unitqid] then
					-- it's on the list of common abbreviations, so use that
					unit = "&nbsp;" .. i18n.abbr[unitqid]
				else
					-- otherwise use the label (i.e. unit name) if it exists
					local uname = mw.wikibase.label( unitqid )
					if uname then unit = " " .. uname end
				end
			end
			out[#out+1] = amount .. unit
			------------------------------------
		-- datatypes which are global coordinates:
		elseif datatype == "globe-coordinate" then
			local display = args.display or ""
			local format = args.format or ""
			if display=="decimal" then
				local latdecimal = 0
				local longdecimal = 0
				local coords = entity:formatPropertyValues(propertyID).value
				-- the latitude and longitude are returned like this: nn°nn&#39;nn.n&#34;
				-- using html entities with hex values really screws up parsing the numbers
				local lat = mw.ustring.match(coords, "^[^,]*")  -- everything from the start to before the comma
				local long = mw.ustring.match(coords, "[^ ]*$") -- everything from after the space to the end
				lat = lat:gsub("&#%d%d;", ":")                  -- clean out the html entities
				long = long:gsub("&#%d%d;", ":")                -- clean out the html entities
				-- read the latitude numbers into a table
				local newlat = {}
				for num in mw.ustring.gmatch(lat, "%d+%.?%d*") do
					newlat[#newlat + 1] = num
				end
				if #newlat==3 then
					latdecimal = newlat[1] + newlat[2]/60 + newlat[3]/3600
				elseif #newlat==2 then
					latdecimal = newlat[1] + newlat[2]/60
				else
					latdecimal = newlat[1]
				end
				if lat:sub(-1)=="S" then
					latdecimal = -latdecimal
				end
				local newlong = {}
				for num in mw.ustring.gmatch(long, "%d+%.?%d*") do
					newlong[#newlong + 1] = num
				end
				if #newlong==3 then
					longdecimal = newlong[1] + newlong[2]/60 + newlong[3]/3600
				elseif #newlat==2 then
					longdecimal = newlong[1] + newlong[2]/60
				else
					longdecimal = newlong[1]
				end
				if long:sub(-1)=="W" then
					longdecimal = -longdecimal
				end
				if format == "longlat" then
					out[#out+1] = longdecimal .. ", " .. latdecimal
				elseif format == "lat" then
					out[#out+1] = latdecimal
				elseif format == "long" then
					out[#out+1] = longdecimal
				else
					out[#out+1] = latdecimal .. ", " .. longdecimal
				end
			else
				out[#out+1] = entity:formatPropertyValues(propertyID).value
			end
		else
			-- some other data type
			-- either write a specific handler
			-- or we can use formatPropertyValues() as a temporary measure.
			-- This won't work with multiple valid values.
			out[#out+1] = entity:formatPropertyValues(propertyID).value
			break
		end -- of datatype/unknown value/sourced check

		-- See if qualifiers are to be returned:
		if v.qualifiers and qualID and snak.snaktype=="value" then
			local qsep = args.qsep or ""
			qsep = string.gsub(qsep, '"', '')
			local qargs = {
				["osd"]      = "false",
				["linked"]   = tostring(linked),
				["prefix"]   = "",
				["postfix"]  = "",
				["lprefix"]  = "",
				["lpostfix"] = "",
				["wdl"]      = "false",
				["unitabbr"] = tostring(uabbr),
				["maxvals"]  = 0,
				["sorted"]   = parseParam(args.qsorted, false),
				["noicon"]   = "true",
				["list"]     = "",
				["sep"]      = qsep
			}
			if qualID == "DATES" then qargs.maxvals = 1 end
			local function qf(dummy)
				return true
			end
			local qlist = {}
			local t1, t2, dsep = "", "", ""
			for k1, v1 in pairs(v.qualifiers) do
				-- look for date range:
				if qualID == "DATES" then
					if k1 == "P580" then -- P580 is "start time"
						t1 = propertyvalueandquals(v1, qargs, qf)[1]
					elseif k1 == "P582" then -- P582 is "end time"
						t2 = propertyvalueandquals(v1, qargs, qf)[1]
					end
				-- check for latest date qualifier:
				elseif k1 == "P1326" then
					-- do nothing - this is handled already
				-- otherwise see if we want this qualifier:
				elseif qualID == "ALL" or qualID == k1 then 
					local ql = propertyvalueandquals(v1, qargs, qf)
					for k2, v2 in ipairs(ql) do
						qlist[#qlist + 1] = v2
					end
				end
			end -- of loop through qualifiers
			local t = t1 .. t2
			-- *** internationalise date separators later ***
			if t:find("%s") or t:find("&nbsp;") then dsep = "  &ndash; " else dsep = "&ndash;" end
			if #qlist > 0 then
				local qstr = assembleoutput(qlist, qargs)
				out[#out] = out[#out] .. " (" .. qstr .. ")"
			elseif t > "" then
				out[#out] = out[#out] .. " (" .. t1 .. dsep .. t2 .. ")"
			end
		end -- of test for qualifiers wanted
		if maxvals > 0 and #out >= maxvals then break end
	end -- of for each value loop
	return out
end


-------------------------------------------------------------------------------
-- _getvalue is the common function for getValue, getPreferredValue, and getNormalValue
--
local function _getvalue(frame, entity, props, propertyID)

	-- qual is a string containing the property ID of the qualifier(s) to be returned
	-- if qual == "ALL" then all qualifiers returned
	-- if qual == "DATES" then qualifiers P580 (start time) and P582 (end time) returned
	-- if nothing or an empty string is passed set it nil -> no qualifiers returned
	local qualID = mw.text.trim(frame.args.qual or ""):upper()
	if qualID == "" then qualID = nil end

	-- create a filter function
	--
	-- rank is a parameter passed, which indicates "preferred" or "normal"
	--
	local rank = (frame.args.rank or ""):lower()
	if rank:sub(1,1) == "p" then
		rank = "preferred"
	elseif rank:sub(1,1) == "n" then
		rank = "normal"
	else
		rank = ""
	end

	local function filter(claim)
		return true
	end

	if rank > "" then
		local rankflag = false
		for k, v in pairs(props) do
			if v.rank == rank then
				rankflag = true
				break
			end
		end
		function filter(claim)
			return claim.rank == rank or rankflag == false
		end
	end

	-- table 'out' stores the return value(s):
	local out = propertyvalueandquals(props, frame.args, filter, qualID)

	-- format the table of values and return it as a string:
	return assembleoutput(out, frame.args, entity.id, propertyID)
end


-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
-- Public functions
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
--
-- getValue is used to get the value(s) of a property
-- The property ID is passed as the first unnamed parameter and is required.
-- A locally supplied parameter may optionaly be supplied as the second unnamed parameter.
-- The function will now also return qualifiers if parameter qual is supplied
--
p.getValue = function(frame)
	if not frame.args[1] then
		frame.args = frame:getParent().args
		if not frame.args[1] then return i18n.errors["No property supplied"] end
	end
	local propertyID = mw.text.trim(frame.args[1] or "")

	local success, errorOrEntity, props = parseInput(frame, frame.args[2], propertyID)
	if not success then
		return errorOrEntity
	end

	local function filter(claim)
		return true
	end
	return _getvalue(frame, errorOrEntity, props, propertyID)
end


-------------------------------------------------------------------------------
-- getPreferredValue is used to get a value,
-- (or a comma separated list of them if multiple values exist).
-- If preferred ranks are set, it will return those values, otherwise values with normal ranks
--
p.getPreferredValue = function(frame)
	frame.args.rank = "preferred"
	return p.getValue(frame)
end


-------------------------------------------------------------------------------
-- getNormalValue is used to get a value,
-- (or a comma separated list of them if multiple values exist).
-- If normal ranks are set, it will return those values, otherwise all values
--
p.getNormalValue = function(frame)
	frame.args.rank = "normal"
	return p.getValue(frame)
end


-------------------------------------------------------------------------------
-- getCoords is used to get coordinates for display in an infobox
-- whitelist and blacklist are implemented
-- optional 'display' parameter is allowed, defaults to "inline, title"
--
p.getCoords = function(frame)
	local propertyID = "P625"

	-- if there is a 'display' parameter supplied, use it
	-- otherwise default to "inline, title"
	local disp = frame.args.display
	if not disp or disp == "" then
		disp = "inline, title"
	end

	local success, errorOrEntity = parseInput(frame, frame.args[1], propertyID)
	if not success then
		return errorOrEntity
	else
		local entity = errorOrEntity
		local lat_long = {}
		local coords = entity:formatPropertyValues(propertyID).value
		-- the latitude and longitude are returned like this: nn°nn&#39;nn.n&#34;
		-- using html entities with hex values really screws up parsing the numbers - thanks devs
		local lat = mw.ustring.match(coords, "^[^,]*")  -- everything from start to before comma
		local long = mw.ustring.match(coords, "[^ ]*$") -- everything from after space to the end
		lat = lat:gsub("&#%d%d;", ":")                  -- replace the html entities with colon
		long = long:gsub("&#%d%d;", ":")                -- replace the html entities with colon
		-- read the latitude numbers into a table
		for num in mw.ustring.gmatch(lat, "%d+%.?%d*") do
			lat_long[#lat_long + 1] = num
		end
		-- add the N/S
		lat_long[#lat_long + 1] = lat:sub(-1)
		-- read the longitude numbers into a table
		for num in mw.ustring.gmatch(long, "%d+%.?%d*") do
			lat_long[#lat_long + 1] = num
		end
		-- add E/W for long
		lat_long[#lat_long + 1] = long:sub(-1)
		-- add named parameter for display
		lat_long["display"] = disp
		-- invoke template Coord with the values stored in the table
		return frame:expandTemplate{title = 'coord', args = lat_long}
	end
end


-------------------------------------------------------------------------------
-- getQualifierValue is used to get a formatted value of a qualifier
--
-- The call needs:	a property (the unnamed parameter or 1=)
-- 					a target value for that property (pval=)
--					a qualifier for that target value (qual=)
-- The usual whitelisting and blacklisting of the property is implemented
-- The boolean onlysourced= parameter can be set to return nothing
-- when the property is unsourced (or only sourced to Wikipedia)
--
p.getQualifierValue = function(frame)

	-- The property ID that will have a qualifier is the first unnamed parameter
	local propertyID = mw.text.trim(frame.args[1] or "")

	-- The value of the property we want to match whose qualifier value is to be returned
	-- is passed in named parameter |pval=
	local propvalue = frame.args.pval

	-- The property ID of the qualifier
	-- whose value is to be returned is passed in named parameter |qual=
	local qualifierID = frame.args.qual

	-- onlysourced is a boolean passed to return qualifiers
	-- only when property values are sourced to something other than Wikipedia
	-- if nothing or an empty string is passed set it true
	-- if "false" or "no" or 0 is passed set it false
	local onlysrc = parseParam(frame.args.onlysourced or frame.args.osd, true)

	-- check for locally supplied parameter in second unnamed parameter
	-- success means no local parameter and the property exists
	local success, errorOrEntity, props = parseInput(frame, frame.args[2], propertyID)
	if success then
		local entity = errorOrEntity
		local out = {}
		-- Scan through the values of the property
		-- we want something like property is P793, significant event (in propertyID)
		-- whose value is something like Q385378, construction (in propvalue)
		-- then we can return the value(s) of a qualifier such as P580, start time (in qualifierID)
		for k1, v1 in pairs(props) do
			if v1.mainsnak.snaktype == "value" and v1.mainsnak.datavalue.type == "wikibase-entityid" then
				-- It's a wiki-linked value, so check if it's the target (in propvalue)
				-- and if it has qualifiers
				if v1.mainsnak.datavalue.value.id == propvalue and v1.qualifiers then
					if onlysrc == false or sourced(v1) then
						-- if we've got this far, we have a (sourced) claim with qualifiers
						-- which matches the target, so find the value(s) of the qualifier we want
						local quals = v1.qualifiers[qualifierID]
						if quals then
							local function filter(claim)
								return true
							end
							local vals = propertyvalueandquals(quals, frame.args, filter)
							for k, v in pairs(vals) do
								out[#out + 1] = v
							end
						end
					end -- of check for sourced
				end -- of check for matching required value and has qualifiers
			end -- of check for wikibase entity
		end -- of loop through values of propertyID
		return assembleoutput(out, frame.args, entity.id, propertyID)
	else
		return errorOrEntity
	end -- of test for success
	return nil
end


-------------------------------------------------------------------------------
-- getLink returns the label for a Qid wiki-linked to the local article (if the article exists)
-- if label doesn't exist, it returns the Qid wiki-linked to the local article (if the article exists)
--
p.getLink = function(frame)
	local itemID = mw.text.trim(frame.args[1] or "")
	if itemID == "" then return end
	local sitelink = mw.wikibase.sitelink(itemID)
	local label = labelOrId(itemID)
	if sitelink then
		return "[[" .. sitelink .. "|" .. label .. "]]"
	else
		return label
	end
end


-------------------------------------------------------------------------------
-- getLabel returns the label for a Qid
-- if label doesn't exist, it returns the Qid
--
p.getLabel = function(frame)
	local itemID = mw.text.trim(frame.args[1] or frame.args.qid or "")
	if itemID == "" then return end
	return labelOrId(itemID)
end


-------------------------------------------------------------------------------
-- getAT returns the article title for a Qid
-- or nothing if it doesn't exist
--
p.getAT = function(frame)
	local itemID = mw.text.trim(frame.args[1] or frame.args.qid or "")
	if itemID == "" then return end
	return mw.wikibase.sitelink(itemID)
end


-------------------------------------------------------------------------------
-- getDescription returns the article description for a Qid
-- Qid defaults to the current article if omitted
-- Any local parameter supplied (other than "Wikidata") becomes the return value
-- Nothing is returned if the description doesn't exist or 'none' is passed locally
--
p.getDescription = function(frame)
	local desc = mw.text.trim(frame.args[1] or "")
	local itemID = mw.text.trim(frame.args.qid or "")
	if itemID == "" then itemID = nil end
	if desc:lower() == 'wikidata' then
		return mw.wikibase.description(itemID)
	elseif desc:lower() == 'none' then
		return nil
	else
		return desc
	end
end


-------------------------------------------------------------------------------
-- formatDate is a wrapper to export the private function format_Date
--
p.formatDate = function(frame)
	return format_Date(frame.args[1], frame.args.df, frame.args.bc)
end


-------------------------------------------------------------------------------
-- checkBlacklist allows a test to check whether a named field is suppressed
-- {{#if:{{#invoke:WikidataIB |checkBlacklist |name=Joe |suppressfields=Dave; Joe; Fred}} | not blacklisted | blacklisted}}
-- displays "blacklisted"
-- {{#if:{{#invoke:WikidataIB |checkBlacklist |name=Jim |suppressfields=Dave; Joe; Fred}} | not blacklisted | blacklisted}}
-- displays "not blacklisted"
--
p.checkBlacklist = function(frame)
	local blacklist = frame.args.suppressfields
	local fieldname = frame.args.name
	if blacklist and fieldname then
		if blacklist:find(fieldname) then return nil end
		return true
	end
end


-------------------------------------------------------------------------------
-- emptyor returns nil if its first unnamed argument is just punctuation, whitespace or html tags
-- otherwise it returns the argument unchanged (including leading/trailing space)
-- unless the argument may contain "=" when it must be called explicitly:
-- |1=arg
-- (when leading/trailing spaces are trimmed)
p.emptyor = function(frame)
	local s = frame.args[1]
	if not s or s == "" then return nil end
	local sx = s:gsub("%s", ""):gsub("<[^>]*>", ""):gsub("%p", "")
	if sx == "" then
		return nil
	else
		return s
	end
end


-------------------------------------------------------------------------------
-- labelorid is a public function to expose the output of labelOrId()
-- pass the Q-number as |qid= or as an unnamed parameter
p.labelorid = function(frame)
	local id = frame.args.qid or frame.args[1]
	return labelOrId(id)
end


return p