def testNeighbor(self):
geog = Geography(couples)
italyNeigh = sorted(geog.neighbors('Italy'))
self.assertEqual(["Croatia", "France", "Switzerland"], italyNeigh)
franceNeigh = sorted(geog.neighbors('France'))
self.assertEqual(["Belgium", "Germany", "Italy", "Switzerland"], franceNeigh)
belgiumNeigh = sorted(geog.neighbors('Belgium'))
self.assertEqual(["France", "Germany"], belgiumNeigh)
def __init__(self, layer, mapfile, fonts=None, projection = "spherical mercator"):
""" Initialize Mapnik provider with layer and mapfile.
XML mapfile keyword arg comes from TileStache config
"""
maphref = urljoin(layer.config.dirpath, mapfile)
scheme, h, path, q, p, f = urlparse(maphref)
if scheme in ('file', ''):
self.mapfile = path
else:
self.mapfile = maphref
self.layer = layer
self.mapnik = None
engine = mapnik.FontEngine.instance()
if fonts:
fontshref = urljoin(layer.config.dirpath, fonts)
scheme, h, path, q, p, f = urlparse(fontshref)
if scheme not in ('file', ''):
raise Exception('Fonts from "%s" can\'t be used by Mapnik' % fontshref)
for font in glob(path.rstrip('/') + '/*.ttf'):
engine.register_font(str(font))
self.projection = Geography.getProjectionByName(projection)
def prepareKeywordArgs(config_dict):
""" Convert configured parameters to keyword args for __init__().
"""
kwargs = {'template': config_dict['template']}
if 'referer' in config_dict:
kwargs['referer'] = config_dict['referer']
if 'source projection' in config_dict:
kwargs['source_projection'] = Geography.getProjectionByName(config_dict['source projection'])
if 'timeout' in config_dict:
kwargs['timeout'] = config_dict['timeout']
return kwargs
class MyTestCase(unittest.TestCase):
city_name = "eesti"
city_code = 372
mainObj = mainGeo.Geography(name=city_name, code=city_code)
city_name = "dsfgsfdg"
city_code = 44444
mainObj2 = mainGeo.Geography(name=city_name, code=city_code)
def test_city(self):
cname = self.mainObj.get_capital_city()
self.assertEqual("Tallinn", cname)
def test_city_negative(self):
cname = self.mainObj2.get_capital_city()
self.assertEqual("Invalid City name or City Not Found", cname)
def test_code(self):
ccode = self.mainObj.get_capital_city()
self.assertEqual("Tallinn", ccode)
def test_code_negative(self):
ccode = self.mainObj2.get_capital_city()
self.assertEqual("Invalid City name or City Not Found", ccode)
def prepareKeywordArgs(config_dict):
""" Convert configured parameters to keyword args for __init__().
"""
kwargs = {'template': config_dict['template']}
if 'referer' in config_dict:
kwargs['referer'] = config_dict['referer']
if 'source projection' in config_dict:
kwargs['source_projection'] = Geography.getProjectionByName(
config_dict['source projection'])
if 'timeout' in config_dict:
kwargs['timeout'] = config_dict['timeout']
return kwargs
def SurroundingRegion(self,
Point,
UTCTimestamp,
MaxDistanceDifference=100,
Above25000=True):
Return = []
for Waypoint in self.Waypoints:
DistanceToWaypointKilometers = Geography.DistanceBetweenPoints(
Waypoint["Position"], Point)
# if the time difference is < 1 hour, the distance is < 50, and the altitude is > 25000
if (
(Above25000 and Waypoint["Altitude"] > 25000) or
(not Above25000 and Waypoint["Altitude"] < 25000)
) and DistanceToWaypointKilometers <= MaxDistanceDifference and abs(
UTCTimestamp - Waypoint["Timestamp"]) < 3600:
WindVector = Geometry.VectorFromSpeedBearing(
Waypoint["WindSpeed"], Waypoint["WindDirection"])
Return.append(WindVector)
return Return
def _parseConfigfileLayer(layer_dict, config, dirpath):
""" Used by parseConfigfile() to parse just the layer parts of a config.
"""
projection = layer_dict.get('projection', 'spherical mercator')
projection = Geography.getProjectionByName(projection)
#
# Add cache lock timeouts and preview arguments
#
layer_kwargs = {}
if 'cache lifespan' in layer_dict:
layer_kwargs['cache_lifespan'] = int(layer_dict['cache lifespan'])
if 'stale lock timeout' in layer_dict:
layer_kwargs['stale_lock_timeout'] = int(
layer_dict['stale lock timeout'])
if 'write cache' in layer_dict:
layer_kwargs['write_cache'] = bool(layer_dict['write cache'])
if 'allowed origin' in layer_dict:
layer_kwargs['allowed_origin'] = str(layer_dict['allowed origin'])
if 'maximum cache age' in layer_dict:
layer_kwargs['max_cache_age'] = int(layer_dict['maximum cache age'])
if 'redirects' in layer_dict:
layer_kwargs['redirects'] = dict(layer_dict['redirects'])
if 'tile height' in layer_dict:
layer_kwargs['tile_height'] = int(layer_dict['tile height'])
if 'preview' in layer_dict:
preview_dict = layer_dict['preview']
for (key, func) in zip(('lat', 'lon', 'zoom', 'ext'),
(float, float, int, str)):
if key in preview_dict:
layer_kwargs['preview_' + key] = func(preview_dict[key])
#
# Do the bounds
#
if 'bounds' in layer_dict:
if type(layer_dict['bounds']) is dict:
layer_kwargs['bounds'] = _parseLayerBounds(layer_dict['bounds'],
projection)
elif type(layer_dict['bounds']) is list:
bounds = [
_parseLayerBounds(b, projection) for b in layer_dict['bounds']
]
layer_kwargs['bounds'] = BoundsList(bounds)
else:
raise Core.KnownUnknown(
'Layer bounds must be a dictionary, not: ' +
dumps(layer_dict['bounds']))
#
# Do the metatile
#
meta_dict = layer_dict.get('metatile', {})
metatile_kwargs = {}
for k in ('buffer', 'rows', 'columns'):
if k in meta_dict:
metatile_kwargs[k] = int(meta_dict[k])
metatile = Core.Metatile(**metatile_kwargs)
#
# Do the per-format options
#
jpeg_kwargs = {}
png_kwargs = {}
if 'jpeg options' in layer_dict:
jpeg_kwargs = dict([(str(k), v)
for (k, v) in layer_dict['jpeg options'].items()])
if 'png options' in layer_dict:
png_kwargs = dict([(str(k), v)
for (k, v) in layer_dict['png options'].items()])
#
# Do the provider
#
provider_dict = layer_dict['provider']
if 'name' in provider_dict:
_class = Providers.getProviderByName(provider_dict['name'])
provider_kwargs = _class.prepareKeywordArgs(provider_dict)
elif 'class' in provider_dict:
_class = loadClassPath(provider_dict['class'])
provider_kwargs = provider_dict.get('kwargs', {})
provider_kwargs = dict([(str(k), v)
for (k, v) in provider_kwargs.items()])
else:
raise Exception('Missing required provider name or class: %s' %
json_dumps(provider_dict))
#
# Finish him!
#
layer = Core.Layer(config, projection, metatile, **layer_kwargs)
layer.provider = _class(layer, **provider_kwargs)
layer.setSaveOptionsJPEG(**jpeg_kwargs)
layer.setSaveOptionsPNG(**png_kwargs)
return layer
def _parseConfigfileLayer(layer_dict, config, dirpath):
""" Used by parseConfigfile() to parse just the layer parts of a config.
"""
projection = layer_dict.get('projection', 'spherical mercator')
projection = Geography.getProjectionByName(projection)
#
# Add cache lock timeouts and preview arguments
#
layer_kwargs = {}
if 'cache lifespan' in layer_dict:
layer_kwargs['cache_lifespan'] = int(layer_dict['cache lifespan'])
if 'stale lock timeout' in layer_dict:
layer_kwargs['stale_lock_timeout'] = int(layer_dict['stale lock timeout'])
if 'write cache' in layer_dict:
layer_kwargs['write_cache'] = bool(layer_dict['write cache'])
if 'allowed origin' in layer_dict:
layer_kwargs['allowed_origin'] = str(layer_dict['allowed origin'])
if 'maximum cache age' in layer_dict:
layer_kwargs['max_cache_age'] = int(layer_dict['maximum cache age'])
if 'redirects' in layer_dict:
layer_kwargs['redirects'] = dict(layer_dict['redirects'])
if 'preview' in layer_dict:
preview_dict = layer_dict['preview']
for (key, func) in zip(('lat', 'lon', 'zoom', 'ext'), (float, float, int, str)):
if key in preview_dict:
layer_kwargs['preview_' + key] = func(preview_dict[key])
#
# Do the bounds
#
if 'bounds' in layer_dict:
if type(layer_dict['bounds']) is dict:
layer_kwargs['bounds'] = _parseLayerBounds(layer_dict['bounds'], projection)
elif type(layer_dict['bounds']) is list:
bounds = [_parseLayerBounds(b, projection) for b in layer_dict['bounds']]
layer_kwargs['bounds'] = BoundsList(bounds)
else:
raise Core.KnownUnknown('Layer bounds must be a dictionary, not: ' + dumps(layer_dict['bounds']))
#
# Do the metatile
#
meta_dict = layer_dict.get('metatile', {})
metatile_kwargs = {}
for k in ('buffer', 'rows', 'columns'):
if k in meta_dict:
metatile_kwargs[k] = int(meta_dict[k])
metatile = Core.Metatile(**metatile_kwargs)
#
# Do the per-format options
#
jpeg_kwargs = {}
png_kwargs = {}
if 'jpeg options' in layer_dict:
jpeg_kwargs = dict([(str(k), v) for (k, v) in layer_dict['jpeg options'].items()])
if 'png options' in layer_dict:
png_kwargs = dict([(str(k), v) for (k, v) in layer_dict['png options'].items()])
#
# Do the provider
#
provider_dict = layer_dict['provider']
if 'name' in provider_dict:
_class = Providers.getProviderByName(provider_dict['name'])
provider_kwargs = {}
if _class is Providers.Mapnik:
provider_kwargs['mapfile'] = provider_dict['mapfile']
provider_kwargs['fonts'] = provider_dict.get('fonts', None)
elif _class is Providers.Proxy:
if 'url' in provider_dict:
provider_kwargs['url'] = provider_dict['url']
if 'provider' in provider_dict:
provider_kwargs['provider_name'] = provider_dict['provider']
elif _class is Providers.UrlTemplate:
provider_kwargs['template'] = provider_dict['template']
if 'referer' in provider_dict:
provider_kwargs['referer'] = provider_dict['referer']
elif _class is Providers.Vector.Provider:
provider_kwargs['driver'] = provider_dict['driver']
provider_kwargs['parameters'] = provider_dict['parameters']
provider_kwargs['properties'] = provider_dict.get('properties', None)
provider_kwargs['projected'] = bool(provider_dict.get('projected', False))
provider_kwargs['verbose'] = bool(provider_dict.get('verbose', False))
provider_kwargs['precision'] = int(provider_dict.get('precision', 6))
if 'spacing' in provider_dict:
provider_kwargs['spacing'] = float(provider_dict.get('spacing', 0.0))
else:
provider_kwargs['spacing'] = None
if provider_dict.get('clipped', None) == 'padded':
provider_kwargs['clipped'] = 'padded'
else:
provider_kwargs['clipped'] = bool(provider_dict.get('clipped', True))
elif _class is Providers.MBTiles.Provider:
provider_kwargs['tileset'] = provider_dict['tileset']
elif 'class' in provider_dict:
_class = loadClassPath(provider_dict['class'])
provider_kwargs = provider_dict.get('kwargs', {})
provider_kwargs = dict( [(str(k), v) for (k, v) in provider_kwargs.items()] )
else:
raise Exception('Missing required provider name or class: %s' % json_dumps(provider_dict))
#
# Finish him!
#
layer = Core.Layer(config, projection, metatile, **layer_kwargs)
layer.provider = _class(layer, **provider_kwargs)
layer.setSaveOptionsJPEG(**jpeg_kwargs)
layer.setSaveOptionsPNG(**png_kwargs)
return layer
def _parseConfigfileLayer(layer_dict, config, dirpath):
""" Used by parseConfigfile() to parse just the layer parts of a config.
"""
projection = layer_dict.get("projection", "spherical mercator")
projection = Geography.getProjectionByName(projection)
#
# Add cache lock timeouts and preview arguments
#
layer_kwargs = {}
if "cache lifespan" in layer_dict:
layer_kwargs["cache_lifespan"] = int(layer_dict["cache lifespan"])
if "stale lock timeout" in layer_dict:
layer_kwargs["stale_lock_timeout"] = int(layer_dict["stale lock timeout"])
if "write cache" in layer_dict:
layer_kwargs["write_cache"] = bool(layer_dict["write cache"])
if "allowed origin" in layer_dict:
layer_kwargs["allowed_origin"] = str(layer_dict["allowed origin"])
if "maximum cache age" in layer_dict:
layer_kwargs["max_cache_age"] = int(layer_dict["maximum cache age"])
if "redirects" in layer_dict:
layer_kwargs["redirects"] = dict(layer_dict["redirects"])
if "tile height" in layer_dict:
layer_kwargs["tile_height"] = int(layer_dict["tile height"])
if "preview" in layer_dict:
preview_dict = layer_dict["preview"]
for (key, func) in zip(("lat", "lon", "zoom", "ext"), (float, float, int, str)):
if key in preview_dict:
layer_kwargs["preview_" + key] = func(preview_dict[key])
#
# Do the bounds
#
if "bounds" in layer_dict:
if type(layer_dict["bounds"]) is dict:
layer_kwargs["bounds"] = _parseLayerBounds(layer_dict["bounds"], projection)
elif type(layer_dict["bounds"]) is list:
bounds = [_parseLayerBounds(b, projection) for b in layer_dict["bounds"]]
layer_kwargs["bounds"] = BoundsList(bounds)
else:
raise Core.KnownUnknown("Layer bounds must be a dictionary, not: " + dumps(layer_dict["bounds"]))
#
# Do the metatile
#
meta_dict = layer_dict.get("metatile", {})
metatile_kwargs = {}
for k in ("buffer", "rows", "columns"):
if k in meta_dict:
metatile_kwargs[k] = int(meta_dict[k])
metatile = Core.Metatile(**metatile_kwargs)
#
# Do the per-format options
#
jpeg_kwargs = {}
png_kwargs = {}
if "jpeg options" in layer_dict:
jpeg_kwargs = dict([(str(k), v) for (k, v) in layer_dict["jpeg options"].items()])
if "png options" in layer_dict:
png_kwargs = dict([(str(k), v) for (k, v) in layer_dict["png options"].items()])
#
# Do the provider
#
provider_dict = layer_dict["provider"]
if "name" in provider_dict:
_class = Providers.getProviderByName(provider_dict["name"])
provider_kwargs = _class.prepareKeywordArgs(provider_dict)
elif "class" in provider_dict:
_class = loadClassPath(provider_dict["class"])
provider_kwargs = provider_dict.get("kwargs", {})
provider_kwargs = dict([(str(k), v) for (k, v) in provider_kwargs.items()])
else:
raise Exception("Missing required provider name or class: %s" % json_dumps(provider_dict))
#
# Finish him!
#
layer = Core.Layer(config, projection, metatile, **layer_kwargs)
layer.provider = _class(layer, **provider_kwargs)
layer.setSaveOptionsJPEG(**jpeg_kwargs)
layer.setSaveOptionsPNG(**png_kwargs)
return layer
def _parseConfigfileLayer(layer_dict, config, dirpath):
""" Used by parseConfigfile() to parse just the layer parts of a config.
"""
projection = layer_dict.get('projection', 'spherical mercator')
projection = Geography.getProjectionByName(projection)
#
# Add cache lock timeouts and preview arguments
#
layer_kwargs = {}
if 'cache lifespan' in layer_dict:
layer_kwargs['cache_lifespan'] = int(layer_dict['cache lifespan'])
if 'stale lock timeout' in layer_dict:
layer_kwargs['stale_lock_timeout'] = int(
layer_dict['stale lock timeout'])
if 'write cache' in layer_dict:
layer_kwargs['write_cache'] = bool(layer_dict['write cache'])
if 'allowed origin' in layer_dict:
layer_kwargs['allowed_origin'] = str(layer_dict['allowed origin'])
if 'maximum cache age' in layer_dict:
layer_kwargs['max_cache_age'] = int(layer_dict['maximum cache age'])
if 'redirects' in layer_dict:
layer_kwargs['redirects'] = dict(layer_dict['redirects'])
if 'preview' in layer_dict:
preview_dict = layer_dict['preview']
for (key, func) in zip(('lat', 'lon', 'zoom', 'ext'),
(float, float, int, str)):
if key in preview_dict:
layer_kwargs['preview_' + key] = func(preview_dict[key])
#
# Do the bounds
#
if 'bounds' in layer_dict:
if type(layer_dict['bounds']) is dict:
layer_kwargs['bounds'] = _parseLayerBounds(layer_dict['bounds'],
projection)
elif type(layer_dict['bounds']) is list:
bounds = [
_parseLayerBounds(b, projection) for b in layer_dict['bounds']
]
layer_kwargs['bounds'] = BoundsList(bounds)
else:
raise Core.KnownUnknown(
'Layer bounds must be a dictionary, not: ' +
dumps(layer_dict['bounds']))
#
# Do the metatile
#
meta_dict = layer_dict.get('metatile', {})
metatile_kwargs = {}
for k in ('buffer', 'rows', 'columns'):
if k in meta_dict:
metatile_kwargs[k] = int(meta_dict[k])
metatile = Core.Metatile(**metatile_kwargs)
#
# Do the per-format options
#
jpeg_kwargs = {}
png_kwargs = {}
if 'jpeg options' in layer_dict:
jpeg_kwargs = dict([(str(k), v)
for (k, v) in layer_dict['jpeg options'].items()])
if 'png options' in layer_dict:
png_kwargs = dict([(str(k), v)
for (k, v) in layer_dict['png options'].items()])
#
# Do the provider
#
provider_dict = layer_dict['provider']
if 'name' in provider_dict:
_class = Providers.getProviderByName(provider_dict['name'])
provider_kwargs = {}
if _class is Providers.MapnikImage:
provider_kwargs['mapfile'] = provider_dict['mapfile']
provider_kwargs['fonts'] = provider_dict.get('fonts', None)
elif _class is Providers.Proxy:
if 'url' in provider_dict:
provider_kwargs['url'] = provider_dict['url']
if 'provider' in provider_dict:
provider_kwargs['provider_name'] = provider_dict['provider']
elif _class is Providers.UrlTemplate:
provider_kwargs['template'] = provider_dict['template']
if 'referer' in provider_dict:
provider_kwargs['referer'] = provider_dict['referer']
elif _class is Providers.Vector.Provider:
provider_kwargs['driver'] = provider_dict['driver']
provider_kwargs['parameters'] = provider_dict['parameters']
provider_kwargs['id_property'] = provider_dict.get(
'id_property', None)
provider_kwargs['properties'] = provider_dict.get(
'properties', None)
provider_kwargs['projected'] = bool(
provider_dict.get('projected', False))
provider_kwargs['verbose'] = bool(
provider_dict.get('verbose', False))
provider_kwargs['precision'] = int(
provider_dict.get('precision', 6))
if 'spacing' in provider_dict:
provider_kwargs['spacing'] = float(
provider_dict.get('spacing', 0.0))
else:
provider_kwargs['spacing'] = None
if provider_dict.get('clipped', None) == 'padded':
provider_kwargs['clipped'] = 'padded'
else:
provider_kwargs['clipped'] = bool(
provider_dict.get('clipped', True))
elif _class is Providers.MBTiles.Provider:
provider_kwargs['tileset'] = provider_dict['tileset']
elif _class is Providers.MapnikGrid:
provider_kwargs['mapfile'] = provider_dict['mapfile']
if 'layers' in provider_dict:
provider_kwargs['layers'] = provider_dict['layers']
if 'fields' in provider_dict:
provider_kwargs['fields'] = provider_dict['fields']
if 'layer index' in provider_dict:
provider_kwargs['layer_index'] = provider_dict['layer index']
if 'scale' in provider_dict:
provider_kwargs['scale'] = provider_dict['scale']
elif 'class' in provider_dict:
_class = loadClassPath(provider_dict['class'])
provider_kwargs = provider_dict.get('kwargs', {})
provider_kwargs = dict([(str(k), v)
for (k, v) in provider_kwargs.items()])
else:
raise Exception('Missing required provider name or class: %s' %
json_dumps(provider_dict))
#
# Finish him!
#
layer = Core.Layer(config, projection, metatile, **layer_kwargs)
layer.provider = _class(layer, **provider_kwargs)
layer.setSaveOptionsJPEG(**jpeg_kwargs)
layer.setSaveOptionsPNG(**png_kwargs)
return layer
def _parseConfigfileLayer(layer_dict, config, dirpath):
""" Used by parseConfigfile() to parse just the layer parts of a config.
"""
projection = layer_dict.get('projection', 'spherical mercator')
projection = Geography.getProjectionByName(projection)
#
# Add cache lock timeouts and preview arguments
#
layer_kwargs = {}
if layer_dict.has_key('stale lock timeout'):
layer_kwargs['stale_lock_timeout'] = int(layer_dict['stale lock timeout'])
if layer_dict.has_key('preview'):
preview_dict = layer_dict['preview']
for (key, func) in zip(('lat', 'lon', 'zoom', 'ext'), (float, float, int, str)):
if key in preview_dict:
layer_kwargs['preview_' + key] = func(preview_dict[key])
#
# Do the metatile
#
meta_dict = layer_dict.get('metatile', {})
metatile_kwargs = {}
for k in ('buffer', 'rows', 'columns'):
if meta_dict.has_key(k):
metatile_kwargs[k] = int(meta_dict[k])
metatile = Core.Metatile(**metatile_kwargs)
#
# Do the provider
#
provider_dict = layer_dict['provider']
if provider_dict.has_key('name'):
_class = Providers.getProviderByName(provider_dict['name'])
provider_kwargs = {}
if _class is Providers.Mapnik:
provider_kwargs['mapfile'] = provider_dict['mapfile']
provider_kwargs['fonts'] = provider_dict.get('fonts', None)
elif _class is Providers.Proxy:
if provider_dict.has_key('url'):
provider_kwargs['url'] = provider_dict['url']
if provider_dict.has_key('provider'):
provider_kwargs['provider_name'] = provider_dict['provider']
elif _class is Providers.UrlTemplate:
provider_kwargs['template'] = provider_dict['template']
elif provider_dict.has_key('class'):
_class = loadClassPath(provider_dict['class'])
provider_kwargs = provider_dict.get('kwargs', {})
provider_kwargs = dict( [(str(k), v) for (k, v) in provider_kwargs.items()] )
else:
raise Exception('Missing required provider name or class: %s' % json_dumps(provider_dict))
#
# Finish him!
#
layer = Core.Layer(config, projection, metatile, **layer_kwargs)
layer.provider = _class(layer, **provider_kwargs)
return layer
def _parseConfigfileLayer(layer_dict, config, dirpath):
""" Used by parseConfigfile() to parse just the layer parts of a config.
"""
projection = layer_dict.get('projection', 'spherical mercator')
projection = Geography.getProjectionByName(projection)
#
# Add cache lock timeouts and preview arguments
#
layer_kwargs = {}
if 'cache lifespan' in layer_dict:
layer_kwargs['cache_lifespan'] = int(layer_dict['cache lifespan'])
if 'stale lock timeout' in layer_dict:
layer_kwargs['stale_lock_timeout'] = int(layer_dict['stale lock timeout'])
if 'write cache' in layer_dict:
layer_kwargs['write_cache'] = bool(layer_dict['write cache'])
if 'allowed origin' in layer_dict:
layer_kwargs['allowed_origin'] = str(layer_dict['allowed origin'])
if 'maximum cache age' in layer_dict:
layer_kwargs['max_cache_age'] = int(layer_dict['maximum cache age'])
if 'redirects' in layer_dict:
layer_kwargs['redirects'] = dict(layer_dict['redirects'])
if 'tile height' in layer_dict:
layer_kwargs['tile_height'] = int(layer_dict['tile height'])
if 'preview' in layer_dict:
preview_dict = layer_dict['preview']
for (key, func) in zip(('lat', 'lon', 'zoom', 'ext'), (float, float, int, str)):
if key in preview_dict:
layer_kwargs['preview_' + key] = func(preview_dict[key])
#
# Do the bounds
#
if 'bounds' in layer_dict:
if type(layer_dict['bounds']) is dict:
layer_kwargs['bounds'] = _parseLayerBounds(layer_dict['bounds'], projection)
elif type(layer_dict['bounds']) is list:
bounds = [_parseLayerBounds(b, projection) for b in layer_dict['bounds']]
layer_kwargs['bounds'] = BoundsList(bounds)
else:
raise Core.KnownUnknown('Layer bounds must be a dictionary, not: ' + dumps(layer_dict['bounds']))
#
# Do the metatile
#
meta_dict = layer_dict.get('metatile', {})
metatile_kwargs = {}
for k in ('buffer', 'rows', 'columns'):
if k in meta_dict:
metatile_kwargs[k] = int(meta_dict[k])
metatile = Core.Metatile(**metatile_kwargs)
#
# Do the per-format options
#
jpeg_kwargs = {}
png_kwargs = {}
if 'jpeg options' in layer_dict:
jpeg_kwargs = dict([(str(k), v) for (k, v) in layer_dict['jpeg options'].items()])
if 'png options' in layer_dict:
png_kwargs = dict([(str(k), v) for (k, v) in layer_dict['png options'].items()])
#
# Do pixel effect
#
pixel_effect = None
if 'pixel effect' in layer_dict:
pixel_effect_dict = layer_dict['pixel effect']
pixel_effect_name = pixel_effect_dict.get('name')
if pixel_effect_name in PixelEffects.all:
pixel_effect_kwargs = {}
for k, v in pixel_effect_dict.items():
if k != 'name':
pixel_effect_kwargs[str(k)] = float(v)
PixelEffectClass = PixelEffects.all[pixel_effect_name]
pixel_effect = PixelEffectClass(**pixel_effect_kwargs)
#
# Do the provider
#
provider_dict = layer_dict['provider']
if 'name' in provider_dict:
_class = Providers.getProviderByName(provider_dict['name'])
provider_kwargs = _class.prepareKeywordArgs(provider_dict)
elif 'class' in provider_dict:
_class = loadClassPath(provider_dict['class'])
provider_kwargs = provider_dict.get('kwargs', {})
provider_kwargs = dict( [(str(k), v) for (k, v) in provider_kwargs.items()] )
else:
raise Exception('Missing required provider name or class: %s' % json_dumps(provider_dict))
#
# Finish him!
#
layer = Core.Layer(config, projection, metatile, **layer_kwargs)
layer.provider = _class(layer, **provider_kwargs)
layer.setSaveOptionsJPEG(**jpeg_kwargs)
layer.setSaveOptionsPNG(**png_kwargs)
layer.pixel_effect = pixel_effect
return layer
def _parseConfigfileLayer(layer_dict, config, dirpath):
""" Used by parseConfigfile() to parse just the layer parts of a config.
"""
projection = layer_dict.get('projection', 'spherical mercator')
projection = Geography.getProjectionByName(projection)
#
# Add cache lock timeouts
#
layer_kwargs = {}
if layer_dict.has_key('stale lock timeout'):
layer_kwargs['stale_lock_timeout'] = int(layer_dict['stale lock timeout'])
#
# Do the metatile
#
meta_dict = layer_dict.get('metatile', {})
metatile_kwargs = {}
for k in ('buffer', 'rows', 'columns'):
if meta_dict.has_key(k):
metatile_kwargs[k] = int(meta_dict[k])
metatile = Core.Metatile(**metatile_kwargs)
#
# Do the provider
#
provider_dict = layer_dict['provider']
if provider_dict.has_key('name'):
_class = Providers.getProviderByName(provider_dict['name'])
provider_kwargs = {}
if _class is Providers.Mapnik:
mapfile = provider_dict['mapfile']
provider_kwargs['mapfile'] = realpath(pathjoin(dirpath, mapfile))
elif _class is Providers.Proxy:
if provider_dict.has_key('url'):
provider_kwargs['url'] = provider_dict['url']
if provider_dict.has_key('provider'):
provider_kwargs['provider_name'] = provider_dict['provider']
elif provider_dict.has_key('class'):
_class = loadClassPath(provider_dict['class'])
provider_kwargs = provider_dict.get('kwargs', {})
provider_kwargs = dict( [(str(k), v) for (k, v) in provider_kwargs.items()] )
else:
raise Exception('Missing required provider name or class: %s' % json_dumps(provider_dict))
#
# Finish him!
#
layer = Core.Layer(config, projection, metatile, **layer_kwargs)
layer.provider = _class(layer, **provider_kwargs)
return layer
