API Reference¶

Whether identity may administer a resource owned by owner.

When no admin_groups are configured administration is unrestricted: the running user (however resolved) may administer any resource. This keeps the default, auth-less deployment fully editable. Once admin_groups are set, only the owner and members of those groups may administer a resource.

Evaluate permission against identity.

Order of precedence:

1. A matching deny_users/deny_groups rule denies access (deny always wins, even for the owner).
2. The owner, if given and matching, is allowed.
3. Any allow_* rule present: allowed iff the identity matches at least one of them.
4. No allow/deny rules at all: fall back to default_allow.

Build a Panel config.authorize_callback gating page routes.

The returned callback authorizes direct HTTP access to code-authored page URLs against the resolved identity. Non-page routes (/components, /dash/... and unknown paths) always pass here and are gated in-app, where per-dashboard permissions and richer denied views live.

url_prefix strips a server route prefix from the request path before matching against registry page paths.

Map each page's URL path to its declared :class:Permission.

Used by the HTTP-boundary authorize callback to gate direct URL access to code-authored pages. Only page entries are included; component and SPA-only routes are gated in-app.

Resolve the current session's :class:Identity.

Prefers the OAuth login (pn.state.user) when a real provider populated it; otherwise falls back to the system user, then to "anonymous". Groups are the union of claim-derived groups, the static user_groups mapping and any dynamic resolve_groups callback.

Entry point for the panel-flowdash CLI.

Build a registry from any supported component declaration.

Parameters:

Returns:

Build a ComponentSpec from a registry entry, caching it on the entry.

A spec is derived purely from the component's class/metadata, so it does not vary between sessions. Registry entries are shared across sessions, which makes the cache process-wide.

Build specs for component-enabled entries in a registry.

Parameters:

Create a Parameterized subclass with one param per port (inputs + outputs).

Scan project_dir for page/component modules without importing them.

Reads each .py file with the AST to extract @register metadata. Modules are not imported at this stage; each RegistryEntry.app is None until RegistryEntry.load() is called.

Metadata-only decorator for app exports.

Annotates an app object/callable without altering runtime behavior.

The config_schema, config and config_editor arguments declare design-time configuration options that appear in the node editor. Use config_schema (a param.Parameterized subclass, a Pydantic model, or a JSON Schema dict) to define config explicitly, or config to name which of a Viewer's own params are configuration rather than input ports. Pass config_editor to supply a custom editor callable instead of the auto-generated form.

The allow_users, allow_groups, deny_users and deny_groups arguments declare page-level authorization rules. Users are matched against either the OAuth login or the system user; groups against the identity's resolved group membership. Deny rules always win; when only allow rules are present the identity must match at least one; with no rules the project's default policy applies. Pass authorize for a custom callable taking the resolved Identity and returning a bool (resolved on import).

Build a Parameterized subclass with one param per declared state key.

Scans the registry for all provides and requires keys and creates a dynamic class whose parameters represent shared session state.

Check which required keys are unsatisfied on the given state instance.

Returns a list of dicts describing each unsatisfied requirement. An empty list means all requirements are met.

Whether obj is a coroutine or async generator function.

Whether obj is an async generator function, seen through decorators.

param.output and functools.wraps return sync wrappers around async functions, which the plain :mod:inspect predicates report as sync, so unwrap before asking.

Whether obj is a coroutine function, seen through decorators.

Emit a Panel notification, falling back to the logger.

pn.state.notifications is None outside a served session (a plain script, a test, or a notebook without the notifications extension), so calling it unguarded raises. Embedders can also opt out entirely by passing enabled=False.

Call a component callable and return a renderable view of the result.

Sync callables are called immediately. Async ones must not be: calling them here would only produce an un-awaited coroutine, which pn.panel wraps as a string. Instead they are deferred to a zero-argument closure that Panel's ParamFunction awaits (or iterates, for async generators) on the event loop when the view is rendered.

Return a renderable view of a Viewer, awaiting an async __panel__.

pn.panel calls __panel__ synchronously, so an async def __panel__ would be wrapped un-awaited. ParamMethod handles both, and additionally re-renders when the method declares param.depends.