def node(self, data, tags):
capture_tags = {}
keys = tags.keys()
err = []
# node[power=transformer][voltage]
if (u'power' in keys and u'voltage' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'power') == mapcss._value_capture(capture_tags, 0, u'transformer') and mapcss._tag_capture(capture_tags, 1, tags, u'voltage'))
except mapcss.RuleAbort: pass
if match:
# -osmoseTags:list("tag")
# -osmoseItemClassLevel:"9100/91002/2"
# throwWarning:tr("On Power Transformers use voltage:primary=* and voltage:secondary=* in place of voltage")
err.append({'class': 91002, 'subclass': 0, 'text': mapcss.tr(u'On Power Transformers use voltage:primary=* and voltage:secondary=* in place of voltage')})
# node[power=transformer][!frequency]
if (u'power' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'power') == mapcss._value_capture(capture_tags, 0, u'transformer') and not mapcss._tag_capture(capture_tags, 1, tags, u'frequency'))
except mapcss.RuleAbort: pass
if match:
# -osmoseTags:list("tag")
# -osmoseItemClassLevel:"9100/91003/3"
# throwWarning:tr("Power Transformers should have a frequency tag")
# assertNoMatch:"node power=transformer frequency=50"
# assertMatch:"node power=transformer"
err.append({'class': 91003, 'subclass': 0, 'text': mapcss.tr(u'Power Transformers should have a frequency tag')})
return err
def way(self, data, tags, nds):
capture_tags = {}
keys = tags.keys()
err = []
# way[place=locality][name=~/.+([Nn]ord|[Ss]ud$|[Ee]st|[Oo]uest|[Cc]entre)$/][inside("FR")]
# way[place=hamlet][name=~/.+([Nn]ord|[Ss]ud$|[Ee]st|[Oo]uest|[Cc]entre)$/][inside("FR")]
if (u'name' in keys and u'place' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'place') == mapcss._value_capture(capture_tags, 0, u'locality') and mapcss.regexp_test(mapcss._value_capture(capture_tags, 1, self.re_422a87ff), mapcss._tag_capture(capture_tags, 1, tags, u'name')) and mapcss.inside(self.father.config.options, u'FR'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'place') == mapcss._value_capture(capture_tags, 0, u'hamlet') and mapcss.regexp_test(mapcss._value_capture(capture_tags, 1, self.re_422a87ff), mapcss._tag_capture(capture_tags, 1, tags, u'name')) and mapcss.inside(self.father.config.options, u'FR'))
except mapcss.RuleAbort: pass
if match:
# -osmoseItemClassLevel:"5080/50801/1"
# throwError:tr("Hamlet or Locality name suffix Nord, Sud, Est, Ouest, Centre should be removed from Cadastre name. Place should be integrated only once.")
# -osmoseAssertNoMatchWithContext:list('node place=hamlet name="ZA Sud Loire"',"inside=FR")
# -osmoseAssertMatchWithContext:list('node place=hamlet name=Montdésert-Sud',"inside=FR")
err.append({'class': 50801, 'subclass': 0, 'text': mapcss.tr(u'Hamlet or Locality name suffix Nord, Sud, Est, Ouest, Centre should be removed from Cadastre name. Place should be integrated only once.')})
return err
def relation(self, data, tags, members):
capture_tags = {}
keys = tags.keys()
err = []
# *[religion=catholic]
if ('religion' in keys):
match = False
if not match:
capture_tags = {}
try: match = ((mapcss._tag_capture(capture_tags, 0, tags, 'religion') == mapcss._value_capture(capture_tags, 0, 'catholic')))
except mapcss.RuleAbort: pass
if match:
# throwWarning:tr("{0}","{0.tag}")
# suggestAlternative:"religion=christian + denomination=catholic"
# fixChangeKey:"religion => denomination"
# fixAdd:"religion=christian"
err.append({'class': 9008005, 'subclass': 97466527, 'text': mapcss.tr('{0}', mapcss._tag_uncapture(capture_tags, '{0.tag}')), 'allow_fix_override': True, 'fix': {
'+': dict([
['denomination', mapcss.tag(tags, 'religion')],
['religion','christian']]),
'-': ([
'religion'])
}})
return err
def way(self, data, tags, nds):
capture_tags = {}
keys = tags.keys()
err = []
# way[power=transformer]
if (u'power' in keys):
match = False
if not match:
capture_tags = {}
try:
match = (mapcss._tag_capture(
capture_tags, 0, tags,
u'power') == mapcss._value_capture(
capture_tags, 0, u'transformer'))
except mapcss.RuleAbort:
pass
if match:
# -osmoseTags:list("geom")
# -osmoseItemClassLevel:"9100/91001/2"
# throwWarning:tr("Power Transformers should always be on a node")
err.append({
'class':
91001,
'subclass':
0,
'text':
mapcss.tr(u'Power Transformers should always be on a node')
})
return err
def relation(self, data, tags, *args):
capture_tags = {}
keys = tags.keys()
err = []
# relation[power=transformer]
if u'power' in keys:
match = False
try:
match = match or ((mapcss._tag_capture(
capture_tags, 0, tags, u'power') == mapcss._value_capture(
capture_tags, 0, u'transformer')))
except mapcss.RuleAbort:
pass
if match:
# osmoseTags:list("geom","power")
# osmoseItemClassLevel:"9100/91001/2"
# throwWarning:tr("Power Transformers should always be on a node")
err.append({
'class':
91001,
'subclass':
0,
'text':
mapcss.tr(u'Power Transformers should always be on a node',
capture_tags)
})
return err
def way(self, data, tags, nds):
capture_tags = {}
keys = tags.keys()
err = []
set_ok_housenumber = False
# *[addr:housenumber][addr:housename]["addr:housenumber"=*"addr:housename"]
if (u'addr:housename' in keys and u'addr:housenumber' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'addr:housenumber') and mapcss._tag_capture(capture_tags, 1, tags, u'addr:housename') and mapcss._tag_capture(capture_tags, 2, tags, u'addr:housenumber') == mapcss._value_capture(capture_tags, 2, mapcss.tag(tags, u'addr:housename')))
except mapcss.RuleAbort: pass
if match:
# throwWarning:tr("Same value of {0} and {1}","{0.key}","{1.key}")
err.append({'class': 9000003, 'subclass': 1820984183, 'text': mapcss.tr(u'Same value of {0} and {1}', mapcss._tag_uncapture(capture_tags, u'{0.key}'), mapcss._tag_uncapture(capture_tags, u'{1.key}'))})
# *[addr:housenumber=bb][inside("BA")]
if (u'addr:housenumber' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'addr:housenumber') == mapcss._value_capture(capture_tags, 0, u'bb') and mapcss.inside(self.father.config.options, u'BA'))
except mapcss.RuleAbort: pass
if match:
# setok_housenumber
set_ok_housenumber = True
# *[addr:housenumber][addr:housenumber!~/[0-9]/]!.ok_housenumber
if (u'addr:housenumber' in keys):
match = False
if not match:
capture_tags = {}
try: match = (not set_ok_housenumber and mapcss._tag_capture(capture_tags, 0, tags, u'addr:housenumber') and not mapcss.regexp_test(mapcss._value_const_capture(capture_tags, 1, self.re_4983542e, u'[0-9]'), mapcss._tag_capture(capture_tags, 1, tags, u'addr:housenumber')))
except mapcss.RuleAbort: pass
if match:
# throwWarning:tr("{0} without number","{0.key}")
# assertNoMatch:"way addr:housenumber=0"
# assertNoMatch:"way addr:housenumber=5/1"
# assertNoMatch:"way addr:housenumber=5a"
# assertMatch:"way addr:housenumber=?"
# assertMatch:"way addr:housenumber=Palace of Westminster"
# assertMatch:"way addr:housenumber=S/N"
# assertMatch:"way addr:housenumber=unknown"
err.append({'class': 9000004, 'subclass': 1053226919, 'text': mapcss.tr(u'{0} without number', mapcss._tag_uncapture(capture_tags, u'{0.key}'))})
return err
def way(self, data, tags, *args):
capture_tags = {}
keys = tags.keys()
err = []
# way[place=locality][name=~/.+([Nn]ord|[Ss]ud$|[Ee]st|[Oo]uest|[Cc]entre)$/][inside("FR")]
# way[place=hamlet][name=~/.+([Nn]ord|[Ss]ud$|[Ee]st|[Oo]uest|[Cc]entre)$/][inside("FR")]
if u'place' in keys:
match = False
try:
match = match or (
(mapcss._tag_capture(capture_tags, 0, tags, u'place')
== mapcss._value_capture(capture_tags, 0, u'locality')
and mapcss.regexp_test_(
mapcss._value_capture(capture_tags, 1,
self.re_422a87ff),
mapcss._tag_capture(capture_tags, 1, tags, u'name'))
and mapcss.inside(self.father.config.options, u'FR')))
except mapcss.RuleAbort:
pass
try:
match = match or (
(mapcss._tag_capture(capture_tags, 0, tags, u'place')
== mapcss._value_capture(capture_tags, 0, u'hamlet')
and mapcss.regexp_test_(
mapcss._value_capture(capture_tags, 1,
self.re_422a87ff),
mapcss._tag_capture(capture_tags, 1, tags, u'name'))
and mapcss.inside(self.father.config.options, u'FR')))
except mapcss.RuleAbort:
pass
if match:
# osmoseTags:list("name")
# osmoseItemClassLevel:"5080/50801/1"
# throwError:tr("Hamlet or Locality name suffix Nord, Sud, Est, Ouest, Centre should be removed from Cadastre name. Place should be integrated only once.")
err.append({
'class':
50801,
'subclass':
0,
'text':
mapcss.tr(
u'Hamlet or Locality name suffix Nord, Sud, Est, Ouest, Centre should be removed from Cadastre name. Place should be integrated only once.',
capture_tags)
})
return err
def relation(self, data, tags, members):
capture_tags = {}
keys = tags.keys()
err = []
# *[leisure=swimming_pool][building=yes]
# *[leisure=swimming_pool][website]
# *[leisure=swimming_pool][url]
# *[leisure=swimming_pool][contact:website]
# *[leisure=swimming_pool][contact:url]
# *[leisure=swimming_pool][phone]
# *[leisure=swimming_pool][contact:phone]
# *[leisure=swimming_pool][wikipedia]
if (u'building' in keys and u'leisure' in keys) or (u'contact:phone' in keys and u'leisure' in keys) or (u'contact:url' in keys and u'leisure' in keys) or (u'contact:website' in keys and u'leisure' in keys) or (u'leisure' in keys and u'phone' in keys) or (u'leisure' in keys and u'url' in keys) or (u'leisure' in keys and u'website' in keys) or (u'leisure' in keys and u'wikipedia' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'leisure') == mapcss._value_capture(capture_tags, 0, u'swimming_pool') and mapcss._tag_capture(capture_tags, 1, tags, u'building') == mapcss._value_capture(capture_tags, 1, u'yes'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'leisure') == mapcss._value_capture(capture_tags, 0, u'swimming_pool') and mapcss._tag_capture(capture_tags, 1, tags, u'website'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'leisure') == mapcss._value_capture(capture_tags, 0, u'swimming_pool') and mapcss._tag_capture(capture_tags, 1, tags, u'url'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'leisure') == mapcss._value_capture(capture_tags, 0, u'swimming_pool') and mapcss._tag_capture(capture_tags, 1, tags, u'contact:website'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'leisure') == mapcss._value_capture(capture_tags, 0, u'swimming_pool') and mapcss._tag_capture(capture_tags, 1, tags, u'contact:url'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'leisure') == mapcss._value_capture(capture_tags, 0, u'swimming_pool') and mapcss._tag_capture(capture_tags, 1, tags, u'phone'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'leisure') == mapcss._value_capture(capture_tags, 0, u'swimming_pool') and mapcss._tag_capture(capture_tags, 1, tags, u'contact:phone'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'leisure') == mapcss._value_capture(capture_tags, 0, u'swimming_pool') and mapcss._tag_capture(capture_tags, 1, tags, u'wikipedia'))
except mapcss.RuleAbort: pass
if match:
# group:tr("Suspicious tag association - possible confusion between swimming_pool and sports_centre")
# -osmoseTags:list("tag","fix:chair","leisure","public equipment")
# -osmoseItemClassLevel:"3080/30801/3"
# throwWarning:tr("If this is a facility containing one or more swimming pools it should be tagged leisure=sports_centre + sport=swimming.")
# assertMatch:"relation leisure=swimming_pool phone=+3334656565"
err.append({'class': 30801, 'subclass': 0, 'text': mapcss.tr(u'If this is a facility containing one or more swimming pools it should be tagged leisure=sports_centre + sport=swimming.')})
return err
def node(self, data, tags):
capture_tags = {}
keys = tags.keys()
err = []
# *[operator=ERDF][inside("FR")]
if (u'operator' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'operator') == mapcss._value_capture(capture_tags, 0, u'ERDF') and mapcss.inside(self.father.config.options, u'FR'))
except mapcss.RuleAbort: pass
if match:
# group:tr("deprecated tagging")
# throwWarning:tr("{0} is deprecated","{0.tag}")
# suggestAlternative:"operator=Enedis"
# fixAdd:"operator=Enedis"
err.append({'class': 9009001, 'subclass': 262422756, 'text': mapcss.tr(u'{0} is deprecated', mapcss._tag_uncapture(capture_tags, u'{0.tag}')), 'allow_fix_override': True, 'fix': {
'+': dict([
[u'operator',u'Enedis']])
}})
# *[addr:street=~/(?i).*Strasse.*/][addr:street!~/(?i).*Strasser.*/][inside("DE,AT")]
# *[name=~/(?i).*Strasse.*/][name!~/(?i).*Strasser.*/][inside("DE,AT")]
if (u'addr:street' in keys) or (u'name' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test(mapcss._value_capture(capture_tags, 0, self.re_5b84a257), mapcss._tag_capture(capture_tags, 0, tags, u'addr:street')) and not mapcss.regexp_test(mapcss._value_capture(capture_tags, 1, self.re_559797c8), mapcss._tag_capture(capture_tags, 1, tags, u'addr:street')) and mapcss.inside(self.father.config.options, u'DE,AT'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test(mapcss._value_capture(capture_tags, 0, self.re_5b84a257), mapcss._tag_capture(capture_tags, 0, tags, u'name')) and not mapcss.regexp_test(mapcss._value_capture(capture_tags, 1, self.re_559797c8), mapcss._tag_capture(capture_tags, 1, tags, u'name')) and mapcss.inside(self.father.config.options, u'DE,AT'))
except mapcss.RuleAbort: pass
if match:
# throwError:tr("street name contains ss")
err.append({'class': 9009002, 'subclass': 821908491, 'text': mapcss.tr(u'street name contains ss')})
# *[addr:street=~/(?i).*Straße.*/][inside("LI,CH")]
# *[name=~/(?i).*Straße.*/][inside("LI,CH")]
if (u'addr:street' in keys) or (u'name' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test(mapcss._value_capture(capture_tags, 0, self.re_3d3faeb5), mapcss._tag_capture(capture_tags, 0, tags, u'addr:street')) and mapcss.inside(self.father.config.options, u'LI,CH'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test(mapcss._value_capture(capture_tags, 0, self.re_3d3faeb5), mapcss._tag_capture(capture_tags, 0, tags, u'name')) and mapcss.inside(self.father.config.options, u'LI,CH'))
except mapcss.RuleAbort: pass
if match:
# throwError:tr("street name contains ß")
err.append({'class': 9009003, 'subclass': 610086334, 'text': mapcss.tr(u'street name contains ß')})
return err
def relation(self, data, tags, members):
capture_tags = {}
keys = tags.keys()
err = []
# *[addr:street=~/(?i).*Strasse.*/][addr:street!~/(?i).*Strasser.*/][inside("DE,AT")]
# *[name=~/(?i).*Strasse.*/][name!~/(?i).*Strasser.*/][inside("DE,AT")]
if (u'addr:street' in keys) or (u'name' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test(mapcss._value_capture(capture_tags, 0, self.re_5b84a257), mapcss._tag_capture(capture_tags, 0, tags, u'addr:street')) and not mapcss.regexp_test(mapcss._value_const_capture(capture_tags, 1, self.re_559797c8, u'(?i).*Strasser.*'), mapcss._tag_capture(capture_tags, 1, tags, u'addr:street')) and mapcss.inside(self.father.config.options, u'DE,AT'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test(mapcss._value_capture(capture_tags, 0, self.re_5b84a257), mapcss._tag_capture(capture_tags, 0, tags, u'name')) and not mapcss.regexp_test(mapcss._value_const_capture(capture_tags, 1, self.re_559797c8, u'(?i).*Strasser.*'), mapcss._tag_capture(capture_tags, 1, tags, u'name')) and mapcss.inside(self.father.config.options, u'DE,AT'))
except mapcss.RuleAbort: pass
if match:
# throwError:tr("street name contains ss")
err.append({'class': 9009002, 'subclass': 821908491, 'text': mapcss.tr(u'street name contains ss')})
# *[addr:street=~/(?i).*Straße.*/][inside("LI,CH")]
# *[name=~/(?i).*Straße.*/][inside("LI,CH")]
if (u'addr:street' in keys) or (u'name' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test(mapcss._value_capture(capture_tags, 0, self.re_3d3faeb5), mapcss._tag_capture(capture_tags, 0, tags, u'addr:street')) and mapcss.inside(self.father.config.options, u'LI,CH'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test(mapcss._value_capture(capture_tags, 0, self.re_3d3faeb5), mapcss._tag_capture(capture_tags, 0, tags, u'name')) and mapcss.inside(self.father.config.options, u'LI,CH'))
except mapcss.RuleAbort: pass
if match:
# throwError:tr("street name contains ß")
err.append({'class': 9009003, 'subclass': 610086334, 'text': mapcss.tr(u'street name contains ß')})
# relation[type=associatedStreet][inside("DE")]
if (u'type' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'type') == mapcss._value_capture(capture_tags, 0, u'associatedStreet') and mapcss.inside(self.father.config.options, u'DE'))
except mapcss.RuleAbort: pass
if match:
# group:tr("deprecated tagging")
# throwWarning:tr("{0} is deprecated in {1}","{0.tag}","Deutschland")
# suggestAlternative:"addr:street"
err.append({'class': 9009001, 'subclass': 746730328, 'text': mapcss.tr(u'{0} is deprecated in {1}', mapcss._tag_uncapture(capture_tags, u'{0.tag}'), u'Deutschland')})
return err
def node(self, data, tags):
capture_tags = {}
keys = tags.keys()
err = []
# *[addr:housenumber][addr:housename]["addr:housenumber"=*"addr:housename"]
if (u'addr:housename' in keys and u'addr:housenumber' in keys):
match = False
if not match:
capture_tags = {}
try:
match = (mapcss._tag_capture(capture_tags, 0, tags,
u'addr:housenumber')
and mapcss._tag_capture(capture_tags, 1, tags,
u'addr:housename')
and mapcss._tag_capture(
capture_tags, 2, tags,
u'addr:housenumber') == mapcss._value_capture(
capture_tags, 2,
mapcss.tag(tags, u'addr:housename')))
except mapcss.RuleAbort:
pass
if match:
# throwWarning:tr("Same value of {0} and {1}","{0.key}","{1.key}")
# assertMatch:"node addr:housename=1 addr:housenumber=1"
# assertNoMatch:"node addr:housename=1 addr:housenumber=2"
err.append({
'class':
9000003,
'subclass':
1820984183,
'text':
mapcss.tr(u'Same value of {0} and {1}',
mapcss._tag_uncapture(capture_tags, u'{0.key}'),
mapcss._tag_uncapture(capture_tags, u'{1.key}'))
})
return err
def node(self, data, tags):
capture_tags = {}
keys = tags.keys()
err = []
# *[building:colour][building:colour=~/^#/][building:colour!~/^#([0-9A-Fa-f]{3}|[0-9A-Fa-f]{6})$/]
# *[roof:colour][roof:colour=~/^#/][roof:colour!~/^#([0-9A-Fa-f]{3}|[0-9A-Fa-f]{6})$/]
# *[ref:colour][ref:colour=~/^#/][ref:colour!~/^#([0-9A-Fa-f]{3}|[0-9A-Fa-f]{6})$/]
if (u'building:colour' in keys) or (u'ref:colour' in keys) or (u'roof:colour' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'building:colour') and mapcss.regexp_test(mapcss._value_capture(capture_tags, 1, self.re_30dca0d4), mapcss._tag_capture(capture_tags, 1, tags, u'building:colour')) and not mapcss.regexp_test(mapcss._value_capture(capture_tags, 2, self.re_1b3f6ace), mapcss._tag_capture(capture_tags, 2, tags, u'building:colour')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'roof:colour') and mapcss.regexp_test(mapcss._value_capture(capture_tags, 1, self.re_30dca0d4), mapcss._tag_capture(capture_tags, 1, tags, u'roof:colour')) and not mapcss.regexp_test(mapcss._value_capture(capture_tags, 2, self.re_1b3f6ace), mapcss._tag_capture(capture_tags, 2, tags, u'roof:colour')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'ref:colour') and mapcss.regexp_test(mapcss._value_capture(capture_tags, 1, self.re_30dca0d4), mapcss._tag_capture(capture_tags, 1, tags, u'ref:colour')) and not mapcss.regexp_test(mapcss._value_capture(capture_tags, 2, self.re_1b3f6ace), mapcss._tag_capture(capture_tags, 2, tags, u'ref:colour')))
except mapcss.RuleAbort: pass
if match:
# group:tr("Colour code should start with '#' followed by 3 or 6 digits")
# -osmoseItemClassLevel:"3091/30911:0/2"
# throwWarning:tr("{0} colour code should start with '#' followed by 3 or 6 digits","{0.tag}")
err.append({'class': 30911, 'subclass': 0, 'text': mapcss.tr(u'{0} colour code should start with \'#\' followed by 3 or 6 digits', mapcss._tag_uncapture(capture_tags, u'{0.tag}'))})
# *[building:colour][building:colour=~/^([0-9A-Fa-f]{3}|[0-9A-Fa-f]{6})$/]
# *[roof:colour][roof:colour=~/^([0-9A-Fa-f]{3}|[0-9A-Fa-f]{6})$/]
# *[ref:colour][ref:colour=~/^([0-9A-Fa-f]{3}|[0-9A-Fa-f]{6})$/]
if (u'building:colour' in keys) or (u'ref:colour' in keys) or (u'roof:colour' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'building:colour') and mapcss.regexp_test(mapcss._value_capture(capture_tags, 1, self.re_7d65c79d), mapcss._tag_capture(capture_tags, 1, tags, u'building:colour')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'roof:colour') and mapcss.regexp_test(mapcss._value_capture(capture_tags, 1, self.re_7d65c79d), mapcss._tag_capture(capture_tags, 1, tags, u'roof:colour')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'ref:colour') and mapcss.regexp_test(mapcss._value_capture(capture_tags, 1, self.re_7d65c79d), mapcss._tag_capture(capture_tags, 1, tags, u'ref:colour')))
except mapcss.RuleAbort: pass
if match:
# group:tr("Colour code should start with '#' followed by 3 or 6 digits")
# -osmoseItemClassLevel:"3091/30911:1/2"
# throwWarning:tr("{0} colour code should start with '#' followed by 3 or 6 digits","{0.tag}")
# fixAdd:"{0.key}=#{0.value}"
err.append({'class': 30911, 'subclass': 1, 'text': mapcss.tr(u'{0} colour code should start with \'#\' followed by 3 or 6 digits', mapcss._tag_uncapture(capture_tags, u'{0.tag}')), 'allow_fix_override': True, 'fix': {
'+': dict([
(mapcss._tag_uncapture(capture_tags, u'{0.key}=#{0.value}')).split('=', 1)])
}})
return err
def node(self, data, tags):
capture_tags = {}
keys = tags.keys()
err = []
# *[phone][contact:phone][contact:phone!=tag(phone)]
# *[fax][contact:fax][contact:fax!=tag(fax)]
# *[email][contact:email][contact:email!=tag(email)]
# *[website][contact:website][contact:website!=tag(website)]
if ('contact:email' in keys and 'email' in keys) or ('contact:fax' in keys and 'fax' in keys) or ('contact:phone' in keys and 'phone' in keys) or ('contact:website' in keys and 'website' in keys):
match = False
if not match:
capture_tags = {}
try: match = ((mapcss._tag_capture(capture_tags, 0, tags, 'phone')) and (mapcss._tag_capture(capture_tags, 1, tags, 'contact:phone')) and (mapcss._tag_capture(capture_tags, 2, tags, 'contact:phone') != mapcss._value_capture(capture_tags, 2, mapcss.tag(tags, 'phone'))))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = ((mapcss._tag_capture(capture_tags, 0, tags, 'fax')) and (mapcss._tag_capture(capture_tags, 1, tags, 'contact:fax')) and (mapcss._tag_capture(capture_tags, 2, tags, 'contact:fax') != mapcss._value_capture(capture_tags, 2, mapcss.tag(tags, 'fax'))))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = ((mapcss._tag_capture(capture_tags, 0, tags, 'email')) and (mapcss._tag_capture(capture_tags, 1, tags, 'contact:email')) and (mapcss._tag_capture(capture_tags, 2, tags, 'contact:email') != mapcss._value_capture(capture_tags, 2, mapcss.tag(tags, 'email'))))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = ((mapcss._tag_capture(capture_tags, 0, tags, 'website')) and (mapcss._tag_capture(capture_tags, 1, tags, 'contact:website')) and (mapcss._tag_capture(capture_tags, 2, tags, 'contact:website') != mapcss._value_capture(capture_tags, 2, mapcss.tag(tags, 'website'))))
except mapcss.RuleAbort: pass
if match:
# group:tr("Different value of tag contact:* and *")
# -osmoseItemClassLevel:"3092/3097/2"
# throwWarning:tr("Different values of {0} and of {1}","{0.key}","{1.key}")
# assertMatch:"node phone=1 contact:phone=2"
# assertNoMatch:"node website=1 contact:website=1"
err.append({'class': 3097, 'subclass': 0, 'text': mapcss.tr('Different values of {0} and of {1}', mapcss._tag_uncapture(capture_tags, '{0.key}'), mapcss._tag_uncapture(capture_tags, '{1.key}'))})
return err
def way(self, data, tags, nds):
capture_tags = {}
keys = tags.keys()
err = []
# way[highway][construction][highway!=construction][construction!=minor]
# way[highway][proposed][highway!=proposed]
# way[railway][construction][railway!=construction][railway!=abandoned][railway!=razed][railway!=dismantled][construction!=minor]
# way[railway][proposed][railway!=proposed][railway!=abandoned][railway!=razed][railway!=dismantled][railway!=disused]
if (u'construction' in keys and u'highway' in keys) or (u'construction' in keys and u'railway' in keys) or (u'highway' in keys and u'proposed' in keys) or (u'proposed' in keys and u'railway' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'highway') and mapcss._tag_capture(capture_tags, 1, tags, u'construction') and mapcss._tag_capture(capture_tags, 2, tags, u'highway') != mapcss._value_const_capture(capture_tags, 2, u'construction', u'construction') and mapcss._tag_capture(capture_tags, 3, tags, u'construction') != mapcss._value_const_capture(capture_tags, 3, u'minor', u'minor'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'highway') and mapcss._tag_capture(capture_tags, 1, tags, u'proposed') and mapcss._tag_capture(capture_tags, 2, tags, u'highway') != mapcss._value_const_capture(capture_tags, 2, u'proposed', u'proposed'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'railway') and mapcss._tag_capture(capture_tags, 1, tags, u'construction') and mapcss._tag_capture(capture_tags, 2, tags, u'railway') != mapcss._value_const_capture(capture_tags, 2, u'construction', u'construction') and mapcss._tag_capture(capture_tags, 3, tags, u'railway') != mapcss._value_const_capture(capture_tags, 3, u'abandoned', u'abandoned') and mapcss._tag_capture(capture_tags, 4, tags, u'railway') != mapcss._value_const_capture(capture_tags, 4, u'razed', u'razed') and mapcss._tag_capture(capture_tags, 5, tags, u'railway') != mapcss._value_const_capture(capture_tags, 5, u'dismantled', u'dismantled') and mapcss._tag_capture(capture_tags, 6, tags, u'construction') != mapcss._value_const_capture(capture_tags, 6, u'minor', u'minor'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'railway') and mapcss._tag_capture(capture_tags, 1, tags, u'proposed') and mapcss._tag_capture(capture_tags, 2, tags, u'railway') != mapcss._value_const_capture(capture_tags, 2, u'proposed', u'proposed') and mapcss._tag_capture(capture_tags, 3, tags, u'railway') != mapcss._value_const_capture(capture_tags, 3, u'abandoned', u'abandoned') and mapcss._tag_capture(capture_tags, 4, tags, u'railway') != mapcss._value_const_capture(capture_tags, 4, u'razed', u'razed') and mapcss._tag_capture(capture_tags, 5, tags, u'railway') != mapcss._value_const_capture(capture_tags, 5, u'dismantled', u'dismantled') and mapcss._tag_capture(capture_tags, 6, tags, u'railway') != mapcss._value_const_capture(capture_tags, 6, u'disused', u'disused'))
except mapcss.RuleAbort: pass
if match:
# -osmoseItemClassLevel:"4070/40701/1"
# throwError:tr("Inconsistent tagging of {0}","{1.key}")
# assertNoMatch:"way highway=construction construction=primary"
# assertNoMatch:"way highway=primary construction=minor"
# assertMatch:"way highway=primary construction=primary"
err.append({'class': 40701, 'subclass': 0, 'text': mapcss.tr(u'Inconsistent tagging of {0}', mapcss._tag_uncapture(capture_tags, u'{1.key}'))})
return err
def way(self, data, tags, nds):
capture_tags = {}
keys = tags.keys()
err = []
# way[place=locality][name=~/.+([- ]([Nn]ord|[Ss]ud$|[Ee]st|[Oo]uest|[Cc]entre))$/][inside("FR")]
# way[place=hamlet][name=~/.+([- ]([Nn]ord|[Ss]ud$|[Ee]st|[Oo]uest|[Cc]entre))$/][inside("FR")]
if ('name' in keys and 'place' in keys):
match = False
if not match:
capture_tags = {}
try: match = ((mapcss._tag_capture(capture_tags, 0, tags, 'place') == mapcss._value_capture(capture_tags, 0, 'locality')) and (mapcss.regexp_test(mapcss._value_capture(capture_tags, 1, self.re_5d724bf1), mapcss._tag_capture(capture_tags, 1, tags, 'name'))) and (mapcss.inside(self.father.config.options, 'FR')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = ((mapcss._tag_capture(capture_tags, 0, tags, 'place') == mapcss._value_capture(capture_tags, 0, 'hamlet')) and (mapcss.regexp_test(mapcss._value_capture(capture_tags, 1, self.re_5d724bf1), mapcss._tag_capture(capture_tags, 1, tags, 'name'))) and (mapcss.inside(self.father.config.options, 'FR')))
except mapcss.RuleAbort: pass
if match:
# -osmoseItemClassLevel:"5080/50801/1"
# throwError:tr("Hamlet or Locality name suffix Nord, Sud, Est, Ouest, Centre should be removed from Cadastre name. Place should be integrated only once.")
err.append({'class': 50801, 'subclass': 0, 'text': mapcss.tr('Hamlet or Locality name suffix Nord, Sud, Est, Ouest, Centre should be removed from Cadastre name. Place should be integrated only once.')})
return err
def way(self, data, tags, nds):
capture_tags = {}
keys = tags.keys()
err = []
# way[highway][construction][highway!=construction]
# way[highway][proposed][highway!=proposed]
# way[railway][construction][railway!=construction]
# way[railway][proposed][railway!=proposed]
if (u'construction' in keys and u'highway' in keys) or (u'construction' in keys and u'railway' in keys) or (u'highway' in keys and u'proposed' in keys) or (u'proposed' in keys and u'railway' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'highway') and mapcss._tag_capture(capture_tags, 1, tags, u'construction') and mapcss._tag_capture(capture_tags, 2, tags, u'highway') != mapcss._value_capture(capture_tags, 2, u'construction'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'highway') and mapcss._tag_capture(capture_tags, 1, tags, u'proposed') and mapcss._tag_capture(capture_tags, 2, tags, u'highway') != mapcss._value_capture(capture_tags, 2, u'proposed'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'railway') and mapcss._tag_capture(capture_tags, 1, tags, u'construction') and mapcss._tag_capture(capture_tags, 2, tags, u'railway') != mapcss._value_capture(capture_tags, 2, u'construction'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'railway') and mapcss._tag_capture(capture_tags, 1, tags, u'proposed') and mapcss._tag_capture(capture_tags, 2, tags, u'railway') != mapcss._value_capture(capture_tags, 2, u'proposed'))
except mapcss.RuleAbort: pass
if match:
# -osmoseItemClassLevel:"4070/40701/1"
# throwError:tr("Inconsistent tagging of {0}","{1.key}")
# assertNoMatch:"way highway=construction construction=primary"
# assertMatch:"way highway=primary construction=primary"
err.append({'class': 40701, 'subclass': 0, 'text': mapcss.tr(u'Inconsistent tagging of {0}', mapcss._tag_uncapture(capture_tags, u'{1.key}'))})
return err
def way(self, data, tags, nds):
capture_tags = {}
keys = tags.keys()
err = []
# way[railway=rail][!gauge][inside("FR")]
if (u'railway' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'railway') == mapcss._value_capture(capture_tags, 0, u'rail') and not mapcss._tag_capture(capture_tags, 1, tags, u'gauge') and mapcss.inside(self.father.config.options, u'FR'))
except mapcss.RuleAbort: pass
if match:
# -osmoseTags:list("tag","railway")
# -osmoseItemClassLevel:"2160/21600/3"
# throwWarning:tr("Missing tag gauge on rail")
# suggestAlternative:"gauge"
# -osmoseAssertNoMatchWithContext:list("way railway=disused","inside=FR")
# -osmoseAssertNoMatchWithContext:list("way railway=rail gauge=1435","inside=FR")
# -osmoseAssertMatchWithContext:list("way railway=rail","inside=FR")
err.append({'class': 21600, 'subclass': 0, 'text': mapcss.tr(u'Missing tag gauge on rail')})
# *[name=~/(?i)co.?voiturage/][amenity!=car_pooling][!carpool][inside("FR")]
if (u'name' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test(mapcss._value_capture(capture_tags, 0, self.re_045a0f34), mapcss._tag_capture(capture_tags, 0, tags, u'name')) and mapcss._tag_capture(capture_tags, 1, tags, u'amenity') != mapcss._value_const_capture(capture_tags, 1, u'car_pooling', u'car_pooling') and not mapcss._tag_capture(capture_tags, 2, tags, u'carpool') and mapcss.inside(self.father.config.options, u'FR'))
except mapcss.RuleAbort: pass
if match:
# -osmoseTags:list("parking","amenity","fix:chair")
# -osmoseItemClassLevel:"2080/20806/3"
# throwWarning:tr("Missing tag carpool on area")
# fixAdd:"amenity=car_pooling"
# fixAdd:"carpool=designated"
# -osmoseAssertNoMatchWithContext:list("way name='Aire de covoiturage' amenity=car_pooling","inside=FR")
# -osmoseAssertMatchWithContext:list("way name='Aire de covoiturage' amenity=car_sharing","inside=FR")
# -osmoseAssertNoMatchWithContext:list("way name='Aire de covoiturage' amenity=parking carpool=designated","inside=FR")
err.append({'class': 20806, 'subclass': 0, 'text': mapcss.tr(u'Missing tag carpool on area'), 'allow_fix_override': True, 'fix': {
'+': dict([
[u'amenity',u'car_pooling'],
[u'carpool',u'designated']])
}})
return err
def way(self, data, tags, nds):
capture_tags = {}
keys = tags.keys()
err = []
set_pt_route = set_pt_route_master = False
# way[highway=bus_stop]
if (u'highway' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'highway') == mapcss._value_capture(capture_tags, 0, u'bus_stop'))
except mapcss.RuleAbort: pass
if match:
# throwError:tr("A bus stop is supposed to be a node")
err.append({'class': 9014019, 'subclass': 1153984743, 'text': mapcss.tr(u'A bus stop is supposed to be a node')})
return err
def relation(self, data, tags, members):
capture_tags = {}
keys = tags.keys()
err = []
# *[addr:housenumber][addr:housenumber!~/^((?:вл)?[0-9]+[А-Я]?(?:\/[0-9]+[А-Я]?)?(?: к[0-9А-Я]+)?(?: с[0-9А-Я]+)?(?: соор[0-9А-Я]+)?(?: лит[0-9А-Я]+)?(?: фл[0-9А-Я]+)?|[0-9]+-[0-9]+|[0-9]+[А-Я]?[\/-][0-9]+[А-Я]?[\/-][0-9]+[А-Я]?|(([0-9]+[А-Я]?[IXV]*)|[IXV]*)[\/-]([0-9]+[А-Я]?|[IXV]*)|ЗЯБ-[0-9]+|С-([0-9]+[А-Я]?(?:\/[0-9]+[А-Я]?)?|[IXV]*)|к[0-9А-Я]+)$/]
if (u'addr:housenumber' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'addr:housenumber') and not mapcss.regexp_test_(mapcss._value_capture(capture_tags, 1, self.re_62d22c1b), mapcss._tag_capture(capture_tags, 1, tags, u'addr:housenumber')))
except mapcss.RuleAbort: pass
if match:
# throwWarning:tr("Номера домов не соответствующие принятому соглашению")
err.append({'class': 9017001, 'subclass': 774061168, 'text': mapcss.tr(u'Номера домов не соответствующие принятому соглашению')})
return err
def relation(self, data, tags, members):
capture_tags = {}
keys = tags.keys()
err = []
# *[addr:housenumber][addr:housenumber!~/^((?:вл)?[0-9]+[А-Я]?(?:\/[0-9]+[А-Я]?)?(?: к[0-9А-Я]+)?(?: с[0-9А-Я]+)?(?: соор[0-9А-Я]+)?(?: лит[0-9А-Я]+)?(?: фл[0-9А-Я]+)?|[0-9]+-[0-9]+|[0-9]+[А-Я]?[\/-][0-9]+[А-Я]?[\/-][0-9]+[А-Я]?|(([0-9]+[А-Я]?[IXV]*)|[IXV]*)[\/-]([0-9]+[А-Я]?|[IXV]*)|ЗЯБ-[0-9]+|С-([0-9]+[А-Я]?(?:\/[0-9]+[А-Я]?)?|[IXV]*)|к[0-9А-Я]+)$/]
if (u'addr:housenumber' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'addr:housenumber') and not mapcss.regexp_test(mapcss._value_capture(capture_tags, 1, self.re_62d22c1b), mapcss._tag_capture(capture_tags, 1, tags, u'addr:housenumber')))
except mapcss.RuleAbort: pass
if match:
# throwWarning:tr("Номера домов не соответствующие принятому соглашению")
err.append({'class': 9017001, 'subclass': 774061168, 'text': mapcss.tr(u'Номера домов не соответствующие принятому соглашению')})
return err
def relation(self, data, tags, members):
capture_tags = {}
keys = tags.keys()
err = []
# *[addr:housenumber][addr:housename]["addr:housenumber"=*"addr:housename"]
if (u'addr:housename' in keys and u'addr:housenumber' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'addr:housenumber') and mapcss._tag_capture(capture_tags, 1, tags, u'addr:housename') and mapcss._tag_capture(capture_tags, 2, tags, u'addr:housenumber') == mapcss._value_capture(capture_tags, 2, mapcss.tag(tags, u'addr:housename')))
except mapcss.RuleAbort: pass
if match:
# throwWarning:tr("Same value of {0} and {1}","{0.key}","{1.key}")
err.append({'class': 9000003, 'subclass': 1820984183, 'text': mapcss.tr(u'Same value of {0} and {1}', mapcss._tag_uncapture(capture_tags, u'{0.key}'), mapcss._tag_uncapture(capture_tags, u'{1.key}'))})
return err
def relation(self, data, tags, members):
capture_tags = {}
keys = tags.keys()
err = []
# *[amenity=pharmacy][!dispensing][inside("IT")]
if (u'amenity' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'amenity') == mapcss._value_capture(capture_tags, 0, u'pharmacy') and not mapcss._tag_capture(capture_tags, 1, tags, u'dispensing') and mapcss.inside(self.father.config.options, u'IT'))
except mapcss.RuleAbort: pass
if match:
# -osmoseTags:list("fix:chair")
# -osmoseItemClassLevel:"2100/21001/3"
# throwWarning:tr("{0} without {1}","{0.tag}","{1.key}")
err.append({'class': 21001, 'subclass': 0, 'text': mapcss.tr(u'{0} without {1}', mapcss._tag_uncapture(capture_tags, u'{0.tag}'), mapcss._tag_uncapture(capture_tags, u'{1.key}'))})
return err
def relation(self, data, tags, members):
capture_tags = {}
keys = tags.keys()
err = []
# relation[power=transformer]
if (u'power' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'power') == mapcss._value_capture(capture_tags, 0, u'transformer'))
except mapcss.RuleAbort: pass
if match:
# -osmoseTags:list("geom")
# -osmoseItemClassLevel:"9100/91001/2"
# throwWarning:tr("Power Transformers should always be on a node")
err.append({'class': 91001, 'subclass': 0, 'text': mapcss.tr(u'Power Transformers should always be on a node')})
return err
def relation(self, data, tags, members):
capture_tags = {}
keys = tags.keys()
err = []
# relation[area?]
if ('area' in keys):
match = False
if not match:
capture_tags = {}
try: match = ((mapcss._tag_capture(capture_tags, 0, tags, 'area') in ('yes', 'true', '1')))
except mapcss.RuleAbort: pass
if match:
# throwWarning:tr("{0} on a relation","{0.key}")
# fixRemove:"{0.key}"
err.append({'class': 9003012, 'subclass': 922972473, 'text': mapcss.tr('{0} on a relation', mapcss._tag_uncapture(capture_tags, '{0.key}')), 'allow_fix_override': True, 'fix': {
'-': ([
mapcss._tag_uncapture(capture_tags, '{0.key}')])
}})
return err
def way(self, data, tags, nds):
capture_tags = {}
keys = tags.keys()
err = []
# way[railway=rail][!gauge][inside("FR")]
if (u'railway' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'railway') == mapcss._value_capture(capture_tags, 0, u'rail') and not mapcss._tag_capture(capture_tags, 1, tags, u'gauge') and mapcss.inside(self.father.config.options, u'FR'))
except mapcss.RuleAbort: pass
if match:
# -osmoseTags:list("tag","railway")
# -osmoseItemClassLevel:"2160/21600/3"
# throwWarning:tr("Tag gauge manquant sur rail")
# suggestAlternative:"gauge"
# -osmoseAssertNoMatchWithContext:list("way railway=disused","inside=FR")
# -osmoseAssertNoMatchWithContext:list("way railway=rail gauge=1435","inside=FR")
# -osmoseAssertMatchWithContext:list("way railway=rail","inside=FR")
err.append({'class': 21600, 'subclass': 0, 'text': mapcss.tr(u'Tag gauge manquant sur rail')})
return err
def way(self, data, tags, nds):
capture_tags = {}
keys = tags.keys()
err = []
# *[addr:street=~/(?i).*Strasse.*/][addr:street!~/(?i).*Strasser.*/][inside("DE,AT")]
# *[name=~/(?i).*Strasse.*/][name!~/(?i).*Strasser.*/][inside("DE,AT")]
if (u'addr:street' in keys) or (u'name' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test(mapcss._value_capture(capture_tags, 0, self.re_5b84a257), mapcss._tag_capture(capture_tags, 0, tags, u'addr:street')) and not mapcss.regexp_test(mapcss._value_const_capture(capture_tags, 1, self.re_559797c8, u'(?i).*Strasser.*'), mapcss._tag_capture(capture_tags, 1, tags, u'addr:street')) and mapcss.inside(self.father.config.options, u'DE,AT'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test(mapcss._value_capture(capture_tags, 0, self.re_5b84a257), mapcss._tag_capture(capture_tags, 0, tags, u'name')) and not mapcss.regexp_test(mapcss._value_const_capture(capture_tags, 1, self.re_559797c8, u'(?i).*Strasser.*'), mapcss._tag_capture(capture_tags, 1, tags, u'name')) and mapcss.inside(self.father.config.options, u'DE,AT'))
except mapcss.RuleAbort: pass
if match:
# throwError:tr("street name contains ss")
# assertMatch:"way name=Hauptstrasse"
# assertNoMatch:"way name=Hauptstraße"
# assertNoMatch:"way name=Kapitän-Strasser-Straße"
# assertNoMatch:"way name=Peter-Strasser-Platz"
err.append({'class': 9009002, 'subclass': 821908491, 'text': mapcss.tr(u'street name contains ss')})
# *[addr:street=~/(?i).*Straße.*/][inside("LI,CH")]
# *[name=~/(?i).*Straße.*/][inside("LI,CH")]
if (u'addr:street' in keys) or (u'name' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test(mapcss._value_capture(capture_tags, 0, self.re_3d3faeb5), mapcss._tag_capture(capture_tags, 0, tags, u'addr:street')) and mapcss.inside(self.father.config.options, u'LI,CH'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test(mapcss._value_capture(capture_tags, 0, self.re_3d3faeb5), mapcss._tag_capture(capture_tags, 0, tags, u'name')) and mapcss.inside(self.father.config.options, u'LI,CH'))
except mapcss.RuleAbort: pass
if match:
# throwError:tr("street name contains ß")
# assertNoMatch:"way name=Hauptstrasse"
# assertMatch:"way name=Hauptstraße"
err.append({'class': 9009003, 'subclass': 610086334, 'text': mapcss.tr(u'street name contains ß')})
return err
def node(self, data, tags):
capture_tags = {}
keys = tags.keys()
err = []
set_fixable_footway = set_link_road = set_major_road = set_minor_road = set_not_fixable_footway = False
# node[highway=~/motorway|trunk|primary|secondary|tertiary|unclassified|residential|service|living_street|pedestrian|track|path|footway|cycleway|bus_guideway|bridleway/][highway!=motorway_junction][highway!=services]
if (u'highway' in keys):
match = False
if not match:
capture_tags = {}
try:
match = (mapcss.regexp_test(
mapcss._value_capture(capture_tags, 0,
self.re_3dc5dd7c),
mapcss._tag_capture(capture_tags, 0, tags, u'highway'))
and mapcss._tag_capture(capture_tags, 1, tags,
u'highway') !=
mapcss._value_const_capture(
capture_tags, 1, u'motorway_junction',
u'motorway_junction') and mapcss._tag_capture(
capture_tags, 2, tags, u'highway') !=
mapcss._value_const_capture(
capture_tags, 2, u'services', u'services'))
except mapcss.RuleAbort:
pass
if match:
# throwWarning:tr("wrong highway tag on a node")
# assertNoMatch:"node highway=bus_stop"
# assertNoMatch:"node highway=crossing"
# assertNoMatch:"node highway=emergency_access_point"
# assertNoMatch:"node highway=give_way"
# assertNoMatch:"node highway=mini_roundabout"
# assertNoMatch:"node highway=motorway_junction"
# assertNoMatch:"node highway=passing_place"
# assertMatch:"node highway=primary"
# assertMatch:"node highway=primary_link"
# assertNoMatch:"node highway=rest_area"
# assertNoMatch:"node highway=services"
# assertNoMatch:"node highway=speed_camera"
# assertNoMatch:"node highway=stop"
# assertNoMatch:"node highway=street_lamp"
# assertNoMatch:"node highway=traffic_calming"
# assertNoMatch:"node highway=traffic_signals"
# assertNoMatch:"node highway=turning_circle"
err.append({
'class': 9004008,
'subclass': 325492196,
'text': mapcss.tr(u'wrong highway tag on a node')
})
# node[footway=crossing]
if (u'footway' in keys):
match = False
if not match:
capture_tags = {}
try:
match = (mapcss._tag_capture(
capture_tags, 0, tags,
u'footway') == mapcss._value_capture(
capture_tags, 0, u'crossing'))
except mapcss.RuleAbort:
pass
if match:
# throwWarning:tr("{0} on a node","{0.tag}")
# suggestAlternative:"highway=crossing"
# suggestAlternative:"railway=crossing"
err.append({
'class':
9004010,
'subclass':
1262520638,
'text':
mapcss.tr(u'{0} on a node',
mapcss._tag_uncapture(capture_tags, u'{0.tag}'))
})
# node[cycleway=crossing]
if (u'cycleway' in keys):
match = False
if not match:
capture_tags = {}
try:
match = (mapcss._tag_capture(
capture_tags, 0, tags,
u'cycleway') == mapcss._value_capture(
capture_tags, 0, u'crossing'))
except mapcss.RuleAbort:
pass
if match:
# throwWarning:tr("{0} on a node","{0.tag}")
# suggestAlternative:"highway=crossing + bicycle=yes"
# suggestAlternative:"railway=crossing + bicycle=yes"
err.append({
'class':
9004010,
'subclass':
1385847744,
'text':
mapcss.tr(u'{0} on a node',
mapcss._tag_uncapture(capture_tags, u'{0.tag}'))
})
# node[railway!=crossing][crossing!=no].is_in_railway.is_in_minor_road!.is_in_major_road
# Use undeclared class is_in_major_road, is_in_minor_road, is_in_railway
# node[railway!=level_crossing].is_in_railway.is_in_major_road!.is_in_minor_road
# Use undeclared class is_in_major_road, is_in_minor_road, is_in_railway
# node[highway=crossing][barrier=kerb].is_in_major_road
# Use undeclared class is_in_major_road
return err
def way(self, data, tags, nds):
capture_tags = {}
keys = tags.keys()
err = []
set_fixable_footway = set_link_road = set_major_road = set_minor_road = set_not_fixable_footway = False
# way[highway=~/^(motorway|trunk|primary|secondary|tertiary)$/]
if (u'highway' in keys):
match = False
if not match:
capture_tags = {}
try:
match = (mapcss.regexp_test(
mapcss._value_capture(capture_tags, 0,
self.re_55ee32ac),
mapcss._tag_capture(capture_tags, 0, tags,
u'highway')))
except mapcss.RuleAbort:
pass
if match:
# setmajor_road
set_major_road = True
# way[highway=~/^.*_link$/]
if (u'highway' in keys):
match = False
if not match:
capture_tags = {}
try:
match = (mapcss.regexp_test(
mapcss._value_capture(capture_tags, 0,
self.re_3092b7ac),
mapcss._tag_capture(capture_tags, 0, tags,
u'highway')))
except mapcss.RuleAbort:
pass
if match:
# setlink_road
set_link_road = True
# way[highway=~/^(unclassified|residential|living_street|service)$/]
if (u'highway' in keys):
match = False
if not match:
capture_tags = {}
try:
match = (mapcss.regexp_test(
mapcss._value_capture(capture_tags, 0,
self.re_015aabd5),
mapcss._tag_capture(capture_tags, 0, tags,
u'highway')))
except mapcss.RuleAbort:
pass
if match:
# setminor_road
set_minor_road = True
# way[highway][name=~/(?i).* (Ave|Blvd|Br|Brg|Cct|Cir|Cl|Cr|Crct|Cres|Crt|Ct|Dr|Drv|Esp|Espl|Hwy|Ln|Mw|Mwy|Pky|Pkwy|Pl|Rd|Qy|Qys|Sq|St|Str|Ter|Tce|Tr|Wy)[.]?$/]
if (u'highway' in keys and u'name' in keys):
match = False
if not match:
capture_tags = {}
try:
match = (mapcss._tag_capture(capture_tags, 0, tags,
u'highway')
and mapcss.regexp_test(
mapcss._value_capture(capture_tags, 1,
self.re_776f2c1a),
mapcss._tag_capture(capture_tags, 1, tags,
u'name')))
except mapcss.RuleAbort:
pass
if match:
# throwWarning:tr("abbreviated street name")
# assertMatch:"way highway=unclassified name=\"Bou Blvd.\""
# assertMatch:"way highway=unclassified name=\"Bou blvd.\""
# assertMatch:"way highway=unclassified name=\"Foo Ave\""
# assertMatch:"way highway=unclassified name=\"Foo Ave.\""
err.append({
'class': 9004001,
'subclass': 544432044,
'text': mapcss.tr(u'abbreviated street name')
})
# way[highway=crossing]
# way[railway=crossing]
# way[railway=level_crossing]
if (u'highway' in keys) or (u'railway' in keys):
match = False
if not match:
capture_tags = {}
try:
match = (mapcss._tag_capture(
capture_tags, 0, tags,
u'highway') == mapcss._value_capture(
capture_tags, 0, u'crossing'))
except mapcss.RuleAbort:
pass
if not match:
capture_tags = {}
try:
match = (mapcss._tag_capture(
capture_tags, 0, tags,
u'railway') == mapcss._value_capture(
capture_tags, 0, u'crossing'))
except mapcss.RuleAbort:
pass
if not match:
capture_tags = {}
try:
match = (mapcss._tag_capture(
capture_tags, 0, tags,
u'railway') == mapcss._value_capture(
capture_tags, 0, u'level_crossing'))
except mapcss.RuleAbort:
pass
if match:
# throwWarning:tr("wrong crossing tag on a way")
# assertMatch:"way highway=crossing"
err.append({
'class': 9004002,
'subclass': 1549110307,
'text': mapcss.tr(u'wrong crossing tag on a way')
})
# way[highway=yes]
# way[highway=road]
if (u'highway' in keys):
match = False
if not match:
capture_tags = {}
try:
match = (mapcss._tag_capture(
capture_tags, 0, tags,
u'highway') == mapcss._value_capture(
capture_tags, 0, u'yes'))
except mapcss.RuleAbort:
pass
if not match:
capture_tags = {}
try:
match = (mapcss._tag_capture(
capture_tags, 0, tags,
u'highway') == mapcss._value_capture(
capture_tags, 0, u'road'))
except mapcss.RuleAbort:
pass
if match:
# throwWarning:tr("Unspecific highway type")
# assertNoMatch:"way highway=residential"
# assertMatch:"way highway=road"
err.append({
'class': 9004004,
'subclass': 1729022478,
'text': mapcss.tr(u'Unspecific highway type')
})
# way[highway=footway][maxspeed]
# way[highway=steps][maxspeed]
# way[highway=cycleway][bicycle=no]
# way[highway=footway][foot=no]
# way[highway=cycleway][cycleway=lane]
if (u'bicycle' in keys and u'highway'
in keys) or (u'cycleway' in keys and u'highway' in keys) or (
u'foot' in keys
and u'highway' in keys) or (u'highway' in keys
and u'maxspeed' in keys):
match = False
if not match:
capture_tags = {}
try:
match = (
mapcss._tag_capture(capture_tags, 0, tags, u'highway')
== mapcss._value_capture(capture_tags, 0, u'footway')
and mapcss._tag_capture(capture_tags, 1, tags,
u'maxspeed'))
except mapcss.RuleAbort:
pass
if not match:
capture_tags = {}
try:
match = (
mapcss._tag_capture(capture_tags, 0, tags, u'highway')
== mapcss._value_capture(capture_tags, 0, u'steps')
and mapcss._tag_capture(capture_tags, 1, tags,
u'maxspeed'))
except mapcss.RuleAbort:
pass
if not match:
capture_tags = {}
try:
match = (
mapcss._tag_capture(capture_tags, 0, tags, u'highway')
== mapcss._value_capture(capture_tags, 0, u'cycleway')
and mapcss._tag_capture(capture_tags, 1, tags,
u'bicycle')
== mapcss._value_capture(capture_tags, 1, u'no'))
except mapcss.RuleAbort:
pass
if not match:
capture_tags = {}
try:
match = (
mapcss._tag_capture(capture_tags, 0, tags, u'highway')
== mapcss._value_capture(capture_tags, 0, u'footway')
and mapcss._tag_capture(capture_tags, 1, tags, u'foot')
== mapcss._value_capture(capture_tags, 1, u'no'))
except mapcss.RuleAbort:
pass
if not match:
capture_tags = {}
try:
match = (
mapcss._tag_capture(capture_tags, 0, tags, u'highway')
== mapcss._value_capture(capture_tags, 0, u'cycleway')
and mapcss._tag_capture(capture_tags, 1, tags,
u'cycleway')
== mapcss._value_capture(capture_tags, 1, u'lane'))
except mapcss.RuleAbort:
pass
if match:
# throwWarning:tr("{0} used with {1}","{0.value}","{1.tag}")
# assertNoMatch:"way highway=cycleway bicycle=yes"
# assertMatch:"way highway=cycleway cycleway=lane"
# assertNoMatch:"way highway=cycleway"
# assertNoMatch:"way highway=cycleway"
# assertNoMatch:"way highway=footway foot=yes"
# assertMatch:"way highway=footway maxspeed=20"
# assertNoMatch:"way highway=footway"
# assertNoMatch:"way highway=footway"
# assertNoMatch:"way highway=residential cycleway=lane"
# assertNoMatch:"way highway=residential maxspeed=20"
err.append({
'class':
9004005,
'subclass':
469607562,
'text':
mapcss.tr(
u'{0} used with {1}',
mapcss._tag_uncapture(capture_tags, u'{0.value}'),
mapcss._tag_uncapture(capture_tags, u'{1.tag}'))
})
# way[footway=left][/^footway:/]
# way[footway=right][/^footway:/]
# way[footway=both][/^footway:/]
# way[footway=no][/^footway:/]
if (u'footway' in keys):
match = False
if not match:
capture_tags = {}
try:
match = (mapcss._tag_capture(capture_tags, 0, tags,
u'footway')
== mapcss._value_capture(capture_tags, 0, u'left')
and mapcss._tag_capture(capture_tags, 1, tags,
self.re_4dcdb354))
except mapcss.RuleAbort:
pass
if not match:
capture_tags = {}
try:
match = (
mapcss._tag_capture(capture_tags, 0, tags, u'footway')
== mapcss._value_capture(capture_tags, 0, u'right')
and mapcss._tag_capture(capture_tags, 1, tags,
self.re_4dcdb354))
except mapcss.RuleAbort:
pass
if not match:
capture_tags = {}
try:
match = (mapcss._tag_capture(capture_tags, 0, tags,
u'footway')
== mapcss._value_capture(capture_tags, 0, u'both')
and mapcss._tag_capture(capture_tags, 1, tags,
self.re_4dcdb354))
except mapcss.RuleAbort:
pass
if not match:
capture_tags = {}
try:
match = (mapcss._tag_capture(capture_tags, 0, tags,
u'footway')
== mapcss._value_capture(capture_tags, 0, u'no')
and mapcss._tag_capture(capture_tags, 1, tags,
self.re_4dcdb354))
except mapcss.RuleAbort:
pass
if match:
# setnot_fixable_footway
# group:tr("deprecated tagging")
# throwWarning:tr("{0} is deprecated, use {1} instead. Also check similar tags like {2}","{0.tag}","sidewalk","{1.key}")
# assertMatch:"way footway=both footway:surface=asphalt"
set_not_fixable_footway = True
err.append({
'class':
9004006,
'subclass':
141262069,
'text':
mapcss.tr(
u'{0} is deprecated, use {1} instead. Also check similar tags like {2}',
mapcss._tag_uncapture(capture_tags, u'{0.tag}'),
u'sidewalk',
mapcss._tag_uncapture(capture_tags, u'{1.key}'))
})
# way[footway=none][/footway:/]
if (u'footway' in keys):
match = False
if not match:
capture_tags = {}
try:
match = (mapcss._tag_capture(capture_tags, 0, tags,
u'footway')
== mapcss._value_capture(capture_tags, 0, u'none')
and mapcss._tag_capture(capture_tags, 1, tags,
self.re_61bbe299))
except mapcss.RuleAbort:
pass
if match:
# setnot_fixable_footway
# group:tr("deprecated tagging")
# throwWarning:tr("{0} is deprecated, use {1} instead. Also check similar tags like {2}","{0.tag}","sidewalk=no","{1.key}")
set_not_fixable_footway = True
err.append({
'class':
9004006,
'subclass':
1570348899,
'text':
mapcss.tr(
u'{0} is deprecated, use {1} instead. Also check similar tags like {2}',
mapcss._tag_uncapture(capture_tags, u'{0.tag}'),
u'sidewalk=no',
mapcss._tag_uncapture(capture_tags, u'{1.key}'))
})
# way[footway=left]!.not_fixable_footway
# way[footway=right]!.not_fixable_footway
# way[footway=both]!.not_fixable_footway
# way[footway=no]!.not_fixable_footway
if (u'footway' in keys):
match = False
if not match:
capture_tags = {}
try:
match = (not set_not_fixable_footway
and mapcss._tag_capture(
capture_tags, 0, tags,
u'footway') == mapcss._value_capture(
capture_tags, 0, u'left'))
except mapcss.RuleAbort:
pass
if not match:
capture_tags = {}
try:
match = (not set_not_fixable_footway
and mapcss._tag_capture(
capture_tags, 0, tags,
u'footway') == mapcss._value_capture(
capture_tags, 0, u'right'))
except mapcss.RuleAbort:
pass
if not match:
capture_tags = {}
try:
match = (not set_not_fixable_footway
and mapcss._tag_capture(
capture_tags, 0, tags,
u'footway') == mapcss._value_capture(
capture_tags, 0, u'both'))
except mapcss.RuleAbort:
pass
if not match:
capture_tags = {}
try:
match = (not set_not_fixable_footway
and mapcss._tag_capture(capture_tags, 0, tags,
u'footway')
== mapcss._value_capture(capture_tags, 0, u'no'))
except mapcss.RuleAbort:
pass
if match:
# setfixable_footway
# group:tr("deprecated tagging")
# throwWarning:tr("{0} is deprecated","{0.tag}")
# suggestAlternative:"sidewalk"
# fixChangeKey:"footway => sidewalk"
set_fixable_footway = True
err.append({
'class':
9004006,
'subclass':
2076937761,
'text':
mapcss.tr(u'{0} is deprecated',
mapcss._tag_uncapture(capture_tags, u'{0.tag}')),
'allow_fix_override':
True,
'fix': {
'+': dict([[u'sidewalk',
mapcss.tag(tags, u'footway')]]),
'-': ([u'footway'])
}
})
# way[footway=none]!.not_fixable_footway
if (u'footway' in keys):
match = False
if not match:
capture_tags = {}
try:
match = (not set_not_fixable_footway
and mapcss._tag_capture(
capture_tags, 0, tags,
u'footway') == mapcss._value_capture(
capture_tags, 0, u'none'))
except mapcss.RuleAbort:
pass
if match:
# setfixable_footway
# group:tr("deprecated tagging")
# throwWarning:tr("{0} is deprecated","{0.tag}")
# suggestAlternative:"sidewalk=no"
# fixRemove:"footway"
# fixAdd:"sidewalk=no"
set_fixable_footway = True
err.append({
'class':
9004006,
'subclass':
430589555,
'text':
mapcss.tr(u'{0} is deprecated',
mapcss._tag_uncapture(capture_tags, u'{0.tag}')),
'allow_fix_override':
True,
'fix': {
'+': dict([[u'sidewalk', u'no']]),
'-': ([u'footway'])
}
})
# way[footway][footway!=sidewalk][footway!=crossing]!.fixable_footway!.not_fixable_footway
if (u'footway' in keys):
match = False
if not match:
capture_tags = {}
try:
match = (
not set_fixable_footway and not set_not_fixable_footway
and mapcss._tag_capture(capture_tags, 0, tags,
u'footway') and
mapcss._tag_capture(capture_tags, 1, tags, u'footway')
!= mapcss._value_const_capture(
capture_tags, 1, u'sidewalk', u'sidewalk') and
mapcss._tag_capture(capture_tags, 2, tags, u'footway')
!= mapcss._value_const_capture(
capture_tags, 2, u'crossing', u'crossing'))
except mapcss.RuleAbort:
pass
if match:
# throwWarning:tr("Value of ''{0}'' should either be ''{1}'' or ''{2}''. For sidewalks use ''{3}'' instead.","{0.key}","{1.value}","{2.value}","sidewalk=left|right|both|no")
# assertMatch:"way footway=bar"
# assertNoMatch:"way footway=left footway:left:surface=asphalt"
# assertNoMatch:"way footway=left"
# assertNoMatch:"way footway=none"
err.append({
'class':
9004007,
'subclass':
156640320,
'text':
mapcss.tr(
u'Value of \'\'{0}\'\' should either be \'\'{1}\'\' or \'\'{2}\'\'. For sidewalks use \'\'{3}\'\' instead.',
mapcss._tag_uncapture(capture_tags, u'{0.key}'),
mapcss._tag_uncapture(capture_tags, u'{1.value}'),
mapcss._tag_uncapture(capture_tags, u'{2.value}'),
u'sidewalk=left|right|both|no')
})
return err
def relation(self, data, tags, members):
capture_tags = {}
keys = tags.keys()
err = []
# *[name=~/(?i)co.?voiturage/][amenity!=car_pooling][!carpool][inside("FR")]
if (u'name' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test(mapcss._value_capture(capture_tags, 0, self.re_045a0f34), mapcss._tag_capture(capture_tags, 0, tags, u'name')) and mapcss._tag_capture(capture_tags, 1, tags, u'amenity') != mapcss._value_const_capture(capture_tags, 1, u'car_pooling', u'car_pooling') and not mapcss._tag_capture(capture_tags, 2, tags, u'carpool') and mapcss.inside(self.father.config.options, u'FR'))
except mapcss.RuleAbort: pass
if match:
# -osmoseTags:list("parking","amenity","fix:chair")
# -osmoseItemClassLevel:"2080/20806/3"
# throwWarning:tr("Missing tag carpool on area")
# fixAdd:"amenity=car_pooling"
# fixAdd:"carpool=designated"
err.append({'class': 20806, 'subclass': 0, 'text': mapcss.tr(u'Missing tag carpool on area'), 'allow_fix_override': True, 'fix': {
'+': dict([
[u'amenity',u'car_pooling'],
[u'carpool',u'designated']])
}})
return err
def relation(self, data, tags, members):
capture_tags = {}
keys = tags.keys()
err = []
set_pt_route = set_pt_route_master = False
# relation[type=route][!route]
if (u'type' in keys):
match = False
if not match:
capture_tags = {}
try:
match = (
mapcss._tag_capture(capture_tags, 0, tags, u'type')
== mapcss._value_capture(capture_tags, 0, u'route')
and not mapcss._tag_capture(capture_tags, 1, tags,
u'route'))
except mapcss.RuleAbort:
pass
if match:
# throwError:tr("Missing transportation mode, add a tag route = bus/coach/tram/etc")
err.append({
'class':
9014009,
'subclass':
828849115,
'text':
mapcss.
tr(u'Missing transportation mode, add a tag route = bus/coach/tram/etc'
)
})
# relation[type=route_master][!route_master][!route]
if (u'type' in keys):
match = False
if not match:
capture_tags = {}
try:
match = (mapcss._tag_capture(
capture_tags, 0, tags,
u'type') == mapcss._value_capture(
capture_tags, 0, u'route_master')
and not mapcss._tag_capture(
capture_tags, 1, tags, u'route_master')
and not mapcss._tag_capture(
capture_tags, 2, tags, u'route'))
except mapcss.RuleAbort:
pass
if match:
# throwError:tr("Missing transportation mode, add a tag route = bus/coach/tram/etc")
err.append({
'class':
9014009,
'subclass':
607011337,
'text':
mapcss.
tr(u'Missing transportation mode, add a tag route = bus/coach/tram/etc'
)
})
# relation[type=route_master][!route_master][route]
if (u'route' in keys and u'type' in keys):
match = False
if not match:
capture_tags = {}
try:
match = (mapcss._tag_capture(
capture_tags, 0, tags,
u'type') == mapcss._value_capture(
capture_tags, 0, u'route_master')
and not mapcss._tag_capture(
capture_tags, 1, tags, u'route_master')
and mapcss._tag_capture(capture_tags, 2, tags,
u'route'))
except mapcss.RuleAbort:
pass
if match:
# throwError:tr("Missing transportation mode, change tag route to route_master")
# fixChangeKey:"route=>route_master"
err.append({
'class':
9014010,
'subclass':
3385524,
'text':
mapcss.
tr(u'Missing transportation mode, change tag route to route_master'
),
'allow_fix_override':
True,
'fix': {
'+':
dict([[u'route_master',
mapcss.tag(tags, u'route')]]),
'-': ([u'route'])
}
})
# relation[type=route][route=~/^(bus|coach|train|subway|monorail|trolleybus|aerialway|funicular|ferry|tram|share_taxi|light_rail|school_bus)$/]
if (u'route' in keys and u'type' in keys):
match = False
if not match:
capture_tags = {}
try:
match = (
mapcss._tag_capture(capture_tags, 0, tags, u'type')
== mapcss._value_capture(capture_tags, 0, u'route')
and mapcss.regexp_test(
mapcss._value_capture(capture_tags, 1,
self.re_37f81db8),
mapcss._tag_capture(capture_tags, 1, tags,
u'route')))
except mapcss.RuleAbort:
pass
if match:
# setpt_route
set_pt_route = True
# relation[type=route_master][route_master=~/^(bus|coach|train|subway|monorail|trolleybus|aerialway|funicular|ferry|tram|share_taxi|light_rail|school_bus)$/]
if (u'route_master' in keys and u'type' in keys):
match = False
if not match:
capture_tags = {}
try:
match = (mapcss._tag_capture(
capture_tags, 0, tags,
u'type') == mapcss._value_capture(
capture_tags, 0, u'route_master')
and mapcss.regexp_test(
mapcss._value_capture(capture_tags, 1,
self.re_37f81db8),
mapcss._tag_capture(capture_tags, 1, tags,
u'route_master')))
except mapcss.RuleAbort:
pass
if match:
# setpt_route_master
set_pt_route_master = True
# relation.pt_route[!public_transport:version]
if True:
match = False
if not match:
capture_tags = {}
try:
match = (set_pt_route and not mapcss._tag_capture(
capture_tags, 0, tags, u'public_transport:version'))
except mapcss.RuleAbort:
pass
if match:
# -osmoseItemClassLevel:"2140/21401/3"
# throwError:tr("Missing public_transport:version tag on a public_transport route relation")
# assertNoMatch:"relation type=route route=bus public_transport:version=1"
# assertMatch:"relation type=route route=bus"
err.append({
'class':
21401,
'subclass':
0,
'text':
mapcss.
tr(u'Missing public_transport:version tag on a public_transport route relation'
)
})
# relation.pt_route[!network]
# relation.pt_route_master[!network]
if True:
match = False
if not match:
capture_tags = {}
try:
match = (set_pt_route and not mapcss._tag_capture(
capture_tags, 0, tags, u'network'))
except mapcss.RuleAbort:
pass
if not match:
capture_tags = {}
try:
match = (set_pt_route_master and not mapcss._tag_capture(
capture_tags, 0, tags, u'network'))
except mapcss.RuleAbort:
pass
if match:
# -osmoseItemClassLevel:"2140/21402/3"
# throwError:tr("Missing network tag on a public_transport relation")
# assertNoMatch:"relation type=route route=bus network=BiBiBus"
# assertMatch:"relation type=route route=bus"
err.append({
'class':
21402,
'subclass':
0,
'text':
mapcss.tr(
u'Missing network tag on a public_transport relation')
})
# relation.pt_route[!operator]
# relation.pt_route_master[!operator]
if True:
match = False
if not match:
capture_tags = {}
try:
match = (set_pt_route and not mapcss._tag_capture(
capture_tags, 0, tags, u'operator'))
except mapcss.RuleAbort:
pass
if not match:
capture_tags = {}
try:
match = (set_pt_route_master and not mapcss._tag_capture(
capture_tags, 0, tags, u'operator'))
except mapcss.RuleAbort:
pass
if match:
# -osmoseItemClassLevel:"2140/21403/3"
# throwError:tr("Missing operator tag on a public_transport relation")
# assertNoMatch:"relation type=route route=bus operator=BiBiBus"
# assertMatch:"relation type=route route=bus"
err.append({
'class':
21403,
'subclass':
0,
'text':
mapcss.tr(
u'Missing operator tag on a public_transport relation')
})
# relation.pt_route[!ref]
# relation.pt_route_master[!ref]
if True:
match = False
if not match:
capture_tags = {}
try:
match = (set_pt_route and not mapcss._tag_capture(
capture_tags, 0, tags, u'ref'))
except mapcss.RuleAbort:
pass
if not match:
capture_tags = {}
try:
match = (set_pt_route_master and not mapcss._tag_capture(
capture_tags, 0, tags, u'ref'))
except mapcss.RuleAbort:
pass
if match:
# -osmoseItemClassLevel:"2140/21404/3"
# throwError:tr("Missing ref tag for line number on a public_transport relation")
# assertNoMatch:"relation type=route route=bus ref=3"
# assertMatch:"relation type=route route=bus"
err.append({
'class':
21404,
'subclass':
0,
'text':
mapcss.
tr(u'Missing ref tag for line number on a public_transport relation'
)
})
# relation.pt_route[!from]
# relation.pt_route[!to]
if True:
match = False
if not match:
capture_tags = {}
try:
match = (set_pt_route and not mapcss._tag_capture(
capture_tags, 0, tags, u'from'))
except mapcss.RuleAbort:
pass
if not match:
capture_tags = {}
try:
match = (set_pt_route and not mapcss._tag_capture(
capture_tags, 0, tags, u'to'))
except mapcss.RuleAbort:
pass
if match:
# -osmoseItemClassLevel:"2140/21405/3"
# throwError:tr("Missing from/to tag on a public_transport route relation")
# assertNoMatch:"relation type=route route=bus from=A to=B"
# assertMatch:"relation type=route route=bus from=A"
# assertMatch:"relation type=route route=bus to=B"
# assertMatch:"relation type=route route=bus"
err.append({
'class':
21405,
'subclass':
0,
'text':
mapcss.
tr(u'Missing from/to tag on a public_transport route relation'
)
})
# relation.pt_route["operator"=~/STIF|Kéolis|Véolia/][inside("FR")]
# relation.pt_route_master["operator"=~/STIF|Kéolis|Véolia/][inside("FR")]
if (u'operator' in keys):
match = False
if not match:
capture_tags = {}
try:
match = (set_pt_route and mapcss.regexp_test(
mapcss._value_capture(capture_tags, 0,
self.re_25554804),
mapcss._tag_capture(capture_tags, 0, tags,
u'operator')) and
mapcss.inside(self.father.config.options, u'FR'))
except mapcss.RuleAbort:
pass
if not match:
capture_tags = {}
try:
match = (set_pt_route_master and mapcss.regexp_test(
mapcss._value_capture(capture_tags, 0,
self.re_25554804),
mapcss._tag_capture(capture_tags, 0, tags,
u'operator')) and
mapcss.inside(self.father.config.options, u'FR'))
except mapcss.RuleAbort:
pass
if match:
# throwError:tr("Check the operator tag")
err.append({
'class': 9014013,
'subclass': 286137008,
'text': mapcss.tr(u'Check the operator tag')
})
# relation.pt_route["network"=~/STIF|Kéolis|Véolia/][inside("FR")]
# relation.pt_route_master["network"=~/STIF|Kéolis|Véolia/][inside("FR")]
if (u'network' in keys):
match = False
if not match:
capture_tags = {}
try:
match = (set_pt_route and mapcss.regexp_test(
mapcss._value_capture(capture_tags, 0,
self.re_25554804),
mapcss._tag_capture(capture_tags, 0, tags, u'network'))
and mapcss.inside(self.father.config.options,
u'FR'))
except mapcss.RuleAbort:
pass
if not match:
capture_tags = {}
try:
match = (set_pt_route_master and mapcss.regexp_test(
mapcss._value_capture(capture_tags, 0,
self.re_25554804),
mapcss._tag_capture(capture_tags, 0, tags, u'network'))
and mapcss.inside(self.father.config.options,
u'FR'))
except mapcss.RuleAbort:
pass
if match:
# throwError:tr("Check the network tag")
err.append({
'class': 9014014,
'subclass': 735027962,
'text': mapcss.tr(u'Check the network tag')
})
# relation.pt_route!.route_ok
# Use undeclared class pt_route, route_ok
return err
def relation(self, data, tags, members):
capture_tags = {}
keys = tags.keys()
err = []
set_pt_route = set_pt_route_master = False
# relation[type=route][!route]
if (u'type' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'type') == mapcss._value_capture(capture_tags, 0, u'route') and not mapcss._tag_capture(capture_tags, 1, tags, u'route'))
except mapcss.RuleAbort: pass
if match:
# throwError:tr("Missing transportation mode, add a tag route = bus/coach/tram/etc")
err.append({'class': 9014009, 'subclass': 828849115, 'text': mapcss.tr(u'Missing transportation mode, add a tag route = bus/coach/tram/etc')})
# relation[type=route_master][!route_master][!route]
if (u'type' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'type') == mapcss._value_capture(capture_tags, 0, u'route_master') and not mapcss._tag_capture(capture_tags, 1, tags, u'route_master') and not mapcss._tag_capture(capture_tags, 2, tags, u'route'))
except mapcss.RuleAbort: pass
if match:
# throwError:tr("Missing transportation mode, add a tag route = bus/coach/tram/etc")
err.append({'class': 9014009, 'subclass': 607011337, 'text': mapcss.tr(u'Missing transportation mode, add a tag route = bus/coach/tram/etc')})
# relation[type=route_master][!route_master][route]
if (u'route' in keys and u'type' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'type') == mapcss._value_capture(capture_tags, 0, u'route_master') and not mapcss._tag_capture(capture_tags, 1, tags, u'route_master') and mapcss._tag_capture(capture_tags, 2, tags, u'route'))
except mapcss.RuleAbort: pass
if match:
# throwError:tr("Missing transportation mode, change tag route to route_master")
# fixChangeKey:"route=>route_master"
err.append({'class': 9014010, 'subclass': 3385524, 'text': mapcss.tr(u'Missing transportation mode, change tag route to route_master'), 'allow_fix_override': True, 'fix': {
'+': dict([
[u'route_master', mapcss.tag(tags, u'route')]]),
'-': ([
u'route'])
}})
# relation[type=route][route=~/^(bus|coach|train|subway|monorail|trolleybus|aerialway|funicular|ferry|tram|share_taxi|light_rail|school_bus)$/]
if (u'route' in keys and u'type' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'type') == mapcss._value_capture(capture_tags, 0, u'route') and mapcss.regexp_test(mapcss._value_capture(capture_tags, 1, self.re_37f81db8), mapcss._tag_capture(capture_tags, 1, tags, u'route')))
except mapcss.RuleAbort: pass
if match:
# setpt_route
set_pt_route = True
# relation[type=route_master][route_master=~/^(bus|coach|train|subway|monorail|trolleybus|aerialway|funicular|ferry|tram|share_taxi|light_rail|school_bus)$/]
if (u'route_master' in keys and u'type' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'type') == mapcss._value_capture(capture_tags, 0, u'route_master') and mapcss.regexp_test(mapcss._value_capture(capture_tags, 1, self.re_37f81db8), mapcss._tag_capture(capture_tags, 1, tags, u'route_master')))
except mapcss.RuleAbort: pass
if match:
# setpt_route_master
set_pt_route_master = True
# relation.pt_route[!public_transport:version]
if True:
match = False
if not match:
capture_tags = {}
try: match = (set_pt_route and not mapcss._tag_capture(capture_tags, 0, tags, u'public_transport:version'))
except mapcss.RuleAbort: pass
if match:
# -osmoseItemClassLevel:"2140/21401/3"
# throwError:tr("Missing public_transport:version tag on a public_transport route relation")
# assertNoMatch:"relation type=route route=bus public_transport:version=1"
# assertMatch:"relation type=route route=bus"
err.append({'class': 21401, 'subclass': 0, 'text': mapcss.tr(u'Missing public_transport:version tag on a public_transport route relation')})
# relation.pt_route[!network]
# relation.pt_route_master[!network]
if True:
match = False
if not match:
capture_tags = {}
try: match = (set_pt_route and not mapcss._tag_capture(capture_tags, 0, tags, u'network'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (set_pt_route_master and not mapcss._tag_capture(capture_tags, 0, tags, u'network'))
except mapcss.RuleAbort: pass
if match:
# -osmoseItemClassLevel:"2140/21402/3"
# throwError:tr("Missing network tag on a public_transport relation")
# assertNoMatch:"relation type=route route=bus network=BiBiBus"
# assertMatch:"relation type=route route=bus"
err.append({'class': 21402, 'subclass': 0, 'text': mapcss.tr(u'Missing network tag on a public_transport relation')})
# relation.pt_route[!operator]
# relation.pt_route_master[!operator]
if True:
match = False
if not match:
capture_tags = {}
try: match = (set_pt_route and not mapcss._tag_capture(capture_tags, 0, tags, u'operator'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (set_pt_route_master and not mapcss._tag_capture(capture_tags, 0, tags, u'operator'))
except mapcss.RuleAbort: pass
if match:
# -osmoseItemClassLevel:"2140/21403/3"
# throwError:tr("Missing operator tag on a public_transport relation")
# assertNoMatch:"relation type=route route=bus operator=BiBiBus"
# assertMatch:"relation type=route route=bus"
err.append({'class': 21403, 'subclass': 0, 'text': mapcss.tr(u'Missing operator tag on a public_transport relation')})
# relation.pt_route[!ref]
# relation.pt_route_master[!ref]
if True:
match = False
if not match:
capture_tags = {}
try: match = (set_pt_route and not mapcss._tag_capture(capture_tags, 0, tags, u'ref'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (set_pt_route_master and not mapcss._tag_capture(capture_tags, 0, tags, u'ref'))
except mapcss.RuleAbort: pass
if match:
# -osmoseItemClassLevel:"2140/21404/3"
# throwError:tr("Missing ref tag for line number on a public_transport relation")
# assertNoMatch:"relation type=route route=bus ref=3"
# assertMatch:"relation type=route route=bus"
err.append({'class': 21404, 'subclass': 0, 'text': mapcss.tr(u'Missing ref tag for line number on a public_transport relation')})
# relation.pt_route[!from]
# relation.pt_route[!to]
if True:
match = False
if not match:
capture_tags = {}
try: match = (set_pt_route and not mapcss._tag_capture(capture_tags, 0, tags, u'from'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (set_pt_route and not mapcss._tag_capture(capture_tags, 0, tags, u'to'))
except mapcss.RuleAbort: pass
if match:
# -osmoseItemClassLevel:"2140/21405/3"
# throwError:tr("Missing from/to tag on a public_transport route relation")
# assertNoMatch:"relation type=route route=bus from=A to=B"
# assertMatch:"relation type=route route=bus from=A"
# assertMatch:"relation type=route route=bus to=B"
# assertMatch:"relation type=route route=bus"
err.append({'class': 21405, 'subclass': 0, 'text': mapcss.tr(u'Missing from/to tag on a public_transport route relation')})
# relation.pt_route["operator"=~/STIF|Kéolis|Véolia/][inside("FR")]
# relation.pt_route_master["operator"=~/STIF|Kéolis|Véolia/][inside("FR")]
if (u'operator' in keys):
match = False
if not match:
capture_tags = {}
try: match = (set_pt_route and mapcss.regexp_test(mapcss._value_capture(capture_tags, 0, self.re_25554804), mapcss._tag_capture(capture_tags, 0, tags, u'operator')) and mapcss.inside(self.father.config.options, u'FR'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (set_pt_route_master and mapcss.regexp_test(mapcss._value_capture(capture_tags, 0, self.re_25554804), mapcss._tag_capture(capture_tags, 0, tags, u'operator')) and mapcss.inside(self.father.config.options, u'FR'))
except mapcss.RuleAbort: pass
if match:
# throwError:tr("Check the operator tag")
err.append({'class': 9014013, 'subclass': 286137008, 'text': mapcss.tr(u'Check the operator tag')})
# relation.pt_route["network"=~/STIF|Kéolis|Véolia/][inside("FR")]
# relation.pt_route_master["network"=~/STIF|Kéolis|Véolia/][inside("FR")]
if (u'network' in keys):
match = False
if not match:
capture_tags = {}
try: match = (set_pt_route and mapcss.regexp_test(mapcss._value_capture(capture_tags, 0, self.re_25554804), mapcss._tag_capture(capture_tags, 0, tags, u'network')) and mapcss.inside(self.father.config.options, u'FR'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (set_pt_route_master and mapcss.regexp_test(mapcss._value_capture(capture_tags, 0, self.re_25554804), mapcss._tag_capture(capture_tags, 0, tags, u'network')) and mapcss.inside(self.father.config.options, u'FR'))
except mapcss.RuleAbort: pass
if match:
# throwError:tr("Check the network tag")
err.append({'class': 9014014, 'subclass': 735027962, 'text': mapcss.tr(u'Check the network tag')})
# relation.pt_route!.route_ok
# Use undeclared class pt_route, route_ok
return err
def node(self, data, tags):
capture_tags = {}
keys = tags.keys()
err = []
set_fixable_footway = set_link_road = set_major_road = set_minor_road = set_not_fixable_footway = False
# node[highway=~/motorway|trunk|primary|secondary|tertiary|unclassified|residential|service|living_street|pedestrian|track|path|footway|cycleway|bus_guideway|bridleway/][highway!=motorway_junction][highway!=services]
if (u'highway' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test(mapcss._value_capture(capture_tags, 0, self.re_3dc5dd7c), mapcss._tag_capture(capture_tags, 0, tags, u'highway')) and mapcss._tag_capture(capture_tags, 1, tags, u'highway') != mapcss._value_capture(capture_tags, 1, u'motorway_junction') and mapcss._tag_capture(capture_tags, 2, tags, u'highway') != mapcss._value_capture(capture_tags, 2, u'services'))
except mapcss.RuleAbort: pass
if match:
# throwWarning:tr("wrong highway tag on a node")
# assertNoMatch:"node highway=bus_stop"
# assertNoMatch:"node highway=crossing"
# assertNoMatch:"node highway=emergency_access_point"
# assertNoMatch:"node highway=give_way"
# assertNoMatch:"node highway=mini_roundabout"
# assertNoMatch:"node highway=motorway_junction"
# assertNoMatch:"node highway=passing_place"
# assertMatch:"node highway=primary"
# assertMatch:"node highway=primary_link"
# assertNoMatch:"node highway=rest_area"
# assertNoMatch:"node highway=services"
# assertNoMatch:"node highway=speed_camera"
# assertNoMatch:"node highway=stop"
# assertNoMatch:"node highway=street_lamp"
# assertNoMatch:"node highway=traffic_calming"
# assertNoMatch:"node highway=traffic_signals"
# assertNoMatch:"node highway=turning_circle"
err.append({'class': 9004008, 'subclass': 325492196, 'text': mapcss.tr(u'wrong highway tag on a node')})
# node[railway!=crossing][crossing!=no].is_in_railway.is_in_minor_road!.is_in_major_road
# Use undeclared class is_in_major_road, is_in_minor_road, is_in_railway
# node[railway!=level_crossing].is_in_railway.is_in_major_road!.is_in_minor_road
# Use undeclared class is_in_major_road, is_in_minor_road, is_in_railway
return err
def way(self, data, tags, nds):
capture_tags = {}
keys = tags.keys()
err = []
# way[emergency=fire_hydrant]
# way[entrance]
# way[door]
# way[railway=subway_entrance]
# way[man_made=survey_point]
# way[aeroway=holding_position]
# way[power=transformer]
# way[power=pole]
# way[power=catenary_mast]
# way[power=terminal]
# way[power=tower]!:closed
# way[amenity=vending_machine]
# way[natural=peak]
# way[natural=saddle]
# way[natural=volcano]
# way[natural=tree]
# way[highway=give_way]
# way[highway=milestone]
# way[highway=mini_roundabout]
# way[highway=stop]
# way[highway=street_lamp]
# way[highway=traffic_signals]
# way[highway=turning_loop]
# way[highway=turning_circle]
# way[highway=motorway_junction]
if (u'aeroway' in keys) or (u'amenity' in keys) or (u'door' in keys) or (u'emergency' in keys) or (u'entrance' in keys) or (u'highway' in keys) or (u'man_made' in keys) or (u'natural' in keys) or (u'power' in keys) or (u'railway' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'emergency') == mapcss._value_capture(capture_tags, 0, u'fire_hydrant'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'entrance'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'door'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'railway') == mapcss._value_capture(capture_tags, 0, u'subway_entrance'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'man_made') == mapcss._value_capture(capture_tags, 0, u'survey_point'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'aeroway') == mapcss._value_capture(capture_tags, 0, u'holding_position'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'power') == mapcss._value_capture(capture_tags, 0, u'transformer'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'power') == mapcss._value_capture(capture_tags, 0, u'pole'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'power') == mapcss._value_capture(capture_tags, 0, u'catenary_mast'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'power') == mapcss._value_capture(capture_tags, 0, u'terminal'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'power') == mapcss._value_capture(capture_tags, 0, u'tower') and nds[0] == nds[-1])
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'amenity') == mapcss._value_capture(capture_tags, 0, u'vending_machine'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'natural') == mapcss._value_capture(capture_tags, 0, u'peak'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'natural') == mapcss._value_capture(capture_tags, 0, u'saddle'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'natural') == mapcss._value_capture(capture_tags, 0, u'volcano'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'natural') == mapcss._value_capture(capture_tags, 0, u'tree'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'highway') == mapcss._value_capture(capture_tags, 0, u'give_way'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'highway') == mapcss._value_capture(capture_tags, 0, u'milestone'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'highway') == mapcss._value_capture(capture_tags, 0, u'mini_roundabout'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'highway') == mapcss._value_capture(capture_tags, 0, u'stop'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'highway') == mapcss._value_capture(capture_tags, 0, u'street_lamp'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'highway') == mapcss._value_capture(capture_tags, 0, u'traffic_signals'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'highway') == mapcss._value_capture(capture_tags, 0, u'turning_loop'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'highway') == mapcss._value_capture(capture_tags, 0, u'turning_circle'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'highway') == mapcss._value_capture(capture_tags, 0, u'motorway_junction'))
except mapcss.RuleAbort: pass
if match:
# throwWarning:tr("{0} on a way. Should be used on a node.","{0.tag}")
err.append({'class': 9003007, 'subclass': 1144340551, 'text': mapcss.tr(u'{0} on a way. Should be used on a node.', mapcss._tag_uncapture(capture_tags, u'{0.tag}'))})
# way[restriction][restriction=~/^(no_right_turn|no_left_turn|no_u_turn|no_straight_on|only_right_turn|only_left_turn|only_straight_on|no_entry|no_exit)$/]
# way[type=multipolygon]
# way[interval][route!=ferry]
# way[route=bus]
if (u'interval' in keys) or (u'restriction' in keys) or (u'route' in keys) or (u'type' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'restriction') and mapcss.regexp_test(mapcss._value_capture(capture_tags, 1, self.re_22f56734), mapcss._tag_capture(capture_tags, 1, tags, u'restriction')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'type') == mapcss._value_capture(capture_tags, 0, u'multipolygon'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'interval') and mapcss._tag_capture(capture_tags, 1, tags, u'route') != mapcss._value_capture(capture_tags, 1, u'ferry'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'route') == mapcss._value_capture(capture_tags, 0, u'bus'))
except mapcss.RuleAbort: pass
if match:
# throwError:tr("{0} on a way. Should be used in a relation","{0.tag}")
err.append({'class': 9003008, 'subclass': 665916193, 'text': mapcss.tr(u'{0} on a way. Should be used in a relation', mapcss._tag_uncapture(capture_tags, u'{0.tag}'))})
# way[place=island]!:closed
if (u'place' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'place') == mapcss._value_capture(capture_tags, 0, u'island') and nds[0] == nds[-1])
except mapcss.RuleAbort: pass
if match:
# throwError:tr("Way with {0} not closed.","{0.tag}")
err.append({'class': 9003010, 'subclass': 167228643, 'text': mapcss.tr(u'Way with {0} not closed.', mapcss._tag_uncapture(capture_tags, u'{0.tag}'))})
return err
def node(self, data, tags):
capture_tags = {}
keys = tags.keys()
err = []
# node[area=no]
# node[oneway]
# node[bridge]
# node[sidewalk]
# node[footway]
# node[man_made=embankment]
# node[man_made=groyne]
# node[man_made=cutline]
# node[power=line]
# node[cutline]
# node[aerialway=cable_car]
# node[aerialway=gondola]
# node[aerialway=chair_lift]
# node[aerialway=mixed_lift]
# node[aerialway=drag_lift]
# node[aerialway=t-bar]
# node[aerialway=j-bar]
# node[aerialway=platter]
# node[aerialway=magic_carpet]
# node[aerialway=rope_tow]
# node[aerialway=goods]
# node[aeroway=taxiway]
# node[aeroway=runway]
# node[railway=rail]
# node[railway=narrow_gauge]
# node[railway=monorail]
# node[railway=preserved]
# node[railway=light_rail]
# node[railway=subway]
# node[railway=tram]
# node[railway=disused]
# node[railway=abandoned]
# node[waterway=river]
# node[waterway=canal]
# node[waterway=stream]
# node[waterway=ditch]
# node[waterway=drain]
# node[natural=coastline]
# node[natural=ridge]
# node[natural=valley]
# node[natural=tree_row]
if (u'aerialway' in keys) or (u'aeroway' in keys) or (u'area' in keys) or (u'bridge' in keys) or (u'cutline' in keys) or (u'footway' in keys) or (u'man_made' in keys) or (u'natural' in keys) or (u'oneway' in keys) or (u'power' in keys) or (u'railway' in keys) or (u'sidewalk' in keys) or (u'waterway' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'area') == mapcss._value_capture(capture_tags, 0, u'no'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'oneway'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'bridge'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'sidewalk'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'footway'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'man_made') == mapcss._value_capture(capture_tags, 0, u'embankment'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'man_made') == mapcss._value_capture(capture_tags, 0, u'groyne'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'man_made') == mapcss._value_capture(capture_tags, 0, u'cutline'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'power') == mapcss._value_capture(capture_tags, 0, u'line'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'cutline'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'aerialway') == mapcss._value_capture(capture_tags, 0, u'cable_car'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'aerialway') == mapcss._value_capture(capture_tags, 0, u'gondola'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'aerialway') == mapcss._value_capture(capture_tags, 0, u'chair_lift'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'aerialway') == mapcss._value_capture(capture_tags, 0, u'mixed_lift'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'aerialway') == mapcss._value_capture(capture_tags, 0, u'drag_lift'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'aerialway') == mapcss._value_capture(capture_tags, 0, u't-bar'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'aerialway') == mapcss._value_capture(capture_tags, 0, u'j-bar'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'aerialway') == mapcss._value_capture(capture_tags, 0, u'platter'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'aerialway') == mapcss._value_capture(capture_tags, 0, u'magic_carpet'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'aerialway') == mapcss._value_capture(capture_tags, 0, u'rope_tow'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'aerialway') == mapcss._value_capture(capture_tags, 0, u'goods'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'aeroway') == mapcss._value_capture(capture_tags, 0, u'taxiway'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'aeroway') == mapcss._value_capture(capture_tags, 0, u'runway'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'railway') == mapcss._value_capture(capture_tags, 0, u'rail'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'railway') == mapcss._value_capture(capture_tags, 0, u'narrow_gauge'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'railway') == mapcss._value_capture(capture_tags, 0, u'monorail'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'railway') == mapcss._value_capture(capture_tags, 0, u'preserved'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'railway') == mapcss._value_capture(capture_tags, 0, u'light_rail'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'railway') == mapcss._value_capture(capture_tags, 0, u'subway'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'railway') == mapcss._value_capture(capture_tags, 0, u'tram'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'railway') == mapcss._value_capture(capture_tags, 0, u'disused'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'railway') == mapcss._value_capture(capture_tags, 0, u'abandoned'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'waterway') == mapcss._value_capture(capture_tags, 0, u'river'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'waterway') == mapcss._value_capture(capture_tags, 0, u'canal'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'waterway') == mapcss._value_capture(capture_tags, 0, u'stream'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'waterway') == mapcss._value_capture(capture_tags, 0, u'ditch'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'waterway') == mapcss._value_capture(capture_tags, 0, u'drain'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'natural') == mapcss._value_capture(capture_tags, 0, u'coastline'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'natural') == mapcss._value_capture(capture_tags, 0, u'ridge'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'natural') == mapcss._value_capture(capture_tags, 0, u'valley'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'natural') == mapcss._value_capture(capture_tags, 0, u'tree_row'))
except mapcss.RuleAbort: pass
if match:
# throwWarning:tr("{0} on a node. Should be used on a way.","{0.tag}")
# assertMatch:"node bridge=viaduct"
# assertMatch:"node bridge=yes"
# assertMatch:"node oneway=-1"
err.append({'class': 9003001, 'subclass': 2132549655, 'text': mapcss.tr(u'{0} on a node. Should be used on a way.', mapcss._tag_uncapture(capture_tags, u'{0.tag}'))})
# node[boundary=administrative]
if (u'boundary' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'boundary') == mapcss._value_capture(capture_tags, 0, u'administrative'))
except mapcss.RuleAbort: pass
if match:
# throwWarning:tr("{0} on a node. Should be used on a way or relation.","{0.tag}")
err.append({'class': 9003002, 'subclass': 1005532536, 'text': mapcss.tr(u'{0} on a node. Should be used on a way or relation.', mapcss._tag_uncapture(capture_tags, u'{0.tag}'))})
# node[golf=green]
# node[golf=bunker]
# node[golf=fairway]
# node[area=yes]
# node[area:highway]
# node[landuse]
# node[natural=scree]
# node[natural=scrub]
# node[natural=fell]
# node[natural=heath]
# node[natural=wood]
# node[natural=grassland]
# node[natural=wetland]
# node[natural=water]
# node[natural=mud]
# node[natural=beach]
# node[natural=sand]
# node[natural=wood]
# node[natural=bare_rock]
# node[natural=glacier]
# node[leisure=park][natural!=tree]
# node[leisure=nature_reserve]
# node[waterway=riverbank]
# node[man_made=bridge]
# node[man_made=breakwater]
# node[aeroway=apron]
# node[power=plant]
# node[power=switchgear]
# node[building:part]
# node[source:outline]
if (u'aeroway' in keys) or (u'area' in keys) or (u'area:highway' in keys) or (u'building:part' in keys) or (u'golf' in keys) or (u'landuse' in keys) or (u'leisure' in keys) or (u'man_made' in keys) or (u'natural' in keys) or (u'power' in keys) or (u'source:outline' in keys) or (u'waterway' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'golf') == mapcss._value_capture(capture_tags, 0, u'green'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'golf') == mapcss._value_capture(capture_tags, 0, u'bunker'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'golf') == mapcss._value_capture(capture_tags, 0, u'fairway'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'area') == mapcss._value_capture(capture_tags, 0, u'yes'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'area:highway'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'landuse'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'natural') == mapcss._value_capture(capture_tags, 0, u'scree'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'natural') == mapcss._value_capture(capture_tags, 0, u'scrub'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'natural') == mapcss._value_capture(capture_tags, 0, u'fell'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'natural') == mapcss._value_capture(capture_tags, 0, u'heath'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'natural') == mapcss._value_capture(capture_tags, 0, u'wood'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'natural') == mapcss._value_capture(capture_tags, 0, u'grassland'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'natural') == mapcss._value_capture(capture_tags, 0, u'wetland'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'natural') == mapcss._value_capture(capture_tags, 0, u'water'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'natural') == mapcss._value_capture(capture_tags, 0, u'mud'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'natural') == mapcss._value_capture(capture_tags, 0, u'beach'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'natural') == mapcss._value_capture(capture_tags, 0, u'sand'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'natural') == mapcss._value_capture(capture_tags, 0, u'wood'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'natural') == mapcss._value_capture(capture_tags, 0, u'bare_rock'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'natural') == mapcss._value_capture(capture_tags, 0, u'glacier'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'leisure') == mapcss._value_capture(capture_tags, 0, u'park') and mapcss._tag_capture(capture_tags, 1, tags, u'natural') != mapcss._value_capture(capture_tags, 1, u'tree'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'leisure') == mapcss._value_capture(capture_tags, 0, u'nature_reserve'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'waterway') == mapcss._value_capture(capture_tags, 0, u'riverbank'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'man_made') == mapcss._value_capture(capture_tags, 0, u'bridge'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'man_made') == mapcss._value_capture(capture_tags, 0, u'breakwater'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'aeroway') == mapcss._value_capture(capture_tags, 0, u'apron'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'power') == mapcss._value_capture(capture_tags, 0, u'plant'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'power') == mapcss._value_capture(capture_tags, 0, u'switchgear'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'building:part'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'source:outline'))
except mapcss.RuleAbort: pass
if match:
# throwWarning:tr("{0} on a node. Should be drawn as an area.","{0.tag}")
err.append({'class': 9003003, 'subclass': 1633038746, 'text': mapcss.tr(u'{0} on a node. Should be drawn as an area.', mapcss._tag_uncapture(capture_tags, u'{0.tag}'))})
# node[type=multipolygon]
# node[interval]
# node[route]
# node[restriction]
if (u'interval' in keys) or (u'restriction' in keys) or (u'route' in keys) or (u'type' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'type') == mapcss._value_capture(capture_tags, 0, u'multipolygon'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'interval'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'route'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'restriction'))
except mapcss.RuleAbort: pass
if match:
# throwError:tr("{0} on a node. Should be used in a relation","{0.tag}")
err.append({'class': 9003004, 'subclass': 104835602, 'text': mapcss.tr(u'{0} on a node. Should be used in a relation', mapcss._tag_uncapture(capture_tags, u'{0.tag}'))})
# node[man_made!=monitoring_station][at(0.0,0.0)]
if True:
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'man_made') != mapcss._value_capture(capture_tags, 0, u'monitoring_station') and mapcss.at(data['lat'], data['lon'], 0.0, 0.0))
except mapcss.RuleAbort: pass
if match:
# throwError:tr("Object at Position 0.00E 0.00N. There is nothing at this position except an already mapped weather buoy.")
# fixDeleteObject:this
err.append({'class': 9003009, 'subclass': 829325630, 'text': mapcss.tr(u'Object at Position 0.00E 0.00N. There is nothing at this position except an already mapped weather buoy.')})
# node[source:geometry]
if (u'source:geometry' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'source:geometry'))
except mapcss.RuleAbort: pass
if match:
# throwWarning:tr("{0} on a node","{0.key}")
# fixChangeKey:"source:geometry => source:position"
err.append({'class': 9003006, 'subclass': 1287904360, 'text': mapcss.tr(u'{0} on a node', mapcss._tag_uncapture(capture_tags, u'{0.key}')), 'allow_fix_override': True, 'fix': {
'+': dict([
[u'source:position', mapcss.tag(tags, u'source:geometry')]]),
'-': ([
u'source:geometry'])
}})
return err
def way(self, data, tags, nds):
capture_tags = {}
keys = tags.keys()
err = []
set_fixable_footway = set_link_road = set_major_road = set_minor_road = set_not_fixable_footway = False
# way[highway=~/^(motorway|trunk|primary|secondary|tertiary)$/]
if (u'highway' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test(mapcss._value_capture(capture_tags, 0, self.re_55ee32ac), mapcss._tag_capture(capture_tags, 0, tags, u'highway')))
except mapcss.RuleAbort: pass
if match:
# setmajor_road
set_major_road = True
# way[highway=~/^.*_link$/]
if (u'highway' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test(mapcss._value_capture(capture_tags, 0, self.re_3092b7ac), mapcss._tag_capture(capture_tags, 0, tags, u'highway')))
except mapcss.RuleAbort: pass
if match:
# setlink_road
set_link_road = True
# way[highway=~/^(unclassified|residential|living_street|service)$/]
if (u'highway' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test(mapcss._value_capture(capture_tags, 0, self.re_015aabd5), mapcss._tag_capture(capture_tags, 0, tags, u'highway')))
except mapcss.RuleAbort: pass
if match:
# setminor_road
set_minor_road = True
# way[highway][name=~/(?i).* (Ave|Blvd|Br|Brg|Cct|Cir|Cl|Cr|Crct|Cres|Crt|Ct|Dr|Drv|Esp|Espl|Hwy|Ln|Mw|Mwy|Pky|Pkwy|Pl|Rd|Qy|Qys|Sq|St|Str|Ter|Tce|Tr|Wy)[.]?$/]
if (u'highway' in keys and u'name' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'highway') and mapcss.regexp_test(mapcss._value_capture(capture_tags, 1, self.re_776f2c1a), mapcss._tag_capture(capture_tags, 1, tags, u'name')))
except mapcss.RuleAbort: pass
if match:
# throwWarning:tr("abbreviated street name")
# assertMatch:"way highway=unclassified name=\"Bou Blvd.\""
# assertMatch:"way highway=unclassified name=\"Bou blvd.\""
# assertMatch:"way highway=unclassified name=\"Foo Ave\""
# assertMatch:"way highway=unclassified name=\"Foo Ave.\""
err.append({'class': 9004001, 'subclass': 544432044, 'text': mapcss.tr(u'abbreviated street name')})
# way[highway=crossing]
# way[railway=crossing]
# way[railway=level_crossing]
if (u'highway' in keys) or (u'railway' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'highway') == mapcss._value_capture(capture_tags, 0, u'crossing'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'railway') == mapcss._value_capture(capture_tags, 0, u'crossing'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'railway') == mapcss._value_capture(capture_tags, 0, u'level_crossing'))
except mapcss.RuleAbort: pass
if match:
# throwWarning:tr("wrong crossing tag on a way")
# assertMatch:"way highway=crossing"
err.append({'class': 9004002, 'subclass': 1549110307, 'text': mapcss.tr(u'wrong crossing tag on a way')})
# way[highway=yes]
# way[highway=road]
if (u'highway' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'highway') == mapcss._value_capture(capture_tags, 0, u'yes'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'highway') == mapcss._value_capture(capture_tags, 0, u'road'))
except mapcss.RuleAbort: pass
if match:
# throwWarning:tr("Unspecific highway type")
# assertNoMatch:"way highway=residential"
# assertMatch:"way highway=road"
err.append({'class': 9004004, 'subclass': 1729022478, 'text': mapcss.tr(u'Unspecific highway type')})
# way[highway=footway][maxspeed]
# way[highway=steps][maxspeed]
# way[highway=cycleway][bicycle=no]
# way[highway=footway][foot=no]
# way[highway=cycleway][cycleway=lane]
if (u'bicycle' in keys and u'highway' in keys) or (u'cycleway' in keys and u'highway' in keys) or (u'foot' in keys and u'highway' in keys) or (u'highway' in keys and u'maxspeed' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'highway') == mapcss._value_capture(capture_tags, 0, u'footway') and mapcss._tag_capture(capture_tags, 1, tags, u'maxspeed'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'highway') == mapcss._value_capture(capture_tags, 0, u'steps') and mapcss._tag_capture(capture_tags, 1, tags, u'maxspeed'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'highway') == mapcss._value_capture(capture_tags, 0, u'cycleway') and mapcss._tag_capture(capture_tags, 1, tags, u'bicycle') == mapcss._value_capture(capture_tags, 1, u'no'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'highway') == mapcss._value_capture(capture_tags, 0, u'footway') and mapcss._tag_capture(capture_tags, 1, tags, u'foot') == mapcss._value_capture(capture_tags, 1, u'no'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'highway') == mapcss._value_capture(capture_tags, 0, u'cycleway') and mapcss._tag_capture(capture_tags, 1, tags, u'cycleway') == mapcss._value_capture(capture_tags, 1, u'lane'))
except mapcss.RuleAbort: pass
if match:
# throwWarning:tr("{0} used with {1}","{0.value}","{1.tag}")
# assertNoMatch:"way highway=cycleway bicycle=yes"
# assertMatch:"way highway=cycleway cycleway=lane"
# assertNoMatch:"way highway=cycleway"
# assertNoMatch:"way highway=cycleway"
# assertNoMatch:"way highway=footway foot=yes"
# assertMatch:"way highway=footway maxspeed=20"
# assertNoMatch:"way highway=footway"
# assertNoMatch:"way highway=footway"
# assertNoMatch:"way highway=residential cycleway=lane"
# assertNoMatch:"way highway=residential maxspeed=20"
err.append({'class': 9004005, 'subclass': 469607562, 'text': mapcss.tr(u'{0} used with {1}', mapcss._tag_uncapture(capture_tags, u'{0.value}'), mapcss._tag_uncapture(capture_tags, u'{1.tag}'))})
# way[footway=left][/^footway:/]
# way[footway=right][/^footway:/]
# way[footway=both][/^footway:/]
# way[footway=no][/^footway:/]
if (u'footway' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'footway') == mapcss._value_capture(capture_tags, 0, u'left') and mapcss._tag_capture(capture_tags, 1, tags, self.re_4dcdb354))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'footway') == mapcss._value_capture(capture_tags, 0, u'right') and mapcss._tag_capture(capture_tags, 1, tags, self.re_4dcdb354))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'footway') == mapcss._value_capture(capture_tags, 0, u'both') and mapcss._tag_capture(capture_tags, 1, tags, self.re_4dcdb354))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'footway') == mapcss._value_capture(capture_tags, 0, u'no') and mapcss._tag_capture(capture_tags, 1, tags, self.re_4dcdb354))
except mapcss.RuleAbort: pass
if match:
# setnot_fixable_footway
# group:tr("deprecated tagging")
# throwWarning:tr("{0} is deprecated, use {1} instead. Also check similar tags like {2}","{0.tag}","sidewalk","{1.key}")
# assertMatch:"way footway=both footway:surface=asphalt"
set_not_fixable_footway = True
err.append({'class': 9004006, 'subclass': 141262069, 'text': mapcss.tr(u'{0} is deprecated, use {1} instead. Also check similar tags like {2}', mapcss._tag_uncapture(capture_tags, u'{0.tag}'), u'sidewalk', mapcss._tag_uncapture(capture_tags, u'{1.key}'))})
# way[footway=none][/footway:/]
if (u'footway' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'footway') == mapcss._value_capture(capture_tags, 0, u'none') and mapcss._tag_capture(capture_tags, 1, tags, self.re_61bbe299))
except mapcss.RuleAbort: pass
if match:
# setnot_fixable_footway
# group:tr("deprecated tagging")
# throwWarning:tr("{0} is deprecated, use {1} instead. Also check similar tags like {2}","{0.tag}","sidewalk=no","{1.key}")
set_not_fixable_footway = True
err.append({'class': 9004006, 'subclass': 1570348899, 'text': mapcss.tr(u'{0} is deprecated, use {1} instead. Also check similar tags like {2}', mapcss._tag_uncapture(capture_tags, u'{0.tag}'), u'sidewalk=no', mapcss._tag_uncapture(capture_tags, u'{1.key}'))})
# way[footway=left]!.not_fixable_footway
# way[footway=right]!.not_fixable_footway
# way[footway=both]!.not_fixable_footway
# way[footway=no]!.not_fixable_footway
if (u'footway' in keys):
match = False
if not match:
capture_tags = {}
try: match = (not set_not_fixable_footway and mapcss._tag_capture(capture_tags, 0, tags, u'footway') == mapcss._value_capture(capture_tags, 0, u'left'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (not set_not_fixable_footway and mapcss._tag_capture(capture_tags, 0, tags, u'footway') == mapcss._value_capture(capture_tags, 0, u'right'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (not set_not_fixable_footway and mapcss._tag_capture(capture_tags, 0, tags, u'footway') == mapcss._value_capture(capture_tags, 0, u'both'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (not set_not_fixable_footway and mapcss._tag_capture(capture_tags, 0, tags, u'footway') == mapcss._value_capture(capture_tags, 0, u'no'))
except mapcss.RuleAbort: pass
if match:
# setfixable_footway
# group:tr("deprecated tagging")
# throwWarning:tr("{0} is deprecated","{0.tag}")
# suggestAlternative:"sidewalk"
# fixChangeKey:"footway => sidewalk"
set_fixable_footway = True
err.append({'class': 9004006, 'subclass': 2076937761, 'text': mapcss.tr(u'{0} is deprecated', mapcss._tag_uncapture(capture_tags, u'{0.tag}')), 'allow_fix_override': True, 'fix': {
'+': dict([
[u'sidewalk', mapcss.tag(tags, u'footway')]]),
'-': ([
u'footway'])
}})
# way[footway=none]!.not_fixable_footway
if (u'footway' in keys):
match = False
if not match:
capture_tags = {}
try: match = (not set_not_fixable_footway and mapcss._tag_capture(capture_tags, 0, tags, u'footway') == mapcss._value_capture(capture_tags, 0, u'none'))
except mapcss.RuleAbort: pass
if match:
# setfixable_footway
# group:tr("deprecated tagging")
# throwWarning:tr("{0} is deprecated","{0.tag}")
# suggestAlternative:"sidewalk=no"
# fixRemove:"footway"
# fixAdd:"sidewalk=no"
set_fixable_footway = True
err.append({'class': 9004006, 'subclass': 430589555, 'text': mapcss.tr(u'{0} is deprecated', mapcss._tag_uncapture(capture_tags, u'{0.tag}')), 'allow_fix_override': True, 'fix': {
'+': dict([
[u'sidewalk',u'no']]),
'-': ([
u'footway'])
}})
# way[footway][footway!=sidewalk][footway!=crossing]!.fixable_footway!.not_fixable_footway
if (u'footway' in keys):
match = False
if not match:
capture_tags = {}
try: match = (not set_fixable_footway and not set_not_fixable_footway and mapcss._tag_capture(capture_tags, 0, tags, u'footway') and mapcss._tag_capture(capture_tags, 1, tags, u'footway') != mapcss._value_capture(capture_tags, 1, u'sidewalk') and mapcss._tag_capture(capture_tags, 2, tags, u'footway') != mapcss._value_capture(capture_tags, 2, u'crossing'))
except mapcss.RuleAbort: pass
if match:
# throwWarning:tr("Value of ''{0}'' should either be ''{1}'' or ''{2}''. For sidewalks use ''{3}'' instead.","{0.key}","{1.value}","{2.value}","sidewalk=left|right|both|no")
# assertMatch:"way footway=bar"
# assertNoMatch:"way footway=left footway:left:surface=asphalt"
# assertNoMatch:"way footway=left"
# assertNoMatch:"way footway=none"
err.append({'class': 9004007, 'subclass': 156640320, 'text': mapcss.tr(u'Value of \'\'{0}\'\' should either be \'\'{1}\'\' or \'\'{2}\'\'. For sidewalks use \'\'{3}\'\' instead.', mapcss._tag_uncapture(capture_tags, u'{0.key}'), mapcss._tag_uncapture(capture_tags, u'{1.value}'), mapcss._tag_uncapture(capture_tags, u'{2.value}'), u'sidewalk=left|right|both|no')})
return err
def way(self, data, tags, nds):
capture_tags = {}
keys = tags.keys()
err = []
# *[building:colour][building:colour=~/^#/][building:colour!~/^#([0-9A-Fa-f]{3}|[0-9A-Fa-f]{6})$/]
# *[roof:colour][roof:colour=~/^#/][roof:colour!~/^#([0-9A-Fa-f]{3}|[0-9A-Fa-f]{6})$/]
# *[colour][colour=~/^#/][colour!~/^#([0-9A-Fa-f]{3}|[0-9A-Fa-f]{6})$/]
# *[ref:colour][ref:colour=~/^#/][ref:colour!~/^#([0-9A-Fa-f]{3}|[0-9A-Fa-f]{6})$/]
if (u'building:colour' in keys) or (u'colour' in keys) or (u'ref:colour' in keys) or (u'roof:colour' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'building:colour') and mapcss.regexp_test(mapcss._value_capture(capture_tags, 1, self.re_30dca0d4), mapcss._tag_capture(capture_tags, 1, tags, u'building:colour')) and not mapcss.regexp_test(mapcss._value_const_capture(capture_tags, 2, self.re_1b3f6ace, u'^#([0-9A-Fa-f]{3}|[0-9A-Fa-f]{6})$'), mapcss._tag_capture(capture_tags, 2, tags, u'building:colour')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'roof:colour') and mapcss.regexp_test(mapcss._value_capture(capture_tags, 1, self.re_30dca0d4), mapcss._tag_capture(capture_tags, 1, tags, u'roof:colour')) and not mapcss.regexp_test(mapcss._value_const_capture(capture_tags, 2, self.re_1b3f6ace, u'^#([0-9A-Fa-f]{3}|[0-9A-Fa-f]{6})$'), mapcss._tag_capture(capture_tags, 2, tags, u'roof:colour')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'colour') and mapcss.regexp_test(mapcss._value_capture(capture_tags, 1, self.re_30dca0d4), mapcss._tag_capture(capture_tags, 1, tags, u'colour')) and not mapcss.regexp_test(mapcss._value_const_capture(capture_tags, 2, self.re_1b3f6ace, u'^#([0-9A-Fa-f]{3}|[0-9A-Fa-f]{6})$'), mapcss._tag_capture(capture_tags, 2, tags, u'colour')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'ref:colour') and mapcss.regexp_test(mapcss._value_capture(capture_tags, 1, self.re_30dca0d4), mapcss._tag_capture(capture_tags, 1, tags, u'ref:colour')) and not mapcss.regexp_test(mapcss._value_const_capture(capture_tags, 2, self.re_1b3f6ace, u'^#([0-9A-Fa-f]{3}|[0-9A-Fa-f]{6})$'), mapcss._tag_capture(capture_tags, 2, tags, u'ref:colour')))
except mapcss.RuleAbort: pass
if match:
# group:tr("Colour code should start with '#' followed by 3 or 6 digits")
# -osmoseItemClassLevel:"3091/30911:0/2"
# throwWarning:tr("{0} colour code should start with '#' followed by 3 or 6 digits","{0.tag}")
# assertNoMatch:"way building:colour=#123"
# assertMatch:"way building:colour=#1234"
# assertNoMatch:"way building:colour=#abcdef"
# assertMatch:"way building:colour=#foobar9"
# assertMatch:"way building:colour=#zzz"
# assertNoMatch:"way roof:colour=#484443 building:colour=#8c6b57"
err.append({'class': 30911, 'subclass': 0, 'text': mapcss.tr(u'{0} colour code should start with \'#\' followed by 3 or 6 digits', mapcss._tag_uncapture(capture_tags, u'{0.tag}'))})
# *[building:colour][building:colour=~/^([0-9A-Fa-f]{3}|[0-9A-Fa-f]{6})$/]
# *[roof:colour][roof:colour=~/^([0-9A-Fa-f]{3}|[0-9A-Fa-f]{6})$/]
# *[colour][colour=~/^([0-9A-Fa-f]{3}|[0-9A-Fa-f]{6})$/]
# *[ref:colour][ref:colour=~/^([0-9A-Fa-f]{3}|[0-9A-Fa-f]{6})$/]
if (u'building:colour' in keys) or (u'colour' in keys) or (u'ref:colour' in keys) or (u'roof:colour' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'building:colour') and mapcss.regexp_test(mapcss._value_capture(capture_tags, 1, self.re_7d65c79d), mapcss._tag_capture(capture_tags, 1, tags, u'building:colour')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'roof:colour') and mapcss.regexp_test(mapcss._value_capture(capture_tags, 1, self.re_7d65c79d), mapcss._tag_capture(capture_tags, 1, tags, u'roof:colour')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'colour') and mapcss.regexp_test(mapcss._value_capture(capture_tags, 1, self.re_7d65c79d), mapcss._tag_capture(capture_tags, 1, tags, u'colour')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'ref:colour') and mapcss.regexp_test(mapcss._value_capture(capture_tags, 1, self.re_7d65c79d), mapcss._tag_capture(capture_tags, 1, tags, u'ref:colour')))
except mapcss.RuleAbort: pass
if match:
# group:tr("Colour code should start with '#' followed by 3 or 6 digits")
# -osmoseItemClassLevel:"3091/30911:1/2"
# throwWarning:tr("{0} colour code should start with '#' followed by 3 or 6 digits","{0.tag}")
# fixAdd:"{0.key}=#{0.value}"
# assertNoMatch:"way building:colour=#123"
# assertMatch:"way building:colour=123"
# assertMatch:"way building:colour=abcdef"
# assertNoMatch:"way building:colour=red"
# assertNoMatch:"way roof:colour=#484443 building:colour=#8c6b57"
err.append({'class': 30911, 'subclass': 1, 'text': mapcss.tr(u'{0} colour code should start with \'#\' followed by 3 or 6 digits', mapcss._tag_uncapture(capture_tags, u'{0.tag}')), 'allow_fix_override': True, 'fix': {
'+': dict([
(mapcss._tag_uncapture(capture_tags, u'{0.key}=#{0.value}')).split('=', 1)])
}})
return err
def way(self, data, tags, nds):
capture_tags = {}
keys = tags.keys()
err = []
# *[name=~/ي/][language("fa")]
# *[name:fa=~/ي/]
if (u'name' in keys) or (u'name:fa' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test(mapcss._value_capture(capture_tags, 0, self.re_5eeade1c), mapcss._tag_capture(capture_tags, 0, tags, u'name')) and mapcss.language(self.father.config.options, u'fa'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test(mapcss._value_capture(capture_tags, 0, self.re_5eeade1c), mapcss._tag_capture(capture_tags, 0, tags, u'name:fa')))
except mapcss.RuleAbort: pass
if match:
# group:tr("Arabic letter detected in Farsi name")
# -osmoseItemClassLevel:"5010/50109001/2"
# throwError:tr("In Farsi, the Arabic letter '{0}' should be replaced by '{1}'","ي","ی")
# fixAdd:concat("{0.key}=",replace("{0.value}","ي","ی"))
# -osmoseAssertMatchWithContext:list('node name="روابط عمومي مجتمع مس شهربابك"','language=fa')
# assertMatch:'node name:fa="روابط عمومي مجتمع مس شهربابك"'
# assertNoMatch:'node name="روابط عمومي مجتمع مس شهربابك"'
err.append({'class': 50109001, 'subclass': 0, 'text': mapcss.tr(u'In Farsi, the Arabic letter \'{0}\' should be replaced by \'{1}\'', u'ي', u'ی'), 'allow_fix_override': True, 'fix': {
'+': dict([
(mapcss.concat(mapcss._tag_uncapture(capture_tags, u'{0.key}='), mapcss.replace(mapcss._tag_uncapture(capture_tags, u'{0.value}'), u'ي', u'ی'))).split('=', 1)])
}})
# *[name=~/ك/][language("fa")]
# *[name:fa=~/ك/]
if (u'name' in keys) or (u'name:fa' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test(mapcss._value_capture(capture_tags, 0, self.re_4234bf3b), mapcss._tag_capture(capture_tags, 0, tags, u'name')) and mapcss.language(self.father.config.options, u'fa'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test(mapcss._value_capture(capture_tags, 0, self.re_4234bf3b), mapcss._tag_capture(capture_tags, 0, tags, u'name:fa')))
except mapcss.RuleAbort: pass
if match:
# group:tr("Arabic letter detected in Farsi name")
# -osmoseItemClassLevel:"5010/50109001/2"
# throwError:tr("In Farsi, the Arabic letter '{0}' should be replaced by '{1}'","ك","ک")
# fixAdd:concat("{0.key}=",replace("{0.value}","ك","ک"))
# -osmoseAssertMatchWithContext:list('node name="روابط عمومي مجتمع مس شهربابك"','language=fa')
# assertMatch:'node name:fa="روابط عمومي مجتمع مس شهربابك"'
# assertNoMatch:'node name="روابط عمومي مجتمع مس شهربابك"'
err.append({'class': 50109001, 'subclass': 0, 'text': mapcss.tr(u'In Farsi, the Arabic letter \'{0}\' should be replaced by \'{1}\'', u'ك', u'ک'), 'allow_fix_override': True, 'fix': {
'+': dict([
(mapcss.concat(mapcss._tag_uncapture(capture_tags, u'{0.key}='), mapcss.replace(mapcss._tag_uncapture(capture_tags, u'{0.value}'), u'ك', u'ک'))).split('=', 1)])
}})
return err
def node(self, data, tags):
capture_tags = {}
keys = tags.keys()
err = []
set_pt_route = set_pt_route_master = False
# node[highway=bus_stop][amenity=bus_station]
if (u'amenity' in keys and u'highway' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'highway') == mapcss._value_capture(capture_tags, 0, u'bus_stop') and mapcss._tag_capture(capture_tags, 1, tags, u'amenity') == mapcss._value_capture(capture_tags, 1, u'bus_station'))
except mapcss.RuleAbort: pass
if match:
# throwError:tr("Is it a bus stop or a bus station?")
# fixRemove:"amenity"
err.append({'class': 9014002, 'subclass': 1676203359, 'text': mapcss.tr(u'Is it a bus stop or a bus station?'), 'allow_fix_override': True, 'fix': {
'-': ([
u'amenity'])
}})
# node[highway=bus_stop][!public_transport]
if (u'highway' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'highway') == mapcss._value_capture(capture_tags, 0, u'bus_stop') and not mapcss._tag_capture(capture_tags, 1, tags, u'public_transport'))
except mapcss.RuleAbort: pass
if match:
# group:tr("Missing public_transport tag on a public transport stop")
# -osmoseItemClassLevel:"2140/21411:0/3"
# throwError:tr("Specify if it is a stop (platform) or a location on the road (stop_position)")
# fixAdd:"public_transport=platform"
# assertNoMatch:"node highway=bus_stop public_transport=platform"
# assertNoMatch:"node highway=bus_stop public_transport=stop_position"
# assertMatch:"node highway=bus_stop"
err.append({'class': 21411, 'subclass': 0, 'text': mapcss.tr(u'Specify if it is a stop (platform) or a location on the road (stop_position)'), 'allow_fix_override': True, 'fix': {
'+': dict([
[u'public_transport',u'platform']])
}})
# node[railway=tram_stop][!public_transport]
if (u'railway' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'railway') == mapcss._value_capture(capture_tags, 0, u'tram_stop') and not mapcss._tag_capture(capture_tags, 1, tags, u'public_transport'))
except mapcss.RuleAbort: pass
if match:
# group:tr("Missing public_transport tag on a public transport stop")
# -osmoseItemClassLevel:"2140/21411:1/3"
# throwError:tr("Specify if it is a stop (platform) or a location on the rails (stop_position)")
# fixAdd:"public_transport=stop_position"
# assertNoMatch:"node railway=tram_stop public_transport=platform"
# assertNoMatch:"node railway=tram_stop public_transport=stop_position"
# assertMatch:"node railway=tram_stop"
err.append({'class': 21411, 'subclass': 1, 'text': mapcss.tr(u'Specify if it is a stop (platform) or a location on the rails (stop_position)'), 'allow_fix_override': True, 'fix': {
'+': dict([
[u'public_transport',u'stop_position']])
}})
# node[public_transport=platform][!highway][!railway][!bus][!shelter]
if (u'public_transport' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'public_transport') == mapcss._value_capture(capture_tags, 0, u'platform') and not mapcss._tag_capture(capture_tags, 1, tags, u'highway') and not mapcss._tag_capture(capture_tags, 2, tags, u'railway') and not mapcss._tag_capture(capture_tags, 3, tags, u'bus') and not mapcss._tag_capture(capture_tags, 4, tags, u'shelter'))
except mapcss.RuleAbort: pass
if match:
# group:tr("Missing legacy tag on a public transport stop")
# -osmoseItemClassLevel:"2140/21412:1/3"
# throwError:tr("The legacy tag is missing, add the tag highway=bus_stop / railway=tram_stop")
err.append({'class': 21412, 'subclass': 1, 'text': mapcss.tr(u'The legacy tag is missing, add the tag highway=bus_stop / railway=tram_stop')})
# node[public_transport=platform][!highway][!railway][bus=yes]
# node[public_transport=platform][!highway][!railway][shelter]
if (u'bus' in keys and u'public_transport' in keys) or (u'public_transport' in keys and u'shelter' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'public_transport') == mapcss._value_capture(capture_tags, 0, u'platform') and not mapcss._tag_capture(capture_tags, 1, tags, u'highway') and not mapcss._tag_capture(capture_tags, 2, tags, u'railway') and mapcss._tag_capture(capture_tags, 3, tags, u'bus') == mapcss._value_capture(capture_tags, 3, u'yes'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'public_transport') == mapcss._value_capture(capture_tags, 0, u'platform') and not mapcss._tag_capture(capture_tags, 1, tags, u'highway') and not mapcss._tag_capture(capture_tags, 2, tags, u'railway') and mapcss._tag_capture(capture_tags, 3, tags, u'shelter'))
except mapcss.RuleAbort: pass
if match:
# group:tr("Missing legacy tag on a public transport stop")
# -osmoseItemClassLevel:"2140/21412:0/3"
# throwError:tr("Is this a bus stop? add the tag highway=bus_stop")
# fixAdd:"highway=bus_stop"
# assertMatch:"node public_transport=platform shelter=yes"
err.append({'class': 21412, 'subclass': 0, 'text': mapcss.tr(u'Is this a bus stop? add the tag highway=bus_stop'), 'allow_fix_override': True, 'fix': {
'+': dict([
[u'highway',u'bus_stop']])
}})
# node[highway=bus_stop][note]
# node[highway=bus_stop][note:fr][inside("FR")]
if (u'highway' in keys and u'note' in keys) or (u'highway' in keys and u'note:fr' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'highway') == mapcss._value_capture(capture_tags, 0, u'bus_stop') and mapcss._tag_capture(capture_tags, 1, tags, u'note'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'highway') == mapcss._value_capture(capture_tags, 0, u'bus_stop') and mapcss._tag_capture(capture_tags, 1, tags, u'note:fr') and mapcss.inside(self.father.config.options, u'FR'))
except mapcss.RuleAbort: pass
if match:
# throwWarning:tr("Check if the note can be deleted")
err.append({'class': 9014006, 'subclass': 673170504, 'text': mapcss.tr(u'Check if the note can be deleted')})
# node[highway=bus_stop][network][inside("FR")]
if (u'highway' in keys and u'network' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'highway') == mapcss._value_capture(capture_tags, 0, u'bus_stop') and mapcss._tag_capture(capture_tags, 1, tags, u'network') and mapcss.inside(self.father.config.options, u'FR'))
except mapcss.RuleAbort: pass
if match:
# throwWarning:tr("The network should be on the transport lines and not on the stops")
# fixRemove:"network"
err.append({'class': 9014007, 'subclass': 1428913922, 'text': mapcss.tr(u'The network should be on the transport lines and not on the stops'), 'allow_fix_override': True, 'fix': {
'-': ([
u'network'])
}})
# node[highway=bus_stop][operator][inside("FR")]
if (u'highway' in keys and u'operator' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'highway') == mapcss._value_capture(capture_tags, 0, u'bus_stop') and mapcss._tag_capture(capture_tags, 1, tags, u'operator') and mapcss.inside(self.father.config.options, u'FR'))
except mapcss.RuleAbort: pass
if match:
# throwWarning:tr("The operator should be on the transport lines and not on the stops")
# fixRemove:"operator"
err.append({'class': 9014008, 'subclass': 210603856, 'text': mapcss.tr(u'The operator should be on the transport lines and not on the stops'), 'allow_fix_override': True, 'fix': {
'-': ([
u'operator'])
}})
return err
def way(self, data, tags, nds):
capture_tags = {}
keys = tags.keys()
err = []
# way[line_attachment]
# way[emergency=fire_hydrant]
# way[entrance]
# way[door]
# way[railway=subway_entrance]
# way[man_made=survey_point]
# way[aeroway=holding_position]
# way[power=transformer]
# way[power=pole]
# way[power=catenary_mast]
# way[power=terminal]
# way[power=tower]!:closed
# way[amenity=vending_machine]
# way[natural=peak]
# way[natural=saddle]
# way[natural=volcano]
# way[natural=tree]
# way[highway=give_way]
# way[highway=milestone]
# way[highway=mini_roundabout]
# way[highway=stop]
# way[highway=street_lamp]
# way[highway=traffic_signals]
# way[highway=turning_loop]
# way[highway=turning_circle]
# way[highway=motorway_junction]
if (u'aeroway' in keys) or (u'amenity' in keys) or (u'door' in keys) or (u'emergency' in keys) or (u'entrance' in keys) or (u'highway' in keys) or (u'line_attachment' in keys) or (u'man_made' in keys) or (u'natural' in keys) or (u'power' in keys) or (u'railway' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'line_attachment'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'emergency') == mapcss._value_capture(capture_tags, 0, u'fire_hydrant'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'entrance'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'door'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'railway') == mapcss._value_capture(capture_tags, 0, u'subway_entrance'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'man_made') == mapcss._value_capture(capture_tags, 0, u'survey_point'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'aeroway') == mapcss._value_capture(capture_tags, 0, u'holding_position'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'power') == mapcss._value_capture(capture_tags, 0, u'transformer'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'power') == mapcss._value_capture(capture_tags, 0, u'pole'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'power') == mapcss._value_capture(capture_tags, 0, u'catenary_mast'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'power') == mapcss._value_capture(capture_tags, 0, u'terminal'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'power') == mapcss._value_capture(capture_tags, 0, u'tower') and nds[0] != nds[-1])
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'amenity') == mapcss._value_capture(capture_tags, 0, u'vending_machine'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'natural') == mapcss._value_capture(capture_tags, 0, u'peak'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'natural') == mapcss._value_capture(capture_tags, 0, u'saddle'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'natural') == mapcss._value_capture(capture_tags, 0, u'volcano'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'natural') == mapcss._value_capture(capture_tags, 0, u'tree'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'highway') == mapcss._value_capture(capture_tags, 0, u'give_way'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'highway') == mapcss._value_capture(capture_tags, 0, u'milestone'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'highway') == mapcss._value_capture(capture_tags, 0, u'mini_roundabout'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'highway') == mapcss._value_capture(capture_tags, 0, u'stop'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'highway') == mapcss._value_capture(capture_tags, 0, u'street_lamp'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'highway') == mapcss._value_capture(capture_tags, 0, u'traffic_signals'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'highway') == mapcss._value_capture(capture_tags, 0, u'turning_loop'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'highway') == mapcss._value_capture(capture_tags, 0, u'turning_circle'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'highway') == mapcss._value_capture(capture_tags, 0, u'motorway_junction'))
except mapcss.RuleAbort: pass
if match:
# throwWarning:tr("{0} on a way. Should be used on a node.","{0.tag}")
err.append({'class': 9003007, 'subclass': 1746469597, 'text': mapcss.tr(u'{0} on a way. Should be used on a node.', mapcss._tag_uncapture(capture_tags, u'{0.tag}'))})
# way[restriction][restriction=~/^(no_right_turn|no_left_turn|no_u_turn|no_straight_on|only_right_turn|only_left_turn|only_straight_on|no_entry|no_exit)$/]
# way[type=multipolygon]
# way[interval][route!=ferry]
# way[route=bus]
if (u'interval' in keys) or (u'restriction' in keys) or (u'route' in keys) or (u'type' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'restriction') and mapcss.regexp_test(mapcss._value_capture(capture_tags, 1, self.re_22f56734), mapcss._tag_capture(capture_tags, 1, tags, u'restriction')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'type') == mapcss._value_capture(capture_tags, 0, u'multipolygon'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'interval') and mapcss._tag_capture(capture_tags, 1, tags, u'route') != mapcss._value_const_capture(capture_tags, 1, u'ferry', u'ferry'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'route') == mapcss._value_capture(capture_tags, 0, u'bus'))
except mapcss.RuleAbort: pass
if match:
# throwError:tr("{0} on a way. Should be used in a relation","{0.tag}")
err.append({'class': 9003008, 'subclass': 665916193, 'text': mapcss.tr(u'{0} on a way. Should be used in a relation', mapcss._tag_uncapture(capture_tags, u'{0.tag}'))})
# way[place=island]!:closed
if (u'place' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'place') == mapcss._value_capture(capture_tags, 0, u'island') and nds[0] != nds[-1])
except mapcss.RuleAbort: pass
if match:
# throwError:tr("Way with {0} not closed.","{0.tag}")
err.append({'class': 9003010, 'subclass': 167228643, 'text': mapcss.tr(u'Way with {0} not closed.', mapcss._tag_uncapture(capture_tags, u'{0.tag}'))})
return err
def node(self, data, tags):
capture_tags = {}
keys = tags.keys()
err = []
set_pt_route = set_pt_route_master = False
# node[highway=bus_stop][amenity=bus_station]
if (u'amenity' in keys and u'highway' in keys):
match = False
if not match:
capture_tags = {}
try:
match = (
mapcss._tag_capture(capture_tags, 0, tags, u'highway')
== mapcss._value_capture(capture_tags, 0, u'bus_stop')
and mapcss._tag_capture(
capture_tags, 1, tags,
u'amenity') == mapcss._value_capture(
capture_tags, 1, u'bus_station'))
except mapcss.RuleAbort:
pass
if match:
# throwError:tr("Is it a bus stop or a bus station?")
# fixRemove:"amenity"
err.append({
'class':
9014002,
'subclass':
1676203359,
'text':
mapcss.tr(u'Is it a bus stop or a bus station?'),
'allow_fix_override':
True,
'fix': {
'-': ([u'amenity'])
}
})
# node[highway=bus_stop][!public_transport]
if (u'highway' in keys):
match = False
if not match:
capture_tags = {}
try:
match = (
mapcss._tag_capture(capture_tags, 0, tags, u'highway')
== mapcss._value_capture(capture_tags, 0, u'bus_stop')
and not mapcss._tag_capture(capture_tags, 1, tags,
u'public_transport'))
except mapcss.RuleAbort:
pass
if match:
# group:tr("Missing public_transport tag on a public transport stop")
# -osmoseItemClassLevel:"2140/21411:0/3"
# throwError:tr("Specify if it is a stop (platform) or a location on the road (stop_position)")
# fixAdd:"public_transport=platform"
# assertNoMatch:"node highway=bus_stop public_transport=platform"
# assertNoMatch:"node highway=bus_stop public_transport=stop_position"
# assertMatch:"node highway=bus_stop"
err.append({
'class':
21411,
'subclass':
0,
'text':
mapcss.
tr(u'Specify if it is a stop (platform) or a location on the road (stop_position)'
),
'allow_fix_override':
True,
'fix': {
'+': dict([[u'public_transport', u'platform']])
}
})
# node[railway=tram_stop][!public_transport]
if (u'railway' in keys):
match = False
if not match:
capture_tags = {}
try:
match = (
mapcss._tag_capture(capture_tags, 0, tags, u'railway')
== mapcss._value_capture(capture_tags, 0, u'tram_stop')
and not mapcss._tag_capture(capture_tags, 1, tags,
u'public_transport'))
except mapcss.RuleAbort:
pass
if match:
# group:tr("Missing public_transport tag on a public transport stop")
# -osmoseItemClassLevel:"2140/21411:1/3"
# throwError:tr("Specify if it is a stop (platform) or a location on the rails (stop_position)")
# fixAdd:"public_transport=stop_position"
# assertNoMatch:"node railway=tram_stop public_transport=platform"
# assertNoMatch:"node railway=tram_stop public_transport=stop_position"
# assertMatch:"node railway=tram_stop"
err.append({
'class':
21411,
'subclass':
1,
'text':
mapcss.
tr(u'Specify if it is a stop (platform) or a location on the rails (stop_position)'
),
'allow_fix_override':
True,
'fix': {
'+': dict([[u'public_transport', u'stop_position']])
}
})
# node[public_transport=platform][!highway][!railway][!bus][!shelter]
if (u'public_transport' in keys):
match = False
if not match:
capture_tags = {}
try:
match = (
mapcss._tag_capture(capture_tags, 0, tags,
u'public_transport')
== mapcss._value_capture(capture_tags, 0, u'platform')
and not mapcss._tag_capture(capture_tags, 1, tags,
u'highway')
and not mapcss._tag_capture(capture_tags, 2, tags,
u'railway') and
not mapcss._tag_capture(capture_tags, 3, tags, u'bus')
and not mapcss._tag_capture(capture_tags, 4, tags,
u'shelter'))
except mapcss.RuleAbort:
pass
if match:
# group:tr("Missing legacy tag on a public transport stop")
# -osmoseItemClassLevel:"2140/21412:1/3"
# throwError:tr("The legacy tag is missing, add the tag highway=bus_stop / railway=tram_stop")
err.append({
'class':
21412,
'subclass':
1,
'text':
mapcss.
tr(u'The legacy tag is missing, add the tag highway=bus_stop / railway=tram_stop'
)
})
# node[public_transport=platform][!highway][!railway][bus=yes]
# node[public_transport=platform][!highway][!railway][shelter]
if (u'bus' in keys and u'public_transport' in keys) or (
u'public_transport' in keys and u'shelter' in keys):
match = False
if not match:
capture_tags = {}
try:
match = (
mapcss._tag_capture(capture_tags, 0, tags,
u'public_transport')
== mapcss._value_capture(capture_tags, 0, u'platform')
and not mapcss._tag_capture(capture_tags, 1, tags,
u'highway')
and not mapcss._tag_capture(capture_tags, 2, tags,
u'railway')
and mapcss._tag_capture(capture_tags, 3, tags, u'bus')
== mapcss._value_capture(capture_tags, 3, u'yes'))
except mapcss.RuleAbort:
pass
if not match:
capture_tags = {}
try:
match = (mapcss._tag_capture(
capture_tags, 0, tags,
u'public_transport') == mapcss._value_capture(
capture_tags, 0, u'platform')
and not mapcss._tag_capture(
capture_tags, 1, tags, u'highway')
and not mapcss._tag_capture(
capture_tags, 2, tags, u'railway')
and mapcss._tag_capture(capture_tags, 3, tags,
u'shelter'))
except mapcss.RuleAbort:
pass
if match:
# group:tr("Missing legacy tag on a public transport stop")
# -osmoseItemClassLevel:"2140/21412:0/3"
# throwError:tr("Is this a bus stop? add the tag highway=bus_stop")
# fixAdd:"highway=bus_stop"
# assertMatch:"node public_transport=platform shelter=yes"
err.append({
'class':
21412,
'subclass':
0,
'text':
mapcss.tr(
u'Is this a bus stop? add the tag highway=bus_stop'),
'allow_fix_override':
True,
'fix': {
'+': dict([[u'highway', u'bus_stop']])
}
})
# node[highway=bus_stop][note]
# node[highway=bus_stop][note:fr][inside("FR")]
if (u'highway' in keys
and u'note' in keys) or (u'highway' in keys
and u'note:fr' in keys):
match = False
if not match:
capture_tags = {}
try:
match = (
mapcss._tag_capture(capture_tags, 0, tags, u'highway')
== mapcss._value_capture(capture_tags, 0, u'bus_stop')
and mapcss._tag_capture(capture_tags, 1, tags,
u'note'))
except mapcss.RuleAbort:
pass
if not match:
capture_tags = {}
try:
match = (
mapcss._tag_capture(capture_tags, 0, tags, u'highway')
== mapcss._value_capture(capture_tags, 0, u'bus_stop')
and mapcss._tag_capture(capture_tags, 1, tags,
u'note:fr')
and mapcss.inside(self.father.config.options, u'FR'))
except mapcss.RuleAbort:
pass
if match:
# throwWarning:tr("Check if the note can be deleted")
err.append({
'class':
9014006,
'subclass':
673170504,
'text':
mapcss.tr(u'Check if the note can be deleted')
})
# node[highway=bus_stop][network][inside("FR")]
if (u'highway' in keys and u'network' in keys):
match = False
if not match:
capture_tags = {}
try:
match = (
mapcss._tag_capture(capture_tags, 0, tags, u'highway')
== mapcss._value_capture(capture_tags, 0, u'bus_stop')
and mapcss._tag_capture(capture_tags, 1, tags,
u'network')
and mapcss.inside(self.father.config.options, u'FR'))
except mapcss.RuleAbort:
pass
if match:
# throwWarning:tr("The network should be on the transport lines and not on the stops")
# fixRemove:"network"
err.append({
'class':
9014007,
'subclass':
1428913922,
'text':
mapcss.
tr(u'The network should be on the transport lines and not on the stops'
),
'allow_fix_override':
True,
'fix': {
'-': ([u'network'])
}
})
# node[highway=bus_stop][operator][inside("FR")]
if (u'highway' in keys and u'operator' in keys):
match = False
if not match:
capture_tags = {}
try:
match = (
mapcss._tag_capture(capture_tags, 0, tags, u'highway')
== mapcss._value_capture(capture_tags, 0, u'bus_stop')
and mapcss._tag_capture(capture_tags, 1, tags,
u'operator')
and mapcss.inside(self.father.config.options, u'FR'))
except mapcss.RuleAbort:
pass
if match:
# throwWarning:tr("The operator should be on the transport lines and not on the stops")
# fixRemove:"operator"
err.append({
'class':
9014008,
'subclass':
210603856,
'text':
mapcss.
tr(u'The operator should be on the transport lines and not on the stops'
),
'allow_fix_override':
True,
'fix': {
'-': ([u'operator'])
}
})
return err
def relation(self, data, tags, members):
capture_tags = {}
keys = tags.keys()
err = []
# *[access][highway=proposed]
# *[motor_vehicle?][vehicle!=no][access!=no][bicycle_road!=yes][highway=~/^(motorway|motorway_link|trunk|trunk_link|primary|primary_link|secondary|secondary_link|tertiary|tertiary_link|unclassified|residential|service|living_street)$/]
# *[bridge=no]
# *[building=no]
# *[elevation="0"]
# *[layer="0"]
if (u'access' in keys and u'highway' in keys) or (u'bridge' in keys) or (u'building' in keys) or (u'elevation' in keys) or (u'highway' in keys and u'motor_vehicle' in keys) or (u'layer' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'access') and mapcss._tag_capture(capture_tags, 1, tags, u'highway') == mapcss._value_capture(capture_tags, 1, u'proposed'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'motor_vehicle') in ('yes', 'true', '1') and mapcss._tag_capture(capture_tags, 1, tags, u'vehicle') != mapcss._value_capture(capture_tags, 1, u'no') and mapcss._tag_capture(capture_tags, 2, tags, u'access') != mapcss._value_capture(capture_tags, 2, u'no') and mapcss._tag_capture(capture_tags, 3, tags, u'bicycle_road') != mapcss._value_capture(capture_tags, 3, u'yes') and mapcss.regexp_test(mapcss._value_capture(capture_tags, 4, self.re_3ad9e1f5), mapcss._tag_capture(capture_tags, 4, tags, u'highway')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'bridge') == mapcss._value_capture(capture_tags, 0, u'no'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'building') == mapcss._value_capture(capture_tags, 0, u'no'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'elevation') == mapcss._value_capture(capture_tags, 0, u'0'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'layer') == mapcss._value_capture(capture_tags, 0, u'0'))
except mapcss.RuleAbort: pass
if match:
# group:tr("unnecessary tag")
# throwWarning:tr("{0} is unnecessary","{0.tag}")
# fixRemove:"{0.key}"
err.append({'class': 9010001, 'subclass': 1949087363, 'text': mapcss.tr(u'{0} is unnecessary', mapcss._tag_uncapture(capture_tags, u'{0.tag}')), 'allow_fix_override': True, 'fix': {
'-': ([
mapcss._tag_uncapture(capture_tags, u'{0.key}')])
}})
# *[emergency=permissive]
if (u'emergency' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'emergency') == mapcss._value_capture(capture_tags, 0, u'permissive'))
except mapcss.RuleAbort: pass
if match:
# throwWarning:tr("{0} makes no sense","{0.tag")
# fixAdd:"emergency=yes"
err.append({'class': 9010002, 'subclass': 325672362, 'text': mapcss.tr(u'{0} makes no sense', u'{0.tag'), 'allow_fix_override': True, 'fix': {
'+': dict([
[u'emergency',u'yes']])
}})
# *[payment:cash][payment:coins][payment:notes]
if (u'payment:cash' in keys and u'payment:coins' in keys and u'payment:notes' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'payment:cash') and mapcss._tag_capture(capture_tags, 1, tags, u'payment:coins') and mapcss._tag_capture(capture_tags, 2, tags, u'payment:notes'))
except mapcss.RuleAbort: pass
if match:
# group:tr("unnecessary tag")
# throwWarning:tr("{0} together with {1} and {2}. Remove {0}.","{0.key}","{1.key}","{2.key}")
# fixRemove:"payment:cash"
err.append({'class': 9010001, 'subclass': 1340792439, 'text': mapcss.tr(u'{0} together with {1} and {2}. Remove {0}.', mapcss._tag_uncapture(capture_tags, u'{0.key}'), mapcss._tag_uncapture(capture_tags, u'{1.key}'), mapcss._tag_uncapture(capture_tags, u'{2.key}')), 'allow_fix_override': True, 'fix': {
'-': ([
u'payment:cash'])
}})
return err
def way(self, data, tags, nds):
capture_tags = {}
keys = tags.keys()
err = []
# way["mtb:scale:uphill"][!incline]
if (u'mtb:scale:uphill' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'mtb:scale:uphill') and not mapcss._tag_capture(capture_tags, 1, tags, u'incline'))
except mapcss.RuleAbort: pass
if match:
# throwWarning:tr("Way contains ''{0}'' but not ''{1}''.","{0.key}","{1.key}")
err.append({'class': 9013001, 'subclass': 1368047539, 'text': mapcss.tr(u'Way contains \'\'{0}\'\' but not \'\'{1}\'\'.', mapcss._tag_uncapture(capture_tags, u'{0.key}'), mapcss._tag_uncapture(capture_tags, u'{1.key}'))})
# way["mtb:scale:uphill"][highway][highway!~/path|track/]
if (u'highway' in keys and u'mtb:scale:uphill' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'mtb:scale:uphill') and mapcss._tag_capture(capture_tags, 1, tags, u'highway') and not mapcss.regexp_test(mapcss._value_capture(capture_tags, 2, self.re_6937bec1), mapcss._tag_capture(capture_tags, 2, tags, u'highway')))
except mapcss.RuleAbort: pass
if match:
# throwWarning:tr("Way contains ''{0}'' but is neither a track nor a path.","{0.key}")
err.append({'class': 9013002, 'subclass': 139842783, 'text': mapcss.tr(u'Way contains \'\'{0}\'\' but is neither a track nor a path.', mapcss._tag_uncapture(capture_tags, u'{0.key}'))})
# way["mtb:scale"]["mtb:scale"!~/^[0-6][-+]?$/]
if (u'mtb:scale' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'mtb:scale') and not mapcss.regexp_test(mapcss._value_capture(capture_tags, 1, self.re_1b95e3e9), mapcss._tag_capture(capture_tags, 1, tags, u'mtb:scale')))
except mapcss.RuleAbort: pass
if match:
# throwWarning:tr("Invalid ''{0}'' value: ''{1}''","{0.key}","{0.value}")
err.append({'class': 9013003, 'subclass': 1229830952, 'text': mapcss.tr(u'Invalid \'\'{0}\'\' value: \'\'{1}\'\'', mapcss._tag_uncapture(capture_tags, u'{0.key}'), mapcss._tag_uncapture(capture_tags, u'{0.value}'))})
# way["mtb:scale:uphill"]["mtb:scale:uphill"!~/^[0-5]$/]
if (u'mtb:scale:uphill' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'mtb:scale:uphill') and not mapcss.regexp_test(mapcss._value_capture(capture_tags, 1, self.re_3d3b0752), mapcss._tag_capture(capture_tags, 1, tags, u'mtb:scale:uphill')))
except mapcss.RuleAbort: pass
if match:
# throwWarning:tr("Invalid ''{0}'' value: ''{1}''","{0.key}","{0.value}")
err.append({'class': 9013003, 'subclass': 86930524, 'text': mapcss.tr(u'Invalid \'\'{0}\'\' value: \'\'{1}\'\'', mapcss._tag_uncapture(capture_tags, u'{0.key}'), mapcss._tag_uncapture(capture_tags, u'{0.value}'))})
# way["mtb:scale:imba"]["mtb:scale:imba"!~/^[0-4]$/]
if (u'mtb:scale:imba' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'mtb:scale:imba') and not mapcss.regexp_test(mapcss._value_capture(capture_tags, 1, self.re_731f6ce6), mapcss._tag_capture(capture_tags, 1, tags, u'mtb:scale:imba')))
except mapcss.RuleAbort: pass
if match:
# throwWarning:tr("Invalid ''{0}'' value: ''{1}''","{0.key}","{0.value}")
err.append({'class': 9013003, 'subclass': 2005358544, 'text': mapcss.tr(u'Invalid \'\'{0}\'\' value: \'\'{1}\'\'', mapcss._tag_uncapture(capture_tags, u'{0.key}'), mapcss._tag_uncapture(capture_tags, u'{0.value}'))})
return err
def relation(self, data, tags, members):
capture_tags = {}
keys = tags.keys()
err = []
# *["addr:street"=~/.+;(.+)?/]
# *[highway=~/.+;(.+)?/]
# *[lanes=~/.+;(.+)?/]
# *[maxspeed=~/.+;(.+)?/]
# *[name=~/.+;(.+)?/]
# *[surface=~/.+;(.+)?/]
# *[water=~/.+;(.+)?/]
if (u'addr:street' in keys) or (u'highway' in keys) or (u'lanes' in keys) or (u'maxspeed' in keys) or (u'name' in keys) or (u'surface' in keys) or (u'water' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test(mapcss._value_capture(capture_tags, 0, self.re_53db61ac), mapcss._tag_capture(capture_tags, 0, tags, u'addr:street')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test(mapcss._value_capture(capture_tags, 0, self.re_53db61ac), mapcss._tag_capture(capture_tags, 0, tags, u'highway')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test(mapcss._value_capture(capture_tags, 0, self.re_53db61ac), mapcss._tag_capture(capture_tags, 0, tags, u'lanes')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test(mapcss._value_capture(capture_tags, 0, self.re_53db61ac), mapcss._tag_capture(capture_tags, 0, tags, u'maxspeed')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test(mapcss._value_capture(capture_tags, 0, self.re_53db61ac), mapcss._tag_capture(capture_tags, 0, tags, u'name')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test(mapcss._value_capture(capture_tags, 0, self.re_53db61ac), mapcss._tag_capture(capture_tags, 0, tags, u'surface')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test(mapcss._value_capture(capture_tags, 0, self.re_53db61ac), mapcss._tag_capture(capture_tags, 0, tags, u'water')))
except mapcss.RuleAbort: pass
if match:
# throwWarning:tr("{0} with multiple values","{0.key}")
err.append({'class': 9005001, 'subclass': 1911063816, 'text': mapcss.tr(u'{0} with multiple values', mapcss._tag_uncapture(capture_tags, u'{0.key}'))})
# *[source=~/^(;.*|.*;;.*|.*;)$/]
# *["source:addr"=~/^(;.*|.*;;.*|.*;)$/]
# *["source:maxspeed"=~/^(;.*|.*;;.*|.*;)$/]
# *["source:name"=~/^(;.*|.*;;.*|.*;)$/]
# *["source:position"=~/^(;.*|.*;;.*|.*;)$/]
# *["source:postcode"=~/^(;.*|.*;;.*|.*;)$/]
# *[ref=~/^(;.*|.*;;.*|.*;)$/]
# *[int_ref=~/^(;.*|.*;;.*|.*;)$/]
# *[old_ref=~/^(;.*|.*;;.*|.*;)$/]
# *[source_ref=~/^(;.*|.*;;.*|.*;)$/]
# *[route_ref=~/^(;.*|.*;;.*|.*;)$/]
# *[attribution=~/^(;.*|.*;;.*|.*;)$/]
# *[name=~/^(;.*|.*;;.*|.*;)$/]
# *[alt_name=~/^(;.*|.*;;.*|.*;)$/]
# *[note=~/^(;.*|.*;;.*|.*;)$/]
# *[fixme=~/^(;.*|.*;;.*|.*;)$/]
# *["addr:housenumber"=~/^(;.*|.*;;.*|.*;)$/]
# *[destination=~/^(;.*|.*;;.*|.*;)$/]
# *[exit_to=~/^(;.*|.*;;.*|.*;)$/]
# *[surface=~/^(;.*|.*;;.*|.*;)$/]
# *["building:use"=~/^(;.*|.*;;.*|.*;)$/]
# *[traffic_sign=~/^(;.*|.*;;.*|.*;)$/]
# *[voltage=~/^(;.*|.*;;.*|.*;)$/]
# *[cuisine=~/^(;.*|.*;;.*|.*;)$/]
if (u'addr:housenumber' in keys) or (u'alt_name' in keys) or (u'attribution' in keys) or (u'building:use' in keys) or (u'cuisine' in keys) or (u'destination' in keys) or (u'exit_to' in keys) or (u'fixme' in keys) or (u'int_ref' in keys) or (u'name' in keys) or (u'note' in keys) or (u'old_ref' in keys) or (u'ref' in keys) or (u'route_ref' in keys) or (u'source' in keys) or (u'source:addr' in keys) or (u'source:maxspeed' in keys) or (u'source:name' in keys) or (u'source:position' in keys) or (u'source:postcode' in keys) or (u'source_ref' in keys) or (u'surface' in keys) or (u'traffic_sign' in keys) or (u'voltage' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test(mapcss._value_capture(capture_tags, 0, self.re_579c7c6a), mapcss._tag_capture(capture_tags, 0, tags, u'source')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test(mapcss._value_capture(capture_tags, 0, self.re_579c7c6a), mapcss._tag_capture(capture_tags, 0, tags, u'source:addr')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test(mapcss._value_capture(capture_tags, 0, self.re_579c7c6a), mapcss._tag_capture(capture_tags, 0, tags, u'source:maxspeed')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test(mapcss._value_capture(capture_tags, 0, self.re_579c7c6a), mapcss._tag_capture(capture_tags, 0, tags, u'source:name')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test(mapcss._value_capture(capture_tags, 0, self.re_579c7c6a), mapcss._tag_capture(capture_tags, 0, tags, u'source:position')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test(mapcss._value_capture(capture_tags, 0, self.re_579c7c6a), mapcss._tag_capture(capture_tags, 0, tags, u'source:postcode')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test(mapcss._value_capture(capture_tags, 0, self.re_579c7c6a), mapcss._tag_capture(capture_tags, 0, tags, u'ref')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test(mapcss._value_capture(capture_tags, 0, self.re_579c7c6a), mapcss._tag_capture(capture_tags, 0, tags, u'int_ref')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test(mapcss._value_capture(capture_tags, 0, self.re_579c7c6a), mapcss._tag_capture(capture_tags, 0, tags, u'old_ref')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test(mapcss._value_capture(capture_tags, 0, self.re_579c7c6a), mapcss._tag_capture(capture_tags, 0, tags, u'source_ref')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test(mapcss._value_capture(capture_tags, 0, self.re_579c7c6a), mapcss._tag_capture(capture_tags, 0, tags, u'route_ref')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test(mapcss._value_capture(capture_tags, 0, self.re_579c7c6a), mapcss._tag_capture(capture_tags, 0, tags, u'attribution')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test(mapcss._value_capture(capture_tags, 0, self.re_579c7c6a), mapcss._tag_capture(capture_tags, 0, tags, u'name')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test(mapcss._value_capture(capture_tags, 0, self.re_579c7c6a), mapcss._tag_capture(capture_tags, 0, tags, u'alt_name')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test(mapcss._value_capture(capture_tags, 0, self.re_579c7c6a), mapcss._tag_capture(capture_tags, 0, tags, u'note')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test(mapcss._value_capture(capture_tags, 0, self.re_579c7c6a), mapcss._tag_capture(capture_tags, 0, tags, u'fixme')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test(mapcss._value_capture(capture_tags, 0, self.re_579c7c6a), mapcss._tag_capture(capture_tags, 0, tags, u'addr:housenumber')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test(mapcss._value_capture(capture_tags, 0, self.re_579c7c6a), mapcss._tag_capture(capture_tags, 0, tags, u'destination')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test(mapcss._value_capture(capture_tags, 0, self.re_579c7c6a), mapcss._tag_capture(capture_tags, 0, tags, u'exit_to')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test(mapcss._value_capture(capture_tags, 0, self.re_579c7c6a), mapcss._tag_capture(capture_tags, 0, tags, u'surface')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test(mapcss._value_capture(capture_tags, 0, self.re_579c7c6a), mapcss._tag_capture(capture_tags, 0, tags, u'building:use')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test(mapcss._value_capture(capture_tags, 0, self.re_579c7c6a), mapcss._tag_capture(capture_tags, 0, tags, u'traffic_sign')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test(mapcss._value_capture(capture_tags, 0, self.re_579c7c6a), mapcss._tag_capture(capture_tags, 0, tags, u'voltage')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test(mapcss._value_capture(capture_tags, 0, self.re_579c7c6a), mapcss._tag_capture(capture_tags, 0, tags, u'cuisine')))
except mapcss.RuleAbort: pass
if match:
# throwWarning:tr("empty value in semicolon-separated ''{0}''","{0.key}")
err.append({'class': 9005002, 'subclass': 978530936, 'text': mapcss.tr(u'empty value in semicolon-separated \'\'{0}\'\'', mapcss._tag_uncapture(capture_tags, u'{0.key}'))})
return err
def node(self, data, tags):
capture_tags = {}
keys = tags.keys()
err = []
# node[area=no]
# node[oneway]
# node[bridge]
# node[sidewalk]
# node[footway][footway!=crossing]
# node[man_made=embankment]
# node[man_made=groyne]
# node[man_made=cutline]
# node[power=line]
# node[cutline]
# node[aerialway=cable_car]
# node[aerialway=gondola]
# node[aerialway=chair_lift]
# node[aerialway=mixed_lift]
# node[aerialway=drag_lift]
# node[aerialway=t-bar]
# node[aerialway=j-bar]
# node[aerialway=platter]
# node[aerialway=magic_carpet]
# node[aerialway=rope_tow]
# node[aerialway=goods]
# node[aeroway=taxiway]
# node[aeroway=runway]
# node[railway=rail]
# node[railway=narrow_gauge]
# node[railway=monorail]
# node[railway=preserved]
# node[railway=light_rail]
# node[railway=subway]
# node[railway=tram]
# node[railway=disused]
# node[railway=abandoned]
# node[waterway=river]
# node[waterway=canal]
# node[waterway=stream]
# node[waterway=ditch]
# node[waterway=drain]
# node[natural=coastline]
# node[natural=ridge]
# node[natural=valley]
# node[natural=tree_row]
if (u'aerialway' in keys) or (u'aeroway' in keys) or (u'area' in keys) or (u'bridge' in keys) or (u'cutline' in keys) or (u'footway' in keys) or (u'man_made' in keys) or (u'natural' in keys) or (u'oneway' in keys) or (u'power' in keys) or (u'railway' in keys) or (u'sidewalk' in keys) or (u'waterway' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'area') == mapcss._value_capture(capture_tags, 0, u'no'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'oneway'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'bridge'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'sidewalk'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'footway') and mapcss._tag_capture(capture_tags, 1, tags, u'footway') != mapcss._value_const_capture(capture_tags, 1, u'crossing', u'crossing'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'man_made') == mapcss._value_capture(capture_tags, 0, u'embankment'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'man_made') == mapcss._value_capture(capture_tags, 0, u'groyne'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'man_made') == mapcss._value_capture(capture_tags, 0, u'cutline'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'power') == mapcss._value_capture(capture_tags, 0, u'line'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'cutline'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'aerialway') == mapcss._value_capture(capture_tags, 0, u'cable_car'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'aerialway') == mapcss._value_capture(capture_tags, 0, u'gondola'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'aerialway') == mapcss._value_capture(capture_tags, 0, u'chair_lift'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'aerialway') == mapcss._value_capture(capture_tags, 0, u'mixed_lift'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'aerialway') == mapcss._value_capture(capture_tags, 0, u'drag_lift'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'aerialway') == mapcss._value_capture(capture_tags, 0, u't-bar'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'aerialway') == mapcss._value_capture(capture_tags, 0, u'j-bar'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'aerialway') == mapcss._value_capture(capture_tags, 0, u'platter'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'aerialway') == mapcss._value_capture(capture_tags, 0, u'magic_carpet'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'aerialway') == mapcss._value_capture(capture_tags, 0, u'rope_tow'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'aerialway') == mapcss._value_capture(capture_tags, 0, u'goods'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'aeroway') == mapcss._value_capture(capture_tags, 0, u'taxiway'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'aeroway') == mapcss._value_capture(capture_tags, 0, u'runway'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'railway') == mapcss._value_capture(capture_tags, 0, u'rail'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'railway') == mapcss._value_capture(capture_tags, 0, u'narrow_gauge'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'railway') == mapcss._value_capture(capture_tags, 0, u'monorail'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'railway') == mapcss._value_capture(capture_tags, 0, u'preserved'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'railway') == mapcss._value_capture(capture_tags, 0, u'light_rail'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'railway') == mapcss._value_capture(capture_tags, 0, u'subway'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'railway') == mapcss._value_capture(capture_tags, 0, u'tram'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'railway') == mapcss._value_capture(capture_tags, 0, u'disused'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'railway') == mapcss._value_capture(capture_tags, 0, u'abandoned'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'waterway') == mapcss._value_capture(capture_tags, 0, u'river'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'waterway') == mapcss._value_capture(capture_tags, 0, u'canal'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'waterway') == mapcss._value_capture(capture_tags, 0, u'stream'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'waterway') == mapcss._value_capture(capture_tags, 0, u'ditch'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'waterway') == mapcss._value_capture(capture_tags, 0, u'drain'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'natural') == mapcss._value_capture(capture_tags, 0, u'coastline'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'natural') == mapcss._value_capture(capture_tags, 0, u'ridge'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'natural') == mapcss._value_capture(capture_tags, 0, u'valley'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'natural') == mapcss._value_capture(capture_tags, 0, u'tree_row'))
except mapcss.RuleAbort: pass
if match:
# throwWarning:tr("{0} on a node. Should be used on a way.","{0.tag}")
# assertMatch:"node bridge=viaduct"
# assertMatch:"node bridge=yes"
# assertMatch:"node oneway=-1"
err.append({'class': 9003001, 'subclass': 431750003, 'text': mapcss.tr(u'{0} on a node. Should be used on a way.', mapcss._tag_uncapture(capture_tags, u'{0.tag}'))})
# node[boundary=administrative]
if (u'boundary' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'boundary') == mapcss._value_capture(capture_tags, 0, u'administrative'))
except mapcss.RuleAbort: pass
if match:
# throwWarning:tr("{0} on a node. Should be used on a way or relation.","{0.tag}")
err.append({'class': 9003002, 'subclass': 1005532536, 'text': mapcss.tr(u'{0} on a node. Should be used on a way or relation.', mapcss._tag_uncapture(capture_tags, u'{0.tag}'))})
# node[golf=green]
# node[golf=bunker]
# node[golf=fairway]
# node[area=yes]
# node[area:highway]
# node[landuse]
# node[natural=scree]
# node[natural=scrub]
# node[natural=fell]
# node[natural=heath]
# node[natural=wood]
# node[natural=grassland]
# node[natural=wetland]
# node[natural=water]
# node[natural=mud]
# node[natural=beach]
# node[natural=sand]
# node[natural=wood]
# node[natural=bare_rock]
# node[natural=glacier]
# node[leisure=park][natural!=tree]
# node[leisure=nature_reserve]
# node[waterway=riverbank]
# node[man_made=bridge]
# node[man_made=breakwater]
# node[aeroway=apron]
# node[power=plant]
# node[power=switchgear]
# node[building:part]
# node[source:outline]
if (u'aeroway' in keys) or (u'area' in keys) or (u'area:highway' in keys) or (u'building:part' in keys) or (u'golf' in keys) or (u'landuse' in keys) or (u'leisure' in keys) or (u'man_made' in keys) or (u'natural' in keys) or (u'power' in keys) or (u'source:outline' in keys) or (u'waterway' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'golf') == mapcss._value_capture(capture_tags, 0, u'green'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'golf') == mapcss._value_capture(capture_tags, 0, u'bunker'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'golf') == mapcss._value_capture(capture_tags, 0, u'fairway'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'area') == mapcss._value_capture(capture_tags, 0, u'yes'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'area:highway'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'landuse'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'natural') == mapcss._value_capture(capture_tags, 0, u'scree'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'natural') == mapcss._value_capture(capture_tags, 0, u'scrub'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'natural') == mapcss._value_capture(capture_tags, 0, u'fell'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'natural') == mapcss._value_capture(capture_tags, 0, u'heath'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'natural') == mapcss._value_capture(capture_tags, 0, u'wood'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'natural') == mapcss._value_capture(capture_tags, 0, u'grassland'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'natural') == mapcss._value_capture(capture_tags, 0, u'wetland'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'natural') == mapcss._value_capture(capture_tags, 0, u'water'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'natural') == mapcss._value_capture(capture_tags, 0, u'mud'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'natural') == mapcss._value_capture(capture_tags, 0, u'beach'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'natural') == mapcss._value_capture(capture_tags, 0, u'sand'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'natural') == mapcss._value_capture(capture_tags, 0, u'wood'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'natural') == mapcss._value_capture(capture_tags, 0, u'bare_rock'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'natural') == mapcss._value_capture(capture_tags, 0, u'glacier'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'leisure') == mapcss._value_capture(capture_tags, 0, u'park') and mapcss._tag_capture(capture_tags, 1, tags, u'natural') != mapcss._value_const_capture(capture_tags, 1, u'tree', u'tree'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'leisure') == mapcss._value_capture(capture_tags, 0, u'nature_reserve'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'waterway') == mapcss._value_capture(capture_tags, 0, u'riverbank'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'man_made') == mapcss._value_capture(capture_tags, 0, u'bridge'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'man_made') == mapcss._value_capture(capture_tags, 0, u'breakwater'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'aeroway') == mapcss._value_capture(capture_tags, 0, u'apron'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'power') == mapcss._value_capture(capture_tags, 0, u'plant'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'power') == mapcss._value_capture(capture_tags, 0, u'switchgear'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'building:part'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'source:outline'))
except mapcss.RuleAbort: pass
if match:
# throwWarning:tr("{0} on a node. Should be drawn as an area.","{0.tag}")
err.append({'class': 9003003, 'subclass': 1633038746, 'text': mapcss.tr(u'{0} on a node. Should be drawn as an area.', mapcss._tag_uncapture(capture_tags, u'{0.tag}'))})
# node[type=multipolygon]
# node[interval]
# node[route]
# node[restriction]
if (u'interval' in keys) or (u'restriction' in keys) or (u'route' in keys) or (u'type' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'type') == mapcss._value_capture(capture_tags, 0, u'multipolygon'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'interval'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'route'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'restriction'))
except mapcss.RuleAbort: pass
if match:
# throwError:tr("{0} on a node. Should be used in a relation","{0.tag}")
err.append({'class': 9003004, 'subclass': 104835602, 'text': mapcss.tr(u'{0} on a node. Should be used in a relation', mapcss._tag_uncapture(capture_tags, u'{0.tag}'))})
# node[man_made!=monitoring_station][at(0.0,0.0)]
if True:
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'man_made') != mapcss._value_const_capture(capture_tags, 0, u'monitoring_station', u'monitoring_station') and mapcss.at(data['lat'], data['lon'], 0.0, 0.0))
except mapcss.RuleAbort: pass
if match:
# throwError:tr("Object at Position 0.00E 0.00N. There is nothing at this position except an already mapped weather buoy.")
# fixDeleteObject:this
err.append({'class': 9003009, 'subclass': 829325630, 'text': mapcss.tr(u'Object at Position 0.00E 0.00N. There is nothing at this position except an already mapped weather buoy.')})
# node[source:geometry]
if (u'source:geometry' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'source:geometry'))
except mapcss.RuleAbort: pass
if match:
# throwWarning:tr("{0} on a node","{0.key}")
# fixChangeKey:"source:geometry => source:position"
err.append({'class': 9003006, 'subclass': 1287904360, 'text': mapcss.tr(u'{0} on a node', mapcss._tag_uncapture(capture_tags, u'{0.key}')), 'allow_fix_override': True, 'fix': {
'+': dict([
[u'source:position', mapcss.tag(tags, u'source:geometry')]]),
'-': ([
u'source:geometry'])
}})
return err
def relation(self, data, tags, members):
capture_tags = {}
keys = tags.keys()
err = []
set_ok_housenumber = False
# *[addr:housenumber][addr:housename]["addr:housenumber"=*"addr:housename"]
if ('addr:housename' in keys and 'addr:housenumber' in keys):
match = False
if not match:
capture_tags = {}
try:
match = ((mapcss._tag_capture(capture_tags, 0, tags,
'addr:housenumber'))
and (mapcss._tag_capture(capture_tags, 1, tags,
'addr:housename'))
and (mapcss._tag_capture(capture_tags, 2, tags,
'addr:housenumber')
== mapcss._value_capture(
capture_tags, 2,
mapcss.tag(tags, 'addr:housename'))))
except mapcss.RuleAbort:
pass
if match:
# throwWarning:tr("Same value of {0} and {1}","{0.key}","{1.key}")
err.append({
'class':
9000003,
'subclass':
1820984183,
'text':
mapcss.tr('Same value of {0} and {1}',
mapcss._tag_uncapture(capture_tags, '{0.key}'),
mapcss._tag_uncapture(capture_tags, '{1.key}'))
})
# *[addr:housenumber=bb][inside("BA")]
if ('addr:housenumber' in keys):
match = False
if not match:
capture_tags = {}
try:
match = ((mapcss._tag_capture(capture_tags, 0, tags,
'addr:housenumber')
== mapcss._value_capture(capture_tags, 0, 'bb'))
and
(mapcss.inside(self.father.config.options, 'BA')))
except mapcss.RuleAbort:
pass
if match:
# setok_housenumber
set_ok_housenumber = True
# *[addr:housenumber][addr:housenumber!~/[0-9]/]!.ok_housenumber
if ('addr:housenumber' in keys):
match = False
if not match:
capture_tags = {}
try:
match = ((not set_ok_housenumber) and (mapcss._tag_capture(
capture_tags, 0, tags,
'addr:housenumber')) and (not mapcss.regexp_test(
mapcss._value_const_capture(
capture_tags, 1, self.re_4983542e, '[0-9]'),
mapcss._tag_capture(capture_tags, 1, tags,
'addr:housenumber'))))
except mapcss.RuleAbort:
pass
if match:
# throwWarning:tr("{0} without number","{0.key}")
err.append({
'class':
9000004,
'subclass':
1053226919,
'text':
mapcss.tr('{0} without number',
mapcss._tag_uncapture(capture_tags, '{0.key}'))
})
return err
def way(self, data, tags, nds):
capture_tags = {}
keys = tags.keys()
err = []
# way[cycleway][cycleway:right][cycleway:left]
if (u'cycleway' in keys and u'cycleway:left' in keys and u'cycleway:right' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'cycleway') and mapcss._tag_capture(capture_tags, 1, tags, u'cycleway:right') and mapcss._tag_capture(capture_tags, 2, tags, u'cycleway:left'))
except mapcss.RuleAbort: pass
if match:
# -osmoseTags:list("cycleway","fix:chair")
# -osmoseItemClassLevel:"4030/40301/2"
# throwWarning:tr("{0} with {1} and {2}","{0.key}","{1.key}","{2.key}")
# assertMatch:"way cycleway=a cycleway:right=b cycleway:left=c"
err.append({'class': 40301, 'subclass': 0, 'text': mapcss.tr(u'{0} with {1} and {2}', mapcss._tag_uncapture(capture_tags, u'{0.key}'), mapcss._tag_uncapture(capture_tags, u'{1.key}'), mapcss._tag_uncapture(capture_tags, u'{2.key}'))})
# way[footway=sidewalk][highway!~/footway|construction/]
if (u'footway' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'footway') == mapcss._value_capture(capture_tags, 0, u'sidewalk') and not mapcss.regexp_test(mapcss._value_capture(capture_tags, 1, self.re_1825c777), mapcss._tag_capture(capture_tags, 1, tags, u'highway')))
except mapcss.RuleAbort: pass
if match:
# -osmoseTags:list("footway","fix:chair")
# -osmoseItemClassLevel:"2080/20805/3"
# throwWarning:tr("{0} without {1}","{0.tag}","highway=footway|construction")
# assertNoMatch:"way footway=sidewalk highway=construction construction=footway"
# assertNoMatch:"way footway=sidewalk highway=footway"
# assertMatch:"way footway=sidewalk highway=path"
err.append({'class': 20805, 'subclass': 0, 'text': mapcss.tr(u'{0} without {1}', mapcss._tag_uncapture(capture_tags, u'{0.tag}'), u'highway=footway|construction')})
# way[highway=service][service=psv][psv!=yes]
if (u'highway' in keys and u'service' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'highway') == mapcss._value_capture(capture_tags, 0, u'service') and mapcss._tag_capture(capture_tags, 1, tags, u'service') == mapcss._value_capture(capture_tags, 1, u'psv') and mapcss._tag_capture(capture_tags, 2, tags, u'psv') != mapcss._value_capture(capture_tags, 2, u'yes'))
except mapcss.RuleAbort: pass
if match:
# -osmoseTags:list("fix:chair")
# -osmoseItemClassLevel:"4010/40101/2"
# throwWarning:tr("{0} is preferred to {1}","{2.tag}","{1.tag}")
# fixAdd:"psv=yes"
# fixRemove:"service"
# assertMatch:"way highway=service service=psv psv=no"
# assertNoMatch:"way highway=service service=psv psv=yes"
err.append({'class': 40101, 'subclass': 0, 'text': mapcss.tr(u'{0} is preferred to {1}', mapcss._tag_uncapture(capture_tags, u'{2.tag}'), mapcss._tag_uncapture(capture_tags, u'{1.tag}')), 'allow_fix_override': True, 'fix': {
'+': dict([
[u'psv',u'yes']]),
'-': ([
u'service'])
}})
# way[highway=cycleway][cycleway=track]
if (u'cycleway' in keys and u'highway' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'highway') == mapcss._value_capture(capture_tags, 0, u'cycleway') and mapcss._tag_capture(capture_tags, 1, tags, u'cycleway') == mapcss._value_capture(capture_tags, 1, u'track'))
except mapcss.RuleAbort: pass
if match:
# -osmoseTags:list("cycleway","fix:chair")
# -osmoseItemClassLevel:"3032/30328/2"
# throwWarning:tr("{0} with {1}","{0.tag}","{1.tag}")
# fixRemove:"cycleway"
err.append({'class': 30328, 'subclass': 0, 'text': mapcss.tr(u'{0} with {1}', mapcss._tag_uncapture(capture_tags, u'{0.tag}'), mapcss._tag_uncapture(capture_tags, u'{1.tag}')), 'allow_fix_override': True, 'fix': {
'-': ([
u'cycleway'])
}})
# way[cycleway=~/opposite|opposite_lane/][!oneway]
# way[cycleway=~/opposite|opposite_lane/][oneway=no]
if (u'cycleway' in keys) or (u'cycleway' in keys and u'oneway' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test(mapcss._value_capture(capture_tags, 0, self.re_67b51e41), mapcss._tag_capture(capture_tags, 0, tags, u'cycleway')) and not mapcss._tag_capture(capture_tags, 1, tags, u'oneway'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test(mapcss._value_capture(capture_tags, 0, self.re_67b51e41), mapcss._tag_capture(capture_tags, 0, tags, u'cycleway')) and mapcss._tag_capture(capture_tags, 1, tags, u'oneway') == mapcss._value_capture(capture_tags, 1, u'no'))
except mapcss.RuleAbort: pass
if match:
# -osmoseTags:list("cycleway","fix:survey")
# -osmoseItemClassLevel:"2030/20301/1"
# throwError:tr("Opposite cycleway without oneway")
# assertNoMatch:"way cycleway=lane oneway=yes"
# assertNoMatch:"way cycleway=opposite oneway=yes"
# assertMatch:"way cycleway=opposite"
err.append({'class': 20301, 'subclass': 0, 'text': mapcss.tr(u'Opposite cycleway without oneway')})
# way:righthandtraffic["cycleway:right"=~/opposite|opposite_lane/][oneway=yes]
# way:righthandtraffic["cycleway:left"=~/opposite|opposite_lane/][oneway="-1"]
# way!:righthandtraffic["cycleway:left"=~/opposite|opposite_lane/][oneway=yes]
# way!:righthandtraffic["cycleway:right"=~/opposite|opposite_lane/][oneway="-1"]
if (u'cycleway:left' in keys and u'oneway' in keys) or (u'cycleway:right' in keys and u'oneway' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test(mapcss._value_capture(capture_tags, 0, self.re_67b51e41), mapcss._tag_capture(capture_tags, 0, tags, u'cycleway:right')) and mapcss._tag_capture(capture_tags, 1, tags, u'oneway') == mapcss._value_capture(capture_tags, 1, u'yes') and mapcss.setting(self.father.config.options, u'driving_side') != u'left')
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test(mapcss._value_capture(capture_tags, 0, self.re_67b51e41), mapcss._tag_capture(capture_tags, 0, tags, u'cycleway:left')) and mapcss._tag_capture(capture_tags, 1, tags, u'oneway') == mapcss._value_capture(capture_tags, 1, u'-1') and mapcss.setting(self.father.config.options, u'driving_side') != u'left')
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test(mapcss._value_capture(capture_tags, 0, self.re_67b51e41), mapcss._tag_capture(capture_tags, 0, tags, u'cycleway:left')) and mapcss._tag_capture(capture_tags, 1, tags, u'oneway') == mapcss._value_capture(capture_tags, 1, u'yes') and mapcss.setting(self.father.config.options, u'driving_side') == u'left')
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss.regexp_test(mapcss._value_capture(capture_tags, 0, self.re_67b51e41), mapcss._tag_capture(capture_tags, 0, tags, u'cycleway:right')) and mapcss._tag_capture(capture_tags, 1, tags, u'oneway') == mapcss._value_capture(capture_tags, 1, u'-1') and mapcss.setting(self.father.config.options, u'driving_side') == u'left')
except mapcss.RuleAbort: pass
if match:
# -osmoseTags:list("cycleway","fix:survey")
# -osmoseItemClassLevel:"2030/20302/1"
# throwError:tr("Opposite or opposite lane in the same way of the oneway")
# assertMatch:"way cycleway:right=opposite oneway=yes"
# assertNoMatch:"way cycleway=opposite oneway=yes"
err.append({'class': 20302, 'subclass': 0, 'text': mapcss.tr(u'Opposite or opposite lane in the same way of the oneway')})
return err
def way(self, data, tags, nds):
capture_tags = {}
keys = tags.keys()
err = []
# way["mtb:scale:uphill"][!incline]
if (u'mtb:scale:uphill' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'mtb:scale:uphill') and not mapcss._tag_capture(capture_tags, 1, tags, u'incline'))
except mapcss.RuleAbort: pass
if match:
# throwWarning:tr("Way contains ''{0}'' but not ''{1}''.","{0.key}","{1.key}")
err.append({'class': 9013001, 'subclass': 1368047539, 'text': mapcss.tr(u'Way contains \'\'{0}\'\' but not \'\'{1}\'\'.', mapcss._tag_uncapture(capture_tags, u'{0.key}'), mapcss._tag_uncapture(capture_tags, u'{1.key}'))})
# way["mtb:scale:uphill"][highway][highway!~/path|track/]
if (u'highway' in keys and u'mtb:scale:uphill' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'mtb:scale:uphill') and mapcss._tag_capture(capture_tags, 1, tags, u'highway') and not mapcss.regexp_test(mapcss._value_const_capture(capture_tags, 2, self.re_6937bec1, u'path|track'), mapcss._tag_capture(capture_tags, 2, tags, u'highway')))
except mapcss.RuleAbort: pass
if match:
# throwWarning:tr("Way contains ''{0}'' but is neither a track nor a path.","{0.key}")
err.append({'class': 9013002, 'subclass': 139842783, 'text': mapcss.tr(u'Way contains \'\'{0}\'\' but is neither a track nor a path.', mapcss._tag_uncapture(capture_tags, u'{0.key}'))})
# way["mtb:scale"]["mtb:scale"!~/^[0-6][-+]?$/]
if (u'mtb:scale' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'mtb:scale') and not mapcss.regexp_test(mapcss._value_const_capture(capture_tags, 1, self.re_1b95e3e9, u'^[0-6][-+]?$'), mapcss._tag_capture(capture_tags, 1, tags, u'mtb:scale')))
except mapcss.RuleAbort: pass
if match:
# throwWarning:tr("Invalid ''{0}'' value: ''{1}''","{0.key}","{0.value}")
err.append({'class': 9013003, 'subclass': 1229830952, 'text': mapcss.tr(u'Invalid \'\'{0}\'\' value: \'\'{1}\'\'', mapcss._tag_uncapture(capture_tags, u'{0.key}'), mapcss._tag_uncapture(capture_tags, u'{0.value}'))})
# way["mtb:scale:uphill"]["mtb:scale:uphill"!~/^[0-5]$/]
if (u'mtb:scale:uphill' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'mtb:scale:uphill') and not mapcss.regexp_test(mapcss._value_const_capture(capture_tags, 1, self.re_3d3b0752, u'^[0-5]$'), mapcss._tag_capture(capture_tags, 1, tags, u'mtb:scale:uphill')))
except mapcss.RuleAbort: pass
if match:
# throwWarning:tr("Invalid ''{0}'' value: ''{1}''","{0.key}","{0.value}")
err.append({'class': 9013003, 'subclass': 86930524, 'text': mapcss.tr(u'Invalid \'\'{0}\'\' value: \'\'{1}\'\'', mapcss._tag_uncapture(capture_tags, u'{0.key}'), mapcss._tag_uncapture(capture_tags, u'{0.value}'))})
# way["mtb:scale:imba"]["mtb:scale:imba"!~/^[0-4]$/]
if (u'mtb:scale:imba' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'mtb:scale:imba') and not mapcss.regexp_test(mapcss._value_const_capture(capture_tags, 1, self.re_731f6ce6, u'^[0-4]$'), mapcss._tag_capture(capture_tags, 1, tags, u'mtb:scale:imba')))
except mapcss.RuleAbort: pass
if match:
# throwWarning:tr("Invalid ''{0}'' value: ''{1}''","{0.key}","{0.value}")
err.append({'class': 9013003, 'subclass': 2005358544, 'text': mapcss.tr(u'Invalid \'\'{0}\'\' value: \'\'{1}\'\'', mapcss._tag_uncapture(capture_tags, u'{0.key}'), mapcss._tag_uncapture(capture_tags, u'{0.value}'))})
return err
def node(self, data, tags):
capture_tags = {}
keys = tags.keys()
err = []
# node[power=transformer][voltage]
if ('power' in keys and 'voltage' in keys):
match = False
if not match:
capture_tags = {}
try:
match = ((mapcss._tag_capture(
capture_tags, 0, tags,
'power') == mapcss._value_capture(
capture_tags, 0, 'transformer'))
and (mapcss._tag_capture(capture_tags, 1, tags,
'voltage')))
except mapcss.RuleAbort:
pass
if match:
# -osmoseTags:list("tag")
# -osmoseItemClassLevel:"9100/91002/2"
# throwWarning:tr("On Power Transformers use voltage:primary=* and voltage:secondary=* in place of voltage")
err.append({
'class':
91002,
'subclass':
0,
'text':
mapcss.
tr('On Power Transformers use voltage:primary=* and voltage:secondary=* in place of voltage'
)
})
# node[power=transformer][!frequency]
if ('power' in keys):
match = False
if not match:
capture_tags = {}
try:
match = ((mapcss._tag_capture(
capture_tags, 0, tags,
'power') == mapcss._value_capture(
capture_tags, 0, 'transformer'))
and (not mapcss._tag_capture(
capture_tags, 1, tags, 'frequency')))
except mapcss.RuleAbort:
pass
if match:
# -osmoseTags:list("tag")
# -osmoseItemClassLevel:"9100/91003/3"
# throwWarning:tr("Power Transformers should have a frequency tag")
# assertNoMatch:"node power=transformer frequency=50"
# assertMatch:"node power=transformer"
err.append({
'class':
91003,
'subclass':
0,
'text':
mapcss.tr('Power Transformers should have a frequency tag')
})
return err
def relation(self, data, tags, members):
capture_tags = {}
keys = tags.keys()
err = []
# relation[!type]
if True:
match = False
if not match:
capture_tags = {}
try: match = (not mapcss._tag_capture(capture_tags, 0, tags, u'type'))
except mapcss.RuleAbort: pass
if match:
# throwError:tr("relation without type")
# assertMatch:"relation name=Foo"
# assertNoMatch:"relation type=route name=Foo"
err.append({'class': 9007002, 'subclass': 1457279320, 'text': mapcss.tr(u'relation without type')})
# relation[type=route][!route]
# relation[type=route_master][!route_master]
# relation[type=restriction][!/^restriction/]
# relation[type=boundary][!boundary]
# relation[type=public_transport][!public_transport]
# relation[type=waterway][!waterway]
# relation[type=enforcement][!enforcement]
if (u'type' in keys):
match = False
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'type') == mapcss._value_capture(capture_tags, 0, u'route') and not mapcss._tag_capture(capture_tags, 1, tags, u'route'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'type') == mapcss._value_capture(capture_tags, 0, u'route_master') and not mapcss._tag_capture(capture_tags, 1, tags, u'route_master'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'type') == mapcss._value_capture(capture_tags, 0, u'restriction') and not mapcss._tag_capture(capture_tags, 1, tags, self.re_67b11051))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'type') == mapcss._value_capture(capture_tags, 0, u'boundary') and not mapcss._tag_capture(capture_tags, 1, tags, u'boundary'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'type') == mapcss._value_capture(capture_tags, 0, u'public_transport') and not mapcss._tag_capture(capture_tags, 1, tags, u'public_transport'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'type') == mapcss._value_capture(capture_tags, 0, u'waterway') and not mapcss._tag_capture(capture_tags, 1, tags, u'waterway'))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = (mapcss._tag_capture(capture_tags, 0, tags, u'type') == mapcss._value_capture(capture_tags, 0, u'enforcement') and not mapcss._tag_capture(capture_tags, 1, tags, u'enforcement'))
except mapcss.RuleAbort: pass
if match:
# group:tr("missing tag")
# throwWarning:tr("{0} relation without {0} tag","{1.key}")
# assertNoMatch:"relation type=boundary boundary=administrative"
# assertMatch:"relation type=boundary"
# assertNoMatch:"relation type=enforcement enforcement=maxspeed"
# assertMatch:"relation type=enforcement"
# assertNoMatch:"relation type=public_transport public_transport=stop_area"
# assertMatch:"relation type=public_transport"
# assertNoMatch:"relation type=restriction restriction=no_left_turn"
# assertMatch:"relation type=restriction"
# assertNoMatch:"relation type=route route=train"
# assertMatch:"relation type=route"
# assertNoMatch:"relation type=route_master route_master=train"
# assertMatch:"relation type=route_master"
# assertNoMatch:"relation type=site site=administrative"
# assertNoMatch:"relation type=waterway waterway=river"
# assertMatch:"relation type=waterway"
err.append({'class': 9007001, 'subclass': 881372982, 'text': mapcss.tr(u'{0} relation without {0} tag', mapcss._tag_uncapture(capture_tags, u'{1.key}'))})
return err