def __init__(self, wik_datafile):
provider = Providers.XMLfile_Provider(wik_datafile)
name = wik_datafile.split("-")[0]
print "Converting", wik_datafile, "into DICT format"
(dictname, dictfilename) = self.get_info(name, provider)
dict_object = self.create_dict_object(dictfilename)
self.process_articles(provider, dict_object)
#dict_object.addentry(GNU_FDL, ["FDL.txt"])
self.finish_dict(dict_object, provider, dictname)
self.dictzip(dictfilename)
del provider
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
