admin-litestar 0.1.0__py3-none-any.whl

admin_litestar/__init__.py

@@ -0,0 +1,50 @@
+"""Server-rendered admin for Litestar + SQLAlchemy applications.
+
+Everything a host application needs is exported here. Deeper import paths such
+as ``admin_litestar.queries`` happen to work, but the compatibility promise is
+this module's ``__all__`` and nothing below it — see ARCHITECTURE.md.
+"""
+
+from importlib.metadata import PackageNotFoundError, version
+
+from .admin import Admin, AdminConfig
+from .auth import actor_of
+from .constants import CAPABILITIES, DELETE, DETAIL, EXPORT, LIST
+from .export import csv_rows
+from .pages import CustomPage
+from .passwords import hash_password, verify_password
+from .protocols import AuditSink, AuthBackend, CacheBackend
+from .queries import count_statement, detail_statement, list_statement
+from .render import is_htmx, project, render_value
+from .spec import ModelSpec
+
+try:
+    __version__ = version("admin-litestar")
+except PackageNotFoundError:  # pragma: no cover - running from a source tree
+    __version__ = "0.0.0.dev0"
+
+__all__ = [
+    "Admin",
+    "AdminConfig",
+    "AuditSink",
+    "AuthBackend",
+    "CAPABILITIES",
+    "CacheBackend",
+    "CustomPage",
+    "DELETE",
+    "DETAIL",
+    "EXPORT",
+    "LIST",
+    "ModelSpec",
+    "__version__",
+    "actor_of",
+    "count_statement",
+    "csv_rows",
+    "detail_statement",
+    "hash_password",
+    "is_htmx",
+    "list_statement",
+    "project",
+    "render_value",
+    "verify_password",
+]

admin_litestar/admin.py

@@ -0,0 +1,183 @@
+"""The object a host application constructs, configures and mounts."""
+
+from __future__ import annotations
+
+from collections.abc import AsyncIterator
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any
+
+from litestar import Router
+from litestar.config.csrf import CSRFConfig
+from litestar.di import Provide
+from litestar.middleware.session.server_side import ServerSideSessionConfig
+from litestar.plugins.jinja import JinjaTemplateEngine
+from litestar.static_files import create_static_files_router
+from litestar.template.config import TemplateConfig
+
+from .auth import Revalidator, require_actor
+from .constants import DEFAULT_PATH, DEFAULT_STATIC_PATH
+from .controllers import ModelController, SessionController
+from .protocols import CacheBackend
+from .render import render_value
+from .spec import Registry
+from .static import STATIC
+from .templates import TEMPLATES
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Sequence
+    from pathlib import Path
+
+    from litestar import Litestar
+    from litestar.stores.base import Store
+
+    from .pages import CustomPage
+    from .protocols import AuditSink, AuthBackend
+    from .spec import ModelSpec
+
+SESSION_STORE_NAME = "admin_sessions"
+CSRF_COOKIE = "admin_csrf"
+
+
+class _HostStoreSessionConfig(ServerSideSessionConfig):
+    """A session config bound to a store object rather than a registry name.
+
+    ``ServerSideSessionConfig`` normally resolves its store by looking up a
+    name in the Litestar app's store registry — but ``Admin`` never builds
+    that app, so it has no way to register the host's store under a name.
+    Binding directly to the supplied store sidesteps that registry entirely.
+    """
+
+    def __init__(self, backing_store: Store) -> None:
+        """Wrap the host's store, keeping the registry-name field cosmetic."""
+        super().__init__(store=SESSION_STORE_NAME)
+        self._backing_store = backing_store
+
+    def get_store_from_app(self, app: Litestar) -> Store:
+        """Return the host-supplied store, ignoring the app's registry."""
+        return self._backing_store
+
+
+@dataclass(frozen=True, slots=True)
+class AdminConfig:
+    """Where the admin lives and what it calls itself."""
+
+    path: str = DEFAULT_PATH
+    static_path: str = DEFAULT_STATIC_PATH
+    brand: str = "admin"
+    template_dirs: tuple[Path, ...] = field(default=())
+
+
+class Admin:
+    """Assembles the admin's router and the Litestar configuration it needs.
+
+    The host supplies ``session_factory``, a zero-argument callable returning
+    an async context manager over a database session (the same shape an
+    ``async_sessionmaker`` provides). ``Admin`` opens one such session per
+    request and injects it into its own handlers as ``admin_session`` — a
+    dependency every handler under :meth:`router` may request. The session is
+    closed automatically once the handler returns, including on error, via
+    Litestar's generator-dependency cleanup.
+    """
+
+    def __init__(
+        self,
+        config: AdminConfig,
+        specs: Sequence[ModelSpec],
+        auth: AuthBackend,
+        audit: AuditSink,
+        cache: Callable[[Any], CacheBackend],
+        session_factory: Callable[[], Any],
+        pages: Sequence[CustomPage] = (),
+    ) -> None:
+        """Store the host's configuration and build the registry."""
+        self.config = config
+        self.registry = Registry(specs)
+        self.auth = auth
+        self.audit = audit
+        self.cache = cache
+        self.session_factory = session_factory
+        self.pages = tuple(pages)
+
+    def _url_for_spec(self, spec: ModelSpec) -> str:
+        """Return the list URL for a spec."""
+        return f"{self.config.path}/m/{spec.slug}"
+
+    def _url_for_page(self, page: CustomPage) -> str:
+        """Return the URL for a host-contributed page."""
+        return f"{self.config.path}/{page.slug}"
+
+    async def _provide_session(self) -> AsyncIterator[Any]:
+        """Open one database session per request for the ``admin_session`` name.
+
+        Yielding keeps the session open for the handler's duration; Litestar
+        resumes this generator after the response is built, closing the
+        context manager whether the handler succeeded or raised.
+        """
+        async with self.session_factory() as session:
+            yield session
+
+    def _dependencies(self) -> dict[str, Provide]:
+        """Provide the admin's collaborators to every handler."""
+        return {
+            "admin_auth": Provide(lambda: self.auth, sync_to_thread=False),
+            "admin_audit": Provide(lambda: self.audit, sync_to_thread=False),
+            "admin_registry": Provide(lambda: self.registry, sync_to_thread=False),
+            "admin_path": Provide(lambda: self.config.path, sync_to_thread=False),
+            "admin_cache": Provide(self._provide_cache, sync_to_thread=False),
+            "admin_session": Provide(self._provide_session),
+        }
+
+    def _provide_cache(self, request: Any) -> CacheBackend:
+        """Return the host's cache for this request."""
+        return self.cache(request)
+
+    def router(self) -> Router:
+        """Build the admin router: generic controllers plus host pages."""
+        handlers: list[Any] = [SessionController, ModelController]
+        for page in self.pages:
+            handlers.extend(page.handlers)
+        return Router(
+            path=self.config.path,
+            route_handlers=handlers,
+            guards=[require_actor],
+            before_request=Revalidator(self.auth, self.session_factory, self.cache),
+            dependencies=self._dependencies(),
+        )
+
+    def static_router(self) -> Router:
+        """Serve the package's vendored CSS and JS."""
+        return create_static_files_router(
+            path=self.config.static_path, directories=[STATIC]
+        )
+
+    def template_config(self) -> TemplateConfig:
+        """Build the Jinja config, host template directories taking precedence.
+
+        The engine is built and populated with globals here, then handed to
+        ``TemplateConfig`` as a ready ``instance``. Passing ``engine=`` (a
+        class) instead would have Litestar build its own, separate engine
+        via ``TemplateConfig.engine_instance`` — a fresh instance that never
+        saw these globals — so the config must carry the instance directly.
+        """
+        directories = [*self.config.template_dirs, TEMPLATES]
+        engine = JinjaTemplateEngine(directory=directories)
+        engine.engine.globals.update(
+            admin_path=self.config.path,
+            static_path=self.config.static_path,
+            brand=self.config.brand,
+            registry=self.registry,
+            groups=self.registry.groups,
+            pages=self.pages,
+            url_for_spec=self._url_for_spec,
+            url_for_page=self._url_for_page,
+            render_value=render_value,
+        )
+        return TemplateConfig(instance=engine)
+
+    def session_config(self, store: Store) -> ServerSideSessionConfig:
+        """Build the server-side session config over a host-supplied store."""
+        return _HostStoreSessionConfig(store)
+
+    def csrf_config(self, secret: str) -> CSRFConfig:
+        """Build CSRF protection for the admin's mutating routes."""
+        return CSRFConfig(secret=secret, cookie_name=CSRF_COOKIE)

admin_litestar/auth.py

@@ -0,0 +1,107 @@
+"""Session gating, revalidation, and login lockout."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from litestar.exceptions import NotAuthorizedException
+
+from .constants import (
+    EXCLUDE_FROM_AUTH_KEY,
+    LOGIN_LOCK_TTL,
+    LOGIN_MAX_ATTEMPTS,
+    REVALIDATE_TTL,
+    SESSION_ACTOR_KEY,
+)
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from litestar.connection import ASGIConnection
+    from litestar.handlers.base import BaseRouteHandler
+
+    from .protocols import AuthBackend, CacheBackend
+
+FAILURE_KEY = "admin:login:fail:{username}:{ip}"
+REVALIDATE_KEY = "admin:actor:{actor_id}"
+
+
+def _failure_key(username: str, ip: str) -> str:
+    """Build the cache key counting failures for a username and address."""
+    return FAILURE_KEY.format(username=username, ip=ip)
+
+
+async def register_failure(cache: CacheBackend, username: str, ip: str) -> int:
+    """Increment and return the failure count for a username and address."""
+    key = _failure_key(username, ip)
+    count = int(await cache.get(key) or 0) + 1
+    await cache.set(key, count, LOGIN_LOCK_TTL)
+    return count
+
+
+async def is_locked(cache: CacheBackend, username: str, ip: str) -> bool:
+    """True when the failure count has reached the lockout threshold."""
+    return int(await cache.get(_failure_key(username, ip)) or 0) >= LOGIN_MAX_ATTEMPTS
+
+
+async def clear_failures(cache: CacheBackend, username: str, ip: str) -> None:
+    """Reset the failure counter after a successful login."""
+    await cache.delete(_failure_key(username, ip))
+
+
+def actor_of(connection: ASGIConnection) -> Any:
+    """Return the acting admin's identity from the session, or None."""
+    return connection.session.get(SESSION_ACTOR_KEY)
+
+
+def require_actor(
+    connection: ASGIConnection, _handler: BaseRouteHandler | None
+) -> None:
+    """Litestar guard: reject requests without a logged-in admin session.
+
+    A handler opted out with ``exclude_from_auth=True`` (the same opt key
+    Litestar's own auth middlewares use) is exempt — this is how the login
+    form and its submission stay reachable by anonymous callers even though
+    the router that hosts them carries this guard for every other route.
+    """
+    if _handler is not None and _handler.opt.get(EXCLUDE_FROM_AUTH_KEY):
+        return
+    if actor_of(connection) is None:
+        raise NotAuthorizedException()
+
+
+class Revalidator:
+    """Re-asserts the host's auth gate on established sessions.
+
+    Runs as a ``before_request`` hook rather than a guard, because guards receive
+    no dependency injection and this needs a database session. Revoking an
+    admin's access therefore takes effect within ``REVALIDATE_TTL`` seconds
+    instead of at session expiry.
+    """
+
+    def __init__(
+        self,
+        backend: AuthBackend,
+        session_factory: Callable[[], Any],
+        cache_provider: Callable[[Any], CacheBackend],
+    ) -> None:
+        """Store the collaborators supplied by :class:`~admin_litestar.Admin`."""
+        self._backend = backend
+        self._session_factory = session_factory
+        self._cache_provider = cache_provider
+
+    async def __call__(self, request: Any) -> None:
+        """Clear the session and reject when the actor no longer qualifies."""
+        actor_id = actor_of(request)
+        if actor_id is None:
+            return
+        cache = self._cache_provider(request)
+        key = REVALIDATE_KEY.format(actor_id=actor_id)
+        if await cache.get(key):
+            return
+        async with self._session_factory() as session:
+            valid = await self._backend.is_valid(session, actor_id)
+        if not valid:
+            request.session.clear()
+            raise NotAuthorizedException()
+        await cache.set(key, True, REVALIDATE_TTL)

admin_litestar/constants.py

@@ -0,0 +1,47 @@
+"""Package-wide defaults and literals."""
+
+DEFAULT_PATH = "/admin"
+DEFAULT_STATIC_PATH = "/admin-static"
+
+SESSION_ACTOR_KEY = "admin_actor_id"
+EXCLUDE_FROM_AUTH_KEY = "exclude_from_auth"
+
+HASH_PREFIX = "scrypt"
+HASH_SEPARATOR = "$"
+HASH_PARTS = 6
+SCRYPT_N = 16384
+SCRYPT_R = 8
+SCRYPT_P = 1
+SCRYPT_DKLEN = 32
+SALT_BYTES = 16
+PASSWORD_MAX_LENGTH = 128
+
+LOGIN_MAX_ATTEMPTS = 5
+LOGIN_LOCK_TTL = 900
+REVALIDATE_TTL = 30
+PAGE_SIZE = 50
+EXPORT_LIMIT = 10000
+
+CELL_MAX_LENGTH = 48
+EMPTY_CELL = "—"
+TRUE_CELL = "yes"
+FALSE_CELL = "no"
+BYTES_CELL = "<{size} bytes>"
+HTMX_HEADER = "HX-Request"
+
+ACTION_LOGIN = "login"
+ACTION_LOGIN_FAILED = "login_failed"
+ACTION_DETAIL_VIEW = "detail_view"
+ACTION_EXPORT = "export"
+ACTION_DELETE = "delete"
+
+LIST = "list"
+DETAIL = "detail"
+DELETE = "delete"
+EXPORT = "export"
+
+# The complete set a ModelSpec may declare. Exported so a host has something to
+# import rather than spelling capability names as bare strings, and validated in
+# ModelSpec.__post_init__ so a typo fails loudly instead of producing a model
+# whose routes silently do not exist.
+CAPABILITIES = frozenset({LIST, DETAIL, DELETE, EXPORT})

admin_litestar/controllers/__init__.py

@@ -0,0 +1,6 @@
+"""Admin route controllers."""
+
+from .models import ModelController
+from .session import SessionController
+
+__all__ = ["ModelController", "SessionController"]

admin_litestar/controllers/models.py

@@ -0,0 +1,176 @@
+"""Generic list, detail, delete and export routes driven by ModelSpec."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from litestar import Controller, Request, get, post
+from litestar.di import NamedDependency
+from litestar.exceptions import NotFoundException
+from litestar.params import FromPath, FromQuery
+from litestar.response import Redirect, Stream, Template
+from litestar.status_codes import HTTP_303_SEE_OTHER
+
+from ..auth import actor_of
+from ..constants import (
+    ACTION_DELETE,
+    ACTION_DETAIL_VIEW,
+    ACTION_EXPORT,
+    DELETE,
+    DETAIL,
+    EXPORT,
+    EXPORT_LIMIT,
+    LIST,
+    PAGE_SIZE,
+)
+from ..export import csv_rows
+from ..protocols import AuditSink
+from ..queries import detail_statement, list_statement
+from ..render import project
+from ..spec import Registry
+
+if TYPE_CHECKING:
+    from ..spec import ModelSpec
+
+LIST_TEMPLATE = "list.html"
+DETAIL_TEMPLATE = "detail.html"
+CSV_MEDIA_TYPE = "text/csv"
+
+
+def _spec_or_404(registry: Registry, slug: str, capability: str) -> ModelSpec:
+    """Return the spec offering ``capability``, or raise 404."""
+    try:
+        spec = registry.get(slug)
+    except KeyError as exc:
+        raise NotFoundException() from exc
+    if not spec.renders(capability):
+        raise NotFoundException()
+    return spec
+
+
+class ModelController(Controller):
+    """Routes shared by every registered model."""
+
+    path = "/m"
+
+    @get("/{slug:str}")
+    async def index(
+        self,
+        slug: FromPath[str],
+        request: Request,
+        admin_session: NamedDependency[Any],
+        admin_registry: NamedDependency[Registry],
+        admin_path: NamedDependency[str],
+        search: FromQuery[str | None] = None,
+        after: FromQuery[str | None] = None,
+    ) -> Template:
+        """Render a filtered, paginated list."""
+        spec = _spec_or_404(admin_registry, slug, LIST)
+        filters = {
+            name: request.query_params[name]
+            for name in spec.filters
+            if request.query_params.get(name)
+        }
+        result = (
+            await admin_session.execute(
+                list_statement(spec, search=search, filters=filters, after=after)
+            )
+        ).scalars().all()
+        rows = [project(row, spec.list_columns) for row in result]
+        cursor = rows[-1][spec.order_by] if len(rows) == PAGE_SIZE else None
+        return Template(
+            LIST_TEMPLATE,
+            context={
+                "spec": spec,
+                "rows": rows,
+                "search": search,
+                "filters": filters,
+                "cursor": cursor,
+                "page_url": f"{admin_path}/m/{spec.slug}",
+            },
+        )
+
+    @get("/{slug:str}/export")
+    async def export(
+        self,
+        slug: FromPath[str],
+        request: Request,
+        admin_session: NamedDependency[Any],
+        admin_registry: NamedDependency[Registry],
+        admin_audit: NamedDependency[AuditSink],
+    ) -> Stream:
+        """Stream the list as CSV and audit the export."""
+        spec = _spec_or_404(admin_registry, slug, EXPORT)
+        result = (
+            await admin_session.execute(list_statement(spec, limit=EXPORT_LIMIT))
+        ).scalars().all()
+        rows = [project(row, spec.list_columns) for row in result]
+        await admin_audit.write(
+            admin_session, actor_of(request), ACTION_EXPORT,
+            subject=spec.slug, request=request, extra={"rows": len(rows)},
+        )
+        return Stream(
+            csv_rows(spec, rows),
+            media_type=CSV_MEDIA_TYPE,
+            headers={
+                "content-disposition": f'attachment; filename="{spec.slug}.csv"'
+            },
+        )
+
+    @get("/{slug:str}/{pk:str}")
+    async def detail(
+        self,
+        slug: FromPath[str],
+        pk: FromPath[str],
+        request: Request,
+        admin_session: NamedDependency[Any],
+        admin_registry: NamedDependency[Registry],
+        admin_audit: NamedDependency[AuditSink],
+        admin_path: NamedDependency[str],
+    ) -> Template:
+        """Render one record, auditing the view when the spec asks for it."""
+        spec = _spec_or_404(admin_registry, slug, DETAIL)
+        row = (
+            await admin_session.execute(detail_statement(spec, pk))
+        ).scalar_one_or_none()
+        if row is None:
+            raise NotFoundException()
+        if spec.audit_on_detail:
+            await admin_audit.write(
+                admin_session, actor_of(request), ACTION_DETAIL_VIEW,
+                subject=spec.slug, subject_pk=pk, request=request,
+            )
+        return Template(
+            DETAIL_TEMPLATE,
+            context={
+                "spec": spec,
+                "pk": pk,
+                "row": project(row, spec.detail_columns),
+                "page_url": f"{admin_path}/m/{spec.slug}",
+            },
+        )
+
+    @post("/{slug:str}/{pk:str}/delete", status_code=HTTP_303_SEE_OTHER)
+    async def delete(
+        self,
+        slug: FromPath[str],
+        pk: FromPath[str],
+        request: Request,
+        admin_session: NamedDependency[Any],
+        admin_registry: NamedDependency[Registry],
+        admin_audit: NamedDependency[AuditSink],
+        admin_path: NamedDependency[str],
+    ) -> Redirect:
+        """Delete one record and audit it."""
+        spec = _spec_or_404(admin_registry, slug, DELETE)
+        row = (
+            await admin_session.execute(detail_statement(spec, pk))
+        ).scalar_one_or_none()
+        if row is None:
+            raise NotFoundException()
+        await admin_session.delete(row)
+        await admin_audit.write(
+            admin_session, actor_of(request), ACTION_DELETE,
+            subject=spec.slug, subject_pk=pk, request=request,
+        )
+        return Redirect(f"{admin_path}/m/{spec.slug}")

admin_litestar/controllers/session.py

@@ -0,0 +1,77 @@
+"""Login and logout."""
+
+from __future__ import annotations
+
+from typing import Annotated, Any
+
+from litestar import Controller, Request, get, post
+from litestar.di import NamedDependency
+from litestar.enums import RequestEncodingType
+from litestar.params import Body
+from litestar.response import Redirect, Template
+from litestar.status_codes import HTTP_303_SEE_OTHER
+
+from ..auth import clear_failures, is_locked, register_failure
+from ..constants import (
+    ACTION_LOGIN,
+    ACTION_LOGIN_FAILED,
+    SESSION_ACTOR_KEY,
+)
+from ..protocols import AuditSink, AuthBackend, CacheBackend
+
+LOCKED_MESSAGE = "too many attempts, try again later"
+INVALID_MESSAGE = "invalid credentials"
+UNKNOWN_IP = "unknown"
+LOGIN_TEMPLATE = "login.html"
+
+Form = Annotated[dict[str, Any], Body(media_type=RequestEncodingType.URL_ENCODED)]
+
+
+class SessionController(Controller):
+    """Renders the login form and manages the admin session."""
+
+    @get("/login", exclude_from_auth=True)
+    async def form(self) -> Template:
+        """Render the login form."""
+        return Template(LOGIN_TEMPLATE, context={"error": None})
+
+    @post("/login", exclude_from_auth=True, status_code=HTTP_303_SEE_OTHER)
+    async def submit(
+        self,
+        request: Request,
+        data: Form,
+        admin_auth: NamedDependency[AuthBackend],
+        admin_audit: NamedDependency[AuditSink],
+        admin_cache: NamedDependency[CacheBackend],
+        admin_session: NamedDependency[Any],
+        admin_path: NamedDependency[str],
+    ) -> Redirect | Template:
+        """Validate credentials, open a session, and audit the outcome."""
+        username = str(data.get("username", ""))
+        password = str(data.get("password", ""))
+        ip = request.client.host if request.client else UNKNOWN_IP
+        if await is_locked(admin_cache, username, ip):
+            return Template(LOGIN_TEMPLATE, context={"error": LOCKED_MESSAGE})
+        user = await admin_auth.authenticate(admin_session, username, password)
+        if user is None:
+            await register_failure(admin_cache, username, ip)
+            await admin_audit.write(
+                admin_session, None, ACTION_LOGIN_FAILED,
+                request=request, extra={"username": username},
+            )
+            return Template(LOGIN_TEMPLATE, context={"error": INVALID_MESSAGE})
+        await clear_failures(admin_cache, username, ip)
+        actor_id = admin_auth.identity_of(user)
+        request.session[SESSION_ACTOR_KEY] = actor_id
+        await admin_audit.write(
+            admin_session, actor_id, ACTION_LOGIN, request=request
+        )
+        return Redirect(f"{admin_path}/")
+
+    @post("/logout", status_code=HTTP_303_SEE_OTHER)
+    async def logout(
+        self, request: Request, admin_path: NamedDependency[str]
+    ) -> Redirect:
+        """Clear the admin session."""
+        request.session.clear()
+        return Redirect(f"{admin_path}/login")

admin_litestar/export.py

@@ -0,0 +1,45 @@
+"""Streaming CSV export driven by a spec's list columns."""
+
+from __future__ import annotations
+
+import csv
+import io
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable, Iterator
+
+    from .spec import ModelSpec
+
+
+class _Sink:
+    """A one-line buffer the csv writer writes into."""
+
+    def __init__(self) -> None:
+        self._buffer = io.StringIO()
+        self._writer = csv.writer(self._buffer)
+
+    def line(self, values: list[Any]) -> str:
+        """Encode one row and return it, clearing the buffer."""
+        self._writer.writerow(values)
+        text = self._buffer.getvalue()
+        self._buffer.seek(0)
+        self._buffer.truncate(0)
+        return text
+
+
+def csv_rows(spec: ModelSpec, rows: Iterable[dict[str, Any]]) -> Iterator[str]:
+    """Yield CSV lines for a spec's list columns, header first.
+
+    Args:
+        spec: The spec being exported. Its ``list_columns`` define the column
+            set, so hidden and excluded columns cannot appear.
+        rows: Projected row dictionaries.
+
+    Yields:
+        CSV-encoded lines, each including its trailing newline.
+    """
+    sink = _Sink()
+    yield sink.line(list(spec.list_columns))
+    for row in rows:
+        yield sink.line([row.get(column) for column in spec.list_columns])