Fixed typo in docstring of opt_tristate_german_comment_from_str.
[philipp/winterrodeln/wrpylib.git] / wrpylib / wrvalidators.py
1 #!/usr/bin/python3.4
2 # $Id$
3 # $HeadURL$
4 """
5 This module contains functions that convert winterrodeln specific strings (like geographic coordinates) from string
6 to appropriate python types and the other way round.
7 Functions that take strings to convert it to python types are called *_from_str(value, [...]) and are supposed to
8 validate the string. In case of errors, a ValueError (or a subclass thereof) is returned.
9 Functions that take python types and convert it to Winterrodeln strings are called *_to_str(value, [...]) and can
10 assume that the value they get is valid. If it is not, the behavior is undefined.
11 The namedtuple FromToConverter groups corresponding *_from_str and *_to_str converters.
12 """
13 import email.headerregistry
14 import urllib.parse
15 import re
16 from collections import OrderedDict, namedtuple
17
18 import mwparserfromhell  # https://github.com/earwig/mwparserfromhell
19
20 from wrpylib.mwmarkup import format_template_table
21
22
23 # FromToConverter type
24 # --------------------
25
26 # namedtuple that groups corresponding *_from_str and *_to_str functions.
27 FromToConverter = namedtuple('FromToConverter', ['from_str', 'to_str'])
28
29
30 # optional converter
31 # ------------------
32
33 def opt_from_str(value, from_str, empty=None):
34     """Makes the converter `from_str` "optional"
35     by replacing the empty string with a predefined value (default: None)."""
36     return empty if value == '' else from_str(value)
37
38
39 def opt_to_str(value, to_str, empty=None):
40     return '' if value == empty else to_str(value)
41
42
43 # "no" converter
44 # --------------
45
46 def no_german_from_str(value, from_str, use_tuple=True, no_value=None):
47     """Makes it possible to have "Nein" as special value. If use_tuple is True, a tuple is returned. The first
48     entry of the tuple is False in case the value is "Nein", otherwiese the first value is True. The second value is
49     no_value in case of the value being "Nein", otherwise it is the result of from_str(value).
50     If use_tuple is False, no_value is returned in case the value is "Nein", otherwise the result of from_str(value)."""
51     if value == 'Nein':
52         return (False, no_value) if use_tuple else no_value
53     return (True, from_str(value)) if use_tuple else from_str(value)
54
55
56 def no_german_to_str(value, to_str, use_tuple=True, no_value=None):
57     if use_tuple:
58         if not value[0]:
59             return 'Nein'
60         return to_str(value[1])
61     else:
62         if value == no_value:
63             return 'Nein'
64         return to_str(value)
65
66
67 # "optional"/"no" converter
68 # -------------------------
69
70 def opt_no_german_from_str(value, from_str, use_tuple=True, no_value=None, empty=(None, None)):
71     return opt_from_str(value, lambda v: no_german_from_str(v, from_str, use_tuple, no_value), empty)
72
73
74 def opt_no_german_to_str(value, to_str, use_tuple=True, no_value=None, empty=(None, None)):
75     return opt_to_str(value, lambda v: no_german_to_str(v, to_str, use_tuple, no_value), empty)
76
77
78 # choice converter
79 # ----------------
80
81 def choice_from_str(value, choices):
82     """Returns the value if it is a member of the choices iterable."""
83     if value not in choices:
84         raise ValueError('{} is an invalid value')
85     return value
86
87
88 # dictkey converter
89 # -----------------
90
91 def dictkey_from_str(value, key_str_dict):
92     """Returns the key of an entry in the key_str_dict if the value of the entry corresponds to the given value."""
93     try:
94         return dict(list(zip(key_str_dict.values(), key_str_dict.keys())))[value]
95     except KeyError:
96         raise ValueError("Invalid value '{}'".format(value))
97
98
99 def dictkey_to_str(value, key_str_dict):
100     try:
101         return key_str_dict[value]
102     except KeyError:
103         raise ValueError("Invalid value '{}'".format(value))
104
105
106 # enum/"list" converter
107 # ---------------------
108
109 def enum_from_str(value, from_str, separator=';', min_len=0):
110     """Semicolon separated list of entries with the same "type"."""
111     values = value.split(separator)
112     if len(values) == 1 and values[0] == '':
113         values = []
114     if len(values) < min_len:
115         raise ValueError('at least {} entry/entries have to be in the enumeration'.format(min_len))
116     return list(map(from_str, map(str.strip, values)))
117
118
119 def enum_to_str(value, to_str, separator='; '):
120     return separator.join(map(to_str, value))
121
122
123 # value/comment converter
124 # -----------------------
125
126 def value_comment_from_str(value, value_from_str, comment_from_str, comment_optional=False):
127     """Makes it possible to have a mandatory comment in parenthesis at the end of the string."""
128     comment = ''
129     if value.endswith(')'):
130         open_brackets = 0
131         for i, char in enumerate(value[::-1]):
132             if char == ')':
133                 open_brackets += 1
134             elif char == '(':
135                 open_brackets -= 1
136                 if open_brackets == 0:
137                     comment = value[-i:-1]
138                     value = value[:-i-1]
139                     if len(value) > 1 and value[-1] != ' ':
140                         raise ValueError('there has to be a space before the opening bracket of the comment')
141                     value = value[:-1]
142                     break
143         else:
144             if open_brackets > 0:
145                 raise ValueError('bracket mismatch')
146             if not comment_optional:
147                 raise ValueError('mandatory comment not found')
148     else:
149         if not comment_optional:
150             raise ValueError('mandatory comment not found in "{}"'.format(value))
151     return value_from_str(value), comment_from_str(comment)
152
153
154 def value_comment_to_str(value, value_to_str, comment_to_str, comment_optional=False):
155     left = value_to_str(value[0])
156     comment = comment_to_str(value[1])
157     if len(comment) > 0 or not comment_optional:
158         comment = '({})'.format(comment)
159     if len(left) == 0:
160         return comment
161     if len(comment) == 0:
162         return left
163     return '{} {}'.format(left, comment)
164
165
166 # string converter
167 # ----------------
168
169 def str_from_str(value):
170     """Converter that takes any string and returns it as string without validation.
171     In other words, this function does nothing and just returns its argument."""
172     return value
173
174
175 def str_to_str(value):
176     return value
177
178
179 def req_str_from_str(value):
180     if value == '':
181         raise ValueError('missing required value')
182     return str_from_str(value)
183
184
185 def opt_str_from_str(value):
186     return opt_from_str(value, str_from_str)
187
188
189 def opt_str_to_str(value):
190     return opt_to_str(value, str_to_str)
191
192
193 opt_str_converter = FromToConverter(opt_str_from_str, opt_str_to_str)
194
195
196 # optional no or string converter
197 # -------------------------------
198
199 def opt_no_or_str_from_str(value):
200     """
201     'Nein' => (False, None); 'Nur Wochenende' => (True, 'Nur Wochenende'); 'Ja' => (True, 'Ja'); '' => (None, None)"""
202     return opt_no_german_from_str(value, req_str_from_str)
203
204
205 def opt_no_or_str_to_str(value):
206     return opt_no_german_to_str(value, str_to_str)
207
208
209 opt_no_or_str_converter = FromToConverter(opt_no_or_str_from_str, opt_no_or_str_to_str)
210
211
212 # integer converter
213 # -----------------
214
215 def int_from_str(value, min=None, max=None):
216     """Converter that takes a string representation of an integer and returns the integer.
217     :param value: string representation of an integer
218     :param min: If not None, the integer has to be at least min
219     :param max: If not None, the integer has to be no more than max
220     """
221     value = int(value)
222     if min is not None and value < min:
223         raise ValueError('{} must be >= than {}'.format(value, min))
224     if max is not None and value > max:
225         raise ValueError('{} must be <= than {}'.format(value, max))
226     return value
227
228
229 def int_to_str(value):
230     return str(value)
231
232
233 def opt_int_from_str(value, min=None, max=None):
234     return opt_from_str(value, lambda val: int_from_str(val, min, max))
235
236
237 def opt_int_to_str(value):
238     return opt_to_str(value, int_to_str)
239
240
241 def opt_uint_from_str(value, min=0, max=None):
242     """Optional positive integer."""
243     return opt_int_from_str(value, min, max)
244
245
246 def opt_uint_to_str(value):
247     return opt_int_to_str(value)
248
249
250 opt_uint_converter = FromToConverter(opt_uint_from_str, opt_uint_to_str)
251
252
253 # bool converter
254 # --------------
255
256 BOOL_GERMAN = OrderedDict([(False, 'Nein'), (True, 'Ja')])
257
258
259 def bool_german_from_str(value):
260     return dictkey_from_str(value, BOOL_GERMAN)
261
262
263 def bool_german_to_str(value):
264     return dictkey_to_str(value, BOOL_GERMAN)
265
266
267 def opt_bool_german_from_str(value):
268     return opt_from_str(value, bool_german_from_str)
269
270
271 def opt_bool_german_to_str(value):
272     return opt_to_str(value, bool_german_to_str)
273
274
275 opt_bool_german_converter = FromToConverter(opt_bool_german_from_str, opt_bool_german_to_str)
276
277
278 # tristate converter
279 # ------------------
280
281 TRISTATE_GERMAN = OrderedDict([(0.0, 'Nein'), (0.5, 'Teilweise'), (1.0, 'Ja')])
282
283
284 def tristate_german_from_str(value):
285     return dictkey_from_str(value, TRISTATE_GERMAN)
286
287
288 def tristate_german_to_str(value):
289     return dictkey_to_str(value, TRISTATE_GERMAN)
290
291
292 def opt_tristate_german_from_str(value):
293     return opt_from_str(value, tristate_german_from_str)
294
295
296 def opt_tristate_german_to_str(value):
297     return opt_to_str(value, tristate_german_to_str)
298
299
300 opt_tristate_german_converter = FromToConverter(opt_tristate_german_from_str, opt_tristate_german_to_str)
301
302
303 # tristate with comment converter
304 # -------------------------------
305
306 def opt_tristate_german_comment_from_str(value):
307     """Ja, Nein or Teilweise, optionally with comment in parenthesis."""
308     return value_comment_from_str(value, opt_tristate_german_from_str, opt_str_from_str, True)
309
310
311 def opt_tristate_german_comment_to_str(value):
312     return value_comment_to_str(value, opt_tristate_german_to_str, opt_str_to_str, True)
313
314
315 opt_tristate_german_comment_converter = FromToConverter(opt_tristate_german_comment_from_str, opt_tristate_german_comment_to_str)
316
317
318 # url converter
319 # -------------
320
321 def url_from_str(value):
322     result = urllib.parse.urlparse(value)
323     if result.scheme not in ['http', 'https']:
324         raise ValueError('scheme has to be http or https')
325     if not result.netloc:
326         raise ValueError('url does not contain netloc')
327     return value
328
329
330 def url_to_str(value):
331     return value
332
333
334 # webauskunft converter
335 # ---------------------
336
337 def webauskunft_from_str(value):
338     return opt_no_german_from_str(value, url_from_str)
339
340
341 def webauskunft_to_str(value):
342     return opt_no_german_to_str(value, url_to_str)
343
344
345 webauskunft_converter = FromToConverter(webauskunft_from_str, webauskunft_to_str)
346
347
348 # wikipage converter
349 # ------------------
350
351 def wikipage_from_str(value):
352     """Validates wiki page name like '[[Birgitzer Alm]]'.
353     The page is not checked for existence.
354     An empty string is an error.
355     '[[Birgitzer Alm]]' => '[[Birgitzer Alm]]'
356     """
357     if not value.startswith('[[') or not value.endswith(']]'):
358         raise ValueError('No valid wiki page name "{}"'.format(value))
359     return value
360
361
362 def wikipage_to_str(value):
363     return value
364
365
366 def opt_wikipage_enum_from_str(value):
367     """Validates a list of wiki pages like '[[Birgitzer Alm]]; [[Kemater Alm]]'.
368     '[[Birgitzer Alm]]; [[Kemater Alm]]' => ['[[Birgitzer Alm]]', '[[Kemater Alm]]']
369     '[[Birgitzer Alm]]'                  => ['[[Birgitzer Alm]]']
370     'Nein'                               => []
371     ''                                   => None
372     """
373     return opt_no_german_from_str(value, lambda val: enum_from_str(val, wikipage_from_str), False, [], None)
374
375
376 def opt_wikipage_enum_to_str(value):
377     return opt_no_german_to_str(value, lambda val: enum_to_str(val, wikipage_to_str), False, [], None)
378
379
380 opt_wikipage_enum_converter = FromToConverter(opt_wikipage_enum_from_str, opt_wikipage_enum_to_str)
381
382
383 # email converter
384 # ---------------
385
386 def email_from_str(value):
387     """Takes an email address like 'office@example.com', checks it for correctness and returns it again as string."""
388     try:
389         email.headerregistry.Address(addr_spec=value)
390     except email.errors.HeaderParseError as e:
391         raise ValueError('Invalid email address: {}'.format(value), e)
392     return value
393
394
395 def email_to_str(value):
396     return str(value)
397
398
399 def masked_email_from_str(value, mask='(at)', masked_only=False):
400     """Converts an email address that is possibly masked. Returns a tuple. The first parameter is the un-masked
401     email address as string, the second is a boolean telling whether the address was masked."""
402     unmasked = value.replace(mask, '@')
403     was_masked = unmasked != value
404     if masked_only and not was_masked:
405         raise ValueError('E-Mail address not masked')
406     return email_from_str(unmasked), was_masked
407
408
409 def masked_email_to_str(value, mask='(at)'):
410     """Value is a tuple. The first entry is the email address, the second one is a boolean telling whether the
411     email address should be masked."""
412     email, do_masking = value
413     email = email_to_str(email)
414     if do_masking:
415         email = email.replace('@', mask)
416     return email
417
418
419 def emails_from_str(value):
420     return opt_no_german_from_str(value, lambda val: enum_from_str(val, lambda v: value_comment_from_str(v, masked_email_from_str, opt_str_from_str, True)), False, [], None)
421
422
423 def emails_to_str(value):
424     return opt_no_german_to_str(value, lambda val: enum_to_str(val, lambda v: value_comment_to_str(v, masked_email_to_str, opt_str_to_str, True)), False, [], None)
425
426
427 emails_converter = FromToConverter(emails_from_str, emails_to_str)
428
429
430 # phone converter
431 # ---------------
432
433 def phone_number_from_str(value):
434     match = re.match(r'\+\d+(-\d+)*$', value)
435     if match is None:
436         raise ValueError('invalid format of phone number - use something like +43-699-1234567')
437     return value
438
439
440 def phone_number_to_str(value):
441     return value
442
443
444 def opt_phone_comment_enum_from_str(value, comment_optional=False):
445     return opt_no_german_from_str(value, lambda val: enum_from_str(val, lambda v: value_comment_from_str(v, phone_number_from_str, opt_str_from_str if comment_optional else req_str_from_str, comment_optional)), False, [], None)
446
447
448 def opt_phone_comment_enum_to_str(value, comment_optional=False):
449     return opt_no_german_to_str(value, lambda val: enum_to_str(val, lambda v: value_comment_to_str(v, phone_number_to_str, opt_str_to_str if comment_optional else str_to_str, comment_optional)), False, [], None)
450
451
452 opt_phone_comment_enum_converter = FromToConverter(opt_phone_comment_enum_from_str, opt_phone_comment_enum_to_str)
453
454
455 opt_phone_comment_opt_enum_converter = FromToConverter(lambda value: opt_phone_comment_enum_from_str(value, True), lambda value: opt_phone_comment_enum_to_str(value, True))
456
457
458 # longitude/latitude converter
459 # ----------------------------
460
461 LonLat = namedtuple('LonLat', ['lon', 'lat'])
462
463
464 lonlat_none = LonLat(None, None)
465
466
467 def lonlat_from_str(value):
468     """Converts a winterrodeln geo string like '47.076207 N 11.453553 E' (being '<latitude> N <longitude> E'
469     to the LonLat(lon, lat) named  tupel."""
470     r = re.match('(\d+\.\d+) N (\d+\.\d+) E', value)
471     if r is None: raise ValueError("Coordinates '{}' have not a format like '47.076207 N 11.453553 E'".format(value))
472     return LonLat(float(r.groups()[1]), float(r.groups()[0]))
473
474
475 def lonlat_to_str(value):
476     return '{:.6f} N {:.6f} E'.format(value.lat, value.lon)
477
478
479 def opt_lonlat_from_str(value):
480     return opt_from_str(value, lonlat_from_str, lonlat_none)
481
482
483 def opt_lonlat_to_str(value):
484     return opt_to_str(value, lonlat_to_str, lonlat_none)
485
486
487 opt_lonlat_converter = FromToConverter(opt_lonlat_from_str, opt_lonlat_to_str)
488
489
490 # difficulty converter
491 # --------------------
492
493 DIFFICULTY_GERMAN = OrderedDict([(1, 'leicht'), (2, 'mittel'), (3, 'schwer')])
494
495
496 def difficulty_german_from_str(value):
497     return dictkey_from_str(value, DIFFICULTY_GERMAN)
498
499
500 def difficulty_german_to_str(value):
501     return dictkey_to_str(value, DIFFICULTY_GERMAN)
502
503
504 def opt_difficulty_german_from_str(value):
505     return opt_from_str(value, difficulty_german_from_str)
506
507
508 def opt_difficulty_german_to_str(value):
509     return opt_to_str(value, difficulty_german_to_str)
510
511
512 opt_difficulty_german_converter = FromToConverter(opt_difficulty_german_from_str, opt_difficulty_german_to_str)
513
514
515 # avalanches converter
516 # --------------------
517
518 AVALANCHES_GERMAN = OrderedDict([(1, 'kaum'), (2, 'selten'), (3, 'gelegentlich'), (4, 'häufig')])
519
520
521 def avalanches_german_from_str(value):
522     return dictkey_from_str(value, AVALANCHES_GERMAN)
523
524
525 def avalanches_german_to_str(value):
526     return dictkey_to_str(value, AVALANCHES_GERMAN)
527
528
529 def opt_avalanches_german_from_str(value):
530     return opt_from_str(value, avalanches_german_from_str)
531
532
533 def opt_avalanches_german_to_str(value):
534     return opt_to_str(value, avalanches_german_to_str)
535
536
537 opt_avalanches_german_converter = FromToConverter(opt_avalanches_german_from_str, opt_avalanches_german_to_str)
538
539
540 # lift converter
541 # --------------
542
543 LIFT_GERMAN = ['Sessellift', 'Gondel', 'Linienbus', 'Taxi', 'Sonstige']
544
545
546 def lift_german_from_str(value):
547     """Checks a lift_details property. It is a value comment property with the following
548     values allowed:
549     'Sessellift'
550     'Gondel'
551     'Linienbus'
552     'Taxi'
553     'Sonstige'
554     Alternatively, the value u'Nein' is allowed.
555     An empty string maps to (None, None).
556
557     Examples:
558     ''                                       <=> None
559     'Nein'                                   <=> []
560     'Sessellift                              <=> [('Sessellift', None)]
561     'Gondel (nur bis zur Hälfte)'            <=> [('Gondel', 'nur bis zur Hälfte')]
562     'Sessellift; Taxi'                       <=> [('Sessellift', None), ('Taxi', None)]
563     'Sessellift (Wochenende); Taxi (6 Euro)' <=> [('Sessellift', 'Wochenende'), ('Taxi', '6 Euro')]
564     """
565     return opt_no_german_from_str(value, lambda value_enum: enum_from_str(value_enum, lambda value_comment: value_comment_from_str(value_comment, lambda v: choice_from_str(v, LIFT_GERMAN), opt_str_from_str, comment_optional=True)), use_tuple=False, no_value=[], empty=None)
566
567
568 def lift_german_to_str(value):
569     return opt_no_german_to_str(value, lambda value_enum: enum_to_str(value_enum, lambda value_comment: value_comment_to_str(value_comment, str_to_str, opt_str_to_str, comment_optional=True)), use_tuple=False, no_value=[], empty=None)
570
571
572 lift_german_converter = FromToConverter(lift_german_from_str, lift_german_to_str)
573
574
575 # public transport converter
576 # --------------------------
577
578 PUBLIC_TRANSPORT_GERMAN = OrderedDict([(1, 'Sehr gut'), (2, 'Gut'), (3, 'Mittelmäßig'), (4, 'Schlecht'), (5, 'Nein'), (6, 'Ja')])
579
580
581 def public_transport_german_from_str(value):
582     return dictkey_from_str(value, PUBLIC_TRANSPORT_GERMAN)
583
584
585 def public_transport_german_to_str(value):
586     return dictkey_to_str(value, PUBLIC_TRANSPORT_GERMAN)
587
588
589 def opt_public_transport_german_from_str(value):
590     return opt_from_str(value, public_transport_german_from_str)
591
592
593 def opt_public_transport_german_to_str(value):
594     return opt_to_str(value, public_transport_german_to_str)
595
596
597 opt_public_transport_german_converter = FromToConverter(opt_public_transport_german_from_str, opt_public_transport_german_to_str)
598
599
600 # cachet converter
601 # ----------------
602
603 CACHET_REGEXP = [r'(Tiroler Naturrodelbahn-Gütesiegel) ([12]\d{3}) (leicht|mittel|schwer)$']
604
605
606 def single_cachet_german_from_str(value):
607     for pattern in CACHET_REGEXP:
608         match = re.match(pattern, value)
609         if match:
610             return match.groups()
611     raise ValueError("'{}' is no valid cachet".format(value))
612
613
614 def single_cachet_german_to_str(value):
615     return ' '.join(value)
616
617
618 def cachet_german_from_str(value):
619     """Converts a "Gütesiegel":
620     '' => None
621     'Nein' => []
622     'Tiroler Naturrodelbahn-Gütesiegel 2009 mittel' => [('Tiroler Naturrodelbahn-Gütesiegel', '2009', 'mittel')]"""
623     return opt_no_german_from_str(value, lambda val: enum_from_str(val, single_cachet_german_from_str), False, [], None)
624
625
626 def cachet_german_to_str(value):
627     return opt_no_german_to_str(value, lambda val: enum_to_str(val, single_cachet_german_to_str), False, [], None)
628
629
630 cachet_german_converter = FromToConverter(cachet_german_from_str, cachet_german_to_str)
631
632
633 # night light days converter
634 # --------------------------
635
636 def nightlightdays_from_str(value):
637     return value_comment_from_str(value, lambda val: opt_from_str(val, lambda v: int_from_str(v, min=0, max=7)), opt_str_from_str, comment_optional=True)
638
639
640 def nightlightdays_to_str(value):
641     return value_comment_to_str(value, lambda val: opt_to_str(val, int_to_str), opt_str_to_str, comment_optional=True)
642
643
644 nightlightdays_converter = FromToConverter(nightlightdays_from_str, nightlightdays_to_str)
645
646
647 # string with optional comment enum/list converter
648 # ------------------------------------------------
649
650 def opt_str_opt_comment_enum_from_str(value):
651     """The value can be an empty string, 'Nein' or a semicolon-separated list of strings with optional comments.
652     ''                                       => None
653     'Nein'                                   => []
654     'Talstation (nur mit Ticket); Schneealm' => [('Talstation', 'nur mit Ticket'), ('Schneealm', None)]"""
655     return opt_no_german_from_str(value, lambda val: enum_from_str(val, lambda v: value_comment_from_str(v, req_str_from_str, opt_str_from_str, True)), False, [], None)
656
657
658 def opt_str_opt_comment_enum_to_str(value):
659     return opt_no_german_to_str(value, lambda val: enum_to_str(val, lambda v: value_comment_to_str(v, str_to_str, opt_str_to_str, True)), False, [], None)
660
661
662 opt_str_opt_comment_enum_converter = FromToConverter(opt_str_opt_comment_enum_from_str, opt_str_opt_comment_enum_to_str)
663
664
665 # wikibox converter
666 # -----------------
667
668 class ValueErrorList(ValueError):
669     pass
670
671
672 def wikibox_from_template(template, converter_dict):
673     """Returns an ordered dict."""
674     result = OrderedDict()
675     exceptions_dict = OrderedDict()
676     # check values
677     for key, converter in converter_dict.items():
678         try:
679             if not template.has(key):
680                 raise ValueError('Missing parameter "{}"'.format(key))
681             result[key] = converter.from_str(str(template.get(key).value.strip()))
682         except ValueError as e:
683             exceptions_dict[key] = e
684     # check if keys are superfluous
685     superfluous_keys = {str(p.name.strip()) for p in template.params} - set(converter_dict.keys())
686     for key in superfluous_keys:
687         exceptions_dict[key] = ValueError('Superfluous parameter: "{}"'.format(key))
688     if len(exceptions_dict) > 0:
689         raise ValueErrorList('{} error(s) occurred when parsing template parameters.'.format(len(exceptions_dict)), exceptions_dict)
690     return result
691
692
693 def wikibox_to_template(value, name, converter_dict):
694     template = mwparserfromhell.nodes.template.Template(name)
695     for key, converter in converter_dict.items():
696         template.add(key, converter.to_str(value[key]))
697     return template
698
699
700 def template_from_str(value, name):
701     wikicode = mwparserfromhell.parse(value)
702     template_list = [template for template in wikicode.filter_templates(name) if template.name.strip() == name]
703     if len(template_list) == 0:
704         raise ValueError('No "{}" template was found'.format(name))
705     if len(template_list) > 1:
706         raise ValueError('{} "{}" templates were found'.format(len(template_list), name))
707     return template_list[0]
708
709
710 def wikibox_from_str(value, name, converter_dict):
711     template = template_from_str(value, name)
712     return wikibox_from_template(template, converter_dict)
713
714
715 def wikibox_to_str(value, name, converter_dict):
716     return str(wikibox_to_template(value, name, converter_dict))
717
718
719 # Rodelbahnbox converter
720 # ----------------------
721
722 RODELBAHNBOX_TEMPLATE_NAME = 'Rodelbahnbox'
723
724
725 RODELBAHNBOX_DICT = OrderedDict([
726     ('Position', opt_lonlat_converter), # '47.583333 N 15.75 E'
727     ('Position oben', opt_lonlat_converter), # '47.583333 N 15.75 E'
728     ('Höhe oben', opt_uint_converter), # '2000'
729     ('Position unten', opt_lonlat_converter), # '47.583333 N 15.75 E'
730     ('Höhe unten', opt_uint_converter), # '1200'
731     ('Länge', opt_uint_converter), # 3500
732     ('Schwierigkeit', opt_difficulty_german_converter), # 'mittel'
733     ('Lawinen', opt_avalanches_german_converter), # 'kaum'
734     ('Betreiber', opt_str_converter), # 'Max Mustermann'
735     ('Öffentliche Anreise', opt_public_transport_german_converter), # 'Mittelmäßig'
736     ('Aufstieg möglich', opt_bool_german_converter), # 'Ja'
737     ('Aufstieg getrennt', opt_tristate_german_comment_converter), # 'Ja'
738     ('Gehzeit', opt_uint_converter), # 90
739     ('Aufstiegshilfe', lift_german_converter), # 'Gondel (unterer Teil)'
740     ('Beleuchtungsanlage', opt_tristate_german_comment_converter),
741     ('Beleuchtungstage', nightlightdays_converter), # '3 (Montag, Mittwoch, Freitag)'
742     ('Rodelverleih', opt_str_opt_comment_enum_converter), # 'Talstation Serlesbahnan'
743     ('Gütesiegel', cachet_german_converter), # 'Tiroler Naturrodelbahn-Gütesiegel 2009 mittel'
744     ('Webauskunft', webauskunft_converter), # 'http://www.nösslachhütte.at/page9.php'
745     ('Telefonauskunft', opt_phone_comment_enum_converter), # '+43-664-5487520 (Mitterer Alm)'
746     ('Bild', opt_str_converter),
747     ('In Übersichtskarte', opt_bool_german_converter),
748     ('Forumid', opt_uint_converter)
749 ])
750
751
752 def rodelbahnbox_from_template(template):
753     """Returns an ordered dict."""
754     return wikibox_from_template(template, RODELBAHNBOX_DICT)
755
756
757 def rodelbahnbox_to_template(value):
758     return wikibox_to_template(value, RODELBAHNBOX_TEMPLATE_NAME, RODELBAHNBOX_DICT)
759
760
761 def rodelbahnbox_from_str(value):
762     """Returns an ordered dict."""
763     return wikibox_from_str(value, RODELBAHNBOX_TEMPLATE_NAME, RODELBAHNBOX_DICT)
764
765
766 def rodelbahnbox_to_str(value):
767     template = rodelbahnbox_to_template(value)
768     format_template_table(template, 20)
769     return str(template)
770
771
772 # Gasthausbox converter
773 # ---------------------
774
775 GASTHAUSBOX_TEMPLATE_NAME = 'Gasthausbox'
776
777
778 GASTHAUSBOX_DICT = OrderedDict([
779     ('Position', opt_lonlat_converter), # '47.583333 N 15.75 E'
780     ('Höhe', opt_uint_converter),
781     ('Betreiber', opt_str_converter),
782     ('Sitzplätze', opt_uint_converter),
783     ('Übernachtung', opt_no_or_str_converter),
784     ('Rauchfrei', opt_tristate_german_converter),
785     ('Rodelverleih', opt_no_or_str_converter),
786     ('Handyempfang', opt_str_opt_comment_enum_converter),
787     ('Homepage', webauskunft_converter),
788     ('E-Mail', emails_converter),
789     ('Telefon', opt_phone_comment_opt_enum_converter),
790     ('Bild', opt_str_converter),
791     ('Rodelbahnen', opt_wikipage_enum_converter)])
792
793
794 def gasthausbox_from_template(template):
795     """Returns an ordered dict."""
796     return wikibox_from_template(template, GASTHAUSBOX_TEMPLATE_NAME, GASTHAUSBOX_DICT)
797
798
799 def gasthausbox_to_template(value):
800     return wikibox_to_template(value, GASTHAUSBOX_TEMPLATE_NAME, GASTHAUSBOX_DICT)
801
802
803 def gasthausbox_from_str(value):
804     """Returns an ordered dict."""
805     return wikibox_from_str(value, GASTHAUSBOX_TEMPLATE_NAME, GASTHAUSBOX_DICT)
806
807
808 def gasthausbox_to_str(value):
809     template = gasthausbox_to_template(value)
810     format_template_table(template, 17)
811     return str(template)
812
813
814 # Helper function to make page title pretty
815 # -----------------------------------------
816
817 def sledrun_page_title_to_pretty_url(page_title):
818     """Converts a page_title from the page_title column of wrsledruncache to name_url.
819     name_url is not used by MediaWiki but by new applications like wrweb."""
820     return page_title.lower().replace(' ', '-').replace('_', '-').replace('(', '').replace(')', '')