Beispiel #1
0
    def add_metatile_splitter(self):
        assert self.tilestream is not None

        splitters = {}
        for lname, layer in self.layers.items():
            if layer.get('meta'):
                splitters[lname] = MetaTileSplitterTileStore(
                    layer['mime_type'], layer['grid_ref']['tile_size'],
                    layer['meta_buffer'])

        store = TimedTileStoreWrapper(MultiTileStore(splitters),
                                      stats_name='splitter')

        if self.options.debug:

            def meta_get(tilestream):  # pragma: no cover
                for metatile in tilestream:
                    substream = store.get((metatile, ))
                    for tile in substream:
                        yield tile

            self.tilestream = meta_get(self.tilestream)  # pragma: no cover
        else:

            def safe_get(tilestream):
                for metatile in tilestream:
                    try:
                        substream = store.get((metatile, ))
                        for tile in substream:
                            yield tile
                    except GeneratorExit as e:
                        raise e

            self.tilestream = safe_get(self.tilestream)
Beispiel #2
0
    def add_metatile_splitter(self):
        class NullSplitter(TileStore):
            @staticmethod
            def get_one(tile):
                return tile

        splitters = {None: NullSplitter()}
        for lname, layer in self.layers.items():
            if layer.get('meta'):
                splitters[lname] = MetaTileSplitterTileStore(
                    layer['mime_type'],
                    layer['grid_ref']['tile_size'],
                    layer['meta_buffer'])

        store = MultiTileStore(splitters)

        if self.options.debug:
            def meta_get(tilestream):  # pragma: no cover
                for metatile in tilestream:
                    substream = store.get((metatile,))
                    for tile in substream:
                        if tile is not metatile:
                            tile.metatile = metatile
                            tile.metadata = metatile.metadata
                            if metatile.error:
                                tile.error = metatile.error
                            elif metatile.data is None:
                                tile.error = "Metatile data is empty"
                        yield tile
            self.tilestream = meta_get(self.tilestream)  # pragma: no cover
        else:
            def safe_get(tilestream):
                for metatile in tilestream:
                    try:
                        substream = store.get((metatile,))
                        for tile in substream:
                            if tile is not metatile:
                                tile.metatile = metatile
                                tile.metadata = metatile.metadata
                                if metatile.error:
                                    tile.error = metatile.error
                                elif metatile.data is None:
                                    tile.error = "Metatile data is empty"
                            yield tile
                    except GeneratorExit as e:
                        raise e
            self.tilestream = safe_get(self.tilestream)
Beispiel #3
0
    def add_metatile_splitter(self):
        store = MetaTileSplitterTileStore(self.layer['mime_type'],
                                          self.layer['grid_ref']['tile_size'],
                                          self.layer['meta_buffer'])

        if self.options.debug:

            def meta_get(tilestream):  # pragma: no cover
                for metatile in tilestream:
                    substream = store.get((metatile, ))
                    for tile in substream:
                        tile.metatile = metatile
                        yield tile

            self.tilestream = meta_get(self.tilestream)  # pragma: no cover
        else:

            def safe_get(tilestream):
                for metatile in tilestream:
                    try:
                        substream = store.get((metatile, ))
                        for tile in substream:
                            tile.metatile = metatile
                            yield tile
                    except GeneratorExit as e:
                        raise e
                    except:  # pragma: no cover
                        data = repr(metatile.data)
                        if len(data) < 2000:
                            metatile.error = str(
                                sys.exc_info()[1]) + " - " + metatile.data
                        else:

                            class NoRepr:
                                def __init__(self, value):
                                    self.value = value

                                def __repr__(self):
                                    return self.value

                            metatile.error = NoRepr(
                                repr(str(sys.exc_info()[1])) + " - " +
                                data[0:2000] + '...')
                        yield metatile

            self.tilestream = safe_get(self.tilestream)
Beispiel #4
0
 def setUp(self):
     self.mtsts = MetaTileSplitterTileStore("image/png",
                                            tile_size=2,
                                            border=2)
Beispiel #5
0
 def setUp(self):
     self.mtsts = MetaTileSplitterTileStore('image/png', tile_size=2)
Beispiel #6
0
 def setUp(self) -> None:
     self.mtsts = MetaTileSplitterTileStore("image/png", tile_size=2)