wraptile 0.2.1.dev1__tar.gz → 0.4.0__tar.gz

{wraptile-0.2.1.dev1 → wraptile-0.4.0}/.gitignore

@@ -1,9 +1,10 @@
 # Testing
 *.zarr/
 .cov-report
+notebooks/auth-test.ipynb
 
-# Documentation generation
-docs/notebooks/*.ipynb
+# Legacy generated documentation (excluded from the site)
+docs/notebooks/
 
 # Byte-compiled / optimized / DLL files
 __pycache__/
@@ -202,3 +203,6 @@ cython_debug/
 #  refer to https://docs.cursor.com/context/ignore-files
 .cursorignore
 .cursorindexingignore
+
+# Downloaded font assets
+docs/assets/downloaded/

{wraptile-0.2.1.dev1 → wraptile-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: wraptile
-Version: 0.2.1.dev1
+Version: 0.4.0
 Summary: FastAPI server that implements the OGC API - Processes
 Project-URL: Documentation, https://eo-tools.github.io/eozilla
 Project-URL: Repository, https://github.com/eo-tools/eozilla
@@ -28,8 +28,8 @@ Classifier: Topic :: Software Development
 Classifier: Typing :: Typed
 Requires-Python: >=3.11
 Requires-Dist: fastapi
-Requires-Dist: gavicore>=0.2.1.dev1
-Requires-Dist: procodile>=0.2.1.dev1
+Requires-Dist: gavicore>=0.4.0
+Requires-Dist: procodile>=0.4.0
 Requires-Dist: pydantic
 Requires-Dist: pyyaml
 Requires-Dist: typer<1,>=0.26.0

{wraptile-0.2.1.dev1 → wraptile-0.4.0}/pyproject.toml

@@ -4,7 +4,7 @@
 
 [project]
 name = "wraptile"
-version = "0.2.1.dev1"
+version = "0.4.0"
 description = "FastAPI server that implements the OGC API - Processes"
 readme = "README.md"
 authors = [
@@ -46,8 +46,8 @@ dependencies = [
   "typer >=0.26.0,<1",
   "uvicorn",
   # local dependency
-  "gavicore >=0.2.1.dev1",
-  "procodile >=0.2.1.dev1",
+  "gavicore >=0.4.0",
+  "procodile >=0.4.0",
 ]
 
 [project.scripts]

{wraptile-0.2.1.dev1 → wraptile-0.4.0}/wraptile/app.py

@@ -4,6 +4,7 @@
 
 import logging
 import time
+from contextlib import asynccontextmanager
 from typing import Awaitable, Callable
 
 from fastapi import FastAPI, Request, Response
@@ -11,8 +12,17 @@ from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import JSONResponse
 
 from .exceptions import ServiceException
+from .provider import get_service
 
-app = FastAPI()
+
+@asynccontextmanager
+async def load_app_eagerly(app: FastAPI):
+    get_service()  # startup ...
+    yield  # running ...
+    # shutdown ...
+
+
+app = FastAPI(lifespan=load_app_eagerly)
 app.add_middleware(
     CORSMiddleware,
     allow_credentials=False,  # we disallow Cookie-Auth (FastAPI default)

{wraptile-0.2.1.dev1 → wraptile-0.4.0}/wraptile/cli.py

@@ -83,7 +83,7 @@ def new_cli(
             `wraptile` help text will be used
         summary: A one-sentence human-readable description of the tool that
             will be used by the default help text. Hence, used only,
-            if `help`is not provided. Should end with a dot '.'.
+            if `help` is not provided. Should end with a dot '.'.
         version: Optional version string. If not provided, the
             `wraptile` version will be used.
     Return:
@@ -114,7 +114,7 @@ def new_cli(
             from wraptile import __version__ as default_version
 
             if version:
-                typer.echo(f"{version} ({DEFAULT_NAME} {default_version})")
+                typer.echo(f"{name} {version} ({DEFAULT_NAME} {default_version})")
             else:
                 typer.echo(default_version)
             return

{wraptile-0.2.1.dev1 → wraptile-0.4.0}/wraptile/exceptions.py

@@ -7,7 +7,7 @@ from typing import Optional
 
 from fastapi import HTTPException
 
-from gavicore.models import ApiError
+from gavicore.models.core import ApiError
 from gavicore.service.errors import (
     ErrorTypeId,
     create_api_error,

wraptile-0.4.0/wraptile/main.py

@@ -0,0 +1,13 @@
+#  Copyright (c) 2025-2026 by the Eozilla team and contributors
+#  Permissions are hereby granted under the terms of the Apache 2.0 License:
+#  https://opensource.org/license/apache-2-0.
+
+"""Export the FastAPI application with its Core routes registered.
+
+DRU routes are registered separately when a DRU-capable service is loaded.
+"""
+
+from .app import app
+from .routes import core
+
+__all__ = ["app", "core"]

{wraptile-0.2.1.dev1 → wraptile-0.4.0}/wraptile/provider.py

@@ -4,7 +4,7 @@
 
 import logging
 
-from gavicore.service import Service
+from gavicore.service.core import Service
 
 from .services.base import ServiceBase
 

wraptile-0.4.0/wraptile/routes/__init__.py

@@ -0,0 +1,5 @@
+#  Copyright (c) 2026 by the Eozilla team and contributors
+#  Permissions are hereby granted under the terms of the Apache 2.0 License:
+#  https://opensource.org/license/apache-2-0.
+
+"""HTTP routes for OGC API - Processes Core and DRU."""

wraptile-0.2.1.dev1/wraptile/routes.py → wraptile-0.4.0/wraptile/routes/core.py

@@ -1,10 +1,12 @@
 # generated by gen_server.py:
-#   filename:  routes.py:
+#   filename:  core.py:
 #   timestamp: 2026-05-27T07:55:14.099104
 
+"""HTTP routes for OGC API - Processes Part 1: Core."""
+
 import fastapi
 
-from gavicore.models import (
+from gavicore.models.core import (
     Capabilities,
     ConformanceDeclaration,
     JobInfo,
@@ -14,10 +16,10 @@ from gavicore.models import (
     ProcessList,
     ProcessRequest,
 )
-from gavicore.service import Service
+from gavicore.service.core import Service
 
-from .app import app
-from .provider import get_service
+from ..app import app
+from ..provider import get_service
 
 
 # noinspection PyPep8Naming

wraptile-0.4.0/wraptile/routes/dru.py

@@ -0,0 +1,167 @@
+#  Copyright (c) 2026 by the Eozilla team and contributors
+#  Permissions are hereby granted under the terms of the Apache 2.0 License:
+#  https://opensource.org/license/apache-2-0.
+
+"""HTTP routes and application package responses for OGC Processes Part 2: DRU."""
+
+import fastapi
+from fastapi.responses import JSONResponse
+
+from gavicore.models.core import ApiError, ProcessSummary
+from gavicore.models.dru import OgcApplicationPackage
+from gavicore.service.dru import DruService
+
+from ..provider import get_service
+
+
+class OgcApplicationPackageResponse(JSONResponse):
+    """Custom response class to correctly incorporate content type in response."""
+
+    media_type = "application/ogcapppkg+json"
+
+
+dru_router = fastapi.APIRouter()
+
+
+# noinspection PyPep8Naming
+@dru_router.post(
+    "/processes",
+    response_model=ProcessSummary,
+    status_code=201,
+    responses={
+        "202": {},
+        "403": {"model": ApiError},
+        "409": {"model": ApiError},
+        "415": {"model": ApiError},
+        "501": {"model": ApiError},
+    },
+    response_model_exclude_none=True,
+    response_model_exclude_unset=True,
+    openapi_extra={
+        "requestBody": {
+            # NOTE: schemas of the request body below are kept abstract since swagger-ui resolves `$ref`,
+            #       thus slowing down its web interface considerably.
+            #       Querying the `openapi.json` directly does not result in slow downs.
+            "content": {
+                "application/cwl": {
+                    "schema": {
+                        "type": "object",
+                        "additionalProperties": True,
+                    }
+                },
+                "application/cwl+json": {
+                    "schema": {
+                        "type": "object",
+                        "additionalProperties": True,
+                    }
+                },
+                "application/cwl+yaml": {
+                    "schema": {
+                        "type": "object",
+                        "additionalProperties": True,
+                    }
+                },
+            },
+            "required": True,
+        }
+    },
+)
+async def deploy_process(
+    request: fastapi.Request,
+    response: fastapi.Response,
+    w: str | None = None,
+    service: DruService = fastapi.Depends(get_service),  # noqa B008
+):
+    return await service.deploy_process(
+        w=w,
+        request=request,
+        response=response,
+    )
+
+
+# noinspection PyPep8Naming
+@dru_router.put(
+    "/processes/{processId}",
+    response_model=ProcessSummary,
+    responses={
+        "201": {"model": ProcessSummary},
+        "202": {"model": ProcessSummary},
+        "204": {},
+        "403": {"model": ApiError},
+        "404": {"model": ApiError},
+        "415": {"model": ApiError},
+        "501": {"model": ApiError},
+    },
+    response_model_exclude_none=True,
+    response_model_exclude_unset=True,
+    openapi_extra={
+        "requestBody": {
+            "content": {
+                "application/cwl": {"schema": ProcessSummary.model_json_schema()},
+                "application/cwl+json": {"schema": ProcessSummary.model_json_schema()},
+                "application/cwl+yaml": {"schema": ProcessSummary.model_json_schema()},
+            },
+            "required": True,
+        }
+    },
+)
+async def replace_process(
+    processId: str,
+    request: fastapi.Request,
+    response: fastapi.Response,
+    w: str | None = None,
+    service: DruService = fastapi.Depends(get_service),  # noqa B008
+):
+    return await service.replace_process(
+        process_id=processId,
+        w=w,
+        request=request,
+        response=response,
+    )
+
+
+# noinspection PyPep8Naming
+@dru_router.delete(
+    "/processes/{processId}",
+    status_code=204,
+    responses={
+        "403": {"model": ApiError},
+        "404": {"model": ApiError},
+        "501": {"model": ApiError},
+    },
+    response_model_exclude_none=True,
+    response_model_exclude_unset=True,
+)
+async def undeploy_process(
+    processId: str,
+    request: fastapi.Request,
+    response: fastapi.Response,
+    service: DruService = fastapi.Depends(get_service),  # noqa B008
+):
+    return await service.undeploy_process(
+        process_id=processId, request=request, response=response
+    )
+
+
+# noinspection PyPep8Naming
+@dru_router.get(
+    "/processes/{processId}/package",
+    response_model=OgcApplicationPackage,
+    response_class=OgcApplicationPackageResponse,
+    responses={
+        "403": {"model": ApiError},
+        "404": {"model": ApiError},
+        "501": {"model": ApiError},
+    },
+    response_model_exclude_none=True,
+    response_model_exclude_unset=True,
+)
+async def get_formal_description(
+    processId: str,
+    request: fastapi.Request,
+    response: fastapi.Response,
+    service: DruService = fastapi.Depends(get_service),  # noqa B008
+):
+    return await service.get_formal_description(
+        process_id=processId, request=request, response=response
+    )

{wraptile-0.2.1.dev1 → wraptile-0.4.0}/wraptile/services/airflow/airflow_service.py

@@ -22,7 +22,7 @@ from airflow_client.client.api import DAGApi
 from airflow_client.client.api import DagRunApi as DAGRunApi
 from airflow_client.client.api import XComApi
 
-from gavicore.models import (
+from gavicore.models.core import (
     InputDescription,
     JobInfo,
     JobList,
@@ -228,7 +228,13 @@ class AirflowService(ServiceBase):
             raise ServiceException(
                 e.status, e.reason, exception=e, is_job_problem=True
             ) from e
-        return self.dag_run_to_job_info(dag_run)
+        job_info: JobInfo = self.dag_run_to_job_info(dag_run)
+        # The OGC Api - Processes specifies that the dismiss operation (`DELETE /jobs/{jobId}`)
+        # must return a job info with state `"dismissed"`, no matter whether the job was successfully
+        # terminated or really already ended (which may take a while). So our interpretation of this
+        # status is a weaker "cancellation requested".
+        job_info.status = JobStatus.dismissed
+        return job_info
 
     async def get_job_results(self, job_id: str, *args, **kwargs) -> JobResults:
         dag_id = self.get_dag_id_from_job_id(job_id)

{wraptile-0.2.1.dev1 → wraptile-0.4.0}/wraptile/services/base/service_base.py

@@ -12,12 +12,13 @@ import fastapi
 import yaml
 from starlette.routing import Route
 
-from gavicore.models import (
+from gavicore.models.core import (
     Capabilities,
     ConformanceDeclaration,
     Link,
 )
-from gavicore.service import Service
+from gavicore.service.core import Service
+from gavicore.service.dru import DruService
 from gavicore.util.dynimp import import_value
 from wraptile.constants import ENV_VAR_SERVICE
 from wraptile.exceptions import ServiceConfigException
@@ -92,6 +93,16 @@ class ServiceBase(Service, ABC):
                 name="service",
                 example="path.to.module:service",
             )
+
+            if issubclass(service.__class__, DruService):
+                from wraptile.app import app as app_module
+                from wraptile.routes.dru import dru_router
+
+                app_module.include_router(dru_router)
+
+                logging.getLogger("uvicorn").info(
+                    "Loaded additional routes to support Deploy, Redeploy, Undeploy"
+                )
         except (ValueError, TypeError) as e:
             raise ServiceConfigException(f"{e}") from e
         logger = logging.getLogger("uvicorn")

wraptile-0.4.0/wraptile/services/local/_testing_stac.py

@@ -0,0 +1,239 @@
+# Copyright (c) 2026 by the Eozilla team and contributors
+# Permissions are hereby granted under the terms of the Apache 2.0 License.
+
+import json
+import os
+from copy import deepcopy
+from pathlib import Path
+from typing import Any
+from urllib.parse import urlsplit
+from uuid import uuid4
+
+from fastapi import FastAPI
+from starlette.staticfiles import StaticFiles
+
+from gavicore.models.core import Link
+
+
+def output_settings() -> tuple[Path, str]:
+    """Return the testing artifact directory and its advertised HTTP base."""
+    directory = Path(os.environ.get("EOZILLA_TESTING_STAC_DIR", ".pixi/testing-stac"))
+    base = os.environ.get(
+        "EOZILLA_TESTING_STAC_URL", "http://localhost:8008/testing-stac"
+    )
+    parsed = urlsplit(base)
+    if (
+        parsed.scheme not in ("http", "https")
+        or not parsed.netloc
+        or parsed.username
+        or parsed.password
+        or parsed.query
+        or parsed.fragment
+    ):
+        raise ValueError(
+            "Testing STAC base must be an absolute HTTP URL without credentials"
+        )
+    return directory.resolve(), base.rstrip("/")
+
+
+def mount_artifacts(app: FastAPI) -> None:
+    """Mount only the configured testing artifact directory, without enumeration."""
+    directory, _ = output_settings()
+    directory.mkdir(parents=True, exist_ok=True)
+    app.routes[:] = [
+        route for route in app.routes if getattr(route, "name", None) != "testing-stac"
+    ]
+    app.mount("/testing-stac", StaticFiles(directory=directory), name="testing-stac")
+
+
+def create_outputs(item_count: int, inline: bool) -> tuple[Any, Any, Link, int, None]:
+    """Generate small owned products and equivalent inline/linked STAC outputs."""
+    import numpy as np
+    import xarray as xr
+
+    directory, public_base = output_settings()
+    run_id = uuid4().hex
+    run_dir = directory / run_id
+    run_dir.mkdir(parents=True)
+    base = f"{public_base}/{run_id}"
+    items = []
+    for index in range(item_count):
+        scene_id = f"scene-{index + 1}"
+        west, south = 10 + index * 1.25, 50
+        products = run_dir / scene_id / "products"
+        products.mkdir(parents=True)
+        dataset = xr.Dataset(
+            {
+                "ndvi": (
+                    ("lat", "lon"),
+                    np.arange(4, dtype="float32").reshape(2, 2) + index,
+                )
+            },
+            coords={
+                "lat": [south + 0.25, south + 0.75],
+                "lon": [west + 0.25, west + 0.75],
+            },
+        )
+        try:
+            dataset.to_zarr(str(products / "data.zarr"), mode="w", zarr_format=2)
+        finally:
+            dataset.close()
+        (products / "summary.csv").write_text(
+            f"scene,mean_ndvi\n{scene_id},{1.5 + index}\n",
+            encoding="utf-8",
+            newline="\n",
+        )
+        item = _item(scene_id, base, products, west, south, index)
+        _write_preview(
+            products / "preview.png", item["geometry"]["coordinates"][0], index
+        )
+        items.append(item)
+        _write_json(run_dir / f"{scene_id}.json", item)
+    collection = {
+        "type": "FeatureCollection",
+        "features": deepcopy(items),
+        "links": [
+            {
+                "rel": "self",
+                "href": f"{base}/items.json",
+                "type": "application/geo+json",
+            }
+        ],
+        "testing:complete": True,
+    }
+    _write_json(run_dir / "items.json", collection)
+    report = Link(href=f"{base}/scene-1/products/summary.csv", type="text/csv")
+    if inline:
+        return items[0], collection, report, item_count, None
+    return (
+        Link(href=f"{base}/scene-1.json", type="application/geo+json"),
+        Link(href=f"{base}/items.json", type="application/geo+json"),
+        report,
+        item_count,
+        None,
+    )
+
+
+def _write_json(path: Path, document: dict[str, Any]) -> None:
+    path.write_text(json.dumps(document, indent=2), encoding="utf-8")
+
+
+def _footprint(west: float, south: float, index: int) -> list[list[float]]:
+    """Return a closed, counterclockwise footprint resembling a clipped scene."""
+    outlines = (
+        ((0, 0.12), (0.18, 0), (0.84, 0.06), (1, 0.82), (0.78, 1), (0.06, 0.88)),
+        ((0, 0.22), (0.26, 0), (0.93, 0.16), (1, 0.73), (0.68, 1), (0.12, 0.91)),
+    )
+    ring = [[west + x, south + y] for x, y in outlines[index % len(outlines)]]
+    return ring + [ring[0].copy()]
+
+
+def _write_preview(path: Path, ring: list[list[float]], index: int) -> None:
+    """Draw deterministic, north-up illustrative vegetation and water scenery.
+
+    This is independent of the tiny 2x2 example array, not satellite imagery
+    or a scientific NDVI rendering. Transparent margins match the STAC
+    footprint.
+    """
+    import numpy as np
+    from PIL import Image, ImageDraw
+
+    size = 384
+    rng = np.random.default_rng(2026 + index)
+    terrain = np.zeros((size, size), dtype="float64")
+    for resolution, weight in ((5, 0.5), (12, 0.25), (32, 0.15), (96, 0.1)):
+        noise = (rng.random((resolution, resolution)) * 255).astype("uint8")
+        with Image.fromarray(noise) as image:
+            with image.resize((size, size), Image.Resampling.BICUBIC) as smooth:
+                terrain += np.asarray(smooth) / 255 * weight
+
+    y, x = np.mgrid[0:size, 0:size] / (size - 1)
+    # Small agricultural parcels soften into forested hills at higher values.
+    parcels = rng.uniform(0.12, 0.7, (24, 24))
+    field_x = (0.94 * x + 0.34 * y + 0.015 * np.sin(15 * y)) % 1
+    field_y = (0.94 * y - 0.34 * x + 0.015 * np.sin(12 * x)) % 1
+    field = parcels[(field_y * 24).astype(int), (field_x * 24).astype(int)]
+    forest = np.clip((terrain - 0.46) * 15, 0, 1)
+    vegetation = np.clip((1 - forest) * field + forest * (0.65 + 0.35 * terrain), 0, 1)
+    palette = np.array([[219, 208, 145], [168, 190, 104], [83, 139, 64], [26, 79, 43]])
+    colours = np.stack(
+        [
+            np.interp(vegetation, [0, 0.35, 0.6, 1], palette[:, channel])
+            for channel in range(3)
+        ],
+        axis=-1,
+    )
+    # A meandering river and a lake provide recognisable landscape structure.
+    river_x = 0.48 + 0.13 * np.sin(8 * y + index) + 0.035 * np.sin(23 * y)
+    lake_edge = 1 + 0.16 * np.sin(35 * x) * np.cos(42 * y)
+    water = (abs(x - river_x) < 0.009) | (
+        ((x - 0.64) / 0.10) ** 2 + ((y - 0.28) / 0.065) ** 2 < lake_edge
+    )
+    shade = 0.85 + 0.3 * terrain + rng.normal(0, 0.045, (size, size))
+    colours = np.clip(colours * shade[..., None], 0, 255).astype("uint8")
+    colours[water] = np.clip(
+        np.array([55, 105, 125]) * shade[water, None], 0, 255
+    ).astype("uint8")
+    west, south = min(p[0] for p in ring), min(p[1] for p in ring)
+    east, north = max(p[0] for p in ring), max(p[1] for p in ring)
+    pixels = [
+        (
+            (lon - west) / (east - west) * (size - 1),
+            (north - lat) / (north - south) * (size - 1),
+        )
+        for lon, lat in ring
+    ]
+    with Image.new("L", (size, size)) as mask:
+        ImageDraw.Draw(mask).polygon(pixels, fill=255)
+        with Image.fromarray(colours) as image:
+            image.putalpha(mask)
+            image.save(path)
+
+
+def _item(
+    scene_id: str, base: str, directory: Path, west: float, south: float, index: int
+) -> dict[str, Any]:
+    products = f"{scene_id}/products"
+    return {
+        "type": "Feature",
+        "stac_version": "1.1.0",
+        "stac_extensions": [
+            "https://stac-extensions.github.io/alternate-assets/v1.2.0/schema.json"
+        ],
+        "id": scene_id,
+        "geometry": {
+            "type": "Polygon",
+            "coordinates": [_footprint(west, south, index)],
+        },
+        "bbox": [west, south, west + 1, south + 1],
+        "properties": {"datetime": "2026-01-01T00:00:00Z", "testing:scene": scene_id},
+        "links": [
+            {
+                "rel": "self",
+                "href": f"{base}/{scene_id}.json",
+                "type": "application/geo+json",
+            }
+        ],
+        "assets": {
+            "data": {
+                "href": f"{products}/data.zarr",
+                "type": "application/zarr",
+                "title": "NDVI grid",
+                "roles": ["data"],
+                "alternate": {"local": {"href": (directory / "data.zarr").as_uri()}},
+            },
+            "preview": {
+                "href": f"{products}/preview.png",
+                "type": "image/png",
+                "title": "Synthetic scene preview",
+                "roles": ["thumbnail"],
+                "alternate": {"local": {"href": (directory / "preview.png").as_uri()}},
+            },
+            "report": {
+                "href": f"{products}/summary.csv",
+                "type": "text/csv",
+                "title": "Scene summary",
+                "roles": ["metadata"],
+            },
+        },
+    }

{wraptile-0.2.1.dev1 → wraptile-0.4.0}/wraptile/services/local/local_service.py

@@ -11,7 +11,7 @@ from typing import Optional
 import fastapi
 from pydantic import ValidationError
 
-from gavicore.models import (
+from gavicore.models.core import (
     JobInfo,
     JobList,
     JobResults,
@@ -162,6 +162,11 @@ class LocalService(ServiceBase):
             del self.jobs[job_id]
             self.job_results.pop(job_id, None)
             self.job_uses_processes.pop(job_id, None)
+        # The OGC Api - Processes specifies that the dismiss operation (`DELETE /jobs/{jobId}`)
+        # must return a job info with state `"dismissed"`, no matter whether the job was successfully
+        # terminated or really already ended (which may take a while). So our interpretation of this
+        # status is a weaker "cancellation requested".
+        job.job_info.status = JobStatus.dismissed
         return job.job_info
 
     async def get_job_results(self, job_id: str, *args, **_kwargs) -> JobResults:

{wraptile-0.2.1.dev1 → wraptile-0.4.0}/wraptile/services/local/testing.py

@@ -5,16 +5,31 @@
 import datetime
 import time
 from pathlib import Path
-from typing import Annotated, Optional
+from typing import Annotated, Any, Optional
 
 import pydantic
 from pydantic import Field
 
-from gavicore.models import InputDescription, Link, OutputDescription, Schema
+from gavicore.models.core import InputDescription, Link, OutputDescription, Schema
 from procodile import FromMain, FromStep, JobContext
-from wraptile.services.local import LocalService
 
-service = LocalService(
+from .local_service import LocalService
+
+
+class _TestingService(LocalService):
+    """Local testing service with HTTP access to its generated STAC products."""
+
+    def configure(self, processes: bool | None = None, max_workers: int | None = None):
+        """Configure execution and mount the testing artifact directory."""
+        super().configure(processes=processes, max_workers=max_workers)
+        from wraptile.app import app
+
+        from ._testing_stac import mount_artifacts
+
+        mount_artifacts(app)
+
+
+service = _TestingService(
     title="Eozilla API Server (local dummy for testing)",
     description="Local test server implementing the OGC API - Processes 1.0 Standard",
 )
@@ -22,6 +37,88 @@ service = LocalService(
 registry = service.process_registry
 
 
+@registry.process(
+    id="create_inline_stac",
+    title="Create inline STAC outputs",
+    outputs={
+        "item": OutputDescription(
+            title="STAC Item",
+            schema=Schema(
+                **{
+                    "$ref": "https://schemas.stacspec.org/v1.1.0/item-spec/json-schema/item.json"
+                }
+            ),
+        ),
+        "item_collection": OutputDescription(
+            title="STAC ItemCollection",
+            schema=Schema(
+                type="object",
+                properties={
+                    "features": {
+                        "type": "array",
+                        "items": {"properties": {"stac_version": {"type": "string"}}},
+                    }
+                },
+            ),
+        ),
+        "report": OutputDescription(
+            title="Ordinary CSV link", schema=Schema(type="object")
+        ),
+        "item_count": OutputDescription(
+            title="Number of embedded Items", schema=Schema(type="integer")
+        ),
+        "optional": OutputDescription(
+            title="Explicit null output", schema=Schema(nullable=True)
+        ),
+    },
+)
+def create_inline_stac(
+    item_count: Annotated[int, Field(ge=1, le=4)] = 2,
+) -> tuple[dict[str, Any], dict[str, Any], Link, int, None]:
+    """Create small real Zarr/CSV products and return inline STAC JSON.
+
+    Output lives under EOZILLA_TESTING_STAC_DIR and is advertised beneath
+    EOZILLA_TESTING_STAC_URL. Each run has its own directory retained for review.
+    Requires the optional xarray, NumPy, and Zarr testing dependencies.
+    """
+    from ._testing_stac import create_outputs
+
+    return create_outputs(item_count, inline=True)
+
+
+@registry.process(
+    id="create_linked_stac",
+    title="Create linked STAC outputs",
+    outputs={
+        "item": OutputDescription(title="STAC Item link", schema=Schema(type="object")),
+        "item_collection": OutputDescription(
+            title="STAC ItemCollection link", schema=Schema(type="object")
+        ),
+        "report": OutputDescription(
+            title="Ordinary CSV link", schema=Schema(type="object")
+        ),
+        "item_count": OutputDescription(
+            title="Number of embedded Items", schema=Schema(type="integer")
+        ),
+        "optional": OutputDescription(
+            title="Explicit null output", schema=Schema(nullable=True)
+        ),
+    },
+)
+def create_linked_stac(
+    item_count: Annotated[int, Field(ge=1, le=4)] = 2,
+) -> tuple[Link, Link, Link, int, None]:
+    """Write the inline demo's equivalent metadata and return ordinary Links.
+
+    The testing service serves metadata and products at /testing-stac; set
+    EOZILLA_TESTING_STAC_URL to its public URL when using another host or port.
+    Generated run directories remain available until explicitly cleaned up.
+    """
+    from ._testing_stac import create_outputs
+
+    return create_outputs(item_count, inline=False)
+
+
 @registry.process(
     id="sleep_a_while",
     title="Sleep Processor",

wraptile-0.2.1.dev1/wraptile/main.py

@@ -1,15 +0,0 @@
-#  Copyright (c) 2025-2026 by the Eozilla team and contributors
-#  Permissions are hereby granted under the terms of the Apache 2.0 License:
-#  https://opensource.org/license/apache-2-0.
-
-from . import routes
-from .app import app
-
-"""
-This module imports both, the FastAPI `app` instance and the application's 
-path functions from the `routes` module. 
-It also sets the server's service instance and exports the application as 
-the `app` module attribute.
-"""
-
-__all__ = ["app", "routes"]