def test_integration2(self): """an even more audacious test for building a horrible wikicode mess""" # {{a|b|{{c|[[d]]{{{e}}}}}}}[[f|{{{g}}}<!--h-->]]{{i|j= }} test = [tokens.TemplateOpen(), tokens.Text(text="a"), tokens.TemplateParamSeparator(), tokens.Text(text="b"), tokens.TemplateParamSeparator(), tokens.TemplateOpen(), tokens.Text(text="c"), tokens.TemplateParamSeparator(), tokens.WikilinkOpen(), tokens.Text(text="d"), tokens.WikilinkClose(), tokens.ArgumentOpen(), tokens.Text(text="e"), tokens.ArgumentClose(), tokens.TemplateClose(), tokens.TemplateClose(), tokens.WikilinkOpen(), tokens.Text(text="f"), tokens.WikilinkSeparator(), tokens.ArgumentOpen(), tokens.Text(text="g"), tokens.ArgumentClose(), tokens.CommentStart(), tokens.Text(text="h"), tokens.CommentEnd(), tokens.WikilinkClose(), tokens.TemplateOpen(), tokens.Text(text="i"), tokens.TemplateParamSeparator(), tokens.Text(text="j"), tokens.TemplateParamEquals(), tokens.HTMLEntityStart(), tokens.Text(text="nbsp"), tokens.HTMLEntityEnd(), tokens.TemplateClose()] valid = wrap( [Template(wraptext("a"), params=[Parameter(wraptext("1"), wraptext( "b"), showkey=False), Parameter(wraptext("2"), wrap([Template( wraptext("c"), params=[Parameter(wraptext("1"), wrap([Wikilink( wraptext("d")), Argument(wraptext("e"))]), showkey=False)])]), showkey=False)]), Wikilink(wraptext("f"), wrap([Argument(wraptext( "g")), Comment("h")])), Template(wraptext("i"), params=[ Parameter(wraptext("j"), wrap([HTMLEntity("nbsp", named=True)]))])]) self.assertWikicodeEqual(valid, self.builder.build(test))
def test_params(self): """test getter for the params attribute""" node1 = Template(wraptext("foobar")) plist = [pgenh("1", "bar"), pgens("abc", "def")] node2 = Template(wraptext("foo"), plist) self.assertEqual([], node1.params) self.assertIs(plist, node2.params)
def test_unicode(self): """test Template.__unicode__()""" node = Template(wraptext("foobar")) self.assertEqual("{{foobar}}", str(node)) node2 = Template(wraptext("foo"), [pgenh("1", "bar"), pgens("abc", "def")]) self.assertEqual("{{foo|bar|abc=def}}", str(node2))
def test_strip(self): """test Template.__strip__()""" node1 = Template(wraptext("foobar")) node2 = Template(wraptext("foo"), [pgenh("1", "bar"), pgens("abc", "def")]) for a in (True, False): for b in (True, False): self.assertEqual(None, node1.__strip__(a, b)) self.assertEqual(None, node2.__strip__(a, b))
def test_name(self): """test getter/setter for the name attribute""" name = wraptext("foobar") node1 = Template(name) node2 = Template(name, [pgenh("1", "bar")]) self.assertIs(name, node1.name) self.assertIs(name, node2.name) node1.name = "asdf" node2.name = "téstïng" self.assertWikicodeEqual(wraptext("asdf"), node1.name) self.assertWikicodeEqual(wraptext("téstïng"), node2.name)
def test_nodes(self): """test getter/setter for the nodes attribute""" code = parse("Have a {{template}}") self.assertEqual(["Have a ", "{{template}}"], code.nodes) L1 = SmartList([Text("foobar"), Template(wraptext("abc"))]) L2 = [Text("barfoo"), Template(wraptext("cba"))] L3 = "abc{{def}}" code.nodes = L1 self.assertIs(L1, code.nodes) code.nodes = L2 self.assertIs(L2, code.nodes) code.nodes = L3 self.assertEqual(["abc", "{{def}}"], code.nodes) self.assertRaises(ValueError, setattr, code, "nodes", object)
def test_parse_anything_valid(self): """tests for valid input to utils.parse_anything()""" tests = [ (wraptext("foobar"), wraptext("foobar")), (Template(wraptext("spam")), wrap([Template(wraptext("spam"))])), ("fóóbar", wraptext("fóóbar")), (b"foob\xc3\xa1r", wraptext("foobár")), (123, wraptext("123")), (True, wraptext("True")), (None, wrap([])), ([Text("foo"), Text("bar"), Text("baz")], wraptext("foo", "bar", "baz")), ([wraptext("foo"), Text("bar"), "baz", 123, 456], wraptext("foo", "bar", "baz", "123", "456")), ([[[([[((("foo", ), ), )], "bar"], )]]], wraptext("foo", "bar")) ] for test, valid in tests: self.assertWikicodeEqual(valid, parse_anything(test))
def test_add(self): """test Tag.add()""" node = Tag(wraptext("ref"), wraptext("cite")) node.add("name", "value") node.add("name", "value", quotes=None) node.add("name", "value", quotes="'") node.add("name") node.add(1, False) node.add("style", "{{foobar}}") node.add("name", "value", '"', "\n", " ", " ") attr1 = ' name="value"' attr2 = " name=value" attr3 = " name='value'" attr4 = " name" attr5 = ' 1="False"' attr6 = ' style="{{foobar}}"' attr7 = '\nname = "value"' self.assertEqual(attr1, node.attributes[0]) self.assertEqual(attr2, node.attributes[1]) self.assertEqual(attr3, node.attributes[2]) self.assertEqual(attr4, node.attributes[3]) self.assertEqual(attr5, node.attributes[4]) self.assertEqual(attr6, node.attributes[5]) self.assertEqual(attr7, node.attributes[6]) self.assertEqual(attr7, node.get("name")) self.assertWikicodeEqual(wrap([Template(wraptext("foobar"))]), node.attributes[5].value) self.assertEqual( "".join(("<ref", attr1, attr2, attr3, attr4, attr5, attr6, attr7, ">cite</ref>")), node) self.assertRaises(ValueError, node.add, "name", "foo", quotes="bar") self.assertRaises(ValueError, node.add, "name", "a bc d", quotes=None)
def add_old_cfd( page: pywikibot.Page, cfd_page: CfdPage, action: str, result: str, summary: str, ) -> None: """Add {{Old CfD}} to the talk page.""" date = cfd_page.title(with_section=False).rpartition('/')[2] if page.exists(): wikicode = mwparserfromhell.parse(page.text, skip_style_tags=True) for tpl in wikicode.ifilter_templates(): try: template = pywikibot.Page(page.site, str(tpl.name), ns=10) if template not in TPL['old cfd'] or not tpl.has( 'date', ignore_empty=True): continue except pywikibot.InvalidTitle: continue if tpl.get('date').value.strip() == date: # Template already present. return old_cfd = Template('Old CfD') old_cfd.add('action', action) old_cfd.add('date', date) old_cfd.add('section', cfd_page.section()) old_cfd.add('result', result) page.text = str(old_cfd) + '\n' + page.text page.save(summary=summary)
def test_name(self): """test getter/setter for the name attribute""" name = wraptext("id") node = Attribute(name, wraptext("bar")) self.assertIs(name, node.name) node.name = "{{id}}" self.assertWikicodeEqual(wrap([Template(wraptext("id"))]), node.name)
def test_add(self): """test Tag.add()""" node = Tag(wraptext("ref"), wraptext("cite")) node.add("name", "value") node.add("name", "value", quoted=False) node.add("name") node.add(1, False) node.add("style", "{{foobar}}") node.add("name", "value", True, "\n", " ", " ") attr1 = ' name="value"' attr2 = " name=value" attr3 = " name" attr4 = ' 1="False"' attr5 = ' style="{{foobar}}"' attr6 = '\nname = "value"' self.assertEqual(attr1, node.attributes[0]) self.assertEqual(attr2, node.attributes[1]) self.assertEqual(attr3, node.attributes[2]) self.assertEqual(attr4, node.attributes[3]) self.assertEqual(attr5, node.attributes[4]) self.assertEqual(attr6, node.attributes[5]) self.assertEqual(attr6, node.get("name")) self.assertWikicodeEqual(wrap([Template(wraptext("foobar"))]), node.attributes[4].value) self.assertEqual( "".join(("<ref", attr1, attr2, attr3, attr4, attr5, attr6, ">cite</ref>")), node)
def create_wikitext(self, vals): wikitext = '' empty_pages = [] first_page = '' for ind, val in vals.items(): t_name, = val[1] if t_name != self.template_name: raise ValueError( f"Unexpected template name {t_name} instead of {self.template_name}" ) t_params = val[1][t_name] t_params2 = { k: t_params[k] for k in t_params if k not in self.ignore_params } if t_params: if not first_page: first_page = val[0] wikitext += f"* _INDEX_={ind}\n" wikitext += str( Template(t_name, params=[ Parameter(k, v) for k, v in t_params2.items() ])) wikitext += '\n' else: empty_pages.append( PageContent(title=val[0], timestamp=datetime.utcnow(), data={})) if wikitext: wikitext += f"* _INDEX_=END\n" return empty_pages, wikitext, first_page
def test_children(self): """test Template.__children__()""" node2p1 = Parameter(wraptext("1"), wraptext("bar"), showkey=False) node2p2 = Parameter(wraptext("abc"), wrap([Text("def"), Text("ghi")]), showkey=True) node1 = Template(wraptext("foobar")) node2 = Template(wraptext("foo"), [node2p1, node2p2]) gen1 = node1.__children__() gen2 = node2.__children__() self.assertEqual(node1.name, next(gen1)) self.assertEqual(node2.name, next(gen2)) self.assertEqual(node2.params[0].value, next(gen2)) self.assertEqual(node2.params[1].name, next(gen2)) self.assertEqual(node2.params[1].value, next(gen2)) self.assertRaises(StopIteration, next, gen1) self.assertRaises(StopIteration, next, gen2)
def creditline_from_row(row): t = Template(parse('Credit line\n ')) t.add("DUMMY ", " VALUE\n ") # to set the formatting t.add("Author", wikify(row['realname'])) t.add("Other", Tag('i', wikify(row['title']), wiki_markup="''")) t.add("License", "CC-BY-SA-2.0") t.remove("DUMMY") return t
def test_integration(self): """a test for building a combination of templates together""" # {{{{{{{{foo}}bar|baz=biz}}buzz}}usr|{{bin}}}} test = [ tokens.TemplateOpen(), tokens.TemplateOpen(), tokens.TemplateOpen(), tokens.TemplateOpen(), tokens.Text(text="foo"), tokens.TemplateClose(), tokens.Text(text="bar"), tokens.TemplateParamSeparator(), tokens.Text(text="baz"), tokens.TemplateParamEquals(), tokens.Text(text="biz"), tokens.TemplateClose(), tokens.Text(text="buzz"), tokens.TemplateClose(), tokens.Text(text="usr"), tokens.TemplateParamSeparator(), tokens.TemplateOpen(), tokens.Text(text="bin"), tokens.TemplateClose(), tokens.TemplateClose() ] valid = wrap([ Template(wrap([ Template( wrap([ Template(wrap([Template(wraptext("foo")), Text("bar")]), params=[ Parameter(wraptext("baz"), wraptext("biz")) ]), Text("buzz") ])), Text("usr") ]), params=[ Parameter(wraptext("1"), wrap([Template(wraptext("bin"))]), showkey=False) ]) ]) self.assertWikicodeEqual(valid, self.builder.build(test))
def test_showtree(self): """test Template.__showtree__()""" output = [] getter, marker = object(), object() get = lambda code: output.append((getter, code)) mark = lambda: output.append(marker) node1 = Template(wraptext("foobar")) node2 = Template(wraptext("foo"), [pgenh("1", "bar"), pgens("abc", "def")]) node1.__showtree__(output.append, get, mark) node2.__showtree__(output.append, get, mark) valid = [ "{{", (getter, node1.name), "}}", "{{", (getter, node2.name), " | ", marker, (getter, node2.params[0].name), " = ", marker, (getter, node2.params[0].value), " | ", marker, (getter, node2.params[1].name), " = ", marker, (getter, node2.params[1].value), "}}"] self.assertEqual(valid, output)
def test_value(self): """test getter/setter for the value attribute""" value = wraptext("foo") node = Attribute(wraptext("id"), value) self.assertIs(value, node.value) node.value = "{{bar}}" self.assertWikicodeEqual(wrap([Template(wraptext("bar"))]), node.value) node.value = None self.assertIs(None, node.value)
def test_closing_tag(self): """test getter/setter for the closing_tag attribute""" tag = wraptext("ref") node = Tag(tag, wraptext("foobar")) self.assertIs(tag, node.closing_tag) node.closing_tag = "ref {{ignore me}}" parsed = wrap([Text("ref "), Template(wraptext("ignore me"))]) self.assertWikicodeEqual(parsed, node.closing_tag) self.assertEqual("<ref>foobar</ref {{ignore me}}>", node)
def test_contents(self): """test getter/setter for the contents attribute""" contents = wraptext("text") node = Tag(wraptext("ref"), contents) self.assertIs(contents, node.contents) node.contents = "text and a {{template}}" parsed = wrap([Text("text and a "), Template(wraptext("template"))]) self.assertWikicodeEqual(parsed, node.contents) self.assertEqual("<ref>text and a {{template}}</ref>", node)
def test_get(self): """test Template.get()""" node1 = Template(wraptext("foobar")) node2p1 = pgenh("1", "bar") node2p2 = pgens("abc", "def") node2 = Template(wraptext("foo"), [node2p1, node2p2]) node3p1 = pgens("b", "c") node3p2 = pgens("1", "d") node3 = Template(wraptext("foo"), [pgenh("1", "a"), node3p1, node3p2]) node4p1 = pgens(" b", " ") node4 = Template(wraptext("foo"), [pgenh("1", "a"), node4p1]) self.assertRaises(ValueError, node1.get, "foobar") self.assertIs(node2p1, node2.get(1)) self.assertIs(node2p2, node2.get("abc")) self.assertRaises(ValueError, node2.get, "def") self.assertIs(node3p1, node3.get("b")) self.assertIs(node3p2, node3.get("1")) self.assertIs(node4p1, node4.get("b "))
def test_has(self): """test Template.has()""" node1 = Template(wraptext("foobar")) node2 = Template(wraptext("foo"), [pgenh("1", "bar"), pgens("\nabc ", "def")]) node3 = Template(wraptext("foo"), [pgenh("1", "a"), pgens("b", "c"), pgens("1", "d")]) node4 = Template(wraptext("foo"), [pgenh("1", "a"), pgens("b", " ")]) self.assertFalse(node1.has("foobar", False)) self.assertTrue(node2.has(1, False)) self.assertTrue(node2.has("abc", False)) self.assertFalse(node2.has("def", False)) self.assertTrue(node3.has("1", False)) self.assertTrue(node3.has(" b ", False)) self.assertTrue(node4.has("b", False)) self.assertTrue(node3.has("b", True)) self.assertFalse(node4.has("b", True)) self.assertFalse(node1.has_param("foobar", False)) self.assertTrue(node2.has_param(1, False))
def test_strip(self): """test Template.__strip__()""" node1 = Template(wraptext("foobar")) node2 = Template( wraptext("foo"), [pgenh("1", "bar"), pgens("foo", ""), pgens("abc", "def")]) node3 = Template(wraptext("foo"), [ pgenh("1", "foo"), Parameter(wraptext("2"), wrap([Template(wraptext("hello"))]), showkey=False), pgenh("3", "bar") ]) self.assertEqual(None, node1.__strip__(keep_template_params=False)) self.assertEqual(None, node2.__strip__(keep_template_params=False)) self.assertEqual("", node1.__strip__(keep_template_params=True)) self.assertEqual("bar def", node2.__strip__(keep_template_params=True)) self.assertEqual("foo bar", node3.__strip__(keep_template_params=True))
def test_parsing(self): """integration test for parsing overall""" text = "this is text; {{this|is=a|template={{with|[[links]]|in}}it}}" expected = wrap([ Text("this is text; "), Template(wraptext("this"), [ Parameter(wraptext("is"), wraptext("a")), Parameter(wraptext("template"), wrap([ Template(wraptext("with"), [ Parameter(wraptext("1"), wrap([Wikilink(wraptext("links"))]), showkey=False), Parameter(wraptext("2"), wraptext("in"), showkey=False) ]), Text("it") ])) ]) ]) actual = parser.Parser().parse(text) self.assertWikicodeEqual(expected, actual)
def redirect_cat(cat: pywikibot.Category, target: pywikibot.Category, summary: str) -> None: """ Redirect a category to another category. @param cat: Category to redirect @param target: Category redirect target @param summary: Edit summary """ tpl = Template('Category redirect') tpl.add('1', target.title(with_ns=False)) cat.text = str(tpl) cat.save(summary=summary)
def handle_template(tpl, code, namespace=None): if tpl.has('sprache'): if tpl.get('sprache').value.strip().lower() in ('englisch', 'english'): set_param_value(tpl, 'sprache', 'en') if tpl.get('sprache').value.strip().lower() in ('deutsch', 'german'): set_param_value(tpl, 'sprache', 'de') if tpl.has('wann'): if tpl.get('wann').value.strip() in ('Sommersemester', 'ss'): set_param_value(tpl, 'wann', 'SS') elif tpl.get('wann').value.strip() in ('Wintersemester', 'ws'): set_param_value(tpl, 'wann', 'WS') elif tpl.get('wann').value.strip() in ('Winter- und Sommersemester', 'Sommer- und Wintersemester'): set_param_value(tpl, 'wann', 'beide') if tpl.has('tiss'): if tpl.get('tiss').value.strip() == '1234567890': tpl.remove('tiss') archived = False successor = None if tpl.has('veraltet'): archived = True tpl.remove('veraltet') if tpl.has('nachfolger'): archived = True successor = tpl.get('nachfolger').value.strip() tpl.remove('nachfolger') for t in code.ifilter_templates( matches=lambda t: t.name.matches('Veraltet')): archived = True code.remove(t) archivedFlag = code.filter_templates( matches=lambda t: t.name.matches('Archiv')) if archived and not archivedFlag: tpl = Template(Wikicode([Text('Archiv')])) if successor: tpl.add('nachfolger', successor) code.insert(0, tpl) code.insert(1, '\n\n') if tpl.has('zuordnungen'): rels = tpl.get('zuordnungen').value.filter_templates() for rel in rels: if rel.has('2'): rel.get('2').value = str(rel.get('2').value).replace('–', '-') rels.sort(key=lambda x: x.get('1')) tpl.get('zuordnungen').value = '\n' + '\n'.join( [' ' * 4 + str(r) for r in rels]) + '\n' return 'fixe LVA-Daten'
def __init__(self, site: EsportsClient, title: str, bestof=1): self.site = site self.event = self.site.target(title).strip() self.toornament = self.site.cargo_client.query_one_result( tables='Tournaments', where='OverviewPage="{}"'.format(self.event), fields='ScrapeLink') self.summary = "Edit made by web scraping!" self.parser = Parser(self.toornament) self.intro_template = Template(name="MatchSchedule/Start") self.intro_template.add('bestof', str(bestof)) self.sandbox_page = self.site.client.pages[ 'User:RheingoldRiver/Toornament_Sandbox']
def treat_page(self) -> None: """Process one page.""" self.check_disabled() try: errors = self.validate_svg() except (AssertionError, RequestException, RuntimeError): pywikibot.exception() return if errors: n_errors = len(errors) new_tpl = Template('Invalid SVG') new_tpl.add('1', n_errors) summary = 'W3C invalid SVG: {} error{}'.format( n_errors, 's' if n_errors > 1 else '') else: new_tpl = Template('Valid SVG') summary = 'W3C valid SVG' wikicode = mwparserfromhell.parse(self.current_page.text, skip_style_tags=True) for tpl in wikicode.ifilter_templates(): try: template = pywikibot.Page( self.site, removeDisabledParts(str(tpl.name), site=self.site).strip(), ns=10, ) template.title() except pywikibot.InvalidTitle: continue if template in self.templates: wikicode.replace(tpl, new_tpl) break else: wikicode.insert(0, '\n') wikicode.insert(0, new_tpl) self.put_current(str(wikicode), summary=summary, minor=not errors)
def print(self): template = Template(name="MatchSchedule") self.add_field(template, 'date', self.timestamp.cet_date) self.add_field(template, 'time', self.timestamp.cet_time) self.add_field(template, 'timezone', 'CET') self.add_field(template, 'dst', self.timestamp.dst) self.add_field(template, 'stream', ' ') self.add_field(template, 'team1', self.team1) self.add_field(template, 'team2', self.team2) self.add_field(template, 'team1score', self.team1score) self.add_field(template, 'team2score', self.team2score) if self.is_forfeit: template.add('ff', self.forfeit) self.add_field(template, 'winner', self.winner) self.add_field(template, 'direct_link', self.url) self.add_field(template, 'page', self.page) self.add_field(template, 'n_in_page', self.index_in_page) return str(template)
def test_template(self): """tests for building Template nodes""" tests = [ ([tokens.TemplateOpen(), tokens.Text(text="foobar"), tokens.TemplateClose()], wrap([Template(wraptext("foobar"))])), ([tokens.TemplateOpen(), tokens.Text(text="spam"), tokens.Text(text="eggs"), tokens.TemplateClose()], wrap([Template(wraptext("spam", "eggs"))])), ([tokens.TemplateOpen(), tokens.Text(text="foo"), tokens.TemplateParamSeparator(), tokens.Text(text="bar"), tokens.TemplateClose()], wrap([Template(wraptext("foo"), params=[ Parameter(wraptext("1"), wraptext("bar"), showkey=False)])])), ([tokens.TemplateOpen(), tokens.Text(text="foo"), tokens.TemplateParamSeparator(), tokens.Text(text="bar"), tokens.TemplateParamEquals(), tokens.Text(text="baz"), tokens.TemplateClose()], wrap([Template(wraptext("foo"), params=[ Parameter(wraptext("bar"), wraptext("baz"))])])), ([tokens.TemplateOpen(), tokens.TemplateParamSeparator(), tokens.TemplateParamSeparator(), tokens.TemplateParamEquals(), tokens.TemplateParamSeparator(), tokens.TemplateClose()], wrap([Template(wrap([]), params=[ Parameter(wraptext("1"), wrap([]), showkey=False), Parameter(wrap([]), wrap([]), showkey=True), Parameter(wraptext("2"), wrap([]), showkey=False)])])), ([tokens.TemplateOpen(), tokens.Text(text="foo"), tokens.TemplateParamSeparator(), tokens.Text(text="bar"), tokens.TemplateParamEquals(), tokens.Text(text="baz"), tokens.TemplateParamSeparator(), tokens.Text(text="biz"), tokens.TemplateParamSeparator(), tokens.Text(text="buzz"), tokens.TemplateParamSeparator(), tokens.Text(text="3"), tokens.TemplateParamEquals(), tokens.Text(text="buff"), tokens.TemplateParamSeparator(), tokens.Text(text="baff"), tokens.TemplateClose()], wrap([Template(wraptext("foo"), params=[ Parameter(wraptext("bar"), wraptext("baz")), Parameter(wraptext("1"), wraptext("biz"), showkey=False), Parameter(wraptext("2"), wraptext("buzz"), showkey=False), Parameter(wraptext("3"), wraptext("buff")), Parameter(wraptext("3"), wraptext("baff"), showkey=False)])])), ] for test, valid in tests: self.assertWikicodeEqual(valid, self.builder.build(test))
def test_value(self): """test getter/setter for the value attribute""" value = wraptext("foo") node = Attribute(wraptext("id"), value) self.assertIs(value, node.value) node.value = "{{bar}}" self.assertWikicodeEqual(wrap([Template(wraptext("bar"))]), node.value) node.value = None self.assertIs(None, node.value) node2 = Attribute(wraptext("id"), wraptext("foo"), None) node2.value = "foo bar baz" self.assertWikicodeEqual(wraptext("foo bar baz"), node2.value) self.assertEqual('"', node2.quotes) node2.value = 'foo "bar" baz' self.assertWikicodeEqual(wraptext('foo "bar" baz'), node2.value) self.assertEqual("'", node2.quotes) node2.value = "foo 'bar' baz" self.assertWikicodeEqual(wraptext("foo 'bar' baz"), node2.value) self.assertEqual('"', node2.quotes) node2.value = "fo\"o 'bar' b\"az" self.assertWikicodeEqual(wraptext("fo\"o 'bar' b\"az"), node2.value) self.assertEqual('"', node2.quotes)