Metadata-Version: 1.1
Name: vision-tile-query
Version: 0.0.4
Summary: Library for creating MVT SQL query
Home-page: https://github.com/eos-vision/vision_tile_query
Author: Andrey Sorokin
Author-email: andreysrkn@eosda.com
License: Unlicense
Description-Content-Type: UNKNOWN
Description: ## EOS vision tile query library 
        
        vision_tile_query is a library for creating SQL with PostGIS As_MVT by XYZ.
        It can be used for constructing vector servers
        ## Architecture
        Vision tile query library provides PostGIS MVT SQL query with special 
        abilities. Polygon simplification and geometries count simplification 
        according to zoom level are the main features. Read more about postgis+MVT 
        https://postgis.net/docs/ST_AsMVT.html
        ### Installing
        Simple run
        ```text
        pip install vision-tile-query
        
        ``` 
        ### Usage examples
        Tile query library requires SQLalchemy table model for constructing SQL query 
        #### Flask
        Example for flask framework with sqlalchemy DB engine
        ```python
        from flask import Flask, render_template
        from sqlalchemy import create_engine
        from vision_tile_query import VisionBaseTileProcessor
        from vision_tile_query import TableManager
        
        app = Flask(__name__)
        # Connect to DB
        app.engine = create_engine('postgresql://postgres@localhost:5432/vision_db')
        table_manager = TableManager(app.engine)
        
        
        @app.route('/')
        def map_page():
            return render_template('main.html')
        
        
        @app.route('/tile/<table>/<zoom>/<x_tile>/<y_tile>.pbf')
        def get_tile(table, x_tile, y_tile, zoom):
            tile = {'x': x_tile, 'y': y_tile, 'z': zoom}
        
            # Define model
            model = table_manager.get_table_model(
                    table, 'public')
        
            tile_query = VisionBaseTileProcessor().get_tile(
                tile, model=model.__table__)
        
            # Exec query and get data
            conn = app.engine.connect()
            query = conn.execute(tile_query)
            tile = query.fetchone()
            conn.close()
        
            # Make response object
            response = app.make_response(bytes(tile[0]))
            response.headers['Content-Type'] = 'application/x-protobuf'
            response.headers['Access-Control-Allow-Origin'] = "*"
            return response
        
        
        if __name__ == '__main__':
            app.run()
        ```
        
        #### Aiohttp
        Simple aiohttp example for MVT tile server with async table manager
        ```python
        import asyncio
        import aiohttp_jinja2
        import jinja2
        import aiopg.sa
        from sqlalchemy.engine.url import URL
        from aiohttp import web
        
        from vision_tile_query import VisionBaseTileProcessor, AsyncTableManager
        
        DNS = str(URL(
            database='vision_db',
            host='localhost',
            username='postgres',
            drivername='postgres',
        ))
        
        
        async def init_pg(app):
            app['db'] = await aiopg.sa.create_engine(DNS)
            app['table_manager'] = AsyncTableManager(app['db'])
        
        
        async def close_pg_connection(app):
            app['db'].close()
            await app['db'].wait_closed()
        
        
        async def get_tile(request):
            params = dict(request.match_info)
        
            tile = {'x': int(params.get('x')),
                    'y': int(params.get('y')),
                    'z': int(params.get('z'))}
        
            # Define model
            model = await app['table_manager'].get_table_model(
                params.get('table'), 'public')
        
            tile_query = VisionBaseTileProcessor().get_tile(
                tile, model=model.__table__)
        
            async with app['db'].acquire() as conn:
                data = await conn.scalar(tile_query)
        
            response = web.Response(
                    body=bytes(data),
                    headers={
                        'Content-Type': "application/x-protobuf",
                    }
                )
            return response
        
        
        @aiohttp_jinja2.template('main.html')
        async def handle(request):
            return {'KEY': 'YOUR MAPBOX TOKEN'}
        
        
        loop = asyncio.get_event_loop()
        app = web.Application(loop=loop)
        app.add_routes([web.get("/", handle),
                        web.get("/tile/{table}/{z}/{x}/{y}.pbf", get_tile)
                        ])
        aiohttp_jinja2.setup(app, loader=jinja2.FileSystemLoader('templates'))
        
        app.update(name='vision-tile-query')
        
        # signal on app start
        app.on_startup.append(init_pg)
        # signal on app end
        app.on_cleanup.append(close_pg_connection)
        
        web.run_app(app)
        ```
        
        ### Requirements
         - mercantile==0.10.0
         - SQLAlchemy==1.1.11
         - geoalchemy2==0.4.0
Platform: UNKNOWN
Classifier: Development Status :: 4 - Beta
Classifier: Intended Audience :: Developers
Classifier: License :: Public Domain
Classifier: Operating System :: OS Independent
Classifier: Programming Language :: Python
Classifier: Programming Language :: Python :: 3
Classifier: Topic :: Database
