api.py

# I mean, this implementation sucks big time, but it works so what?

import json
import contextlib

from starlette.applications import Starlette
from starlette.responses import JSONResponse
from starlette.routing import Route
from starlette.exceptions import HTTPException

import sqlite3
import aiosqlite

from config import config


class Network:

    stations = None
    vehicles = None

    @staticmethod
    def from_row(row):
        n = Network()
        meta = json.loads(row['meta'])

        n.id = row['tag']
        n.name = meta.pop('name')
        n.location = {
            'latitude': meta.pop('latitude'),
            'longitude': meta.pop('longitude'),
            'city': meta.pop('city'),
            'country': meta.pop('country'),
        }

        n.href = f'{config.prefix}/networks/{n.id}'

        # over-set anything else present in meta
        for k, v in meta.items():
            setattr(n, k, v)

        return n

    def dump(self):
        rpr = dict(self.__dict__)

        if self.stations:
            rpr['stations'] = [s.dump() for s in self.stations]
        if self.vehicles:
            rpr['vehicles'] = [v.dump() for v in self.vehicles]

        return rpr


class Station:

    @staticmethod
    def from_row(row):
        n = Station()
        stat = json.loads(row['stat'])
        row.update(stat)

        n.id = row['hash']
        n.name = row['name']
        n.latitude = row['latitude']
        n.longitude = row['longitude']
        n.timestamp = row['timestamp'] + 'Z'
        n.free_bikes = row['bikes']
        n.empty_slots = row['free']
        n.extra = row['extra']

        return n

    def dump(self):
        return self.__dict__


class Vehicle:

    @staticmethod
    def from_row(row):
        n = Vehicle()
        stat = json.loads(row['stat'])
        row.update(stat)

        n.id = row['hash']
        n.latitude = row['latitude']
        n.longitude = row['longitude']
        n.timestamp = row['timestamp'] + 'Z'
        n.extra = row['extra']
        n.kind = row['kind']

        return n

    def dump(self):
        return self.__dict__


def named_params(handler):
    async def _handler(request):
        args = request.path_params
        r = await handler(request, ** args)
        return r
    return _handler


# Good enough
def ffilter(obj, query, prefix=''):


    def deep_merge(* dicts):
        """ naive recursive of dicts and only dicts """
        def merge(d1, d2):
            r = dict(d1)
            for k, v in d2.items():
                if k in r:
                    if isinstance(r[k], dict):
                        r[k] = merge(r[k], v)
                    else:
                        r[k] = v
                else:
                    r[k] = v
            return r

        res = {}
        for d in dicts:
            res = merge(res, d)

        return res

    result = type(obj)()

    def _filter(obj, query, target):
        if not query:
            return

        _query = query.split('.', 1)
        h, r = _query.pop(0), ''.join(_query)

        if isinstance(obj, dict):
            if h not in obj:
                return

            body = obj[h]

            if r == "":
                target[h] = body

                return

            if h not in target:
                target[h] = type(obj[h])()

            _filter(body, r, target[h])

        elif isinstance(obj, list):
            body = []
            for thing in obj:
                t = {}
                _filter(thing, h + '.' + r, t)
                body.append(t)

            if len(target) == 0:
                target += body
            else:
                for i in range(len(target)):
                    target[i] = deep_merge(target[i], body[i])

    # Define max to bail early
    if query.count(',') > 25 or query.count('.') > 25:
        raise Exception()

    for q in map(str.strip, query.split(',')):
        q = q.removeprefix(prefix + '.')
        _filter(obj, q, result)

    return result



async def networks(request):
    db = request.app.db
    cur = await db.execute('SELECT * FROM networks ORDER BY tag')
    rows = await cur.fetchall()
    networks = [Network.from_row(r).dump() for r in rows]
    response = list(networks)
    fields = request.query_params.get('fields')
    if fields:
        try:
            response = ffilter(response, fields, 'networks')
        except:
            raise HTTPException(status_code=400)

    return JSONResponse({'networks': response})


async def network(request, uid=None):
    db = request.app.db
    cur = await db.execute("""
        SELECT * FROM networks
        WHERE tag = ?
        LIMIT 1
    """, (uid, ))
    net = await cur.fetchone()
    if not net:
        raise HTTPException(status_code=404)

    cur = await db.execute("""
        SELECT s.*
        FROM stations s
        WHERE network_tag = ?
          AND hash IN (
            SELECT value FROM networks
              JOIN json_each(networks.stations) ON networks.tag = ?
        )
        ORDER BY hash
    """, (uid, uid, ))
    stations = await cur.fetchall()

    fields = request.query_params.get('fields')

    network = Network.from_row(net)
    network.stations = [Station.from_row(row) for row in stations]

    # Do not include 'vehicles' on the response if no vehicles at all
    if fields and 'vehicles' in fields:
        cur = await db.execute("""
            SELECT v.*
            FROM vehicles v
            WHERE network_tag = ?
              AND hash IN (
                  SELECT value FROM networks
                  JOIN json_each(networks.vehicles) ON networks.tag = ?
            )
            ORDER BY hash
        """, (uid, uid, ))
        vehicles = await cur.fetchall()

        if vehicles:
            network.vehicles = [Vehicle.from_row(row) for row in vehicles]

    response = network.dump()

    if fields:
        try:
            response = ffilter(response, fields, 'network')
        except:
            raise HTTPException(status_code=400)

    return JSONResponse({'network': response})


async def station(request, uid=None, suid=None):
    if not uid or not suid:
        raise HTTPException(status_code=400)

    db = request.app.db
    cur = await db.execute("""
        SELECT * FROM stations
        WHERE network_tag = ?
        AND hash = ?
    """, (uid, suid, ))
    row = await cur.fetchone()
    if not row:
        raise HTTPException(status_code=404)
    station = Station.from_row(row).dump()

    fields = request.query_params.get('fields')
    if fields:
        try:
            station = ffilter(station, fields, 'station')
        except:
            raise HTTPException(status_code=400)

    return JSONResponse({"station": station})


async def home(request):
    return JSONResponse({'hello': 'world'})


from citybikes.db.asyncio import CBD, get_session, migrate

@contextlib.asynccontextmanager
async def lifespan(app):
    async with get_session(config.db_uri) as db:
        assert await migrate(db)
        app.db = CBD(db)
        yield


routes = [
    Route('/', home),
    Route('/networks', networks),
    # XXX this until we fix ROOT_PATH uvicorn/gunicorn NONSENSE
    Route('/networks/', networks),
    Route('/networks/{uid}', named_params(network)),
    Route('/networks/{uid}/stations/{suid}', named_params(station)),
]

app = Starlette(
    debug=config.debug,
    routes=routes,
    lifespan=lifespan,
)