Module:Nsm/Faculté

Une page de Wikiversité.
Sauter à la navigation Sauter à la recherche

Le Module:Nsm/Faculté utilise les tables du Module:Nsm/Table/106, lui-même écrit par le biais du script python fac.py (cf fr-wikiversity-ns sur gerrit.wikimedia.org). L'objectif est de créer une série de fonctions, pour générer différents tableaux, listes, vues, calculs statistiques ; à partir des données récoltées par Python.

  • fac_dpt affiche une liste des départements par faculté.
  • liste affiche les départements et leur(s) faculté(s) attachée(s).
  • classement affiche le classement des facultés en fonction du nombre de documents existants ; avec la taille du classement comme paramètre.
  • print_cat() affiche les catégories éponymes.
  • n_dpt_fac affiche le nombre de départements recensé dans l’espace de noms Faculté.
  • nombre_de_facultes affiche le nombre de facultés.

Librairies : Module:Nsm/Lib, Module:Nsm/Lib/Sub, Module:Nsm/Lib/Sortable class, Module:Nsm/Lib/Category

Voir aussi 
Projet:Laboratoire/Espaces de noms/Minute technique

info Documentation du Module:Nsm/Faculté : v · d · m · h.


local p            = require("Module:Nsm/Lib")       -- Bibliothèque NameSpace Monitor
local import       = require("Module:Nsm/Table/106") -- Tables Lua via Python
local import_talk  = require("Module:Nsm/Table/107") -- talkpages tables
-- Librairies
local import_tri   = require("Module:Lib_table_tri") -- Fonctions tri spairs
-- Table département
local import_dpt   = require("Module:Nsm/Table/108") -- Table des départements
-- Variables
t_prop     = import.t_prop    -- Propriétés de l'espace
label      = t_prop.label     -- Label de l'espace 
t_pages    = import.t_pages   -- Table pages faculté
t_dpt_fac  = import.t_dpt_fac -- Table inverse
talk_prop  = import_talk.t_prop      -- ns talk properties
talk_pages = import_talk.t_talkpages -- talk pages table
talk_label = talk_prop.label         -- Label espace discussion
lang 	   = t_prop.lang             -- GLOBAL pour lnk(var)
t_root     = ns_root_only(t_pages)   -- Pages racines (avec redir)
t_sub     = ns_subpages_only(t_pages)
pfix       = prefix(lang, label)     -- Prefixe des pages de l'espace
local ns_departement = import_dpt.t_pages    -- table des départements

-- SOUS-FONCTIONS
function get_dpt_in(fac, l_dpt) --[[ Reçoit page de faculté et liste des dpt ; retourne table des départements ajoute le champ fac.]]--
	local tr = {} -- table résultat
	for kd, dpt in pairs(l_dpt) do -- pour chaque dpt dans la liste de la fac
		for kdpt, departement in pairs(ns_departement) do -- table pages dept
				if departement.page == dpt then -- si les titres sont equivalents
					departement['fac'] = fac    -- Ajoute le titre de la faculté
					tr[kdpt] = ns_departement[kdpt] -- construire table
				end end end
	return tr
end

function fac_sum_links(t) -- Retourne la somme des liens par faculté - Voir classement()
	for k, fac in pairs(t) do 
		local c = 0     --Compteur de lien
		local fdpt = {} -- départements ventilés par faculté
		fdpt = get_dpt_in(fac.page, fac.l_dpt) --SUB FX
		for kf, dpt in pairs(fdpt) do c = c + dpt.n_exist end -- additionne
		fac['liens'] = c -- Ajoute la somme des liens
	end
	return t
end
-- FONCTIONS
function p.classement_test(frame)  
	local t_in = {}              -- Table en entrée
	t_in = fac_sum_links(t_root) -- Calcul la somme des liens
	table.sort(t_in)
	--return st_print(t_in, col) --r, '-i'
	local t_seq = {}             -- Table en sortie
	for k, v in pairs(t_in) do table.insert(t_seq, v) end  -- SEQUENCE
	t_out = {}
	for k, v in pairs(t_seq) do t_out[k] = v.liens end  -- table simple index | liens
	table.sort(t_out, function(a, b) return a > b end)
	local result = {}
	local col = {'page', 'liens'}
	return st_print(result, col)
end

function p.classement(frame) -- RELIRE Classement des facultés selon les liens des départements SIMPLIFIER :-P 
	local t_in = {}              -- Table en entrée
	t_in = fac_sum_links(t_root) -- Calcul la somme des liens
	t_out = {}                   -- Table en sortie
	for k, v in pairs(t_in) do   -- chaque page en entrée
		t_out[v.page] = v.liens end -- table simple page | liens
	local t_classement = t_out      -- change nom variable
    local c = 0                     -- compteur d'occurrences
    local st_classement = {}        -- Table...
    for k, v in spairs(t_classement, function(t,a,b) return t[b] < t[a] end) do
    	c = c + 1
		st_classement[c] = {k, v}
	end
	if frame.args[1] ~= nil then limite = tonumber(frame.args[1]) else limite = table.maxn(st_classement) end
	local t = {}
	for i, v in ipairs(st_classement) do
		if i <= limite then
			tv = {}
			tv['page']  = v[1]
			tv['liens'] = v[2]
			table.insert(t, tv)
			end end
	local col = {'page', 'liens'}
	return st_print(t, col) --r, '-i'
end

function p.liens(frame) -- liens(|fac) Affiche les liens existants ventilés par département. Argument1 filtre les facultés.
	--if frame.args[1] ~= nil then motif = pfix .. frame.args[1] else motif ='' end
	local result = ''
	if frame.args['nom'] then motif = frame.args['nom']
		result = result .. motif .. '\n' end
	--local motif = frame.args['nom']
	local t_dpt = pages(t_root, motif) -- Filtre selon argument1
	t_dpt = liens(t_dpt) -- 
	local col = {'fac', 'page', 'l_exist', 'n_exist'}
	result = result .. st_print(t_dpt, col, '-i')
	
	return result --
end
function liens(t) -- Reçoit table de facultés ; Retourne table des départements ventilés par faculté. 
	local tr = {} -- Table des résultats
	for k, fac in pairs(t) do  -- Chaque faculté
		local fdpt = {}        -- Liste départements associés
		fdpt = get_dpt_in(fac.page, fac.l_dpt) -- retourne les dpt associés aux facultés
		for k, v in pairs(fdpt) do tr[k] = fdpt[k] end -- Ajoute aux résultats
	end
	return tr    -- Retourne pages départements associés aux facultés
end

function p.departement(frame) -- Affiche les département et le(s) liens(s) vers la(les) facultés. L'argument |multiple filtre les départements attachés à plusieurs facultés.
	local t_out = t_dpt_fac
	if frame.args[1] == 'multiple' then
		t_out = {} -- Filtre des départements multiples
		for k, v in pairs(t_dpt_fac) do
			if v.n_fac > 1 then t_out[k] = t_dpt_fac[k] end end  end
	local module_name = frame:getTitle()    -- Nom du module qui appel via frame
	local col = {'page', 'n_fac', 'l_fac'}  -- 'l_exist' pas disponible
	local result = lnk(module_name) .. '\n' .. st_print(t_out, col, '-i')
	return result
end
function p.n_dpt_fac() -- Option de sortie pour main fx Voir p.departement(frame)
	local n_dpt_fac = table.maxn(t_dpt_fac)
	return n_dpt_fac
end

function p.fac_dpt() --[[Nlle version imprime une section par faculté contenat un tableau des départements. RENOMMER Il faudrait pouvoir filtrer par faculté]]--
	local r = ''
	for k, fac in pairs(t_root) do
		local fdpt = {}
		fdpt = get_dpt_in(fac.page, fac.l_dpt) --SUB FX 
		r = r .. '==[[' ..fac.page .. ']]' ..' ==\n'
		r = r.. 'La faculté hébèrge, ' .. tostring(fac.n_dpt) ..' département(s).' .. '\n'
		local col = {'page'} -- 'l_exist' NOMBRE POUR CHAQUE Liste VIA PYTHON !
		r = r .. st_print(fdpt, col, '-i') ..'\n'
	end
	return r
end

function p.nombre_de_facultes() --Affiche le nombre de facultés
	local n_fac = t_prop.racine
	return n_fac
end

return p