Module:Wikidata/Récup : Différence entre versions

De Lagny-sur-Marne Wiki
Aller à : navigation, rechercher
m (A changé le niveau de protection pour « Module:Wikidata/Récup » ([Modifier=Autoriser uniquement les utilisateurs autopatrolled] (infini) [Renommer=Autoriser uniquement les administrateurs] (infini)))
 
(56 révisions intermédiaires par 5 utilisateurs non affichées)
Ligne 1 : Ligne 1 :
 
local p = {}
 
local p = {}
 
local datequalifiers = {'P585', 'P571', 'P580', 'P582'}
 
local datequalifiers = {'P585', 'P571', 'P580', 'P582'}
 +
local tools = require "Module:Wikidata/Outils"
 +
local datemod -- = require "Module:Date complexe" -- chargé uniquement si nécessaire
  
−
local function severalProperties(args)
+
local function notSpecial(claim)
−
local newargs = args
+
return tools.isValue(claim.mainsnak)
−
for i, j in pairs(args.property) do
 
−
newargs.property = j
 
−
local newstatements = p.getstatements(newargs)
 
−
if statements then
 
−
return statements
 
−
end
 
−
end
 
 
end
 
end
  
−
local function hastargetvalue(statement, target)
+
local function hastargetvalue(claim, targets) -- retourne true si la valeur est dans la liste des target, ou si c'est une valeur spéciale filtrée séparément par excludespecial
−
if target == nil then
+
local id = tools.getMainId(claim)
−
return true
+
local targets = tools.splitStr(targets)
−
end
+
return tools.isHere(targets, id) or tools.isSpecial(claim.mainsnak)
−
return samevalue(statement.mainsnak, target)
 
 
end
 
end
  
−
local function hasrank(statement, target)
+
local function excludevalues(claim, values) -- true si la valeur n'est pas dans la liste, ou si c'est une valeur spéciale (filtrée à part par excludespecial)
−
if target == 'valid' then
+
return tools.isSpecial(claim.mainsnak) or not ( hastargetvalue(claim, values) )
−
return hasrank(statement, 'preferred') or hasrank(statement, 'normal')
 
−
end
 
−
if statement.rank == target then
 
−
return true
 
−
end
 
−
return false
 
 
end
 
end
  
−
local function bestranked(statements)
+
local function bestranked(claims)
−
if not statements then
+
if not claims then
 
return nil
 
return nil
 
end
 
end
 
local preferred, normal = {}, {}
 
local preferred, normal = {}, {}
−
for i, j in pairs(statements) do
+
for i, j in pairs(claims) do
 
if j.rank == 'preferred' then
 
if j.rank == 'preferred' then
 
table.insert(preferred, j)
 
table.insert(preferred, j)
Ligne 49 : Ligne 37 :
 
end
 
end
  
−
local function hasqualifier(statement, qualifier, qualifiervalues)
+
local function withrank(claims, target)
−
local statementqualifs = statements.qualifiers
+
if target == 'best' then
−
  if (not statementqualifs) or not(statementqualifs[qualifier]) then
+
return bestranked(claims)
−
  return false
+
end
−
  end
+
local newclaims = {}
 +
for pos, claim in pairs(claims)  do
 +
if target == 'valid' then
 +
if claim.rank ~= 'deprecated' then
 +
table.insert(newclaims, claim)
 +
end
 +
elseif claim.rank == target then
 +
table.insert(newclaims, claim)
 +
end
 +
end
 +
return newclaims
 +
end
 +
 
 +
function p.hasqualifier(claim, acceptedqualifs, acceptedvals, excludequalifiervalues)
 +
local claimqualifs = claim.qualifiers
 +
 +
if (not claimqualifs) then
 +
return false
 +
end
  
−
  if (not qualifiervalues) or (qualifiervalues == {}) then
+
acceptedqualifs = tools.splitStr(acceptedqualifs)
−
  return true -- si aucune valeur spécifique n'est exigée, c'est bon
+
acceptedvals = tools.splitStr( acceptedvals)
−
  end
 
  
−
  if type(qualifiervalues) == 'string' then
 
−
  qualifiervalues = {qualifiervalues}
 
−
  end
 
  
−
  for i, j in pairs(statement.qualifiers[qualifier]) do
+
local function ok(qualif) -- vérification pour un qualificatif individuel
−
  local val = p.getRawvalue(j)
+
if not claimqualifs[qualif] then
−
  for k, l in pairs(qualifiervalues) do
+
return false
−
  if l == val then
+
end
−
  return true
+
if not (acceptedvals) then  -- si aucune valeur spécifique n'est demandée, OK
−
  end
+
return true
−
  end
+
end
−
  end
+
for i, wanted in pairs(acceptedvals) do
−
  return false
+
for j, actual in pairs(claimqualifs[qualif]) do
 +
if tools.getId(actual) == wanted then
 +
return true
 +
end
 +
end
 +
end
 +
end
 +
 
 +
for i, qualif in pairs(acceptedqualifs) do
 +
if ok(qualif) then
 +
return true
 +
end
 +
end
 +
return false
 
  end
 
  end
  
−
local function hassource(statement, targetsource, sourceproperty)
+
local function hassource(claim, targetsource, sourceproperty)
−
    sourceproperty = sourceproperty or 'P248'
+
sourceproperty = sourceproperty or 'P248'
−
if not statement.references or not statement.references[sourceproperty] then
+
if targetsource == "-" then
 +
return true
 +
end
 +
if (not claim.references) then return
 +
false
 +
end
 +
local candidates = claim.references[1].snaks[sourceproperty] -- les snaks utilisant la propriété demandée
 +
if (not candidates) then
 
return false
 
return false
 
end
 
end
−
if not targetsource then -- si toutes les sources sont valides, du moment qu'elles utilisent sourceproperty
+
if (targetsource == "any") then -- si n'importe quelle valeur est acceptée tant qu'elle utilise en ref la propriété demandée
 
return true
 
return true
 
end
 
end
−
for _, source in pairs(statement.references[sourceproperty]) do
+
targetsource = tools.splitStr(targetsource)
−
if (source.snaktype == 'value') and (source.datavalue.value['numeric-id'] == targetsource) then
+
for _, source in pairs(candidates) do
−
return true
+
local s = tools.getId(source)
 +
for i, target in pairs(targetsource) do
 +
if s == target then return true end
 
end
 
end
 
end
 
end
−
return true
+
return false
 +
end
 +
 
 +
local function excludequalifier(claim, qualifier, qualifiervalues)
 +
return not p.hasqualifier(claim, qualifier, qualifiervalues)
 
end
 
end
  
−
local function hasdate(statement)
+
 
−
local statementqualifs = statements.qualifiers
+
local function hasdate(claim)
−
if not statementqualifs then
+
local claimqualifs = claims.qualifiers
 +
if not claimqualifs then
 
return false
 
return false
 
end
 
end
−
for _, qualif in pairs(statementqualifs) do
+
for _, qualif in pairs(claimqualifs) do
−
if statementsqualifs[qualif] and statementsqualifs[qualif][1].snaktype == 'value' then
+
if claimsqualifs[qualif] and claimsqualifs[qualif][1].snaktype == 'value' then
 
return true
 
return true
 
end
 
end
Ligne 103 : Ligne 132 :
 
end
 
end
  
−
local function isinlanguage(snak, lang) -- ne fonctionne que pour les monolingualtext / étendre aux autres types en utilisant les qualifiers ?
+
local function haslink(claim, site, lang)
−
if snak.snaktype == 'value' and snak.datavalue.type == 'monolingualtext' and snak.datavalue.value.language == lang then
+
if not(tools.isValue(claim.mainsnak)) then -- ne pas supprimer les valeurs spéciales, il y a une fonction dédiée pour ça
 +
return true
 +
end
 +
local id = tools.getMainId(claim)
 +
local link = tools.siteLink(id, site, lang)
 +
if link then
 
return true
 
return true
 
end
 
end
−
return false
 
 
end
 
end
  
−
local function isSpecial(snak)
+
local function isinlanguage(claim, lang) -- ne fonctionne que pour les monolingualtext / étendre aux autres types en utilisant les qualifiers ?
−
if snak.snaktype == 'value' then
+
local snak = claim.mainsnak
 +
if tools.isSpecial(snak) then
 
return false
 
return false
 
end
 
end
−
return true
+
if snak.datavalue.type == 'monolingualtext' and snak.datavalue.value.language == lang then
 +
return true
 +
end
 +
return false
 
end
 
end
  
−
local function numval(statements, numval) -- retourn les numval premières valeurs de la table statements
+
local function firstvals(claims, numval) -- retourn les numval premières valeurs de la table claims
 
     local numval = tonumber(numval) or 0 -- raise a error if numval is not a positive integer ?
 
     local numval = tonumber(numval) or 0 -- raise a error if numval is not a positive integer ?
−
     if #statements <= numval then
+
     if not claims then
−
     return statements
+
     return nil
 
     end
 
     end
−
    local newstatements = {}
+
     while (#claims > numval) do
−
     while #newstatements < numval do
+
     table.remove(claims)
−
     table.insert(newstatements, statements[#newstatements + 1])
 
 
     end
 
     end
−
     return newstatements
+
     return claims
 
end
 
end
  
−
local function comparedate(a, b) -- returns true if a is earlier than B or if a has a date but not b
+
local function valinQualif(claim, qualifs)
−
if a and b then
+
local claimqualifs = claim.qualifiers
−
return a.timestamp < b.timestamp
+
if not claimqualifs then
−
elseif a then
+
return nil
−
return true
+
end
 +
for i, qualif in pairs(qualifs) do
 +
local vals = claimqualifs[qualif]
 +
if vals and tools.isValue(vals[1]) then
 +
return tools.getValue(vals[1]).time
 +
end
 
end
 
end
 
end
 
end
  
−
local function chronosort(statements, inverted)
+
local function chronosort(claims, inverted)
−
local function getTimestamp(statement)
+
table.sort(
−
local statementqualifs = statements.qualifiers
+
claims,
−
if not statementqualif then
+
function(a,b)
−
return nil
+
local timeA = valinQualif(a, datequalifiers) or ''
−
end
+
local timeB = valinQualif(b, datequalifiers) or ''
−
for _, qualif in pairs(datequalifiers) do
+
if inverted then
−
if statementqualif[qualif] and statementqualif[1].snaktype == 'value' then
+
return timeA > timeB -- marche sauf pour les dates < 10 000 av-JC utiliser datemod.before produit un bug
−
return statementqualif[1].datavalue.value
+
else
 +
return timeB > timeA
 
end
 
end
 
end
 
end
 +
)
 +
return claims
 +
end
 +
 +
local function atDate(claim, mydate)
 +
if mydate == "today" then
 +
mydate = os.date("!%Y-%m-%dT%TZ")
 +
end
 +
local newclaims = {}
 +
local mindate = valinQualif(claim, {'P580'})
 +
local maxdate = valinQualif(claim, {'P582'})
 +
datemod = require "Module:Date complexe"
 +
if datemod.before(mydate, mindate) and datemod.before(maxdate, mydate) then
 +
return true
 +
end
 +
end
 +
 +
local function check(claim, condition)
 +
if type(condition) == 'function' then -- cas standard
 +
return condition(claim)
 
end
 
end
−
table.sort(statements, function(a,b)
+
local msg = "args.condition should be a function"
−
local timeA = p.getDate(a)
+
return error(msg)
−
local timeB = p.getDate(b)
 
−
if inverted then
 
−
return comparedate(timeB, timeA)
 
−
else
 
−
return comparedate(timeA, timeB)
 
−
end
 
−
end
 
−
)
 
−
return statements
 
 
end
 
end
  
−
function p.sortstatements(statements, sorttype)
+
function p.sortclaims(claims, sorttype)
 +
if not claims then
 +
return nil
 +
end
 
if sorttype == 'chronological' then
 
if sorttype == 'chronological' then
−
return chronosort(statements)
+
return chronosort(claims)
 
elseif sorttype == 'inverted' then
 
elseif sorttype == 'inverted' then
−
return chronosort(statements, true)
+
return chronosort(claims, true)
 
elseif type(sorttype) == 'function' then
 
elseif type(sorttype) == 'function' then
−
table.sort(statements, sorttype)
+
table.sort(claims, sorttype)
−
return statements
+
return claims
 
end
 
end
−
return statements
+
return claims
 
end
 
end
  
−
function p.getstatements( args ) -- returns a table of the statements matching some conditions given in args
+
 
−
if args.statements then -- if statements have already been set, return them
+
function p.filterClaims(claims, args) --retire de la tables de claims celles qui sont éliminés par un des filters de la table des filters
−
return args.statements
+
 
 +
local function filter(condition, filterfunction, funargs)
 +
if not args[condition] then
 +
return
 +
end
 +
for i = #claims, 1, -1 do
 +
if not( filterfunction(claims[i], args[funargs[1]], args[funargs[2]], args[funargs[3]]) ) then
 +
table.remove(claims, i)
 +
end
 +
end
 
end
 
end
−
if not args.property then
+
 
−
return formatError( 'property-param-not-provided' )
+
filter('targetvalue', hastargetvalue, {'targetvalue'} )
 +
filter('isinlang', isinlanguage, {'isinlang'} )
 +
filter('atdate', atDate, {'atdate'} )
 +
filter('qualifier', p.hasqualifier, {'qualifier', 'qualifiervalue'} )
 +
filter('excludequalifier', excludequalifier, {'excludequalifier', 'excludequalifiervalue'} )
 +
filter('withsource', hassource, {'withsource', 'sourceproperty'} )
 +
filter('withdate', hasdate, {} )
 +
filter('excludespecial', notSpecial, {} )
 +
filter('excludevalues', excludevalues, {'excludevalues'})
 +
filter('withlink', haslink, {'withlink', 'linklang'} )
 +
filter('condition', check, {'condition'})
 +
 
 +
claims = withrank(claims, args.rank or 'best')
 +
if args.sorttype then
 +
claims = p.sortclaims(claims, args.sorttype)
 
end
 
end
−
if type(args.property) == 'table' then
+
if #claims == 0 then
−
return severalProperties(args)
+
return nil
 
end
 
end
 +
if args.numval then
 +
claims = firstvals(claims, args.numval)
 +
end
 +
return claims
 +
 +
end
 +
 +
function p.loadEntity(entity, cache)
 +
if type(entity) ~= 'table' then
 +
if cache then
 +
if not cache[entity] then
 +
cache[entity] = mw.wikibase.getEntity(entity)
 +
mw.log("cached")
 +
    end
 +
return cache[entity]
 +
        else
 +
if entity == '' then
 +
entity = nil
 +
end
 +
        return mw.wikibase.getEntity(entity)
 +
        end
 +
    else
 +
    return entity
 +
    end
 +
end
 +
 +
 +
function p.getClaims( args ) -- returns a table of the claims matching some conditions given in args
 +
if args.claims then -- if claims have already been set, return them
 +
return args.claims
 +
end
 +
local properties = tools.splitStr(args.property)
 +
 +
if not properties then
 +
return error( 'property-param-not-provided' )
 +
end
 +
 
--Get entity
 
--Get entity
 
local entity = args.entity
 
local entity = args.entity
−
  if type(entity) ~= 'table' then
+
  entity = p.loadEntity(args.entity, args.cache)
−
        entity = mw.wikibase.getEntityObject( args.entity )
+
      
−
     end
+
if (not entity) or (not entity.claims) then
−
if (not entity) or (not entity.statements) then
 
−
return nil
 
−
end
 
−
local property = string.upper(args.property)
 
−
if not entity.statements[property] then
 
 
return nil
 
return nil
 
end
 
end
−
if not args.rank then
+
local claims = {}
−
args.rank = 'best'
+
for i, prop in pairs(properties) do
−
end
+
prop = string.upper(prop)
−
local statements = {}
+
for j, claim in pairs(entity.claims[prop] or {}) do
−
    -- ~= '' lorsque le paramètre est écrit mais laissé blanc dans une fonction frame
+
table.insert(claims, claim)
−
    for i, statement in pairs(entity.statements[property]) do
 
−
    if
 
−
    (
 
−
    not args.excludespecial
 
−
    or
 
−
    not (isSpecial(statement.mainsnak))
 
−
    )
 
−
    and
 
−
    (
 
−
not args.targetvalue
 
−
or
 
−
hastargetvalue(statement, args.targetvalue)
 
−
)
 
−
    and
 
−
    (
 
−
    not args.qualifier
 
−
    or
 
−
    hasqualifier(statement, args.qualifier, args.qualifiervalue or args.qualifiervalues)
 
−
    )
 
−
and
 
−
(
 
−
not args.source
 
−
or
 
−
hassource(statement, args.source, args.sourceproperty)
 
−
)
 
−
and
 
−
not args.isinlanguage
 
−
or
 
−
isinlanguage(statement.mainsnak, args.isinlanguage)
 
−
and
 
−
args.rank == 'best' -- rank == best est traité à a fin
 
−
or
 
−
hasrank(statement, rank)
 
−
then
 
−
table.insert(statements, statement)
 
 
end
 
end
 
end
 
end
−
if #statements == 0 then
+
 
 +
if (#claims == 0) then
 
return nil
 
return nil
 
end
 
end
−
    if args.rank == 'best' then
+
return p.filterClaims(claims, args)
−
    statements = bestranked(statements)
 
−
    end
 
−
    if args.sorttype then
 
−
    statements = p.sortstatements(statements, args.sorttype)
 
−
    end
 
−
 
 
−
if args.numval then
 
−
return numval(statements, args.numval)
 
−
end
 
−
return statements
 
 
end
 
end
  
 
return p
 
return p

Version actuelle datée du 17 mai 2017 à 13:42

La documentation pour ce module peut être créée à Module:Wikidata/Récup/doc 

local p = {}
local datequalifiers = {'P585', 'P571', 'P580', 'P582'}
local tools = require "Module:Wikidata/Outils"
local datemod -- = require "Module:Date complexe" -- chargé uniquement si nécessaire

local function notSpecial(claim)
	return tools.isValue(claim.mainsnak)
end

local function hastargetvalue(claim, targets) -- retourne true si la valeur est dans la liste des target, ou si c'est une valeur spéciale filtrée séparément par excludespecial
	local id = tools.getMainId(claim)
	local targets = tools.splitStr(targets)
	return tools.isHere(targets, id) or tools.isSpecial(claim.mainsnak)
end

local function excludevalues(claim, values) -- true si la valeur n'est pas dans la liste, ou si c'est une valeur spéciale (filtrée à part par excludespecial)
	return tools.isSpecial(claim.mainsnak) or not ( hastargetvalue(claim, values) )
end

local function bestranked(claims)
	if not claims then
		return nil
	end
	local preferred, normal = {}, {}
	for i, j in pairs(claims) do
		if j.rank == 'preferred' then
			table.insert(preferred, j)
		elseif j.rank == 'normal' then
			table.insert(normal, j)
		end
	end
	if #preferred > 0 then
		return preferred
	else
		return normal
	end
end

local function withrank(claims, target)
	if target == 'best' then
		return bestranked(claims)
	end
	local newclaims = {}
	for pos, claim in pairs(claims)  do
		if target == 'valid' then
			if claim.rank ~= 'deprecated' then
				table.insert(newclaims, claim)
			end
		elseif claim.rank == target then
			table.insert(newclaims, claim)
		end
	end
	return newclaims
end

function p.hasqualifier(claim, acceptedqualifs, acceptedvals, excludequalifiervalues)
	local claimqualifs = claim.qualifiers
	
	if (not claimqualifs) then
		return false
	end

	acceptedqualifs = tools.splitStr(acceptedqualifs)
	acceptedvals = tools.splitStr( acceptedvals)


	local function ok(qualif) -- vérification pour un qualificatif individuel
		if not claimqualifs[qualif] then
			return false
		end
		if not (acceptedvals) then  -- si aucune valeur spécifique n'est demandée, OK
			return true
		end
		for i, wanted in pairs(acceptedvals) do
			for j, actual in pairs(claimqualifs[qualif]) do
				if tools.getId(actual) == wanted then
					return true
				end
			end
		end
	end

	for i, qualif in pairs(acceptedqualifs) do
		if ok(qualif) then
			return true
		end
	end
	return false
 end

local function hassource(claim, targetsource, sourceproperty)
	sourceproperty = sourceproperty or 'P248'
	if targetsource == "-" then
		return true
	end
	if (not claim.references) then return
		false
	end
	local candidates = claim.references[1].snaks[sourceproperty] -- les snaks utilisant la propriété demandée
	if (not candidates) then
		return false
	end
	if (targetsource == "any") then -- si n'importe quelle valeur est acceptée tant qu'elle utilise en ref la propriété demandée
		return true
	end
	targetsource = tools.splitStr(targetsource)
	for _, source in pairs(candidates) do
		local s = tools.getId(source)
		for i, target in pairs(targetsource) do
			if s == target then return true end
		end
	end
	return false
end

local function excludequalifier(claim, qualifier, qualifiervalues)
	return not p.hasqualifier(claim, qualifier, qualifiervalues)
end


local function hasdate(claim)
	local claimqualifs = claims.qualifiers
	if not claimqualifs then
		return false
	end
	for _, qualif in pairs(claimqualifs) do
		if claimsqualifs[qualif] and claimsqualifs[qualif][1].snaktype == 'value' then
			return true
		end
	end
	return false
end

local function haslink(claim, site, lang)
	if not(tools.isValue(claim.mainsnak)) then -- ne pas supprimer les valeurs spéciales, il y a une fonction dédiée pour ça
		return true
	end
	local id = tools.getMainId(claim)
	local link = tools.siteLink(id, site, lang)
	if link then
		return true
	end
end

local function isinlanguage(claim, lang) -- ne fonctionne que pour les monolingualtext / étendre aux autres types en utilisant les qualifiers ?
	local snak = claim.mainsnak
	if tools.isSpecial(snak) then
		return false
	end
	if snak.datavalue.type == 'monolingualtext' and snak.datavalue.value.language == lang then
		return true
	end
	return false
end

local function firstvals(claims, numval) -- retourn les numval premières valeurs de la table claims
    local numval = tonumber(numval) or 0 -- raise a error if numval is not a positive integer ?
    if not claims then
    	return nil
    end
    while (#claims > numval) do
    	table.remove(claims)
    end
    return claims
end

local function valinQualif(claim, qualifs)
	local claimqualifs = claim.qualifiers
	if not claimqualifs then
		return nil
	end
	for i, qualif in pairs(qualifs) do
		local vals = claimqualifs[qualif]
		if vals and tools.isValue(vals[1]) then
			return tools.getValue(vals[1]).time
		end
	end
end

local function chronosort(claims, inverted)
	table.sort(
		claims,
		function(a,b)
			local timeA = valinQualif(a, datequalifiers) or ''
			local timeB = valinQualif(b, datequalifiers) or ''
			if inverted then
				return timeA > timeB -- marche sauf pour les dates < 10 000 av-JC utiliser datemod.before produit un bug
			else
				return timeB > timeA
			end
		end
	)
	return claims
end

local function atDate(claim, mydate)
	if mydate == "today" then
		mydate = os.date("!%Y-%m-%dT%TZ")
	end	
	local newclaims = {}
	local mindate = valinQualif(claim, {'P580'}) 
	local maxdate = valinQualif(claim, {'P582'})
	datemod = require "Module:Date complexe"
	if datemod.before(mydate, mindate) and datemod.before(maxdate, mydate) then
		return true
	end
end

local function check(claim, condition)
	if type(condition) == 'function' then -- cas standard
		return condition(claim)
	end
	local msg = "args.condition should be a function"
	return error(msg)
end

function p.sortclaims(claims, sorttype)
	if not claims then
		return nil
	end
	if sorttype == 'chronological' then
		return chronosort(claims)
	elseif sorttype == 'inverted' then
		return chronosort(claims, true)
	elseif type(sorttype) == 'function' then
		table.sort(claims, sorttype)
		return claims
	end
	return claims
end


function p.filterClaims(claims, args) --retire de la tables de claims celles qui sont éliminés par un des filters de la table des filters

	local function filter(condition, filterfunction, funargs)
		if not args[condition] then
			return
		end
		for i = #claims, 1, -1 do
			if not( filterfunction(claims[i], args[funargs[1]], args[funargs[2]], args[funargs[3]]) ) then
				table.remove(claims, i)
			end
		end
	end

	filter('targetvalue', hastargetvalue, {'targetvalue'} )
	filter('isinlang', isinlanguage, {'isinlang'} )
	filter('atdate', atDate, {'atdate'} )
	filter('qualifier', p.hasqualifier, {'qualifier', 'qualifiervalue'} )
	filter('excludequalifier', excludequalifier, {'excludequalifier', 'excludequalifiervalue'} )
	filter('withsource', hassource, {'withsource', 'sourceproperty'} )
	filter('withdate', hasdate, {} )
	filter('excludespecial', notSpecial, {} )
	filter('excludevalues', excludevalues, {'excludevalues'})
	filter('withlink', haslink, {'withlink', 'linklang'} )
	filter('condition', check, {'condition'})

	claims = withrank(claims, args.rank or 'best')
	if args.sorttype then
		claims = p.sortclaims(claims, args.sorttype)
	end
	if #claims == 0 then
		return nil
	end
	if args.numval then
		claims = firstvals(claims, args.numval)
	end
	return claims

end

function p.loadEntity(entity, cache)
	if type(entity) ~= 'table' then
		if cache then
			if not cache[entity] then 
				cache[entity] = mw.wikibase.getEntity(entity)
				mw.log("cached")
     		end
			return cache[entity]
        else
			if entity == '' then
				entity = nil
			end
        	return mw.wikibase.getEntity(entity)
        end
    else 
    	return entity
    end
end


function p.getClaims( args ) -- returns a table of the claims matching some conditions given in args
	if args.claims then -- if claims have already been set, return them
		return args.claims
	end
	local properties = tools.splitStr(args.property)

	if not properties then
		return error( 'property-param-not-provided' )
	end

	--Get entity
	local entity = args.entity
 	entity = p.loadEntity(args.entity, args.cache)
    
	if (not entity) or (not entity.claims) then
		return nil
	end
	local claims = {}
	for i, prop in pairs(properties) do
		prop = string.upper(prop)
		for j, claim in pairs(entity.claims[prop] or {}) do
			table.insert(claims, claim)
		end
	end

	if (#claims == 0) then
		return nil
	end
	return p.filterClaims(claims, args)
end

return p
Récupérée de « https://lagny-sur-marne.wiki/index.php?title=Module:Wikidata/Récup&oldid=19355 »