Created function to translate between sledrun title names and urls.
[philipp/winterrodeln/wrpylib.git] / wrpylib / mwmarkup.py
index ca9a87fa947d537778d5407e225837a850a3c660..572b30cfc3fed4258e585f18a913946ade9dc7b5 100644 (file)
@@ -1,4 +1,4 @@
-#!/usr/bin/python2.7
+#!/usr/bin/python3.4
 # -*- coding: iso-8859-15 -*-
 # $Id$
 # $HeadURL$
@@ -44,7 +44,7 @@ def find_template(wikitext, template_title):
         (start, end) of the first occurence with start >= 0 and end > start.
         (None, None) if the template is not found.
     """ 
-    match = re.search(u"\{\{" + template_title + "\s*(\|[^\}]*)?\}\}", wikitext,  re.DOTALL)
+    match = re.search("\{\{" + template_title + "\s*(\|[^\}]*)?\}\}", wikitext,  re.DOTALL)
     if match is None: return None, None
     return match.start(), match.end()
 
@@ -64,22 +64,22 @@ class TemplateValidator(formencode.FancyValidator):
         (title, anonym_params, named_params) where title is the template title,
         anonym_params is a list of anonymous parameters and named_params is a OrderedDict
         of named parameters. Whitespace of the parameters is stripped."""
-        if not value.startswith(u'{{'):
-            raise formencode.Invalid(u'Template does not start with "{{"', value, state)
-        if not value.endswith(u'}}'):
-            raise formencode.Invalid(u'Template does not end with "}}"', value, state)
-        parts = value[2:-2].split(u'|')
+        if not value.startswith('{{'):
+            raise formencode.Invalid('Template does not start with "{{"', value, state)
+        if not value.endswith('}}'):
+            raise formencode.Invalid('Template does not end with "}}"', value, state)
+        parts = value[2:-2].split('|')
 
         # template name
         title = self.strip(parts[0])
         if len(title) == 0:
-            raise formencode.Invalid(u'Empty template tilte.', value, state)
+            raise formencode.Invalid('Empty template tilte.', value, state)
         del parts[0]
 
         # anonymous parameters
         anonym_params = []
         while len(parts) > 0:
-            equalsign_pos = parts[0].find(u'=')
+            equalsign_pos = parts[0].find('=')
             if equalsign_pos >= 0: break # named parameter
             anonym_params.append(self.strip(parts[0]))
             del parts[0]
@@ -87,15 +87,15 @@ class TemplateValidator(formencode.FancyValidator):
         # named or numbered parameters
         named_params = collections.OrderedDict()
         while len(parts) > 0:
-            equalsign_pos = parts[0].find(u'=')
+            equalsign_pos = parts[0].find('=')
             if equalsign_pos < 0:
-                raise formencode.Invalid(u'Anonymous parameter after named parameter.', value, state)
-            key, sep, value = parts[0].partition(u'=')
+                raise formencode.Invalid('Anonymous parameter after named parameter.', value, state)
+            key, sep, value = parts[0].partition('=')
             key = self.strip(key)
             if len(key) == 0:
-                raise formencode.Invalid(u'Empty key.', value, state)
-            if named_params.has_key(key):
-                raise formencode.Invalid(u'Duplicate key: "{0}"'.format(key), value, state)
+                raise formencode.Invalid('Empty key.', value, state)
+            if key in named_params:
+                raise formencode.Invalid('Duplicate key: "{0}"'.format(key), value, state)
             named_params[key] = self.strip(value)
             del parts[0]
 
@@ -107,16 +107,18 @@ class TemplateValidator(formencode.FancyValidator):
         where title is the template title, anonym_params is a list of anonymous parameters and
         named_params is a dict or OrderedDict of named parameters."""
         title, anonym_params, named_params = value
-        pipe_char, equal_char, end_char = (u'\n| ', u' = ', u'\n}}') if self.as_table else (u'|', u'=', u'}}')
-        parts = [u"{{" + title]
+        pipe_char, equal_char, end_char = ('\n| ', ' = ', '\n}}') if self.as_table else ('|', '=', '}}')
+        parts = ["{{" + title]
         parts += anonym_params
         as_table_keylen = self.as_table_keylen
         if self.as_table and as_table_keylen is None:
-            as_table_keylen = max(map(len, named_params.iterkeys()))
-        for k, v in named_params.iteritems():
+            as_table_keylen = max(list(map(len, iter(named_params.keys()))))
+        for k, v in named_params.items():
             if self.as_table:
                 k = k.ljust(as_table_keylen)
-            parts.append(k + equal_char + v)
+                parts.append((k + equal_char + v).rstrip())
+            else:
+                parts.append(k + equal_char + v)
         return pipe_char.join(parts) + end_char
 
 
@@ -132,8 +134,8 @@ def split_template(template):
     try:
         title, anonym_params, named_params = TemplateValidator().to_python(template)
         parameters = dict(named_params)
-        for i in xrange(len(anonym_params)):
-            parameters[unicode(i+1)] = anonym_params[i]
+        for i in range(len(anonym_params)):
+            parameters[str(i+1)] = anonym_params[i]
     except formencode.Invalid as e:
         raise ValueError(e[0])
     return title, parameters
@@ -150,7 +152,7 @@ def create_template(template_title, anonym_params=[], named_param_keys=[], named
     :param as_table: formats the returned template in one row for each parameter
     :param as_table_keylen: length of the key field. None for "automatic".
     :return: unicode template"""
-    named_params = collections.OrderedDict(zip(named_param_keys, named_param_values))
+    named_params = collections.OrderedDict(list(zip(named_param_keys, named_param_values)))
     return TemplateValidator(as_table=as_table, as_table_keylen=as_table_keylen).from_python((template_title, anonym_params, named_params))
 
 
@@ -176,7 +178,7 @@ def find_tag(wikitext, tagname, pos=0):
         (None, None, None, None) is returned.
     """
     # Find start tag
-    regexp_starttag = re.compile(u"<{0}.*?(/?)>".format(tagname), re.DOTALL)
+    regexp_starttag = re.compile("<{0}.*?(/?)>".format(tagname), re.DOTALL)
     match_starttag = regexp_starttag.search(wikitext, pos)
     if match_starttag is None:
         return None, None, None, None
@@ -187,7 +189,7 @@ def find_tag(wikitext, tagname, pos=0):
         return match_starttag.start(), None, None, match_starttag.end()
 
     # tag with content
-    regexp_endtag = re.compile(u'</{0}>'.format(tagname), re.DOTALL)
+    regexp_endtag = re.compile('</{0}>'.format(tagname), re.DOTALL)
     match_endtag = regexp_endtag.search(wikitext, match_starttag.end())
     if match_endtag is None:
         # No closing tag - error in wikitext
@@ -237,19 +239,19 @@ def parse_googlemap(wikitext):
 
     def parse_coord(line):
         """Returns (lon, lat, symbol, title). If symbol or text is not present, None is returned."""
-        match = re.match(u'\(([^)]+)\) ?([0-9]{1,2}\.[0-9]+), ?([0-9]{1,2}\.[0-9]+), ?(.*)', line)
+        match = re.match('\(([^)]+)\) ?([0-9]{1,2}\.[0-9]+), ?([0-9]{1,2}\.[0-9]+), ?(.*)', line)
         if not match is None: return (float(match.group(3)), float(match.group(2)), match.group(1), match.group(4))
-        match = re.match(u'\(([^)]+)\) ?([0-9]{1,2}\.[0-9]+), ?([0-9]{1,2}\.[0-9]+)', line)
+        match = re.match('\(([^)]+)\) ?([0-9]{1,2}\.[0-9]+), ?([0-9]{1,2}\.[0-9]+)', line)
         if not match is None: return (float(match.group(3)), float(match.group(2)), match.group(1), None)
-        match = re.match(u'([0-9]{1,2}\.[0-9]+), ?([0-9]{1,2}\.[0-9]+), ?(.*)', line)
+        match = re.match('([0-9]{1,2}\.[0-9]+), ?([0-9]{1,2}\.[0-9]+), ?(.*)', line)
         if not match is None: return (float(match.group(2)), float(match.group(1)), None, match.group(3))
-        match = re.match(u'([0-9]{1,2}\.[0-9]+), ?([0-9]{1,2}\.[0-9]+)', line)
+        match = re.match('([0-9]{1,2}\.[0-9]+), ?([0-9]{1,2}\.[0-9]+)', line)
         if not match is None: return (float(match.group(2)), float(match.group(1)), None, None)
-        return ParseError(u'Could not parse line ' + line)
+        return ParseError('Could not parse line ' + line)
 
     start, content, endtag, end = find_tag(wikitext, 'googlemap')
     if start is None:
-        raise ParseError(u'<googlemap> tag not found.')
+        raise ParseError('<googlemap> tag not found.')
     if content is None:
         xml_only = wikitext[start:endtag]
     else:
@@ -259,7 +261,7 @@ def parse_googlemap(wikitext):
         gm = xml.etree.ElementTree.XML(xml_only.encode('UTF8'))
     except xml.etree.ElementTree.ParseError as e:
         row, column = e.position
-        raise ParseError(u"XML parse error in <googlemap ...>.")
+        raise ParseError("XML parse error in <googlemap ...>.")
 
     # parse attributes
     attributes = {}
@@ -271,7 +273,7 @@ def parse_googlemap(wikitext):
             if gm.get(key) is not None:
                 attributes[key] = int(gm.get(key))
     except ValueError as error:
-        raise ParseError(u'Error at parsing attribute {0} of <googlemap>: {1}'.format(key, unicode(error)))
+        raise ParseError('Error at parsing attribute {0} of <googlemap>: {1}'.format(key, str(error)))
 
     # parse points and lines
     coords = []
@@ -287,7 +289,7 @@ def parse_googlemap(wikitext):
 
         # Handle a path
         if is_path(line):
-            match = re.match(u'([0-9]#[0-9a-fA-F]{8})', line)
+            match = re.match('([0-9]#[0-9a-fA-F]{8})', line)
             style =  match.group(1)
             local_coords = []
             while i < len(lines):
@@ -315,7 +317,7 @@ def parse_googlemap(wikitext):
             coords.append((lon, lat, symbol, title))
             continue
 
-        raise ParseError(u'Unknown line syntax: ' + line)
+        raise ParseError('Unknown line syntax: ' + line)
 
     return (attributes, coords, paths)