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 = []
# *[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 init(self, logger):
super().init(logger)
tags = capture_tags = {}
self.errors[9005001] = self.def_class(item = 9005, level = 3, tags = ["tag", "value"], title = mapcss.tr(u'{0} with multiple values', mapcss._tag_uncapture(capture_tags, u'{0.key}')))
self.errors[9005002] = self.def_class(item = 9005, level = 3, tags = ["tag", "value"], title = mapcss.tr(u'empty value in semicolon-separated \'\'{0}\'\'', mapcss._tag_uncapture(capture_tags, u'{0.key}')))
self.re_53db61ac = re.compile(r'.+;(.+)?')
self.re_579c7c6a = re.compile(r'^(;.*|.*;;.*|.*;)$')
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,
'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('relation without type')
})
# relation[type=boundary][!boundary][!disused:boundary]
# relation[type=destination_sign][!destination]
# relation[type=enforcement][!enforcement]
# relation[type=public_transport][!public_transport]
# relation[type=route][!route]
# relation[type=route_master][!route_master]
# relation[type=waterway][!waterway]
if ('type' in keys):
match = False
if not match:
capture_tags = {}
try:
match = (
(mapcss._tag_capture(capture_tags, 0, tags, 'type')
== mapcss._value_capture(capture_tags, 0, 'boundary'))
and (not mapcss._tag_capture(capture_tags, 1, tags,
'boundary'))
and (not mapcss._tag_capture(capture_tags, 2, tags,
'disused:boundary')))
except mapcss.RuleAbort:
pass
if not match:
capture_tags = {}
try:
match = ((mapcss._tag_capture(
capture_tags, 0, tags,
'type') == mapcss._value_capture(
capture_tags, 0, 'destination_sign'))
and (not mapcss._tag_capture(
capture_tags, 1, tags, 'destination')))
except mapcss.RuleAbort:
pass
if not match:
capture_tags = {}
try:
match = ((mapcss._tag_capture(
capture_tags, 0, tags,
'type') == mapcss._value_capture(
capture_tags, 0, 'enforcement'))
and (not mapcss._tag_capture(
capture_tags, 1, tags, 'enforcement')))
except mapcss.RuleAbort:
pass
if not match:
capture_tags = {}
try:
match = ((mapcss._tag_capture(
capture_tags, 0, tags,
'type') == mapcss._value_capture(
capture_tags, 0, 'public_transport'))
and (not mapcss._tag_capture(
capture_tags, 1, tags, 'public_transport')))
except mapcss.RuleAbort:
pass
if not match:
capture_tags = {}
try:
match = (
(mapcss._tag_capture(capture_tags, 0, tags, 'type')
== mapcss._value_capture(capture_tags, 0, 'route'))
and (not mapcss._tag_capture(capture_tags, 1, tags,
'route')))
except mapcss.RuleAbort:
pass
if not match:
capture_tags = {}
try:
match = ((mapcss._tag_capture(
capture_tags, 0, tags,
'type') == mapcss._value_capture(
capture_tags, 0, 'route_master'))
and (not mapcss._tag_capture(
capture_tags, 1, tags, 'route_master')))
except mapcss.RuleAbort:
pass
if not match:
capture_tags = {}
try:
match = (
(mapcss._tag_capture(capture_tags, 0, tags, 'type')
== mapcss._value_capture(capture_tags, 0, 'waterway'))
and (not mapcss._tag_capture(capture_tags, 1, tags,
'waterway')))
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=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':
93004660,
'text':
mapcss.tr('{0} relation without {0} tag',
mapcss._tag_uncapture(capture_tags, '{1.key}'))
})
# relation[type=restriction][!/^restriction/]
if ('type' in keys):
match = False
if not match:
capture_tags = {}
try:
match = ((mapcss._tag_capture(
capture_tags, 0, tags,
'type') == mapcss._value_capture(
capture_tags, 0, 'restriction'))
and (not mapcss._tag_capture(
capture_tags, 1, tags, self.re_67b11051)))
except mapcss.RuleAbort:
pass
if match:
# group:tr("missing tag")
# throwWarning:tr("{0} relation without {0} tag","restriction")
# assertNoMatch:"relation type=restriction restriction:hgv=no_left_turn"
# assertNoMatch:"relation type=restriction restriction=no_left_turn"
# assertMatch:"relation type=restriction"
err.append({
'class':
9007001,
'subclass':
1097316614,
'text':
mapcss.tr('{0} relation without {0} tag', 'restriction')
})
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 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 ('construction' in keys and 'highway' in keys) or (
'construction' in keys
and 'railway' in keys) or ('highway' in keys and 'proposed'
in keys) or ('proposed' in keys
and 'railway' in keys):
match = False
if not match:
capture_tags = {}
try:
match = (
mapcss._tag_capture(capture_tags, 0, tags, 'highway')
and mapcss._tag_capture(capture_tags, 1, tags,
'construction') and
mapcss._tag_capture(capture_tags, 2, tags, 'highway')
!= mapcss._value_const_capture(
capture_tags, 2, 'construction', 'construction')
and mapcss._tag_capture(
capture_tags, 3, tags,
'construction') != mapcss._value_const_capture(
capture_tags, 3, 'minor', 'minor'))
except mapcss.RuleAbort:
pass
if not match:
capture_tags = {}
try:
match = (
mapcss._tag_capture(capture_tags, 0, tags, 'highway')
and mapcss._tag_capture(capture_tags, 1, tags,
'proposed') and
mapcss._tag_capture(capture_tags, 2, tags, 'highway')
!= mapcss._value_const_capture(capture_tags, 2,
'proposed', 'proposed'))
except mapcss.RuleAbort:
pass
if not match:
capture_tags = {}
try:
match = (
mapcss._tag_capture(capture_tags, 0, tags, 'railway')
and mapcss._tag_capture(capture_tags, 1, tags,
'construction') and
mapcss._tag_capture(capture_tags, 2, tags, 'railway')
!= mapcss._value_const_capture(
capture_tags, 2, 'construction', 'construction')
and
mapcss._tag_capture(capture_tags, 3, tags, 'railway')
!= mapcss._value_const_capture(
capture_tags, 3, 'abandoned', 'abandoned') and
mapcss._tag_capture(capture_tags, 4, tags, 'railway')
!= mapcss._value_const_capture(capture_tags, 4,
'razed', 'razed') and
mapcss._tag_capture(capture_tags, 5, tags, 'railway')
!= mapcss._value_const_capture(
capture_tags, 5, 'dismantled', 'dismantled')
and mapcss._tag_capture(
capture_tags, 6, tags,
'construction') != mapcss._value_const_capture(
capture_tags, 6, 'minor', 'minor'))
except mapcss.RuleAbort:
pass
if not match:
capture_tags = {}
try:
match = (
mapcss._tag_capture(capture_tags, 0, tags, 'railway')
and mapcss._tag_capture(capture_tags, 1, tags,
'proposed') and
mapcss._tag_capture(capture_tags, 2, tags, 'railway')
!= mapcss._value_const_capture(
capture_tags, 2, 'proposed', 'proposed') and
mapcss._tag_capture(capture_tags, 3, tags, 'railway')
!= mapcss._value_const_capture(
capture_tags, 3, 'abandoned', 'abandoned') and
mapcss._tag_capture(capture_tags, 4, tags, 'railway')
!= mapcss._value_const_capture(capture_tags, 4,
'razed', 'razed') and
mapcss._tag_capture(capture_tags, 5, tags, 'railway')
!= mapcss._value_const_capture(
capture_tags, 5, 'dismantled', 'dismantled') and
mapcss._tag_capture(capture_tags, 6, tags, 'railway')
!= mapcss._value_const_capture(capture_tags, 6,
'disused', '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('Inconsistent tagging of {0}',
mapcss._tag_uncapture(capture_tags, '{1.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]
# 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 init(self, logger):
Plugin.init(self, logger)
tags = capture_tags = {}
self.errors[20301] = {'item': 2030, 'level': 1, 'tag': mapcss.list_(u'tag', u'highway') + mapcss.list_(u'cycleway', u'fix:survey'), 'desc': mapcss.tr(u'Opposite cycleway without oneway')}
self.errors[20302] = {'item': 2030, 'level': 1, 'tag': mapcss.list_(u'tag', u'highway') + mapcss.list_(u'cycleway', u'fix:survey'), 'desc': mapcss.tr(u'Opposite or opposite lane in the same way of the oneway')}
self.errors[20805] = {'item': 2080, 'level': 3, 'tag': mapcss.list_(u'tag', u'highway') + mapcss.list_(u'footway', u'fix:chair'), 'desc': mapcss.tr(u'{0} without {1}', mapcss._tag_uncapture(capture_tags, u'{0.tag}'), u'highway=footway|construction')}
self.errors[30328] = {'item': 3032, 'level': 2, 'tag': mapcss.list_(u'tag', u'highway') + mapcss.list_(u'cycleway', u'fix:chair'), 'desc': mapcss.tr(u'{0} with {1}', mapcss._tag_uncapture(capture_tags, u'{0.tag}'), mapcss._tag_uncapture(capture_tags, u'{1.tag}'))}
self.errors[40101] = {'item': 4010, 'level': 2, 'tag': mapcss.list_(u'tag', u'highway') + mapcss.list_(u'fix:chair'), 'desc': mapcss.tr(u'{0} is preferred to {1}', mapcss._tag_uncapture(capture_tags, u'{2.tag}'), mapcss._tag_uncapture(capture_tags, u'{1.tag}'))}
self.errors[40301] = {'item': 4030, 'level': 2, 'tag': mapcss.list_(u'tag', u'highway') + mapcss.list_(u'cycleway', u'fix:chair'), 'desc': 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}'))}
self.re_1825c777 = re.compile(r'footway|construction')
self.re_67b51e41 = re.compile(r'opposite|opposite_lane')
def relation(self, data, tags, members):
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 init(self, logger):
Plugin.init(self, logger)
tags = capture_tags = {}
self.errors[20301] = {
'item':
2030,
'level':
1,
'tag':
mapcss.list_(u'tag', u'highway') +
mapcss.list_(u'cycleway', u'fix:survey'),
'desc':
mapcss.tr(u'Opposite cycleway without oneway')
}
self.errors[20302] = {
'item':
2030,
'level':
1,
'tag':
mapcss.list_(u'tag', u'highway') +
mapcss.list_(u'cycleway', u'fix:survey'),
'desc':
mapcss.tr(
u'Opposite or opposite lane in the same way of the oneway')
}
self.errors[20805] = {
'item':
2080,
'level':
3,
'tag':
mapcss.list_(u'tag', u'highway') +
mapcss.list_(u'footway', u'fix:chair'),
'desc':
mapcss.tr(u'{0} without {1}',
mapcss._tag_uncapture(capture_tags, u'{0.tag}'),
u'highway=footway|construction')
}
self.errors[30328] = {
'item':
3032,
'level':
2,
'tag':
mapcss.list_(u'tag', u'highway') +
mapcss.list_(u'cycleway', u'fix:chair'),
'desc':
mapcss.tr(u'{0} with {1}',
mapcss._tag_uncapture(capture_tags, u'{0.tag}'),
mapcss._tag_uncapture(capture_tags, u'{1.tag}'))
}
self.errors[30329] = {
'item':
3032,
'level':
2,
'tag':
mapcss.list_(u'tag', u'highway') + mapcss.list_(u'fix:chair'),
'desc':
mapcss.tr(u'{0} with {1}',
mapcss._tag_uncapture(capture_tags, u'{0.tag}'),
mapcss._tag_uncapture(capture_tags, u'{1.tag}'))
}
self.errors[40101] = {
'item':
4010,
'level':
2,
'tag':
mapcss.list_(u'tag', u'highway') + mapcss.list_(u'fix:chair'),
'desc':
mapcss.tr(u'{0} is preferred to {1}',
mapcss._tag_uncapture(capture_tags, u'{2.tag}'),
mapcss._tag_uncapture(capture_tags, u'{1.tag}'))
}
self.errors[40301] = {
'item':
4030,
'level':
2,
'tag':
mapcss.list_(u'tag', u'highway') +
mapcss.list_(u'cycleway', u'fix:chair'),
'desc':
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}'))
}
self.re_1825c777 = re.compile(r'footway|construction')
self.re_5b286a0d = re.compile(r'no|use_sidepath')
self.re_6781a1fd = re.compile(r'no|none|separate')
self.re_67b51e41 = re.compile(r'opposite|opposite_lane')
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 ('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, 'highway'))
and mapcss._tag_capture(capture_tags, 1, tags,
'highway') !=
mapcss._value_const_capture(
capture_tags, 1, 'motorway_junction',
'motorway_junction') and mapcss._tag_capture(
capture_tags, 2, tags, 'highway') !=
mapcss._value_const_capture(
capture_tags, 2, 'services', '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('wrong highway tag on a node')
})
# node[footway=crossing]
if ('footway' in keys):
match = False
if not match:
capture_tags = {}
try:
match = (mapcss._tag_capture(
capture_tags, 0, tags,
'footway') == mapcss._value_capture(
capture_tags, 0, '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('{0} on a node',
mapcss._tag_uncapture(capture_tags, '{0.tag}'))
})
# node[cycleway=crossing]
if ('cycleway' in keys):
match = False
if not match:
capture_tags = {}
try:
match = (mapcss._tag_capture(
capture_tags, 0, tags,
'cycleway') == mapcss._value_capture(
capture_tags, 0, '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('{0} on a node',
mapcss._tag_uncapture(capture_tags, '{0.tag}'))
})
# node[railway!=crossing][crossing!=no].is_in_railway.is_in_minor_road!.is_in_major_road
if True:
match = False
# Skip selector using undeclared class is_in_major_road, is_in_minor_road, is_in_railway
if match:
# group:tr("missing tag")
# throwWarning:tr("pedestrian railway crossing without {0}","{0.tag}")
# fixAdd:"railway=crossing"
err.append({
'class':
9004009,
'subclass':
18813378,
'text':
mapcss.tr('pedestrian railway crossing without {0}',
mapcss._tag_uncapture(capture_tags, '{0.tag}')),
'allow_fix_override':
True,
'fix': {
'+': dict([['railway', 'crossing']])
}
})
# node[railway!=level_crossing].is_in_railway.is_in_major_road!.is_in_minor_road
if True:
match = False
# Skip selector using undeclared class is_in_major_road, is_in_minor_road, is_in_railway
if match:
# group:tr("missing tag")
# throwWarning:tr("railway crossing without {0}","{0.tag}")
# fixAdd:"railway=level_crossing"
err.append({
'class':
9004009,
'subclass':
1127761651,
'text':
mapcss.tr('railway crossing without {0}',
mapcss._tag_uncapture(capture_tags, '{0.tag}')),
'allow_fix_override':
True,
'fix': {
'+': dict([['railway', 'level_crossing']])
}
})
# node[highway=crossing][barrier=kerb].is_in_major_road
if ('barrier' in keys and 'highway' in keys):
match = False
# Skip selector using undeclared class is_in_major_road
if match:
# group:tr("suspicious tag combination")
# throwWarning:tr("{0} together with {1}","{0.tag}","{1.tag}")
# suggestAlternative:"kerb=*"
err.append({
'class':
9004011,
'subclass':
440952770,
'text':
mapcss.tr('{0} together with {1}',
mapcss._tag_uncapture(capture_tags, '{0.tag}'),
mapcss._tag_uncapture(capture_tags, '{1.tag}'))
})
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 init(self, logger):
Plugin.init(self, logger)
tags = capture_tags = {}
self.errors[9013001] = {'item': 9013, 'level': 3, 'tag': ["tag", "sport"], 'desc': 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}'))}
self.errors[9013002] = {'item': 9013, 'level': 3, 'tag': ["tag", "sport"], 'desc': mapcss.tr(u'Way contains \'\'{0}\'\' but is neither a track nor a path.', mapcss._tag_uncapture(capture_tags, u'{0.key}'))}
self.errors[9013003] = {'item': 9013, 'level': 3, 'tag': ["tag", "sport"], 'desc': mapcss.tr(u'Invalid \'\'{0}\'\' value: \'\'{1}\'\'', mapcss._tag_uncapture(capture_tags, u'{0.key}'), mapcss._tag_uncapture(capture_tags, u'{0.value}'))}
self.re_1b95e3e9 = re.compile(r'^[0-6][-+]?$')
self.re_3d3b0752 = re.compile(r'^[0-5]$')
self.re_6937bec1 = re.compile(r'path|track')
self.re_731f6ce6 = re.compile(r'^[0-4]$')
def node(self, data, tags):
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}")
# 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}'))
})
# *[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}")
err.append({
'class':
9000004,
'subclass':
1053226919,
'text':
mapcss.tr(u'{0} without number',
mapcss._tag_uncapture(capture_tags, u'{0.key}'))
})
return err
def init(self, logger):
Plugin.init(self, logger)
tags = capture_tags = {}
self.errors[9004001] = {'item': 9004, 'level': 3, 'tag': ["tag", "highway"], 'desc': mapcss.tr(u'abbreviated street name')}
self.errors[9004002] = {'item': 9004, 'level': 3, 'tag': ["tag", "highway"], 'desc': mapcss.tr(u'wrong crossing tag on a way')}
self.errors[9004004] = {'item': 9004, 'level': 3, 'tag': ["tag", "highway"], 'desc': mapcss.tr(u'Unspecific highway type')}
self.errors[9004005] = {'item': 9004, 'level': 3, 'tag': ["tag", "highway"], 'desc': mapcss.tr(u'{0} used with {1}', mapcss._tag_uncapture(capture_tags, u'{0.value}'), mapcss._tag_uncapture(capture_tags, u'{1.tag}'))}
self.errors[9004006] = {'item': 9004, 'level': 3, 'tag': ["tag", "highway"], 'desc': mapcss.tr(u'deprecated tagging')}
self.errors[9004007] = {'item': 9004, 'level': 3, 'tag': ["tag", "highway"], 'desc': 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')}
self.errors[9004008] = {'item': 9004, 'level': 3, 'tag': ["tag", "highway"], 'desc': mapcss.tr(u'wrong highway tag on a node')}
self.re_015aabd5 = re.compile(r'^(unclassified|residential|living_street|service)$')
self.re_3092b7ac = re.compile(r'^.*_link$')
self.re_3dc5dd7c = re.compile(r'motorway|trunk|primary|secondary|tertiary|unclassified|residential|service|living_street|pedestrian|track|path|footway|cycleway|bus_guideway|bridleway')
self.re_4dcdb354 = re.compile(r'^footway:')
self.re_55ee32ac = re.compile(r'^(motorway|trunk|primary|secondary|tertiary)$')
self.re_61bbe299 = re.compile(r'footway:')
self.re_776f2c1a = re.compile(r'(?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)[.]?$')
def init(self, logger):
Plugin.init(self, logger)
tags = capture_tags = {}
self.errors[9005001] = {'item': 9005, 'level': 3, 'tag': ["tag", "value"], 'desc': mapcss.tr(u'{0} with multiple values', mapcss._tag_uncapture(capture_tags, u'{0.key}'))}
self.errors[9005002] = {'item': 9005, 'level': 3, 'tag': ["tag", "value"], 'desc': mapcss.tr(u'empty value in semicolon-separated \'\'{0}\'\'', mapcss._tag_uncapture(capture_tags, u'{0.key}'))}
self.re_53db61ac = re.compile(r'.+;(.+)?')
self.re_579c7c6a = re.compile(r'^(;.*|.*;;.*|.*;)$')
def way(self, data, tags, nds):
capture_tags = {}
keys = tags.keys()
err = []
# way[highway][destination][destination*="|"]
# way[highway][/^destination:/][!/^destination:lanes/][!/^destination:.*:lanes/][/^destination:/=~/\|/]
# way[waterway][destination][destination*="|"]
# way[waterway][/^destination:/][!/^destination:lanes/][!/^destination:.*:lanes/][/^destination:/=~/\|/]
if ('destination' in keys and 'highway' in keys) or (
'destination' in keys
and 'waterway' in keys) or ('highway' in keys) or ('waterway'
in keys):
match = False
if not match:
capture_tags = {}
try:
match = (mapcss._tag_capture(capture_tags, 0, tags,
'highway')
and mapcss._tag_capture(capture_tags, 1, tags,
'destination')
and mapcss.string_contains(
mapcss._tag_capture(capture_tags, 2, tags,
'destination'),
mapcss._value_capture(capture_tags, 2, '|')))
except mapcss.RuleAbort:
pass
if not match:
capture_tags = {}
try:
match = (mapcss._tag_capture(capture_tags, 0, tags,
'highway')
and mapcss._tag_capture(capture_tags, 1, tags,
self.re_53d7e349)
and not mapcss._tag_capture(
capture_tags, 2, tags, self.re_49b44b3d)
and not mapcss._tag_capture(
capture_tags, 3, tags, self.re_60b51c01)
and mapcss.regexp_test(
self.re_262d3d80,
mapcss._match_regex(tags, self.re_53d7e349)))
except mapcss.RuleAbort:
pass
if not match:
capture_tags = {}
try:
match = (mapcss._tag_capture(capture_tags, 0, tags,
'waterway')
and mapcss._tag_capture(capture_tags, 1, tags,
'destination')
and mapcss.string_contains(
mapcss._tag_capture(capture_tags, 2, tags,
'destination'),
mapcss._value_capture(capture_tags, 2, '|')))
except mapcss.RuleAbort:
pass
if not match:
capture_tags = {}
try:
match = (mapcss._tag_capture(capture_tags, 0, tags,
'waterway')
and mapcss._tag_capture(capture_tags, 1, tags,
self.re_53d7e349)
and not mapcss._tag_capture(
capture_tags, 2, tags, self.re_49b44b3d)
and not mapcss._tag_capture(
capture_tags, 3, tags, self.re_60b51c01)
and mapcss.regexp_test(
self.re_262d3d80,
mapcss._match_regex(tags, self.re_53d7e349)))
except mapcss.RuleAbort:
pass
if match:
# group:tr("Pipe characters should not be used in destination tag, only in destination:lanes")
# -osmoseItemClassLevel:"3160/316010:0/3"
# suggestAlternative:tr("In case of multiple values, use instead a semicolon to separate values")
# throwError:tr("{0} contains a pipe character","{1.tag}")
# fixAdd:concat("{1.key}=",replace("{1.value}","|",";"))
# assertNoMatch:"way highway=primary destination:colour=Red"
# assertMatch:"way highway=primary destination:colour=Red|Yellow"
# assertNoMatch:"way highway=primary destination:lanes:backward=A8|Centre|Plage"
# assertNoMatch:"way highway=primary destination:lanes=A8|Centre|Plage"
# assertNoMatch:"way highway=primary destination:ref:lanes=A8|A10|A23"
# assertNoMatch:"way highway=primary destination=A8"
# assertMatch:"way highway=primary destination=A8|Centre|Plage"
# assertNoMatch:"way highway=tertiary destination:ref:lanes:backward=B 3|B 3"
# assertNoMatch:"way highway=tertiary destination:ref:to:lanes=A 7|"
# assertNoMatch:"way waterway=river destination=East"
# assertMatch:"way waterway=river destination=East|West"
err.append({
'class':
316010,
'subclass':
0,
'text':
mapcss.tr('{0} contains a pipe character',
mapcss._tag_uncapture(capture_tags, '{1.tag}')),
'allow_fix_override':
True,
'fix': {
'+':
dict([(mapcss.concat(
mapcss._tag_uncapture(capture_tags, '{1.key}='),
mapcss.replace(
mapcss._tag_uncapture(capture_tags,
'{1.value}'), '|',
';'))).split('=', 1)])
}
})
return err
def way(self, data, tags, nds):
capture_tags = {}
keys = tags.keys()
err = []
# way[cycleway][cycleway:right][cycleway:left]
if ('cycleway' in keys and 'cycleway:left' in keys
and 'cycleway:right' in keys):
match = False
if not match:
capture_tags = {}
try:
match = (mapcss._tag_capture(capture_tags, 0, tags,
'cycleway')
and mapcss._tag_capture(capture_tags, 1, tags,
'cycleway:right')
and mapcss._tag_capture(capture_tags, 2, tags,
'cycleway:left'))
except mapcss.RuleAbort:
pass
if match:
# -osmoseTags:list("cycleway","fix:chair")
# -osmoseItemClassLevel:"4030/40301/2"
# throwWarning:tr("{0} with {1} and {2}","cycleway","cycleway:right","{cycleway:left}")
# assertMatch:"way cycleway=a cycleway:right=b cycleway:left=c"
err.append({
'class':
40301,
'subclass':
0,
'text':
mapcss.tr('{0} with {1} and {2}', 'cycleway',
'cycleway:right', '{cycleway:left}')
})
# way[footway=sidewalk][highway!~/footway|construction/]
if ('footway' in keys):
match = False
if not match:
capture_tags = {}
try:
match = (
mapcss._tag_capture(capture_tags, 0, tags, 'footway')
== mapcss._value_capture(capture_tags, 0, 'sidewalk')
and not mapcss.regexp_test(
mapcss._value_const_capture(
capture_tags, 1, self.re_1825c777,
'footway|construction'),
mapcss._tag_capture(capture_tags, 1, tags,
'highway')))
except mapcss.RuleAbort:
pass
if match:
# -osmoseTags:list("footway","fix:chair")
# -osmoseItemClassLevel:"2080/20805/3"
# throwWarning:tr("{0} without {1}","footway=sidewalk","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('{0} without {1}', 'footway=sidewalk',
'highway=footway|construction')
})
# way[highway=service][service=psv][psv!=yes]
if ('highway' in keys and 'service' in keys):
match = False
if not match:
capture_tags = {}
try:
match = (
mapcss._tag_capture(capture_tags, 0, tags, 'highway')
== mapcss._value_capture(capture_tags, 0, 'service')
and mapcss._tag_capture(capture_tags, 1, tags,
'service')
== mapcss._value_capture(capture_tags, 1, 'psv')
and mapcss._tag_capture(capture_tags, 2, tags, 'psv')
!= mapcss._value_const_capture(capture_tags, 2, 'yes',
'yes'))
except mapcss.RuleAbort:
pass
if match:
# -osmoseTags:list("fix:chair")
# -osmoseItemClassLevel:"4010/40101/2"
# throwWarning:tr("{0} is preferred to {1}","psv","service=psv")
# 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('{0} is preferred to {1}', 'psv', 'service=psv'),
'allow_fix_override':
True,
'fix': {
'+': dict([['psv', 'yes']]),
'-': (['service'])
}
})
# way[highway=cycleway][cycleway=track]
if ('cycleway' in keys and 'highway' in keys):
match = False
if not match:
capture_tags = {}
try:
match = (
mapcss._tag_capture(capture_tags, 0, tags, 'highway')
== mapcss._value_capture(capture_tags, 0, 'cycleway')
and mapcss._tag_capture(capture_tags, 1, tags,
'cycleway')
== mapcss._value_capture(capture_tags, 1, 'track'))
except mapcss.RuleAbort:
pass
if match:
# -osmoseTags:list("cycleway","fix:chair")
# -osmoseItemClassLevel:"3032/30328/2"
# throwWarning:tr("{0} with {1}","highway=cycleway","cycleway=track")
# fixRemove:"cycleway"
err.append({
'class':
30328,
'subclass':
0,
'text':
mapcss.tr('{0} with {1}', 'highway=cycleway',
'cycleway=track'),
'allow_fix_override':
True,
'fix': {
'-': (['cycleway'])
}
})
# way[bicycle=~/no|use_sidepath/][cycleway][cycleway!~/no|none|separate/]
# way[bicycle=~/no|use_sidepath/][cycleway:left][cycleway:left!~/no|none|separate/]
# way[bicycle=~/no|use_sidepath/][cycleway:right][cycleway:right!~/no|none|separate/]
if ('bicycle' in keys and 'cycleway' in keys) or (
'bicycle' in keys
and 'cycleway:left' in keys) or ('bicycle' in keys
and 'cycleway:right' in keys):
match = False
if not match:
capture_tags = {}
try:
match = (mapcss.regexp_test(
mapcss._value_capture(capture_tags, 0,
self.re_5b286a0d),
mapcss._tag_capture(capture_tags, 0, tags, 'bicycle'))
and mapcss._tag_capture(capture_tags, 1, tags,
'cycleway')
and not mapcss.regexp_test(
mapcss._value_const_capture(
capture_tags, 2, self.re_6781a1fd,
'no|none|separate'),
mapcss._tag_capture(capture_tags, 2, tags,
'cycleway')))
except mapcss.RuleAbort:
pass
if not match:
capture_tags = {}
try:
match = (mapcss.regexp_test(
mapcss._value_capture(capture_tags, 0,
self.re_5b286a0d),
mapcss._tag_capture(capture_tags, 0, tags, 'bicycle'))
and mapcss._tag_capture(capture_tags, 1, tags,
'cycleway:left')
and not mapcss.regexp_test(
mapcss._value_const_capture(
capture_tags, 2, self.re_6781a1fd,
'no|none|separate'),
mapcss._tag_capture(capture_tags, 2, tags,
'cycleway:left')))
except mapcss.RuleAbort:
pass
if not match:
capture_tags = {}
try:
match = (mapcss.regexp_test(
mapcss._value_capture(capture_tags, 0,
self.re_5b286a0d),
mapcss._tag_capture(capture_tags, 0, tags, 'bicycle'))
and mapcss._tag_capture(capture_tags, 1, tags,
'cycleway:right')
and not mapcss.regexp_test(
mapcss._value_const_capture(
capture_tags, 2, self.re_6781a1fd,
'no|none|separate'),
mapcss._tag_capture(capture_tags, 2, tags,
'cycleway:right')))
except mapcss.RuleAbort:
pass
if match:
# -osmoseTags:list("fix:chair")
# -osmoseItemClassLevel:"3032/30329/2"
# throwWarning:tr("{0} with {1}","{0.tag}","{1.tag}")
# assertNoMatch:"way bicycle=no cycleway:right=no"
# assertMatch:"way bicycle=no cycleway=track"
# assertMatch:"way bicycle=use_sidepath cycleway:left=lane"
# assertNoMatch:"way bicycle=use_sidepath cycleway:left=none"
# assertNoMatch:"way highway=cycleway cycleway=separate"
# assertNoMatch:"way highway=residential bicycle=use_sidepath"
err.append({
'class':
30329,
'subclass':
0,
'text':
mapcss.tr('{0} with {1}',
mapcss._tag_uncapture(capture_tags, '{0.tag}'),
mapcss._tag_uncapture(capture_tags, '{1.tag}'))
})
# way[cycleway=~/opposite|opposite_lane/][!oneway]
# way[cycleway=~/opposite|opposite_lane/][oneway=no]
if ('cycleway' in keys) or ('cycleway' in keys and '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, 'cycleway'))
and not mapcss._tag_capture(
capture_tags, 1, tags, '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, 'cycleway'))
and mapcss._tag_capture(capture_tags, 1, tags,
'oneway')
== mapcss._value_capture(capture_tags, 1, '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('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 ('cycleway:left' in keys
and 'oneway' in keys) or ('cycleway:right' in keys
and '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,
'cycleway:right'))
and mapcss._tag_capture(capture_tags, 1, tags,
'oneway')
== mapcss._value_capture(capture_tags, 1, 'yes')
and mapcss.setting(self.father.config.options,
'driving_side') != '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,
'cycleway:left'))
and mapcss._tag_capture(capture_tags, 1, tags,
'oneway')
== mapcss._value_capture(capture_tags, 1, '-1')
and mapcss.setting(self.father.config.options,
'driving_side') != '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,
'cycleway:left'))
and mapcss._tag_capture(capture_tags, 1, tags,
'oneway')
== mapcss._value_capture(capture_tags, 1, 'yes')
and mapcss.setting(self.father.config.options,
'driving_side') == '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,
'cycleway:right'))
and mapcss._tag_capture(capture_tags, 1, tags,
'oneway')
== mapcss._value_capture(capture_tags, 1, '-1')
and mapcss.setting(self.father.config.options,
'driving_side') == '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('Opposite or opposite lane in the same way of the oneway'
)
})
return err
def init(self, logger):
Plugin.init(self, logger)
tags = capture_tags = {}
self.errors[9000003] = {'item': 9000, 'level': 3, 'tag': ["tag", "addr"], 'desc': 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}'))}
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
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 init(self, logger):
Plugin.init(self, logger)
tags = capture_tags = {}
self.errors[40701] = {'item': 4070, 'level': 1, 'tag': mapcss.list_(u'tag', u'highway', u'fix:survey'), 'desc': mapcss.tr(u'Inconsistent tagging of {0}', mapcss._tag_uncapture(capture_tags, u'{1.key}'))}
def way(self, data, tags, nds):
capture_tags = {}
keys = tags.keys()
err = []
# way[line_attachment]
# way[line_management]
# way[emergency=fire_hydrant]
# way[emergency=defibrillator]
# way[entrance]
# way[door]
# way[railway=subway_entrance]
# way[man_made=survey_point]
# way[power=transformer]
# way[transformer]
# way[power=pole]
# way[power=catenary_mast]
# way[power=connection]
# 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 ('amenity' in keys) or ('door' in keys) or ('emergency' in keys) or ('entrance' in keys) or ('highway' in keys) or ('line_attachment' in keys) or ('line_management' in keys) or ('man_made' in keys) or ('natural' in keys) or ('power' in keys) or ('railway' in keys) or ('transformer' in keys):
match = False
if not match:
capture_tags = {}
try: match = ((mapcss._tag_capture(capture_tags, 0, tags, 'line_attachment')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = ((mapcss._tag_capture(capture_tags, 0, tags, 'line_management')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = ((mapcss._tag_capture(capture_tags, 0, tags, 'emergency') == mapcss._value_capture(capture_tags, 0, 'fire_hydrant')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = ((mapcss._tag_capture(capture_tags, 0, tags, 'emergency') == mapcss._value_capture(capture_tags, 0, 'defibrillator')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = ((mapcss._tag_capture(capture_tags, 0, tags, 'entrance')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = ((mapcss._tag_capture(capture_tags, 0, tags, 'door')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = ((mapcss._tag_capture(capture_tags, 0, tags, 'railway') == mapcss._value_capture(capture_tags, 0, 'subway_entrance')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = ((mapcss._tag_capture(capture_tags, 0, tags, 'man_made') == mapcss._value_capture(capture_tags, 0, 'survey_point')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = ((mapcss._tag_capture(capture_tags, 0, tags, 'power') == mapcss._value_capture(capture_tags, 0, 'transformer')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = ((mapcss._tag_capture(capture_tags, 0, tags, 'transformer')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = ((mapcss._tag_capture(capture_tags, 0, tags, 'power') == mapcss._value_capture(capture_tags, 0, 'pole')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = ((mapcss._tag_capture(capture_tags, 0, tags, 'power') == mapcss._value_capture(capture_tags, 0, 'catenary_mast')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = ((mapcss._tag_capture(capture_tags, 0, tags, 'power') == mapcss._value_capture(capture_tags, 0, 'connection')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = ((mapcss._tag_capture(capture_tags, 0, tags, 'power') == mapcss._value_capture(capture_tags, 0, 'terminal')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = ((mapcss._tag_capture(capture_tags, 0, tags, 'power') == mapcss._value_capture(capture_tags, 0, 'tower')) and (nds[0] != nds[-1]))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = ((mapcss._tag_capture(capture_tags, 0, tags, 'amenity') == mapcss._value_capture(capture_tags, 0, 'vending_machine')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = ((mapcss._tag_capture(capture_tags, 0, tags, 'natural') == mapcss._value_capture(capture_tags, 0, 'peak')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = ((mapcss._tag_capture(capture_tags, 0, tags, 'natural') == mapcss._value_capture(capture_tags, 0, 'saddle')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = ((mapcss._tag_capture(capture_tags, 0, tags, 'natural') == mapcss._value_capture(capture_tags, 0, 'volcano')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = ((mapcss._tag_capture(capture_tags, 0, tags, 'natural') == mapcss._value_capture(capture_tags, 0, 'tree')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = ((mapcss._tag_capture(capture_tags, 0, tags, 'highway') == mapcss._value_capture(capture_tags, 0, 'give_way')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = ((mapcss._tag_capture(capture_tags, 0, tags, 'highway') == mapcss._value_capture(capture_tags, 0, 'milestone')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = ((mapcss._tag_capture(capture_tags, 0, tags, 'highway') == mapcss._value_capture(capture_tags, 0, 'mini_roundabout')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = ((mapcss._tag_capture(capture_tags, 0, tags, 'highway') == mapcss._value_capture(capture_tags, 0, 'stop')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = ((mapcss._tag_capture(capture_tags, 0, tags, 'highway') == mapcss._value_capture(capture_tags, 0, 'street_lamp')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = ((mapcss._tag_capture(capture_tags, 0, tags, 'highway') == mapcss._value_capture(capture_tags, 0, 'traffic_signals')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = ((mapcss._tag_capture(capture_tags, 0, tags, 'highway') == mapcss._value_capture(capture_tags, 0, 'turning_loop')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = ((mapcss._tag_capture(capture_tags, 0, tags, 'highway') == mapcss._value_capture(capture_tags, 0, 'turning_circle')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = ((mapcss._tag_capture(capture_tags, 0, tags, 'highway') == mapcss._value_capture(capture_tags, 0, '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': 1374694710, 'text': mapcss.tr('{0} on a way. Should be used on a node.', mapcss._tag_uncapture(capture_tags, '{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 ('interval' in keys) or ('restriction' in keys) or ('route' in keys) or ('type' in keys):
match = False
if not match:
capture_tags = {}
try: match = ((mapcss._tag_capture(capture_tags, 0, tags, 'restriction')) and (mapcss.regexp_test(mapcss._value_capture(capture_tags, 1, self.re_22f56734), mapcss._tag_capture(capture_tags, 1, tags, 'restriction'))))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = ((mapcss._tag_capture(capture_tags, 0, tags, 'type') == mapcss._value_capture(capture_tags, 0, 'multipolygon')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = ((mapcss._tag_capture(capture_tags, 0, tags, 'interval')) and (mapcss._tag_capture(capture_tags, 1, tags, 'route') != mapcss._value_const_capture(capture_tags, 1, 'ferry', 'ferry')))
except mapcss.RuleAbort: pass
if not match:
capture_tags = {}
try: match = ((mapcss._tag_capture(capture_tags, 0, tags, 'route') == mapcss._value_capture(capture_tags, 0, '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('{0} on a way. Should be used in a relation', mapcss._tag_uncapture(capture_tags, '{0.tag}'))})
# way:closed[power=line]
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, 'line')) and (nds[0] == nds[-1]))
except mapcss.RuleAbort: pass
if match:
# throwWarning:tr("{0} on a closed way. Should be used on an unclosed way.","{1.tag}")
err.append({'class': 9003011, 'subclass': 2100265426, 'text': mapcss.tr('{0} on a closed way. Should be used on an unclosed way.', mapcss._tag_uncapture(capture_tags, '{1.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][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 init(self, logger):
super().init(logger)
tags = capture_tags = {} # noqa
self.errors[21001] = self.def_class(item = 2100, level = 3, tags = mapcss.list_(u'fix:chair'), title = mapcss.tr(u'{0} without {1}', mapcss._tag_uncapture(capture_tags, u'{0.tag}'), mapcss._tag_uncapture(capture_tags, u'{1.key}')))
def relation(self, data, tags, members):
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}")
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 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 = []
# *[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 init(self, logger):
Plugin.init(self, logger)
tags = capture_tags = {}
self.errors[9013001] = {'item': 9013, 'level': 3, 'tag': ["tag", "sport"], 'desc': 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}'))}
self.errors[9013002] = {'item': 9013, 'level': 3, 'tag': ["tag", "sport"], 'desc': mapcss.tr(u'Way contains \'\'{0}\'\' but is neither a track nor a path.', mapcss._tag_uncapture(capture_tags, u'{0.key}'))}
self.errors[9013003] = {'item': 9013, 'level': 3, 'tag': ["tag", "sport"], 'desc': mapcss.tr(u'Invalid \'\'{0}\'\' value: \'\'{1}\'\'', mapcss._tag_uncapture(capture_tags, u'{0.key}'), mapcss._tag_uncapture(capture_tags, u'{0.value}'))}
self.re_1b95e3e9 = re.compile(r'^[0-6][-+]?$')
self.re_3d3b0752 = re.compile(r'^[0-5]$')
self.re_6937bec1 = re.compile(r'path|track')
self.re_731f6ce6 = re.compile(r'^[0-4]$')
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 relation(self, data, tags, members):
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}")
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}"
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 = []
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 init(self, logger):
super().init(logger)
tags = capture_tags = {} # noqa
self.errors[20301] = self.def_class(item = 2030, level = 1, tags = mapcss.list_('tag', 'highway') + mapcss.list_('cycleway', 'fix:survey'), title = mapcss.tr('Opposite cycleway without oneway'))
self.errors[20302] = self.def_class(item = 2030, level = 1, tags = mapcss.list_('tag', 'highway') + mapcss.list_('cycleway', 'fix:survey'), title = mapcss.tr('Opposite or opposite lane in the same way of the oneway'))
self.errors[20805] = self.def_class(item = 2080, level = 3, tags = mapcss.list_('tag', 'highway') + mapcss.list_('footway', 'fix:chair'), title = mapcss.tr('{0} without {1}', mapcss._tag_uncapture(capture_tags, '{0.tag}'), 'highway=footway|construction'))
self.errors[30328] = self.def_class(item = 3032, level = 2, tags = mapcss.list_('tag', 'highway') + mapcss.list_('cycleway', 'fix:chair'), title = mapcss.tr('{0} with {1}', mapcss._tag_uncapture(capture_tags, '{0.tag}'), mapcss._tag_uncapture(capture_tags, '{1.tag}')))
self.errors[30329] = self.def_class(item = 3032, level = 2, tags = mapcss.list_('tag', 'highway') + mapcss.list_('fix:chair'), title = mapcss.tr('{0} with {1}', mapcss._tag_uncapture(capture_tags, '{0.tag}'), mapcss._tag_uncapture(capture_tags, '{1.tag}')))
self.errors[40101] = self.def_class(item = 4010, level = 2, tags = mapcss.list_('tag', 'highway') + mapcss.list_('fix:chair'), title = mapcss.tr('{0} is preferred to {1}', mapcss._tag_uncapture(capture_tags, '{2.tag}'), mapcss._tag_uncapture(capture_tags, '{1.tag}')))
self.errors[40301] = self.def_class(item = 4030, level = 2, tags = mapcss.list_('tag', 'highway') + mapcss.list_('cycleway', 'fix:chair'), title = mapcss.tr('{0} with {1} and {2}', mapcss._tag_uncapture(capture_tags, '{0.key}'), mapcss._tag_uncapture(capture_tags, '{1.key}'), mapcss._tag_uncapture(capture_tags, '{2.key}')))
self.re_1825c777 = re.compile(r'footway|construction')
self.re_5b286a0d = re.compile(r'no|use_sidepath')
self.re_6781a1fd = re.compile(r'no|none|separate')
self.re_67b51e41 = re.compile(r'opposite|opposite_lane')
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 init(self, logger):
super().init(logger)
tags = capture_tags = {} # noqa
self.errors[9008005] = self.def_class(item = 9008, level = 3, tags = ["tag"], title = mapcss.tr('{0}', mapcss._tag_uncapture(capture_tags, '{0.tag}')))
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 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["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 init(self, logger):
super().init(logger)
tags = capture_tags = {} # noqa
self.errors[9004001] = self.def_class(
item=9004,
level=3,
tags=["tag", "highway"],
title=mapcss.tr(u'abbreviated street name'))
self.errors[9004002] = self.def_class(
item=9004,
level=3,
tags=["tag", "highway"],
title=mapcss.tr(u'wrong crossing tag on a way'))
self.errors[9004004] = self.def_class(
item=9004,
level=3,
tags=["tag", "highway"],
title=mapcss.tr(u'Unspecific highway type'))
self.errors[9004005] = self.def_class(
item=9004,
level=3,
tags=["tag", "highway"],
title=mapcss.tr(u'{0} used with {1}',
mapcss._tag_uncapture(capture_tags, u'{0.value}'),
mapcss._tag_uncapture(capture_tags, u'{1.tag}')))
self.errors[9004006] = self.def_class(
item=9004,
level=3,
tags=["tag", "highway"],
title=mapcss.tr(u'deprecated tagging'))
self.errors[9004007] = self.def_class(
item=9004,
level=3,
tags=["tag", "highway"],
title=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'))
self.errors[9004008] = self.def_class(
item=9004,
level=3,
tags=["tag", "highway"],
title=mapcss.tr(u'wrong highway tag on a node'))
self.errors[9004010] = self.def_class(
item=9004,
level=3,
tags=["tag", "highway"],
title=mapcss.tr(u'{0} on a node',
mapcss._tag_uncapture(capture_tags, u'{0.tag}')))
self.re_015aabd5 = re.compile(
r'^(unclassified|residential|living_street|service)$')
self.re_3092b7ac = re.compile(r'^.*_link$')
self.re_3dc5dd7c = re.compile(
r'motorway|trunk|primary|secondary|tertiary|unclassified|residential|service|living_street|pedestrian|track|path|footway|cycleway|bus_guideway|bridleway'
)
self.re_4dcdb354 = re.compile(r'^footway:')
self.re_55ee32ac = re.compile(
r'^(motorway|trunk|primary|secondary|tertiary)$')
self.re_61bbe299 = re.compile(r'footway:')
self.re_776f2c1a = re.compile(
r'(?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)[.]?$'
)
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 = []
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 init(self, logger):
Plugin.init(self, logger)
tags = capture_tags = {}
self.errors[9003001] = {'item': 9003, 'level': 3, 'tag': ["geom"], 'desc': mapcss.tr(u'{0} on a node. Should be used on a way.', mapcss._tag_uncapture(capture_tags, u'{0.tag}'))}
self.errors[9003002] = {'item': 9003, 'level': 3, 'tag': ["geom"], 'desc': mapcss.tr(u'{0} on a node. Should be used on a way or relation.', mapcss._tag_uncapture(capture_tags, u'{0.tag}'))}
self.errors[9003003] = {'item': 9003, 'level': 3, 'tag': ["geom"], 'desc': mapcss.tr(u'{0} on a node. Should be drawn as an area.', mapcss._tag_uncapture(capture_tags, u'{0.tag}'))}
self.errors[9003004] = {'item': 9003, 'level': 2, 'tag': ["geom"], 'desc': mapcss.tr(u'{0} on a node. Should be used in a relation', mapcss._tag_uncapture(capture_tags, u'{0.tag}'))}
self.errors[9003006] = {'item': 9003, 'level': 3, 'tag': ["geom"], 'desc': mapcss.tr(u'{0} on a node', mapcss._tag_uncapture(capture_tags, u'{0.key}'))}
self.errors[9003007] = {'item': 9003, 'level': 3, 'tag': ["geom"], 'desc': mapcss.tr(u'{0} on a way. Should be used on a node.', mapcss._tag_uncapture(capture_tags, u'{0.tag}'))}
self.errors[9003008] = {'item': 9003, 'level': 2, 'tag': ["geom"], 'desc': mapcss.tr(u'{0} on a way. Should be used in a relation', mapcss._tag_uncapture(capture_tags, u'{0.tag}'))}
self.errors[9003009] = {'item': 9003, 'level': 2, 'tag': ["geom"], 'desc': mapcss.tr(u'Object at Position 0.00E 0.00N. There is nothing at this position except an already mapped weather buoy.')}
self.errors[9003010] = {'item': 9003, 'level': 2, 'tag': ["geom"], 'desc': mapcss.tr(u'Way with {0} not closed.', mapcss._tag_uncapture(capture_tags, u'{0.tag}'))}
self.re_22f56734 = re.compile(r'^(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)$')
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 = []
# 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 init(self, logger):
super().init(logger)
tags = capture_tags = {}
self.errors[9003001] = self.def_class(item = 9003, level = 3, tags = ["geom"], title = mapcss.tr(u'{0} on a node. Should be used on a way.', mapcss._tag_uncapture(capture_tags, u'{0.tag}')))
self.errors[9003002] = self.def_class(item = 9003, level = 3, tags = ["geom"], title = mapcss.tr(u'{0} on a node. Should be used on a way or relation.', mapcss._tag_uncapture(capture_tags, u'{0.tag}')))
self.errors[9003003] = self.def_class(item = 9003, level = 3, tags = ["geom"], title = mapcss.tr(u'{0} on a node. Should be drawn as an area.', mapcss._tag_uncapture(capture_tags, u'{0.tag}')))
self.errors[9003004] = self.def_class(item = 9003, level = 2, tags = ["geom"], title = mapcss.tr(u'{0} on a node. Should be used in a relation', mapcss._tag_uncapture(capture_tags, u'{0.tag}')))
self.errors[9003006] = self.def_class(item = 9003, level = 3, tags = ["geom"], title = mapcss.tr(u'{0} on a node', mapcss._tag_uncapture(capture_tags, u'{0.key}')))
self.errors[9003007] = self.def_class(item = 9003, level = 3, tags = ["geom"], title = mapcss.tr(u'{0} on a way. Should be used on a node.', mapcss._tag_uncapture(capture_tags, u'{0.tag}')))
self.errors[9003008] = self.def_class(item = 9003, level = 2, tags = ["geom"], title = mapcss.tr(u'{0} on a way. Should be used in a relation', mapcss._tag_uncapture(capture_tags, u'{0.tag}')))
self.errors[9003009] = self.def_class(item = 9003, level = 2, tags = ["geom"], title = mapcss.tr(u'Object at Position 0.00E 0.00N. There is nothing at this position except an already mapped weather buoy.'))
self.errors[9003010] = self.def_class(item = 9003, level = 2, tags = ["geom"], title = mapcss.tr(u'Way with {0} not closed.', mapcss._tag_uncapture(capture_tags, u'{0.tag}')))
self.re_22f56734 = re.compile(r'^(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)$')
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 = []
# *[name=~/ي/][language("fa")]
# *[name:fa=~/ي/]
if ('name' in keys) or ('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, 'name')))
and (mapcss.language(self.father.config.options,
'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,
'name:fa'))))
except mapcss.RuleAbort:
pass
if match:
# group:tr("Arabic letter detected in Farsi name")
# -osmoseItemClassLevel:"5010/50109001:0/2"
# throwError:tr("In Farsi, the Arabic letter '{0}' should be replaced by '{1}'","ي","ی")
# fixAdd:concat("{0.key}=",replace("{0.value}","ي","ی"))
err.append({
'class':
50109001,
'subclass':
0,
'text':
mapcss.tr(
'In Farsi, the Arabic letter \'{0}\' should be replaced by \'{1}\'',
'ي', 'ی'),
'allow_fix_override':
True,
'fix': {
'+':
dict([(mapcss.concat(
mapcss._tag_uncapture(capture_tags, '{0.key}='),
mapcss.replace(
mapcss._tag_uncapture(capture_tags,
'{0.value}'), 'ي',
'ی'))).split('=', 1)])
}
})
# *[name=~/ك/][language("fa")]
# *[name:fa=~/ك/]
if ('name' in keys) or ('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, 'name')))
and (mapcss.language(self.father.config.options,
'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,
'name:fa'))))
except mapcss.RuleAbort:
pass
if match:
# group:tr("Arabic letter detected in Farsi name")
# -osmoseItemClassLevel:"5010/50109001:1/2"
# throwError:tr("In Farsi, the Arabic letter '{0}' should be replaced by '{1}'","ك","ک")
# fixAdd:concat("{0.key}=",replace("{0.value}","ك","ک"))
err.append({
'class':
50109001,
'subclass':
1,
'text':
mapcss.tr(
'In Farsi, the Arabic letter \'{0}\' should be replaced by \'{1}\'',
'ك', 'ک'),
'allow_fix_override':
True,
'fix': {
'+':
dict([(mapcss.concat(
mapcss._tag_uncapture(capture_tags, '{0.key}='),
mapcss.replace(
mapcss._tag_uncapture(capture_tags,
'{0.value}'), 'ك',
'ک'))).split('=', 1)])
}
})
return err
