Module:EUPP seats

1. ^ "European People's Party". Authority for European Political Parties and European Political Foundations. Retrieved 4 November 2024.

 require ('strict');
 local get_args = require ('Module:Arguments').getArgs;							-- function to fetch frame and parent frame arguments
 local cfg = mw.loadData ('Module:EUPP seats/config');							-- defines, configuration data, and i18n support
 local namespace = mw.title.getCurrentTitle().namespace;							-- used for categorization


 --[[--------------------------< S U B S T I T U T E >----------------------------------------------------------

 Substitutes 1,ドル 2,ドル etc in <message> with data from <data_t>. Returns plain-text substituted string when
 <data_t> not nil; returns <message> else.

 ]]

 local function substitute (message, data_t)
	return data_t and mw.message.newRawMessage (message, data_t):plain() or message;
 end


 --[[--------------------------< M A K E _ E R R O R _ M S G >--------------------------------------------------

 Assembles an error message from template name, message text, help link, and error category.

 ]]

 local function make_error_msg (msg, template_name, nocat)
	local category;

	local category_link = ((0 == namespace) and not nocat) and substitute ('[[Category:1ドル]]', {cfg.settings_t.err_category}) or '';
	return substitute ('<span style="color:#d33">Error: {{1ドル}}: 2ドル ([[:Template:1ドル|3ドル]])</span>4ドル',
		{
		template_name or cfg.settings_t.template_name,							-- the template name without namespace
		msg,																	-- the error message
		cfg.settings_t.help,													-- help wikilink display text
		category_link															-- link to error category (main namespace only)
		})
 end
	

 --[[--------------------------< R O U N D >--------------------------------------------------------------------

 return the rounded value of the arguments with two digits

 ]]

 local function round (n)
 return math.floor(100 * n + 0.5) / 100										-- round argument to two decimals
 end


 --[[--------------------------< S U M >------------------------------------------------------------------------

 return the sum of seats for all parties of <institution> listed in <cfg.parties_t> (so not including lower and upper houses). <body_prop> is the wikidata
 property:
 	P194: legislative body
 	P208: executive body

 <frame> required to expand {{wikidata}} template 

 Note: P1410 is the property "number of seats in assembly", used to record an entity's seats in legislative or executive bodies

 ]]

 local function sum (frame, institution, body_prop)
	local sum = 0;																-- init

	local args_t = {[1]='property', [3]='P1410'};								-- init some of the {{wikidata}} parameters
	args_t[body_prop] = cfg.institutions_t[institution];

	for _, qid in pairs (cfg.parties_t) do										-- loop through all parties in <cfg.parties_t>
		args_t[2] = qid;														-- set the last {{wikidata}} parameter
		sum = sum + frame:expandTemplate ({title='wikidata', args = args_t});	-- expand and tally
	end

	return sum;
 end


 --[[--------------------------< G E T _ C O L O U R >----------------------------------------------------------

 return the hex colour of a European party with '#' prefix

 <frame> required to expand {{wikidata}} template

 ]]

 local function get_colour (frame, party)
	local args_t = {'property'};												-- build an arguments table for expandTemplate()
	if party ~= "THISPARTY" then												-- when not on a party page
		if cfg.parties_t[party] then
			table.insert (args_t, cfg.parties_t[party]);						-- must name the party
		elseif cfg.alliances_t[party] then
			table.insert (args_t, cfg.alliances_t[party]);						-- must name the alliance
		end
	end
	table.insert (args_t, 'P465');												-- last argument is P465; sRGB color hex triplet property
	
	local color = frame:expandTemplate ({title='wikidata', args = args_t});		-- get the color
	if '' == color then															-- if no color
		color = 'BBB';															-- use a default color; some sort of gray
	end
	return '#' .. color;														-- add the '#' prefix
 end


 --[[--------------------------< G E T _ R E F >---------------------------------------------------------------

 return the reference for a seat claim relating to <institution> listed in <cfg.parties_t> or in <cfg.alliances_t> (so not including lower and upper houses)

 <frame> required to expand {{wikidata}} template

 ]]

 local function get_ref (frame, institution, party)
	if institution == 'EP' or institution == 'COR' then
		if party == "THISPARTY" then
			return frame:expandTemplate ({title='wikidata', args = {'references', 'P1410', P194 = cfg.institutions_t[institution]}});
		elseif cfg.parties_t[party] then
			return frame:expandTemplate ({title='wikidata', args = {'references', cfg.parties_t[party], 'P1410', P194 = cfg.institutions_t[institution]}});
		elseif cfg.alliances_t[party] then
			return frame:expandTemplate ({title='wikidata', args = {'references', cfg.alliances_t[party], 'P1410', P194 = cfg.institutions_t[institution]}});
		end
	elseif institution == 'EP' or institution == 'COR' then
		if party == "THISPARTY" then
			return frame:expandTemplate ({title='wikidata', args = {'references', 'P1410', P208 = cfg.institutions_t[institution]}});
		elseif parties_t[party] then
			return frame:expandTemplate ({title='wikidata', args = {'references', cfg.parties_t[party], 'P1410', P208 = cfg.institutions_t[institution]}});
		elseif alliances_t[party] then
			return frame:expandTemplate ({title='wikidata', args = {'references', cfg.alliances_t[party], 'P1410', P208 = cfg.institutions_t[institution]}});
		end
	end
 end
	

 --[[--------------------------< S I N G L E >------------------------------------------------------------------

 return the number of seats occupied by one party in an <institution> listed in <cfg.parties_t> or in <cfg.alliances_t> (so not including lower and upper houses). <body_prop> is the wikidata property:
 	P194: legislative body
 	P208: executive body

 <frame> required to expand {{wikidata}} template 

 Note: P1410 is the property "number of seats in assembly", used to record an entity's seats in legislative or executive bodies

 ]]

 local function single (frame, institution, party, body_prop)
	local args_t = {};	
	if party == "THISPARTY" then												-- flag used when module is called from the page of a European party; less expensive
		args_t = {'property', 'P1410'};											-- init some of the {{wikidata}} parameters with THISPARTY (only when called from the page of a European party)
	elseif cfg.alliances_t[party] then
		args_t = {'property', cfg.alliances_t[party], 'P1410'};					-- init some of the {{wikidata}} parameters
	else
		args_t = {'property', cfg.parties_t[party], 'P1410'};					-- init some of the {{wikidata}} parameters
	end
	args_t[body_prop] = cfg.institutions_t[institution];

	local retval = frame:expandTemplate ({title='wikidata', args = args_t})
	if '' == retval then														-- {{wikidata}} returns empty string when <party> not known to <institution>
		if party == "THISPARTY" then											-- specific error message if the module was called with THISPARTY from the wrong page
			return make_error_msg (cfg.error_messages_t.thisparty);
		elseif not party then
			return	make_error_msg (substitute (cfg.error_messages_t.party_req_share));
		else
			return make_error_msg (substitute (cfg.error_messages_t.inst_unknown_party, {institution, party}));
		end
	end
	return retval;
 end


 --[[--------------------------< S H A R E _ F C >--------------------------------------------------------------

 return the share of a party's seats relative to the total size of a given institution listed in <cfg.parties_t> or <cfg.alliances_t> (so not including lower and upper houses)

 <frame> required to expand {{wikidata}} template 

 Note: P1342 is the property "number of seats", used to record an institution's number of seats

 ]]

 local function share_fc (frame, party_seats, institution)
	return tonumber (party_seats) and round (100 * party_seats / frame:expandTemplate ({title='wikidata', args = {'property', cfg.institutions_t[institution], 'P1342'}})) or party_seats;
 end


 --[[--------------------------< S E A T S >--------------------------------------------------------------------

 return a number of seats either for an institution or occupied by one or more parties, or by none of them, in an <institution> listed in <cfg.parties_t> or <cfg.alliances_t> (so not including lower and upper houses).

 <frame> required to expand {{wikidata}} template 

 Note: 
 * P1410 is the property "number of seats in assembly", used to record an entity's seats in legislative or executive bodies
 * P1342 is the property "number of seats", used to record an institution's number of seats
 * P208 is the property "executive body"
 * P194 is the property "legislative body"

 ]]

 local function seats (frame, institution, party)
	if not party then															-- party not specified, returns seats of the institution
		return frame:expandTemplate ({title='wikidata', args = {'property', cfg.institutions_t[institution], 'P1342'}});

	elseif party == "IND" and institution == "EUCO" then						-- special case of independent politicians on European Council
		return frame:expandTemplate ({title='wikidata', args = {'property', cfg.misc_parties_t['IND'], 'P1410', P208 = cfg.institutions_t[institution]}});

	elseif party == "NONE" then													-- returns seats not occupied by European parties
		local retval = frame:expandTemplate ({title='wikidata', args = {'property', cfg.institutions_t[institution], 'P1342'}});	-- get number of seats in the institution

		if institution == "EUCO" then											-- if EUCO, use P208 and separate case to account for independent politicians
			local ind = frame:expandTemplate ({title='wikidata', args = {'property', cfg.misc_parties_t['IND'], 'P1410', P208 = cfg.institutions_t[institution]}});
			return retval - (sum (frame, institution, cfg.body_prop_t[institution]) + ind);

		else																	-- COR, EC, EP
			return retval - sum (frame, institution, cfg.body_prop_t[institution]);
		end

	elseif party == "ALL" then													-- returns seats occupied by all European parties combined
		return sum (frame, institution, cfg.body_prop_t[institution]);

	else																		-- returns the number of seats occupied by one party in one institution
		return single (frame, institution, party, cfg.body_prop_t[institution]);
	end
 end


 --[[--------------------------< S E A T S _ S H A R E >--------------------------------------------------------

 return a share of seats occupied by one or more parties, or by none of them, in an <institution> listed in <cfg.parties_t> or <cfg.alliances_t> (so not including lower and upper houses).

 <frame> required to expand {{wikidata}} template 

 Note: 
 * P1410 is the property "number of seats in assembly", used to record an entity's seats in legislative or executive bodies
 * P1342 is the property "number of seats", used to record an institution's number of seats
 * P208 is the property "executive body"
 * P194 is the property "legislative body"

 ]]

 local function seats_share (frame, institution, party)
	if party == "IND" and institution == "EUCO" then							-- special case of independent politicians on European Council
		return share_fc (frame, frame:expandTemplate ({title='wikidata', args = {'property', cfg.misc_parties_t['IND'], 'P1410', P208 = cfg.institutions_t[institution]}}), institution);

	elseif party == "NONE" then													-- returns seats not occupied by European parties
		local retval = frame:expandTemplate ({title='wikidata', args = {'property', cfg.institutions_t[institution], 'P1342'}});

		if institution == "EUCO" then											-- if EUCO, use P208 and separate case to account for independent politicians
			local ind = frame:expandTemplate ({title='wikidata', args = {'property', cfg.misc_parties_t['IND'], 'P1410', P208 = cfg.institutions_t[institution]}})
			return share_fc (frame, retval - (sum (frame, institution, cfg.body_prop_t[institution]) + ind), institution);

		else																	-- for COR, EC, EP
			return share_fc (frame, retval - sum (frame, institution, cfg.body_prop_t[institution]), institution);
		end

	elseif party == "ALL" then													-- returns seats occupied by all European parties combined
		return share_fc (frame, sum (frame, institution, cfg.body_prop_t[institution]), institution);

	else																		-- returns the number of seats occupied by one party in one institution
		return share_fc (frame, single (frame, institution, party, cfg.body_prop_t[institution]), institution);
	end
 end


 --[[--------------------------< V A L I D A T E _ W I D T H >--------------------------------------------------

 validates data format for width parameter (for composition bar()); returns boolean true when valid; nil else

 ]]

 local function validate_width (width)
	local patterns_t = {'^%d+$', '^%d+px$', '^%d+%%$', '^%d+em$'};				-- valid <width> patterns
	for i, pattern in ipairs (patterns_t) do									-- loop through the patterns in <patterns_t>
		if width:match (pattern) then											-- is there a match?
			return true;														-- yes, done
		end
	end
 end


 --[[--------------------------< V A L I D A T E _ I N S T I T U T I O N _ P A R T Y >--------------------------

 validates data format for institution and party parameters, for main() and compositionbar() for institutions listed in <cfg.parties_t> or <cfg.alliances_t> (so not including lower and upper houses)

 returns boolean true when valid; error message else

 ]]

 local function validate_institution_party (institution, party, template_name)
	if not institution then														-- institution is required
		return make_error_msg (cfg.error_messages_t.missing_inst, template_name);
	elseif not cfg.institutions_t[institution] then
		return make_error_msg (substitute (cfg.error_messages_t.unknown_inst, {institution}), template_name);	-- if institution is present, it must be known
	end
	
	if party == "%" or party == "SHARE" then									-- if party is missing and %/share is entered instead
		return make_error_msg (cfg.error_messages_t.party_req_share, template_name);
	end
	
	if party and not cfg.parties_t[party] and not cfg.alliances_t[party] and not cfg.misc_parties_t[party] and not cfg.keywords_t[party] then	-- party is optional; but if party is present, it must be known
		return make_error_msg (substitute (cfg.error_messages_t.unknown_party, {party}), template_name);
	end

	if 'THISPARTY' == party then												-- 'THISPARTY' parameter only to be used by templates on European party articles
		local frame = mw.getCurrentFrame();										-- we need a copy of the frame for this test
		if '' == frame:expandTemplate ({title='wikidata', args = {'property', 'P1410', cfg.institutions_t[institution]}}) then	-- empty string when this article not an EU party article
			return make_error_msg (cfg.error_messages_t.thisparty , template_name);
		end
	end

	return true;
 end


 --[[--------------------------< S T R I P _ H O U S E _ T Y P E >----------------------------------------------

 strips down parts of the house type (for calls relating to lower and upper houses)

 ]]

 local function strip_house_type (house_type)
	if house_type == "LOWER-HOUSE" or house_type == "LOWER" or house_type == "MS-LOWER-HOUSE"then	-- three accepted formats for input
		return "LOWER-HOUSE";													-- format actually used in the code
	elseif house_type == "UPPER-HOUSE" or house_type == "UPPER" or house_type == "MS-UPPER-HOUSE" then		-- three accepted formats for input
		return "UPPER-HOUSE";													-- format actually used in the code
	else
		return house_type;
	end
 end


 --[[--------------------------< V A L I D A T E _ P A R T Y _ H O U S E _ T Y P E >----------------------------

 validates data format for party name (for main() and compositionbar() for calls relating to lower and upper houses).

 returns boolean true when valid; error message else

 ]]

 local function validate_party_house_type (house_type, european_party, template_name)
	if european_party and not cfg.parties_t[european_party] and not cfg.alliances_t[european_party] and not cfg.keywords_lower_upper_t[european_party] then	-- party is optional; but if party is present, it must be known
		return make_error_msg (substitute (cfg.error_messages_t.unknown_party, {european_party}), template_name);
	end
	
	if 'THISPARTY' == european_party then										-- 'THISPARTY' parameter only to be used by templates on European party articles
		local this_page_qid = mw.wikibase.getEntityIdForCurrentPage();			-- looking up qID of the page from which the call is made
		if cfg.rev_parties_t[this_page_qid] then
			return true;														-- true if the <this_page_qid> matches a European party in the config file
		end

		return make_error_msg (cfg.error_messages_t.thisparty , template_name);
	end
	
	return true;
 end


 --[[--------------------------< G E T _ H O U S E _ S E A T S >------------------------------------------------

 returns the number of seats in a given lower or upper house (identified by a row in the master table) from
 wikidata. When <house_type> not recognized or when <ms_data_t> does not have 'that' house, returns 0

 ]]

 local function get_house_seats (frame, row, house_type)
	local house_qid;

	if house_type == "LOWER-HOUSE" then
		house_qid = cfg.ms_data_t[row].lower_house_qid;							-- get the lower house qid
	elseif house_type == "UPPER-HOUSE" then
		house_qid = cfg.ms_data_t[row].upper_house_qid;							-- get the upper house qid
	end

	return house_qid and frame:expandTemplate ({title='wikidata', args = {'property', house_qid, 'P1342'}}) or 0;	-- house_qid is nil when no upper or lower house 
 end


 --[[--------------------------< S U M _ H O U S E _ S E A T S >------------------------------------------------

 returns the total number of seats of all lower or upper houses in all member states.

 ]]

 local function sum_house_seats (frame, house_type)
	local sum_seats = 0;														-- init sum of seats of European party's member parties in house_type

	for row, _ in ipairs (cfg.ms_data_t) do										-- for all member states
		sum_seats = sum_seats + get_house_seats (frame, row, house_type);		-- increase sum_seats
	end

	return sum_seats;
 end


 --[[--------------------------< G E T _ N A T I O N A L _ P A R T Y _ S E A T S >------------------------------

 returns the number of seats occupied by a given party (identified by a given row in the master table) in the
 lower or upper house of its member state from wikidata. When <house_type> not recognized or when <tab_data_t>
 does not have 'that' house, returns 0

 ]]

 local function get_national_party_seats (frame, row, house_type)
	local house_qid = "";
	local national_party_qid = cfg.tab_data_t[row].national_party_qid;

	if house_type == "LOWER-HOUSE" then
		house_qid = cfg.tab_data_t[row].lower_house_qid;
	elseif house_type == "UPPER-HOUSE" then
		house_qid = cfg.tab_data_t[row].upper_house_qid;
	end
	
	return house_qid and frame:expandTemplate ({title='wikidata', args = {'property', national_party_qid, 'P1410', P194 = house_qid}}) or 0;
 end


 --[[--------------------------< S U M _ N A T I O N A L _ P A R T Y _ S E A T S >------------------------------

 returns the sum of seats occupied by all national parties members of a given European party in the lower or upper house of its member state.

 ]]

 local function sum_national_party_seats (frame, european_party, house_type)
	local sum_seats = 0;														-- init sum of seats of European party's member parties in house_type

	if not european_party then													-- if no European party is listed, then returns the total number of seats of all lower or upper houses
		sum_seats = sum_house_seats(frame, house_type);
	else	
		for row, _ in ipairs (cfg.tab_data_t) do
			if european_party == "ALL" then										-- sum for all rows
				sum_seats = sum_seats + get_national_party_seats (frame, row, house_type);		-- increase sum_seats
			elseif european_party == "THISPARTY" then							-- if called from the page of a European party
				local thisparty_qid = mw.wikibase.getEntityIdForCurrentPage();	-- get party qiD
				local thisparty_name = cfg.rev_parties_t[thisparty_qid];

				if thisparty_name == cfg.tab_data_t[row]['european_party'] then
					sum_seats = sum_seats + get_national_party_seats (frame, row, house_type);		-- increase sum_seats
				end
			else
				if european_party == cfg.tab_data_t[row]['european_party'] then
					sum_seats = sum_seats + get_national_party_seats (frame, row, house_type);		-- increase sum_seats
				end
			end
		end
 end

	return sum_seats;
 end


 --[[--------------------------< M A I N >----------------------------------------------------------------------

 implements {{EUPP seats}}

 carries out input error detection, reporting, and function dispatching

 ]]

 local function main (frame)
	local args_t = get_args (frame);											-- get arguments; empty string or whitespace positional parameters set to nil

	local institution = args_t[1] and args_t[1]:upper();						-- force to upper case
	local party = args_t[2] and args_t[2]:upper();
	local share = args_t[3] and args_t[3]:upper();
	
 --[=[ harmonise institution name (in case of lower/upper house) ]=]	

	institution = strip_house_type (institution);								-- "ms-lower-house" and "lower" are turned to "lower-house" (same for upper house)
	
 --[=[ data validation for institution and party ]=]	
	local is_valid = false;
	
	if institution == "LOWER-HOUSE" or institution == "UPPER-HOUSE" then
		is_valid = validate_party_house_type (institution, party, 'EU party seats lower upper houses');
	else
		is_valid = validate_institution_party (institution, party, 'EUPP seats');

	end
	
	if true ~= is_valid then													-- boolean true when valid; error message else
		return is_valid;														-- yep, abandon with error message
	end

 --[=[ function dispatching ]=]	

	if institution == "LOWER-HOUSE" or institution == "UPPER-HOUSE" then
		if not share then			
			return sum_national_party_seats (frame, party, institution)			-- return number of seats by calling sum_national_party_seats()
		elseif share == "%" or share == "SHARE" then
			return round (100 * sum_national_party_seats (frame, party, institution) / sum_house_seats (frame, institution));	-- return share of seats by calling seats_share()
		else 
			return make_error_msg (substitute (cfg.error_messages_t.unknown_param, {share}));
		end	
	else	
		if not share then			
			return seats (frame, institution, party);							-- return number of seats by calling seats()
	
		elseif share == "%" or share == "SHARE" then
			return seats_share (frame, institution, party);						-- return share of seats by calling seats_share()
		else 
			return make_error_msg (substitute (cfg.error_messages_t.unknown_param, {share}));
		end
	end
 end


 --[[--------------------------< C O M P O S I T I O N _ B A R >------------------------------------------------

 this function does whatever it is that {{composition bar}} does

 implements {{EUPP composition bar}}

 	{{EUPP composition bar|<institution>|<party>|width=<width>|percent=yes|reference=yes|bar-color=<color>|background-color=<color>|border=<color>}}

 ]]

 local function composition_bar (frame)
	local args_t = get_args (frame);											-- get arguments; empty string or whitespace positional parameters set to nil

	local institution = args_t[1] and args_t[1]:upper();						-- force to upper case
	local party = args_t[2] and args_t[2]:upper();
	local width = args_t.width;													-- must be a number, or number with unit suffix: 'px', '%', 'em'; whitespace not allowed
	local percentage = args_t.percent and args_t.percent:lower();											-- 
	percentage = 'yes' == percentage;											-- make a boolean
	local reference = args_t.reference and args_t.reference:lower();			
	reference = 'yes' == reference;												-- make a boolean
	
	local background_color = args_t['background-color'];
	local border = args_t.border;
	
 --[=[ harmonise institution name (in case of lower/upper house) ]=]	

	institution = strip_house_type (institution);								-- "ms-lower-house" and "lower" are turned to "lower-house" (same for upper house)
	
 --[=[ data validation for institution, party and width ]=]	
	local is_valid = false;
	
	if institution == "LOWER-HOUSE" or institution == "UPPER-HOUSE" then
		is_valid = validate_party_house_type (institution, party, 'EU party seats lower upper houses');
	else
		is_valid = validate_institution_party (institution, party, 'EUPP composition bar');
	end
	
	if true ~= is_valid then													-- boolean true when valid; error message else
		return is_valid;														-- yep, abandon with error message
	end
	
	if width and not validate_width (width) then
		return make_error_msg (substitute (cfg.error_messages_t.parameter_invalid, {width}), 'EUPP composition bar');	-- yep, abandon with error message
	end

 --[=[ prepare arguments for composition bar ]=]	

	if institution == "LOWER-HOUSE" or institution == "UPPER-HOUSE" then
		local sum_house_seats = sum_house_seats(frame, institution);			-- get total seats of lower or upper houses
		local sum_national_party_seats = sum_national_party_seats(frame, party, institution)		-- get sum of seats occupied by members of a European party
		local color = args_t['bar-color'] or get_colour (frame, party);			-- get color associated with <party>; |bar-color= overrides wikidata
	
		local comp_bar_args_t = {
			sum_national_party_seats,
			sum_house_seats, 
			color,
			width=width,
			per=percentage,
			['background-color'] = background_color,
			border = border,
		}
	
		return frame:expandTemplate ({title='Composition bar', args = comp_bar_args_t});
	else
		local inst_seats = seats (frame, institution);							-- get total seats in <institution>
		local party_seats = seats (frame, institution, party);					-- get total seats in <institution> occupied by <party>
		local color = args_t['bar-color'] or get_colour (frame, party);			-- get color associated with <party>; |bar-color= overrides wikidata
	
		local comp_bar_args_t = {
			party_seats,
			inst_seats, 
			color,
			width=width,
			per=percentage,
			['background-color'] = background_color,
			border = border,
		}
	
		return frame:expandTemplate ({title='Composition bar', args = comp_bar_args_t}) .. ((reference and get_ref (frame, institution, party)) or '');
	end
 end


 --[[--------------------------< T E S T >----------------------------------------------------------------------
 ]]

 local function test (frame)														-- to test calls and functions, for verification purposes
	local args_t = get_args (frame);											-- get arguments; empty string or whitespace positional parameters set to nil

	local institution = args_t[1] and args_t[1]:upper();						-- force to upper case
	local party = args_t[2] and args_t[2]:upper();
	local share = args_t[3] and args_t[3]:upper();

	institution = strip_house_type (institution);								-- here, testing strip_house_type
	return institution;
 end


 --[[--------------------------< E X P O R T S >----------------------------------------------------------------
 ]]

 return {
	main = main,
	composition_bar = composition_bar,
	test = test,
	}