def _create_bulk_meta_tile(self, meta_tile):
"""
_create_bulk_meta_tile queries each tile of the meta tile in parallel
(using concurrent_tile_creators).
"""
tile_size = self.grid.tile_size
main_tile = Tile(meta_tile.main_tile_coord)
with self.tile_mgr.lock(main_tile):
if not all(
self.is_cached(t)
for t in meta_tile.tiles if t is not None):
async_pool = async_.Pool(
self.tile_mgr.concurrent_tile_creators)
def query_tile(coord):
try:
query = MapQuery(self.grid.tile_bbox(coord),
tile_size,
self.grid.srs,
self.tile_mgr.request_format,
dimensions=self.dimensions)
tile_image = self._query_sources(query)
if tile_image is None:
return None
if self.tile_mgr.image_opts != tile_image.image_opts:
# call as_buffer to force conversion into cache format
tile_image.as_buffer(self.tile_mgr.image_opts)
tile = Tile(coord, cacheable=tile_image.cacheable)
tile.source = tile_image
tile = self.tile_mgr.apply_tile_filter(tile)
except BlankImage:
return None
else:
return tile
tiles = []
for tile_task in async_pool.imap(
query_tile,
[t for t in meta_tile.tiles if t is not None],
use_result_objects=True,
):
if tile_task.exception is None:
tile = tile_task.result
if tile is not None:
tiles.append(tile)
else:
ex = tile_task.exception
async_pool.shutdown(True)
reraise(ex)
self.cache.store_tiles([t for t in tiles if t.cacheable])
return tiles
# else
tiles = [Tile(coord) for coord in meta_tile.tiles]
self.cache.load_tiles(tiles)
return tiles
def render(self, layer_merger):
render_layers = combined_layers(self.layers, self.query)
if not render_layers: return
async_pool = async_.Pool(size=min(len(render_layers), self.concurrent_rendering))
if self.raise_source_errors:
return self._render_raise_exceptions(async_pool, render_layers, layer_merger)
else:
return self._render_capture_source_errors(async_pool, render_layers,
layer_merger)
def _create_threaded(self, create_func, tiles):
result = []
async_pool = async_.Pool(self.tile_mgr.concurrent_tile_creators)
for new_tiles in async_pool.imap(create_func, tiles):
result.extend(new_tiles)
return result
def store_tiles(self, tiles):
p = async_.Pool(min(self._concurrent_writer, len(tiles)))
p.map(self.store_tile, tiles)
def load_tiles(self, tiles, with_metadata=True):
p = async_.Pool(min(4, len(tiles)))
return all(p.map(self.load_tile, tiles))
