Skip to content

Examples and Outputs

This page shows concrete source inputs, converted output, and report excerpts.

FastAPI to Lilya Example

FastAPI input:

from fastapi import APIRouter, FastAPI
from fastapi.responses import ORJSONResponse, PlainTextResponse

app = FastAPI(openapi_url=None)
router = APIRouter()


@router.api_route(
    "/payload",
    methods=["PATCH"],
    response_class=ORJSONResponse,
    response_model=dict,
    responses={404: {"description": "missing"}},
    status_code=201,
)
async def payload():
    return {"value": 1}


@router.trace("/trace", include_in_schema=False)
async def trace_route():
    return PlainTextResponse("trace")


app.include_router(router)

Converted Lilya output:

from lilya.apps import Lilya as FastAPI
from lilya.responses import PlainText as PlainTextResponse
from lilya.routing import Router as APIRouter

app = FastAPI(enable_openapi=False)
router = APIRouter()


@router.route("/payload", methods=["PATCH"])
async def payload():
    return {"value": 1}


@router.route("/trace", include_in_schema=False, methods=["TRACE"])
async def trace_route():
    return PlainTextResponse("trace")


app.include(path="", app=router)

Flask to Lilya Example

Flask input:

from flask import Blueprint, Flask

app = Flask(__name__)
api = Blueprint("api", __name__, url_prefix="/api")


@api.route("/items", endpoint="list_items", strict_slashes=False)
def list_items():
    return {"items": []}


app.register_blueprint(api)

Converted Lilya output:

from lilya.apps import Lilya as Flask
from lilya.routing import Router as Blueprint

app = Flask()
api = Blueprint()


@api.route('/api/items', name='list_items', methods=['GET'])
def list_items():
    return {'items': []}


app.include(path='/', app=api)

Django URLConf Example

Django input:

from django.urls import include, path

from .views import health

urlpatterns = [
    path("", health, name="health"),
    path("api/", include("api.urls")),
]

Converted Lilya output:

from lilya.apps import Lilya
from lilya.routing import Include, Path
from .views import health

urlpatterns = [Path('/', health, name='health'), Include(path='/api/', app='api.urls')]
app = Lilya(routes=urlpatterns)

Litestar Example

Litestar input:

from litestar import Litestar, Router, get


@get("/health")
async def health() -> dict[str, bool]:
    return {"ok": True}


@get("")
async def list_items() -> dict[str, list[str]]:
    return {"items": []}


api = Router(path="/api", route_handlers=[list_items])
app = Litestar(route_handlers=[health, api])

Converted Lilya output:

from lilya.apps import Lilya as Litestar
from lilya.routing import Router, Path, Include


async def health() -> dict[str, bool]:
    return {'ok': True}


async def list_items() -> dict[str, list[str]]:
    return {'items': []}


api = Router(routes=[Path('/', list_items, methods=['GET'])])
app = Litestar(routes=[Path('/health', health, methods=['GET']), Include(path='/api', app=api)])

Starlette Example

Starlette input:

from starlette.applications import Starlette
from starlette.routing import Mount, Route


async def homepage(request):
    return None


async def users(request):
    return None


api = Starlette(routes=[Route("/users", users)])
routes = [Route("", homepage), Mount("/api", app=api)]
app = Starlette(debug=True, routes=routes)
app.mount("", app=api)
app.add_route("", route=homepage, methods=["GET"])

Converted Lilya output:

from lilya.apps import Lilya as Starlette
from lilya.routing import Include as Mount, Path as Route


async def homepage(request):
    return None


async def users(request):
    return None


api = Starlette(routes=[Route('/users', users)])
routes = [Route('/', homepage), Mount('/api', app=api)]
app = Starlette(debug=True, routes=routes)
app.include(path='/', app=api)
app.add_route(path='/', handler=homepage, methods=['GET'])

Example Analyze Output

$ lilya-converter analyze ./flask_project --source flask
Source framework: flask
Source root: /workspace/flask_project
Files scanned: 3
Routes detected: 4
Diagnostics: 0
- app/main.py: apps=2 routes=2 includes=1
- app/admin.py: apps=1 routes=1 includes=0
- app/api.py: apps=1 routes=1 includes=0

Example scan.json Excerpt

{
  "source_root": "/workspace/flask_project",
  "modules": [
    {
      "relative_path": "app/main.py",
      "app_instances": [
        {"name": "app", "kind": "Flask", "line": 3, "prefix_expr": null},
        {"name": "api", "kind": "Blueprint", "line": 4, "prefix_expr": "'/api'"}
      ],
      "routes": [
        {
          "function_name": "list_items",
          "owner": "api",
          "method": "route",
          "path": "'/items'",
          "line": 7
        }
      ],
      "include_routers": [
        {"owner": "app", "router_expr": "api", "prefix_expr": null, "line": 11}
      ]
    }
  ],
  "diagnostics": []
}

Example convert.json Excerpt

{
  "source_root": "/workspace/flask_project",
  "target_root": "/workspace/lilya_project",
  "dry_run": false,
  "files_total": 3,
  "files_changed": 2,
  "files_written": 3,
  "applied_rules": [
    "blueprint_prefix_extracted",
    "blueprint_prefix_to_route_path",
    "flask_imports_to_lilya",
    "flask_constructor_sanitized",
    "flask_route_default_methods",
    "flask_route_endpoint_to_name",
    "flask_route_kwargs_filtered",
    "register_blueprint_to_include"
  ],
  "diagnostics": [
    {
      "code": "convert.flask.route_kwargs_removed",
      "message": "Removed unsupported Flask route kwargs on 'list_items': strict_slashes",
      "severity": "warning",
      "file": "app/main.py",
      "line": 7
    }
  ]
}

Example verify.json Excerpt

{
  "target_root": "/workspace/lilya_project",
  "diagnostics": [
    {
      "code": "verify.flask_import_remaining",
      "severity": "warning",
      "message": "Flask imports are still present after conversion.",
      "file": "app/legacy.py"
    }
  ]
}

Reading The Reports

  1. Use scan.json to confirm route/include detection before conversion.
  2. Use convert.json to inspect rule application and warnings.
  3. Use verify.json to identify residual source-framework artifacts.