pinky-provider 0.1.0.dev1__py3-none-any.whl

pinky_provider/__init__.py

@@ -0,0 +1,26 @@
+"""pinky-provider — declarative, idempotent IaC engine for Snowflake.
+
+Top-level names are imported lazily (PEP 562): ``import pinky_provider`` stays light and never
+pulls ``snowflake.core`` until you actually touch :class:`Provider` or
+:class:`~pinky_provider.resources.schema.SchemaProvider`. This keeps the engine's pure logic
+(``core.diff``, ``core.manifest``, ``resources.base``) importable on its own — and supports the
+lightweight ``ARTIFACT_REPOSITORY`` import path (ADR-0014).
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+__all__ = ["Provider", "SchemaProvider"]
+
+
+def __getattr__(name: str) -> Any:
+    if name == "Provider":
+        from pinky_provider.provider import Provider
+
+        return Provider
+    if name == "SchemaProvider":
+        from pinky_provider.resources.schema import SchemaProvider
+
+        return SchemaProvider
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

pinky_provider/cli/__init__.py

@@ -0,0 +1,3 @@
+from pinky_provider.cli.main import main
+
+__all__ = ["main"]

pinky_provider/cli/main.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+import rich_click as click
+from rich.console import Console
+
+from pinky_provider.core.diff import Action, ResourceDiff
+
+# Symbol + colour per action, matching the plan/apply display contract (ADR-0003).
+_STYLE: dict[Action, tuple[str, str]] = {
+    Action.CREATE: ("+", "green"),
+    Action.ALTER: ("~", "yellow"),
+    Action.UNCHANGED: ("=", "dim"),
+    Action.DROP: ("-", "red"),
+}
+
+
+def _render(console: Console, diffs: list[ResourceDiff], title: str) -> None:
+    console.print(f"[bold]{title}[/bold]")
+    if not diffs:
+        console.print("  [dim]no resources declared[/dim]")
+        return
+    for diff in diffs:
+        symbol, colour = _STYLE[diff.action]
+        detail = f"  [dim]({diff.details})[/dim]" if diff.details else ""
+        console.print(
+            f"  [{colour}]{symbol}  {diff.resource_type}/{diff.name}[/{colour}]"
+            f"  [{colour}]{diff.action}[/{colour}]{detail}"
+        )
+
+
+@click.group()
+def main() -> None:
+    """pinky-provider — declarative IaC engine for Snowflake."""
+
+
+@main.command()
+@click.option(
+    "--env", required=True, help="Target environment (SANDBOX or PRODUCTION)."
+)
+@click.option("--source", default="manifest.yml", show_default=True)
+def plan(env: str, source: str) -> None:
+    """Show changes without applying them."""
+    from pinky_provider.core.session import get_session
+    from pinky_provider.provider import Provider
+
+    console = Console()
+    provider = Provider(get_session())
+    diffs = provider.plan(source=source, env=env)
+    _render(console, diffs, f"Plan · {env}")
+
+
+@main.command()
+@click.option(
+    "--env", required=True, help="Target environment (SANDBOX or PRODUCTION)."
+)
+@click.option("--source", default="manifest.yml", show_default=True)
+def apply(env: str, source: str) -> None:
+    """Apply the manifest to the target schema."""
+    from pinky_provider.core.session import get_session
+    from pinky_provider.provider import Provider
+
+    console = Console()
+    provider = Provider(get_session())
+    diffs = provider.apply(source=source, env=env)
+    _render(console, diffs, f"Apply · {env}")
+
+
+@main.command()
+@click.option(
+    "--out", default=".pinky/schemas", show_default=True, help="Output directory."
+)
+def schemas(out: str) -> None:
+    """Generate JSON Schemas for resource YAML files (editor autocomplete). No Snowflake session."""
+    from pinky_provider.core.schemas import write_schemas
+
+    console = Console()
+    written = write_schemas(out)
+    console.print(f"[bold]Schemas · {len(written)}[/bold]")
+    for type_name, path in written:
+        console.print(f"  [green]+[/green]  {type_name}  [dim]{path}[/dim]")
+    console.print(
+        "\n[dim]Wire autocomplete — add to .vscode/settings.json (key = schema, value = glob):[/dim]\n"
+        f'  "yaml.schemas": {{ "./{out}/<type>.schema.json": "resources/<type>/*.yml" }}'
+    )

pinky_provider/core/__init__.py

@@ -0,0 +1,5 @@
+from pinky_provider.core.diff import Action, ResourceDiff, compute_diff
+from pinky_provider.core.manifest import Manifest
+from pinky_provider.core.session import inject_query_tag
+
+__all__ = ["Action", "Manifest", "ResourceDiff", "compute_diff", "inject_query_tag"]

pinky_provider/core/diff.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping
+from dataclasses import dataclass
+from enum import StrEnum
+from typing import Any
+
+
+class Action(StrEnum):
+    CREATE = "CREATE"
+    ALTER = "ALTER"
+    UNCHANGED = "UNCHANGED"
+    DROP = "DROP"
+
+
+@dataclass
+class ResourceDiff:
+    """Result of comparing desired resource state against Snowflake's current state.
+
+    Attributes:
+        resource_type: The resource type key (e.g. ``table``, ``warehouse``).
+        name: Object name.
+        action: The DDL action the provider will take.
+        details: Comma-separated changed field names (populated for ``ALTER`` only).
+    """
+
+    resource_type: str
+    name: str
+    action: Action
+    details: str = ""
+
+
+def _normalize(value: Any) -> Any:
+    """Default comparison: case-insensitive for strings, pass-through otherwise."""
+    return value.upper() if isinstance(value, str) else value
+
+
+def compute_diff(
+    resource_type: str,
+    name: str,
+    desired: dict[str, Any],
+    actual: dict[str, Any] | None,
+    normalizers: Mapping[str, Callable[[Any], Any]] | None = None,
+) -> ResourceDiff:
+    """Compare a desired resource descriptor to the current Snowflake object state.
+
+    Args:
+        resource_type: Resource type key.
+        name: Object name.
+        desired: The SDK-facing payload (``to_sdk_dict``); ``_``-keys and ``name`` are ignored.
+        actual: Current state fetched from ``snowflake.core`` (``.to_dict()``), or ``None`` if absent.
+        normalizers: Per-field comparison function (e.g. ``warehouse_size`` → size canonicaliser),
+            declared per resource via ``_field_normalizers``. Fields without one use case-insensitive
+            comparison.
+
+    Returns:
+        A :class:`ResourceDiff` describing the required DDL action. Only fields present in
+        ``desired`` are compared — pinky never asserts on fields it does not declare.
+    """
+    if actual is None:
+        return ResourceDiff(resource_type, name, Action.CREATE)
+
+    field_normalizers = normalizers or {}
+    changed = []
+    for key, want in desired.items():
+        if key.startswith("_") or key == "name":
+            continue
+        norm = field_normalizers.get(key, _normalize)
+        if norm(actual.get(key)) != norm(want):
+            changed.append(key)
+    if changed:
+        return ResourceDiff(
+            resource_type, name, Action.ALTER, ", ".join(sorted(changed))
+        )
+    return ResourceDiff(resource_type, name, Action.UNCHANGED)

pinky_provider/core/manifest.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+import yaml
+from jinja2 import Environment, StrictUndefined, UndefinedError
+
+
+@dataclass
+class ResourceSpec:
+    """One declared Snowflake object, after Jinja resolution.
+
+    Attributes:
+        resource_type: Type key, inferred from the parent folder (``resources/warehouse/`` → ``warehouse``).
+        data: Rendered YAML payload — Snowflake fields plus ``_``-prefixed provider keys.
+    """
+
+    resource_type: str
+    data: dict[str, Any] = field(default_factory=dict)
+
+    @property
+    def name(self) -> str:
+        return str(self.data.get("name", ""))
+
+
+class Manifest:
+    """Parsed ``manifest.yml`` with Jinja2 variable resolution applied.
+
+    The manifest declares the deployment ``scope`` and the resource files to load. Each resource
+    file is rendered with the variables from ``vars/<ENV>.yml`` (overridable), then parsed. Its
+    type is the parent folder name — ``1 file = 1 object`` (AGENT.md).
+
+    Args:
+        source: Path to ``manifest.yml``.
+        env: Target environment — selects ``vars/<env>.yml`` (e.g. ``SANDBOX``).
+        vars: Variable overrides injected on top of the env file.
+
+    Attributes:
+        resources: Resource specs in declared order.
+        scope: ``schema``, ``database``, or ``account``.
+        env: The resolved environment name.
+    """
+
+    resources: list[ResourceSpec]
+    scope: str
+    env: str
+
+    def __init__(
+        self, source: str | Path, env: str, vars: dict[str, str] | None = None
+    ) -> None:
+        source_path = Path(source).resolve()
+        self.root_dir = source_path.parent
+        self.env = env
+
+        manifest = yaml.safe_load(source_path.read_text()) or {}
+        self.scope = str(manifest.get("scope", "schema"))
+
+        merged_vars = self._load_vars(env, vars)
+        self.resources = self._load_resources(
+            manifest.get("resources", []) or [], merged_vars
+        )
+
+    def _load_vars(self, env: str, overrides: dict[str, str] | None) -> dict[str, Any]:
+        vars_file = self.root_dir / "vars" / f"{env}.yml"
+        base: dict[str, Any] = {}
+        if vars_file.exists():
+            base = yaml.safe_load(vars_file.read_text()) or {}
+        if overrides:
+            base = {**base, **overrides}
+        return base
+
+    def _render(self, text: str, merged_vars: dict[str, Any]) -> str:
+        environment = Environment(undefined=StrictUndefined, autoescape=False)  # nosec B701
+        try:
+            return environment.from_string(text).render(vars=merged_vars, env=self.env)
+        except UndefinedError as exc:
+            raise KeyError(f"Missing manifest variable while rendering: {exc}") from exc
+
+    def _resolve_paths(self, entry: str) -> list[Path]:
+        base = self.root_dir / "resources"
+        rel = entry if entry.endswith((".yml", ".yaml")) else f"{entry}.yml"
+        if any(ch in rel for ch in "*?["):
+            matches = sorted(base.glob(rel))
+            if not matches:
+                raise FileNotFoundError(f"No resource file matches: {base / rel}")
+            return matches
+        candidate = base / rel
+        if not candidate.exists():
+            raise FileNotFoundError(f"Resource file not found: {candidate}")
+        return [candidate]
+
+    def _load_resources(
+        self, entries: list[str], merged_vars: dict[str, Any]
+    ) -> list[ResourceSpec]:
+        specs: list[ResourceSpec] = []
+        for entry in entries:
+            for path in self._resolve_paths(entry):
+                rendered = self._render(path.read_text(), merged_vars)
+                data = yaml.safe_load(rendered) or {}
+                specs.append(ResourceSpec(resource_type=path.parent.name, data=data))
+        return specs
+
+    @classmethod
+    def from_git(cls, repo_url: str, vars: dict[str, str] | None = None) -> Manifest:
+        """Load a manifest from a Snowflake-hosted Git repository.
+
+        Not yet implemented — local filesystem manifests only for now.
+        """
+        raise NotImplementedError("Git-repo manifest source is not implemented yet")

pinky_provider/core/schemas.py

@@ -0,0 +1,47 @@
+"""JSON Schema generation for resource YAML files — editor autocomplete & validation.
+
+Schemas are produced from the Pydantic resource models, which are themselves introspected from
+``snowflake.core`` (ADR-0001). They therefore stay in sync with the SDK automatically — no hand-
+maintained schema. Wired to the YAML language server, they give field-name autocomplete, unknown-
+field errors (``additionalProperties: false`` from ``extra="forbid"``), type errors, and required-
+field checks — all at authoring time, before any ``apply`` (ADR-0015).
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+from pinky_provider.resources.base import BaseResource
+
+
+def all_resource_classes() -> dict[str, type[BaseResource]]:
+    """Map of resource type key → model class, across every implemented scope registry."""
+    classes: dict[str, type[BaseResource]] = {}
+    from pinky_provider.resources.account import RESOURCES as account_resources
+
+    classes.update(account_resources)
+    # database / schema registries are added here as those scopes are implemented.
+    return classes
+
+
+def resource_json_schema(resource_cls: type[BaseResource]) -> dict[str, Any]:
+    """JSON Schema for one resource type, generated from its Pydantic model."""
+    return resource_cls.model_json_schema()
+
+
+def write_schemas(out_dir: str | Path) -> list[tuple[str, Path]]:
+    """Write one ``<type>.schema.json`` per resource type into ``out_dir``.
+
+    Returns the ``(type, path)`` pairs written, so the CLI can report them.
+    """
+    out = Path(out_dir)
+    out.mkdir(parents=True, exist_ok=True)
+    written: list[tuple[str, Path]] = []
+    for type_name, resource_cls in sorted(all_resource_classes().items()):
+        schema = resource_json_schema(resource_cls)
+        path = out / f"{type_name}.schema.json"
+        path.write_text(json.dumps(schema, indent=2) + "\n")
+        written.append((type_name, path))
+    return written

pinky_provider/core/session.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+import json
+from typing import Any
+
+
+def get_session() -> Any:
+    """Build (or reuse) a Snowpark ``Session`` from the default Snowflake connection.
+
+    Used by the CLI in a local / CI context. Resolves credentials from the standard Snowflake
+    connection sources — ``connections.toml`` (``SNOWFLAKE_DEFAULT_CONNECTION_NAME``) or
+    ``SNOWFLAKE_*`` environment variables. Never called inside a stored procedure, where the
+    session is always passed in.
+
+    Returns:
+        An active Snowpark ``Session``.
+    """
+    from snowflake.snowpark import Session
+
+    return Session.builder.getOrCreate()
+
+
+def build_query_tag(repo: str, schema: str, resource_type: str, name: str) -> str:
+    """Build a structured JSON query tag for credit attribution.
+
+    Args:
+        repo: Git repository name (maps to the schema being deployed).
+        schema: Target Snowflake schema (``DATABASE.SCHEMA``).
+        resource_type: Resource type being applied (e.g. ``table``, ``procedure``).
+        name: Resource object name.
+
+    Returns:
+        JSON string ready for :meth:`snowflake.snowpark.Session.append_query_tag`.
+    """
+    return json.dumps(
+        {"pinky_provider": {"repo": repo, "schema": schema, resource_type: name}},
+        separators=(",", ":"),
+    )
+
+
+def inject_query_tag(
+    session: Any, repo: str, schema: str, resource_type: str, name: str
+) -> None:
+    """Append a structured query tag to the active Snowflake session.
+
+    Uses :meth:`snowflake.snowpark.Session.append_query_tag` — non-destructive,
+    preserves any tag already set on the session.
+
+    Args:
+        session: Active Snowpark ``Session``.
+        repo: Git repository name.
+        schema: Target Snowflake schema (``DATABASE.SCHEMA``).
+        resource_type: Resource type being applied.
+        name: Resource object name.
+    """
+    session.append_query_tag(build_query_tag(repo, schema, resource_type, name))

pinky_provider/dag/__init__.py

@@ -0,0 +1,3 @@
+from pinky_provider.dag.dag import Dag
+
+__all__ = ["Dag"]

pinky_provider/dag/dag.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import Field
+
+from pinky_provider.resources.base import BaseResource
+
+
+class Dag(BaseResource):
+    """Meta-resource that generates a Snowflake Task DAG from a list of task descriptors.
+
+    Produces the full DAG topology: ``ROOT_TASK_WRAPPER`` (finalizer + notification)
+    and ``TASK_WRAPPER`` (per-step SP caller with SKIP cascade). Never maps 1:1 to
+    a single Snowflake object — see ``explanation/dag.md`` for the generated structure.
+
+    Attributes:
+        tasks: Ordered list of task descriptors (each maps to one ``TASK_WRAPPER``).
+        trigger: Trigger mode — ``CRON``, ``CONDITIONAL_CRON``, or ``STREAM``.
+        alerts_to: Notification target on technical failure.
+        contact_to: Notification target on business rejection.
+    """
+
+    tasks: list[dict[str, Any]] = Field(default_factory=list)
+    trigger: str = "CRON"
+    alerts_to: str | None = None
+    contact_to: str | None = None

pinky_provider/provider.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+from typing import Any
+
+from pinky_provider.core.diff import ResourceDiff
+from pinky_provider.core.manifest import Manifest
+from pinky_provider.resources.account import AccountProvider
+from pinky_provider.resources.database import DatabaseProvider
+from pinky_provider.resources.schema import SchemaProvider
+
+
+class Provider:
+    """Full-scope provider — assembles schema, database, and account resources.
+
+    Entry point for CLI and CI/CD pipelines. Never use inside a stored procedure
+    (imports the full resource graph including account-level objects).
+
+    The manifest's ``scope`` selects which sub-provider runs. Only ``account`` scope is wired in
+    this first slice; ``schema`` and ``database`` follow.
+
+    Example:
+        .. code-block:: python
+
+            from pinky_provider import Provider
+
+            provider = Provider(session)
+            provider.plan(source="manifest.yml", env="SANDBOX")
+            provider.apply(source="manifest.yml", env="SANDBOX")
+
+    Args:
+        session: Active Snowpark ``Session``.
+    """
+
+    def __init__(self, session: Any) -> None:
+        self._session = session
+        self.schema = SchemaProvider(session)
+        self.database = DatabaseProvider(session)
+        self.account = AccountProvider(session)
+
+    def _route(self, manifest: Manifest) -> AccountProvider:
+        if manifest.scope == "account":
+            return self.account
+        raise NotImplementedError(
+            f"scope {manifest.scope!r} not implemented yet — only 'account' is wired"
+        )
+
+    def plan(
+        self,
+        source: str,
+        target: str | None = None,
+        env: str = "SANDBOX",
+        vars: dict[str, str] | None = None,
+    ) -> list[ResourceDiff]:
+        """Compute the full change plan without applying anything.
+
+        Args:
+            source: Path to ``manifest.yml``.
+            target: Target schema as ``DATABASE.SCHEMA`` (schema scope) — unused at account scope.
+            env: Environment selecting ``vars/<env>.yml`` (e.g. ``SANDBOX``).
+            vars: Variable overrides injected into the manifest.
+
+        Returns:
+            Ordered list of :class:`~pinky_provider.core.diff.ResourceDiff`.
+        """
+        manifest = Manifest(source, env=env, vars=vars)
+        return self._route(manifest).plan(manifest)
+
+    def apply(
+        self,
+        source: str,
+        target: str | None = None,
+        env: str = "SANDBOX",
+        vars: dict[str, str] | None = None,
+    ) -> list[ResourceDiff]:
+        """Apply the manifest — deploys or alters all declared objects.
+
+        Args:
+            source: Path to ``manifest.yml``.
+            target: Target schema as ``DATABASE.SCHEMA`` (schema scope) — unused at account scope.
+            env: Environment selecting ``vars/<env>.yml``.
+            vars: Variable overrides injected into the manifest.
+
+        Returns:
+            The diffs actually executed.
+        """
+        manifest = Manifest(source, env=env, vars=vars)
+        return self._route(manifest).apply(manifest)

pinky_provider/resources/__init__.py

@@ -0,0 +1,27 @@
+"""Scope providers, imported lazily (PEP 562).
+
+Importing ``pinky_provider.resources`` (or the pure ``resources.base`` module) does not pull the
+account graph — and therefore ``snowflake.core`` — until a scope provider is actually accessed.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+__all__ = ["AccountProvider", "DatabaseProvider", "SchemaProvider"]
+
+
+def __getattr__(name: str) -> Any:
+    if name == "AccountProvider":
+        from pinky_provider.resources.account import AccountProvider
+
+        return AccountProvider
+    if name == "DatabaseProvider":
+        from pinky_provider.resources.database import DatabaseProvider
+
+        return DatabaseProvider
+    if name == "SchemaProvider":
+        from pinky_provider.resources.schema import SchemaProvider
+
+        return SchemaProvider
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

pinky_provider/resources/account/__init__.py

@@ -0,0 +1,96 @@
+from __future__ import annotations
+
+from typing import Any
+
+from pinky_provider.core.diff import Action, ResourceDiff, compute_diff
+from pinky_provider.core.manifest import Manifest, ResourceSpec
+from pinky_provider.core.session import inject_query_tag
+from pinky_provider.resources.account.warehouse import Warehouse
+from pinky_provider.resources.base import BaseResource
+
+# Resource type key → resource class. Extended as account types are implemented.
+RESOURCES: dict[str, type[BaseResource]] = {
+    "warehouse": Warehouse,
+}
+
+
+class AccountProvider:
+    """Account-scoped provider — deploys account-level objects (warehouses, roles, etc.).
+
+    Never imported inside a stored procedure. Used only by the CLI in CI/CD context.
+
+    Args:
+        session: Active Snowpark ``Session`` with ``ACCOUNTADMIN`` or equivalent role.
+    """
+
+    def __init__(self, session: Any) -> None:
+        from snowflake.core import Root
+
+        self._session = session
+        self._root = Root(session)
+
+    def _build(self, spec: ResourceSpec) -> BaseResource:
+        """Construct a validated resource model from a manifest spec.
+
+        ``_``-prefixed YAML keys (``_depends_on``, ``_tags``) are stripped before validation and
+        re-attached as private attributes, so ``extra="forbid"`` only sees Snowflake fields.
+        """
+        cls = RESOURCES.get(spec.resource_type)
+        if cls is None:
+            raise ValueError(
+                f"Unsupported account resource type: {spec.resource_type!r}"
+            )
+        meta = {k: v for k, v in spec.data.items() if k.startswith("_")}
+        fields = {k: v for k, v in spec.data.items() if not k.startswith("_")}
+        resource = cls(**fields)
+        resource._depends_on = meta.get("_depends_on", [])
+        resource._tags = meta.get("_tags", {})
+        return resource
+
+    def _fetch(self, resource: BaseResource) -> dict[str, Any] | None:
+        """Fetch the current Snowflake state, or ``None`` if the object does not exist."""
+        from snowflake.core.exceptions import NotFoundError
+
+        try:
+            current = resource.collection(self._root)[resource.name].fetch().to_dict()
+        except NotFoundError:
+            return None
+        return dict(current)
+
+    def _diff(self, spec: ResourceSpec, resource: BaseResource) -> ResourceDiff:
+        desired = resource.to_sdk_dict()  # exactly what Snowflake will receive
+        actual = self._fetch(resource)
+        return compute_diff(
+            spec.resource_type,
+            resource.name,
+            desired,
+            actual,
+            normalizers=type(resource)._field_normalizers,
+        )
+
+    def plan(self, manifest: Manifest) -> list[ResourceDiff]:
+        """Compute changes without applying them."""
+        return [self._diff(spec, self._build(spec)) for spec in manifest.resources]
+
+    def apply(self, manifest: Manifest) -> list[ResourceDiff]:
+        """Apply the manifest at account scope — creates or alters each declared object.
+
+        Returns the diff list actually executed, so the CLI can render what happened.
+        """
+        applied: list[ResourceDiff] = []
+        for spec in manifest.resources:
+            resource = self._build(spec)
+            diff = self._diff(spec, resource)
+            if diff.action in (Action.CREATE, Action.ALTER):
+                inject_query_tag(
+                    self._session,
+                    repo=manifest.root_dir.name,
+                    schema=manifest.scope,
+                    resource_type=spec.resource_type,
+                    name=resource.name,
+                )
+                resource.collection(self._root)[resource.name].create_or_alter(
+                    resource.to_sdk()
+                )
+            applied.append(diff)
+        return applied

pinky_provider/resources/account/api_integration.py

@@ -0,0 +1,6 @@
+from __future__ import annotations
+
+from pinky_provider.resources.base import BaseResource
+
+
+class ApiIntegration(BaseResource): ...

pinky_provider/resources/account/compute_pool.py

@@ -0,0 +1,6 @@
+from __future__ import annotations
+
+from pinky_provider.resources.base import BaseResource
+
+
+class ComputePool(BaseResource): ...

pinky_provider/resources/account/database.py

@@ -0,0 +1,6 @@
+from __future__ import annotations
+
+from pinky_provider.resources.base import BaseResource
+
+
+class Database(BaseResource): ...