def test_loc_objloc(self): loc = Template('Object location') loc.add(1, "one") set_location(self.tree, None) set_object_location(self.tree, loc) # Might be better without the spurious newline, but this will do. self.assertEqual( str(self.tree), """ == {{int:filedesc}} == {{Information |description={{en|1=Street Waste Bin Waste bin on the street outside Crosby and Blundellsands Station}} |date=2010-04-11 |source=From [http://www.geograph.org.uk/photo/1801330 geograph.org.uk] |author=[http://www.geograph.org.uk/profile/46411 Paul Glover] |permission= |other_versions= }} {{Object location|one}} == {{int:license-header}} == {{Geograph|1801330|Paul Glover}} [[Category:Streets in Sefton]] [[Category:Geograph images in Merseyside]] """)
def backup_template(self, template: Template, page: Union[str, Page], key: Union[str, List[str]]): """ Backs up a template in the `Backup` namespace. The template can later be restored with `get_restored_template`. :param template: Template object :param page: Page or title where the template is located on :param key: Identifying set of params that we can use to locate the template when we restore it :return: null """ if isinstance(page, str): page = self.client.pages[page] if isinstance(key, str): key = [key] key_template = Template('BackupKey') for key_param in key: key_template.add(key_param, template.get(key_param, Parameter('', '')).value) # this method will be used in TemplateModifier so it is essential that # we do not modify the original copy_template = copy.deepcopy(template) copy_template.add('backup_key', str(key_template)) self.client.pages['Backup:' + page.name].append('\n' + str(copy_template), contentmodel='text')
def test_objloc(self): loc = Template('Object location') loc.add(1, "one") set_object_location(self.tree, loc) self.assertEqual( str(self.tree), "{{Information}}\n{{location dec}}\n{{Object location|one}}")
def format(self, citation: Citation): tname = CiteTemplate.TEMPLATE_FALLBACK.get( citation.type, CiteTemplate.TEMPLATE_FALLBACK['default']) template = Template(tname) for fragment in CiteTemplate.ORDER: func = getattr(self, '_fragment_' + fragment, None) if func: func(template, citation) elif fragment in citation: template.add(fragment, str(citation[fragment])) return str(template)
def to_mediawiki_template(self, maccabi_games: MaccabiGamesStats) -> str: tag_paper_template = Template(f'{_PAPER_TAG_TEMPLATE_NAME}\n') tag_paper_template.add(_PAPER_NAME_PARAM_NAME, f'{self.paper_name}\n') if self.paper_publish_date is not None: tag_paper_template.add( _PAPER_PUBLISH_DATE_PARAM_NAME, f'{self.paper_publish_date.strftime("%d-%m-%Y")}\n') if math.fabs((self.paper_publish_date - self.paper_related_game_date).days) > 7: raise RuntimeError( f'There is more than a week between the publish and the game date, is it an error?' ) potential_games = maccabi_games.played_at(self.paper_related_game_date) if len(potential_games) != 1: raise RuntimeError( f'Could not match exactly one game for date: {self.paper_related_game_date}, ' f'found these games: {potential_games}') game_page_name = _generate_page_name_from_game(potential_games[0]) tag_paper_template.add(_PAPER_RELATED_GAME_PARAM_NAME, f'{game_page_name}') return str(tag_paper_template)
def format(self, citation: Citation): tname = CiteTemplate.TEMPLATE_FALLBACK.get( citation.type, CiteTemplate.TEMPLATE_FALLBACK['default'] ) template = Template(tname) for fragment in CiteTemplate.ORDER: func = getattr(self, '_fragment_' + fragment, None) if func: func(template, citation) elif fragment in citation: template.add(fragment, str(citation[fragment])) return str(template)
def combine_template_chains(wc: Wikicode, new_template_name: str, template_indices: List[int], text_indices: List[int]) -> None: """ Helper function for combining templates that are linked via free text into a structured template hierarchy. """ index_combos = [] index_combo = [] combine = False for i in template_indices: if (i + 1 in text_indices) or (i - 2 in index_combo and combine): index_combo.append(i) combine = i + 1 in text_indices if not combine: if len(index_combo) > 1: index_combos.append(index_combo) index_combo = [] if len(index_combo) > 1: index_combos.append(index_combo) combo_nodes = [[wc.nodes[i] for i in chain] for chain in index_combos] for combo in combo_nodes: params = [ Parameter(str(i + 1), t, showkey=False) for i, t in enumerate(combo) ] new_template = Template(new_template_name, params=params) wc.insert_before(combo[0], new_template, recursive=False) for node in combo: wc.remove(node, recursive=False)
def merge_etyl_templates(wc: Wikicode) -> Wikicode: """ Given a chunk of wikicode, finds instances where the deprecated `etyl` template is immediately followed by either a word in free text, a linked word, or a generic `mention`/`link`/`langname-mention` template. It replaces this pattern with a new `derived-parsed` template -- meaning the same thing as the `derived` template but namespaced to differentiate. For cases where the `mention` language is different from the `etyl` language, we use the former. The template is removed if we can't parse it effectively. """ etyl_indices = [ i for i, node in enumerate(wc.nodes) if isinstance(node, Template) and node.name == "etyl" and i < len(wc.nodes) - 1 ] nodes_to_remove = [] for i in etyl_indices: make_new_template = False etyl: Template = wc.nodes[i] related_language = etyl.params[0] if len(etyl.params) == 1: language = "en" else: language = etyl.params[1] node = wc.nodes[i + 1] if isinstance(node, Text): val = re.split(",| |", node.value.strip())[0] if val: make_new_template = True elif isinstance(node, Wikilink): val = node.text or node.title val = re.split(",| |", val.strip())[0] if val: make_new_template = True elif isinstance(node, Template): if node.name in ("m", "mention", "m+", "langname-mention", "l", "link"): related_language = node.params[0] if len(node.params) > 1: val = node.params[1].value make_new_template = True nodes_to_remove.append(node) if make_new_template: params = [ Parameter(str(i + 1), str(param), showkey=False) for i, param in enumerate([language, related_language, val]) ] new_template = Template("derived-parsed", params=params) wc.replace(etyl, new_template, recursive=False) else: nodes_to_remove.append(etyl) for node in nodes_to_remove: wc.remove(node, recursive=False) return wc
def get_restored_template( self, template: Template, page: Union[str, Page], key: Union[str, List[str]]) -> Optional[Template]: """ Looks for the backed-up version of the specified template on the backup page & returns it The template should have been backed up using the backup_template method earlier. :param template: Template object that we want to restore from backup page :param page: Page or title where the template is located on :param key: Identifying set of params to use to restore the template from :return: Template object, if found, else None """ if isinstance(page, str): page = self.client.pages[page] if isinstance(key, str): key = [key] backup_text = self.client.pages['Backup:' + page.name].text() for backup_template in mwparserfromhell.parse( backup_text).filter_templates(): if not backup_template.name.matches(template.name): continue # kinda need to do a hack to get this as a template backup_key_str = str(backup_template.get('backup_key').value) backup_key_wikitext = mwparserfromhell.parse(backup_key_str) backup_key = None for tl in backup_key_wikitext.filter_templates(): if tl.name.matches('BackupKey'): backup_key = tl break # now backup_key is a template value of BackupKey is_match = True i = 0 for param in backup_key.params: name = param.name.strip() if name in key: if param.value.strip() == template.get( name, Parameter('', '')).value.strip(): i += 1 else: is_match = False if i == len(key) and is_match: return backup_template return None
def update_plaintext(self): print('starting page ' + self.current_page.name) chromas = [] price = '' release = '' template_list = self.current_wikitext.filter_templates() for infobox in template_list: infobox: Template if infobox.name.matches('ChromaSet'): self.current_wikitext.remove(infobox) self.current_text = str(self.current_wikitext) self.current_text = self.current_text.replace('== Chromas ==', '') if not infobox.name.matches('Infobox Skin'): continue if not infobox.has('chroma'): return if infobox.has('chroma_rp'): price = infobox.get('chroma_rp').value.strip() if infobox.has('chroma_date'): release = infobox.get('chroma_date').value.strip() param = infobox.get('chroma').value for tl in param.filter_templates(): if not tl.name.matches('ChromaBox'): continue i = 1 while tl.has('chroma' + str(i)): s = str(i) new_chroma = Template('ChromaSet/Line') add_param(new_chroma, tl, s, '') add_param(new_chroma, tl, s, 'hex1') add_param(new_chroma, tl, s, 'hex2') add_param(new_chroma, tl, s, 'name') add_param(new_chroma, tl, s, 'rp') add_special_param(new_chroma, tl, s) chromas.append(str(new_chroma)) i += 1 chroma_section = ['== Chromas ==', '{{{{ChromaSet|price={}|release={}'.format(price, release)] for chroma in chromas: chroma_section.append('|' + chroma) chroma_section.append('}}') self.current_text = self.current_text.replace( '{{ChampionSkinImageSections}}', '\n'.join(chroma_section) + '\n' + '{{ChampionSkinImageSections}}' ) self.current_text = self.current_text.replace('\n\n\n', '\n') self.current_text = self.current_text.replace('\n\n', '\n')
def location_from_grid(grid, e, n, digits, view_direction, use6fig, mapit=None): latstr, lonstr, prec = latlon_from_grid(grid, e, n, digits, use6fig) precstr = "{:g}".format(prec) paramstr = "source:" + source_from_grid(grid, e, n, digits) region = region_of(grid, e, n, latstr, lonstr, mapit) if region != None: paramstr += "_region:{}".format(region) if view_direction != None: paramstr += "_heading:{}".format(view_direction) t = Template(mwparserfromhell.parse('Location')) t.add(1, latstr) t.add(2, lonstr) t.add(3, paramstr) t.add('prec', precstr) return t
def get_football_stadium_template_object(): return Template(stadium_template_name)
def __init__(self): self._template = Template(self.get_name()) self._parameters = [] self._parameters_map = {}
def get_football_player_template_object(): return Template(player_template_name)
def get_football_team_template_object(): return Template(team_template_name)
def test_loc(self): loc = Template('Location') loc.add(1, "one") set_location(self.tree, loc) self.assertEqual(str(self.tree), "{{Location|one}}\n{{object location}}")
def get_football_games_template_object(): return Template(football_games_template_name)
def get_football_referee_template_object(): return Template(referee_template_name)