-#!/usr/bin/python2.6
+#!/usr/bin/python3.4
# -*- coding: iso-8859-15 -*-
# $Id$
# $HeadURL$
* py-wikimarkup https://github.com/dcramer/py-wikimarkup
* mwlib http://code.pediapress.com/wiki/wiki
"""
+import re
+import xml.etree.ElementTree
+import collections
+import formencode
+
+
+class ParseError(RuntimeError):
+ """Exception used by some of the functions"""
+ pass
+
+
+def find_template(wikitext, template_title):
+ """Returns the tuple (start, end) of the first occurence of the template '{{template ...}} within wikitext'.
+ (None, None) is returned if the template is not found.
+ If you are sure that the wikitext contains the template, the template could be extracted like follows:
+
+ >>> wikitext = u'This is a {{Color|red|red text}} template.'
+ >>> start, end = find_template(wikitext, u'Color')
+ >>> print wikitext[start:end]
+ {{Color|red|red text}}
+
+ or just:
+
+ >>> print wikitext.__getslice__(*find_template(wikitext, u'Color'))
+ {{Color|red|red text}}
+
+ The search is done with regular expression. It gives wrong results when parsing a template
+ containing the characters "}}"
+
+ :param wikitext: The text (preferalbe unicode) that has the template in it.
+ :param template_title: The page title of the template with or without namespace (but as in the wikitext).
+ :return:
+ (start, end) of the first occurence with start >= 0 and end > start.
+ (None, None) if the template is not found.
+ """
+ match = re.search("\{\{" + template_title + "\s*(\|[^\}]*)?\}\}", wikitext, re.DOTALL)
+ if match is None: return None, None
+ return match.start(), match.end()
+
+
+class TemplateValidator(formencode.FancyValidator):
+ def __init__(self, strip=True, as_table=False, as_table_keylen=None):
+ """Validates a MediaWiki template, e.g. {{Color|red}}
+ :param stip: If strip is True, the title, and the parameter keys and values are stripped in to_python.
+ :param as_table: formats the returned template in one row for each parameter
+ :param as_table_keylen: length of the key field for from_python. None for "automatic"."""
+ self.strip = (lambda s: s.strip()) if strip else (lambda s: s)
+ self.as_table = as_table
+ self.as_table_keylen = as_table_keylen
+
+ def to_python(self, value, state=None):
+ """Takes a template, like u'{{Color|red|text=Any text}}' and translates it to a Python tuple
+ (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('{{'):
+ 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('Empty template tilte.', value, state)
+ del parts[0]
+
+ # anonymous parameters
+ anonym_params = []
+ while len(parts) > 0:
+ equalsign_pos = parts[0].find('=')
+ if equalsign_pos >= 0: break # named parameter
+ anonym_params.append(self.strip(parts[0]))
+ del parts[0]
+
+ # named or numbered parameters
+ named_params = collections.OrderedDict()
+ while len(parts) > 0:
+ equalsign_pos = parts[0].find('=')
+ if equalsign_pos < 0:
+ 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('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]
+
+ return title, anonym_params, named_params
+
+ def from_python(self, value, state=None):
+ """Formats a MediaWiki template.
+ value is a tuple: (title, anonym_params, named_params)
+ 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 = ('\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(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).rstrip())
+ else:
+ parts.append(k + equal_char + v)
+ return pipe_char.join(parts) + end_char
+
+
+def split_template(template):
+ """Deprecated legacy function.
+
+ Takes a template, like u'{{Color|red|text=Any text}}' and translates it to a Python tuple
+ (template_title, parameters) where parameters is a Python dictionary {u'1': u'red', u'text'=u'Any text'}.
+ Anonymous parameters get integer keys (converted to unicode) starting with 1
+ like in MediaWiki, named parameters are unicode strings.
+ Whitespace is stripped.
+ If an unexpected format is encountered, a ValueError is raised."""
+ try:
+ title, anonym_params, named_params = TemplateValidator().to_python(template)
+ parameters = dict(named_params)
+ 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
+
+
+def create_template(template_title, anonym_params=[], named_param_keys=[], named_param_values=[], as_table=False, as_table_keylen=None):
+ """Deprecated legacy function.
+
+ Formats a MediaWiki template.
+ :param template_title: Unicode string with the template name
+ :param anonym_params: list with parameters without keys
+ :param named_param_keys: list with keys of named parameters
+ :param named_param_values: list with values of named parameters, corresponding to named_param_keys.
+ :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(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))
+
+
+def find_tag(wikitext, tagname, pos=0):
+ """Returns position information of the first occurence of the tag '<tag ...>...</tag>'
+ or '<tag ... />'.
+ If you are sure that the wikitext contains the tag, the tag could be extracted like follows:
+
+ >>> wikitext = u'This is a <tag>mytag</tag> tag.'
+ >>> start, content, endtag, end = find_template(wikitext, u'tag')
+ >>> print wikitext[start:end]
+ <tag>mytag</tag>
+
+ :param wikitext: The text (preferalbe unicode) that has the template in it.
+ :param tagname: Name of the tag, e.g. u'tag' for <tag>.
+ :param pos: position within wikitext to start searching the tag.
+ :return:
+ (start, content, endtag, end). start is the position of '<' of the tag,
+ content is the beginning of the content (after '>'), enttag is the
+ beginning of the end tag ('</') and end is one position after the end tag.
+ For single tags, (start, None, None, end) is returned.
+ If the tag is not found (or only the start tag is present,
+ (None, None, None, None) is returned.
+ """
+ # Find start tag
+ 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
+
+ # does the tag have content?
+ if len(match_starttag.group(1)) == 1: # group(1) is either '' or '/'.
+ # single tag
+ return match_starttag.start(), None, None, match_starttag.end()
+
+ # tag with content
+ 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
+ return None, None, None, None
+ return match_starttag.start(), match_starttag.end(), match_endtag.start(), match_endtag.end()
+
+
+def parse_googlemap(wikitext):
+ """Parses the (unicode) u'<googlemap ...>content</googlemap>' of the googlemap extension.
+ If wikitext does not contain the <googlemap> tag or if the <googlemap> tag contains
+ invalid formatted lines, a ParseError is raised.
+ Use find_tag(wikitext, 'googlemap') to find the googlemap tag within an arbitrary
+ wikitext before using this function.
+
+ :param wikitext: wikitext containing the template. Example:
+
+ wikitext = '''
+ <googlemap version="0.9" lat="47.113291" lon="11.272337" zoom="15">
+ (Parkplatz)47.114958,11.266026
+ Parkplatz
+
+ (Gasthaus) 47.114715, 11.266262, Alt Bärnbad (Gasthaus)
+ 6#FF014E9A
+ 47.114715,11.266262
+ 47.114135,11.268381
+ 47.113421,11.269322
+ 47.11277,11.269979
+ 47.112408,11.271119
+ </googlemap>
+ '''
+ :returns: The tuple (attributes, coords, paths) is returned.
+ attributes is a dict that contains the attribues that are present
+ (e.g. lon, lat, zoom, width, height) converted to float (lon, lat) or int.
+ coords is a list of (lon, lat, symbol, title) tuples.
+ paths is a list of (style, coords) tuples.
+ coords is again a list of (lon, lat, symbol, title) tuples."""
+
+ def is_coord(line):
+ """Returns True if the line contains a coordinate."""
+ match = re.search('[0-9]{1,2}\.[0-9]+, ?[0-9]{1,2}\.[0-9]+', line)
+ return not match is None
+
+ def is_path(line):
+ """Returns True if the line contains a path style definition."""
+ match = re.match('[0-9]#[0-9a-fA-F]{8}', line)
+ return not match is None
+
+ def parse_coord(line):
+ """Returns (lon, lat, symbol, title). If symbol or text is not present, None is returned."""
+ 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('\(([^)]+)\) ?([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('([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('([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('Could not parse line ' + line)
+
+ start, content, endtag, end = find_tag(wikitext, 'googlemap')
+ if start is None:
+ raise ParseError('<googlemap> tag not found.')
+ if content is None:
+ xml_only = wikitext[start:endtag]
+ else:
+ xml_only = wikitext[start:content]+wikitext[endtag:end]
+
+ try:
+ gm = xml.etree.ElementTree.XML(xml_only.encode('UTF8'))
+ except xml.etree.ElementTree.ParseError as e:
+ row, column = e.position
+ raise ParseError("XML parse error in <googlemap ...>.")
+
+ # parse attributes
+ attributes = {}
+ try:
+ for key in ['lon', 'lat']:
+ if gm.get(key) is not None:
+ attributes[key] = float(gm.get(key))
+ for key in ['zoom', 'width', 'height']:
+ if gm.get(key) is not None:
+ attributes[key] = int(gm.get(key))
+ except ValueError as error:
+ raise ParseError('Error at parsing attribute {0} of <googlemap>: {1}'.format(key, str(error)))
+
+ # parse points and lines
+ coords = []
+ paths = []
+ lines = wikitext[content:endtag].split("\n")
+ i = 0
+ while i < len(lines):
+ line = lines[i].strip()
+ i += 1
+
+ # Skip whitespace
+ if len(line) == 0: continue
+
+ # Handle a path
+ if is_path(line):
+ match = re.match('([0-9]#[0-9a-fA-F]{8})', line)
+ style = match.group(1)
+ local_coords = []
+ while i < len(lines):
+ line = lines[i].strip()
+ i += 1
+ if is_path(line):
+ i -= 1
+ break
+ if is_coord(line):
+ lon, lat, symbol, title = parse_coord(line)
+ local_coords.append((lon, lat, symbol, title))
+ paths.append((style, local_coords))
+ continue
+
+ # Handle a coordinate
+ if is_coord(line):
+ lon, lat, symbol, title = parse_coord(line)
+ while i < len(lines):
+ line = lines[i].strip()
+ i += 1
+ if is_path(line) or is_coord(line):
+ i -= 1
+ break
+ if len(line) > 0 and title is None: title = line
+ coords.append((lon, lat, symbol, title))
+ continue
+
+ raise ParseError('Unknown line syntax: ' + line)
+
+ return (attributes, coords, paths)
ToastFreeware / philipp / winterrodeln / wrpylib.git / blobdiff