karni-cli 0.3.1__py3-none-any.whl

karni_cli/_templates/project/{{cookiecutter.project_slug}}/config/asgi.py

@@ -0,0 +1,14 @@
+"""ASGI config for {{ cookiecutter.project_name }}.
+
+Exposes the ASGI callable as a module-level variable named ``application``.
+This is what gunicorn runs in production (with uvicorn workers); see the
+Dockerfile ``prod`` target.
+"""
+
+import os
+
+from django.core.asgi import get_asgi_application
+
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "config.settings")
+
+application = get_asgi_application()

karni_cli/_templates/project/{{cookiecutter.project_slug}}/config/celery.py

@@ -0,0 +1,17 @@
+"""Celery entry point for {{ cookiecutter.project_name }}.
+
+Used by ``celery -A config worker`` and ``celery -A config beat``. The app
+is configured from Django settings (every ``CELERY_*`` name), so override
+Celery behaviour in config/settings.py, or pass keyword overrides to
+``create_celery_app()`` here.
+"""
+
+import os
+
+from karni.celery import create_celery_app
+
+# create_celery_app() requires DJANGO_SETTINGS_MODULE to be set already;
+# setdefault here covers the `celery -A config ...` entry points.
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "config.settings")
+
+app = create_celery_app()

karni_cli/_templates/project/{{cookiecutter.project_slug}}/config/settings.py

@@ -0,0 +1,28 @@
+"""Django settings for {{ cookiecutter.project_name }}.
+
+karni_settings() fills this module with Karni's defaults — INSTALLED_APPS,
+middleware, DRF, Celery, Redis cache, storage, logging, security headers,
+CORS and Sentry — all read from environment variables (see .env.example).
+
+Overriding: anything assigned *after* the call wins, and any name defined
+*before* the call is never overwritten by Karni.
+"""
+
+from karni.conf import karni_settings
+
+karni_settings(globals())
+
+# --- Project apps ------------------------------------------------------------
+INSTALLED_APPS += [  # noqa: F821
+    # "myapp",
+]  # karni:apps
+
+# --- Project middleware (runs after Karni's stack) ----------------------------
+MIDDLEWARE += [  # noqa: F821
+    # "myapp.middleware.MyMiddleware",
+]  # karni:middleware
+
+# --- Project overrides -------------------------------------------------------
+# Any Django/Karni setting assigned here beats the Karni default, e.g.:
+# REST_FRAMEWORK["PAGE_SIZE"] = 25
+# CELERY_TASK_TIME_LIMIT = 600

karni_cli/_templates/project/{{cookiecutter.project_slug}}/config/urls.py

@@ -0,0 +1,31 @@
+"""URL configuration for {{ cookiecutter.project_name }}.
+
+Routes: Django admin, the OpenAPI schema and Swagger UI (drf-spectacular),
+Karni's auth endpoints (/api/auth/), the auto-routed API (/api/), Karni's
+health endpoints (/health/ liveness, /health/ready/ readiness) and, last,
+the welcome page at "/" while DEBUG is on. Add project routes to
+``urlpatterns`` below; to replace a single Karni endpoint, declare your
+``path(...)`` for it BEFORE the include — first match wins. Your own
+``path("", ...)`` replaces the welcome page the same way.
+"""
+
+from django.conf import settings
+from django.contrib import admin
+from django.urls import include, path
+from drf_spectacular.views import SpectacularAPIView, SpectacularSwaggerView
+
+from karni.welcome import media_urls, welcome_urls
+
+urlpatterns = [
+    # KARNI_ADMIN_PATH (env, default "admin/"): move the admin off the guessable path.
+    path(settings.KARNI_ADMIN_PATH, admin.site.urls),
+    path("api/schema/", SpectacularAPIView.as_view(), name="schema"),
+    path("api/docs/", SpectacularSwaggerView.as_view(url_name="schema"), name="swagger-ui"),
+    path("api/auth/", include("karni.accounts.urls")),
+    path("api/", include("karni.api.urls")),
+    path("health/", include("karni.health.urls")),
+    # Uploads under MEDIA_URL while DEBUG is on and storage is local (dev only).
+    *media_urls(),
+    # Only while DEBUG is on, and only until a route above answers "/".
+    *welcome_urls(),
+]

karni_cli/_templates/project/{{cookiecutter.project_slug}}/config/wsgi.py

@@ -0,0 +1,14 @@
+"""WSGI config for {{ cookiecutter.project_name }}.
+
+Exposes the WSGI callable as a module-level variable named ``application``.
+The production stack serves ASGI (config/asgi.py) by default; this module is
+kept for WSGI-only hosts.
+"""
+
+import os
+
+from django.core.wsgi import get_wsgi_application
+
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "config.settings")
+
+application = get_wsgi_application()

karni_cli/_templates/project/{{cookiecutter.project_slug}}/docker-compose.yml

@@ -0,0 +1,126 @@
+# Development stack for {{ cookiecutter.project_name }}.
+#
+#   cp .env.example .env && docker compose up --build
+#
+# django runs migrations before serving, so worker and beat (which need the
+# django-celery-beat / django-celery-results tables) wait on django's
+# healthcheck, not just on db/redis.
+# KARNI_SRC (from .env) optionally installs a vendored karni checkout — see README.md.
+
+services:
+  django:
+    build:
+      context: .
+      target: dev
+      args:
+        KARNI_SRC: ${KARNI_SRC:-}
+    command: sh -c "python manage.py migrate --noinput && python manage.py runserver 0.0.0.0:8000"
+    ports:
+      - "8000:8000"
+    env_file: .env
+    volumes:
+      - .:/app
+      - app_data:/data
+    depends_on:
+      db:
+        condition: service_healthy
+      redis:
+        condition: service_healthy
+    healthcheck:
+      # Liveness endpoint only responds once migrations have finished and
+      # runserver is up — downstream services key off this.
+      test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:8000/health/')"]
+      interval: 5s
+      timeout: 5s
+      retries: 30
+      start_period: 30s
+
+  db:
+    image: postgres:16
+    environment:
+      POSTGRES_USER: karni
+      POSTGRES_PASSWORD: karni
+      POSTGRES_DB: karni
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+    healthcheck:
+      test: ["CMD", "pg_isready", "-U", "karni", "-d", "karni"]
+      interval: 5s
+      timeout: 5s
+      retries: 10
+
+  redis:
+    image: redis:7
+    healthcheck:
+      test: ["CMD", "redis-cli", "ping"]
+      interval: 5s
+      timeout: 5s
+      retries: 10
+
+  worker:
+    build:
+      context: .
+      target: dev
+      args:
+        KARNI_SRC: ${KARNI_SRC:-}
+    command: celery -A config worker -l info
+    env_file: .env
+    volumes:
+      - .:/app
+      - app_data:/data
+    depends_on:
+      db:
+        condition: service_healthy
+      redis:
+        condition: service_healthy
+      django:
+        condition: service_healthy
+
+  beat:
+    build:
+      context: .
+      target: dev
+      args:
+        KARNI_SRC: ${KARNI_SRC:-}
+    # --pidfile= disables the pidfile; a stale one in the bind mount would
+    # otherwise block restarts.
+    command: celery -A config beat -l info --pidfile=
+    env_file: .env
+    volumes:
+      - .:/app
+    depends_on:
+      db:
+        condition: service_healthy
+      redis:
+        condition: service_healthy
+      django:
+        condition: service_healthy
+
+  frontend:
+    build:
+      context: ./frontend
+      dockerfile: Dockerfile.dev
+    # Runs `npm install`, then Vite (see frontend/Dockerfile.dev).
+    environment:
+      KARNI_API_PROXY: http://django:8000
+    ports:
+      - "5173:5173"
+    volumes:
+      - ./frontend:/app
+      # Container-built node_modules (Linux binaries), never the host's.
+      - frontend_node_modules:/app/node_modules
+{%- if cookiecutter.karni_ui.startswith("file:") %}
+      # The local @karni/ui checkout that package.json's "file:" spec names,
+      # mounted read-only where that spec resolves inside the container (the
+      # same absolute path, or /app/<relative path> for a project inside the
+      # Karni checkout) so npm resolves it here too.
+      - type: bind
+        source: {{ cookiecutter.karni_ui[5:] | tojson }}
+        target: {{ cookiecutter.karni_ui_mount | tojson }}
+        read_only: true
+{%- endif %}
+
+volumes:
+  postgres_data:
+  app_data:
+  frontend_node_modules:

karni_cli/_templates/project/{{cookiecutter.project_slug}}/frontend/.dockerignore

@@ -0,0 +1,2 @@
+node_modules
+dist

karni_cli/_templates/project/{{cookiecutter.project_slug}}/frontend/.jscpd.json

@@ -0,0 +1,9 @@
+{
+  "minTokens": 70,
+  "threshold": 2,
+  "path": ["src"],
+  "pattern": "**/*.{ts,tsx}",
+  "ignore": ["**/node_modules/**", "src/api/**"],
+  "exitCode": 1,
+  "reporters": ["consoleFull"]
+}

karni_cli/_templates/project/{{cookiecutter.project_slug}}/frontend/.npmrc

@@ -0,0 +1,7 @@
+# A local @karni/ui ("file:<path>" in package.json, written by `karni new`
+# from a Karni checkout) installs as a packed COPY, exactly like the npm
+# release: its dependencies and peers land in this node_modules, so there is
+# one React and one QueryClient, never the checkout's own node_modules.
+# The copy is a snapshot: after rebuilding the checkout (npm run build there),
+# refresh it with `rm -rf node_modules/@karni/ui && npm install`.
+install-links=true

karni_cli/_templates/project/{{cookiecutter.project_slug}}/frontend/Dockerfile.dev

@@ -0,0 +1,17 @@
+# Dev-only image for the Vite dev server. docker-compose bind-mounts the
+# source over /app and keeps node_modules in a named volume.
+#
+# Dependencies install when the container STARTS, not at image build: a local
+# @karni/ui ("file:<path>" in package.json, written by `karni new` from a Karni
+# checkout) lives outside this build context and is only reachable through
+# the read-only mount docker-compose.yml adds at that same path. Installing on
+# start also keeps the node_modules volume in sync with package.json.
+#
+# --no-package-lock: the host's package-lock.json records a local @karni/ui
+# relative to the host's frontend/ directory, which does not hold from /app;
+# the container resolves from package.json and never rewrites the host lock.
+FROM node:20-alpine
+WORKDIR /app
+COPY . .
+EXPOSE 5173
+CMD ["sh", "-c", "npm install --no-package-lock --no-audit --no-fund && exec npm run dev -- --host"]

karni_cli/_templates/project/{{cookiecutter.project_slug}}/frontend/eslint.config.js

@@ -0,0 +1,32 @@
+// ESLint flat config (ESLint >= 9) for the frontend.
+//
+// The Karni enforcement rules come from @karni/ui's bundled plugin:
+// karni/no-raw-elements (compose ResourceTable/ResourceForm/Input instead of
+// raw elements), karni/max-page-lines (pages cap at 50 physical lines),
+// karni/no-deep-imports (never import @karni/ui/dist or /src),
+// karni/no-direct-http (fetch/axios only under src/api/), plus a required
+// reason on every disable directive and errors on unused directives.
+import karni from "@karni/ui/eslint-plugin";
+import js from "@eslint/js";
+import globals from "globals";
+import tseslint from "typescript-eslint";
+
+export default tseslint.config(
+    // src/api/ is generated by `karni types` (and is the allowed home of raw
+    // HTTP) — lint what you write, not what Karni generates.
+    { ignores: ["dist/", "node_modules/", "src/api/**"] },
+    js.configs.recommended,
+    ...tseslint.configs.recommended,
+    ...karni.configs.recommended,
+    {
+        files: ["**/*.ts", "**/*.tsx"],
+        languageOptions: {
+            globals: { ...globals.browser },
+            parserOptions: { ecmaFeatures: { jsx: true } },
+        },
+    },
+    {
+        files: ["*.config.js", "*.config.ts"],
+        languageOptions: { globals: { ...globals.node } },
+    },
+);

karni_cli/_templates/project/{{cookiecutter.project_slug}}/frontend/index.html

@@ -0,0 +1,14 @@
+<!doctype html>
+<html lang="en">
+    <head>
+        <meta charset="UTF-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+        <title>{{ cookiecutter.project_name }}</title>
+        <!-- public/favicon.svg is a placeholder: replace it with your own mark. -->
+        <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
+    </head>
+    <body>
+        <div id="root"></div>
+        <script type="module" src="/src/main.tsx"></script>
+    </body>
+</html>

karni_cli/_templates/project/{{cookiecutter.project_slug}}/frontend/package.json

@@ -0,0 +1,43 @@
+{
+    "name": "{{ cookiecutter.project_slug }}-frontend",
+    "private": true,
+    "version": "0.1.0",
+    "type": "module",
+    "scripts": {
+        "dev": "vite",
+        "build": "tsc && vite build",
+        "preview": "vite preview",
+        "lint": "eslint .",
+        "dup": "jscpd --config .jscpd.json"
+    },
+    "dependencies": {
+        "@hookform/resolvers": "^3.9.0",
+        "@karni/ui": {{ cookiecutter.karni_ui | tojson }},
+        "@tanstack/react-query": "^5.56.0",
+        "@tanstack/react-router": "^1.130.0",
+        "@tanstack/react-table": "^8.20.5",
+        "react": "^18.3.1",
+        "react-dom": "^18.3.1",
+        "react-hook-form": "^7.53.0",
+        "zod": "^3.23.8"
+    },
+    "devDependencies": {
+        "@eslint/js": "^9.39.5",
+        "@types/react": "^18.3.5",
+        "@types/react-dom": "^18.3.0",
+        "@vitejs/plugin-react": "^4.7.0",
+        "autoprefixer": "^10.4.20",
+        "eslint": "^9.39.5",
+        "globals": "^15.15.0",
+        "jscpd": "5.4.0",
+        "openapi-typescript": "^7.4.0",
+        "postcss": "^8.4.45",
+        "tailwindcss": "~3.4.19",
+        "typescript": "^5.5.4",
+        "typescript-eslint": "^8.71.0",
+        "vite": "^6.4.4"
+    },
+    "overrides": {
+        "postcss-selector-parser": "^7.1.7"
+    }
+}

karni_cli/_templates/project/{{cookiecutter.project_slug}}/frontend/postcss.config.js

@@ -0,0 +1,6 @@
+export default {
+    plugins: {
+        tailwindcss: {},
+        autoprefixer: {},
+    },
+};

karni_cli/_templates/project/{{cookiecutter.project_slug}}/frontend/public/favicon.svg

@@ -0,0 +1,6 @@
+<!-- Placeholder icon. Replace this file with your own mark (keep the name, or
+     change the <link rel="icon"> in index.html). It is deliberately plain. -->
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32" width="32" height="32" role="img" aria-label="{{ cookiecutter.project_name }}">
+  <rect width="32" height="32" rx="7" fill="#64748B"/>
+  <circle cx="16" cy="16" r="6" fill="#FFFFFF"/>
+</svg>

karni_cli/_templates/project/{{cookiecutter.project_slug}}/frontend/src/App.tsx

@@ -0,0 +1,18 @@
+import { AuthProvider, KarniProvider, Toaster, createKarniClient } from "@karni/ui";
+import { RouterProvider } from "@tanstack/react-router";
+import { router } from "./routes";
+
+// One client for the whole app: every @karni/ui hook and component reaches
+// the Django API through it (same origin; the Vite dev server proxies /api).
+const client = createKarniClient({ baseUrl: "/api" });
+
+export default function App() {
+    return (
+        <KarniProvider client={client}>
+            <AuthProvider>
+                <RouterProvider router={router} />
+                <Toaster />
+            </AuthProvider>
+        </KarniProvider>
+    );
+}

karni_cli/_templates/project/{{cookiecutter.project_slug}}/frontend/src/api/health.ts

@@ -0,0 +1,21 @@
+/**
+ * Dev health probe. src/api/ is the one home of raw HTTP
+ * (karni/no-direct-http allows it); everywhere else, data access goes through
+ * the typed hooks and client that `karni types` generates into this
+ * directory.
+ */
+export type Health = "ok" | "fail" | "unreachable";
+
+export async function fetchHealth(): Promise<Health> {
+    try {
+        const response = await fetch("/health/ready/");
+        const data: unknown = await response.json();
+        const status =
+            typeof data === "object" && data !== null
+                ? (data as { status?: unknown }).status
+                : undefined;
+        return status === "ok" ? "ok" : "fail";
+    } catch {
+        return "unreachable";
+    }
+}

karni_cli/_templates/project/{{cookiecutter.project_slug}}/frontend/src/index.css

@@ -0,0 +1,11 @@
+/* Tailwind layers. The --karni-* tokens come from @karni/ui/styles.css
+   (imported first in main.tsx); override any token below to retheme. */
+@tailwind base;
+@tailwind components;
+@tailwind utilities;
+
+@layer base {
+    body {
+        @apply bg-background text-foreground antialiased;
+    }
+}

karni_cli/_templates/project/{{cookiecutter.project_slug}}/frontend/src/layout.tsx

@@ -0,0 +1,51 @@
+// The app shell: @karni/ui's <Layout>, with one nav entry per static route in
+// routes.tsx, in registration order — pages from `karni make page` show up
+// here on their own.
+// Detail/edit routes ($id) and "new" forms are reached from their list page.
+import { Layout, type LayoutNavItem } from "@karni/ui";
+import { Outlet, useRouter, useRouterState } from "@tanstack/react-router";
+
+function label(path: string): string {
+    const name = path.split("/").filter(Boolean).at(-1) ?? "home";
+    return name.replace(/[-_]+/g, " ").replace(/^./, (first) => first.toUpperCase());
+}
+
+export default function AppLayout() {
+    const router = useRouter();
+    const pathname = useRouterState({ select: (state) => state.location.pathname });
+    const navItems: LayoutNavItem[] = Object.keys(router.routesByPath)
+        .filter((path) => !path.includes("$") && !path.endsWith("/new"))
+        .map((href) => ({
+            href,
+            label: label(href),
+            active: href === pathname || (href !== "/" && pathname.startsWith(`${href}/`)),
+        }));
+    return (
+        <Layout
+            navItems={navItems}
+            // Your brand goes here: swap the placeholder square for your mark
+            // (an <img src="/favicon.svg">, an inline SVG, or a component).
+            sidebarHeader={
+                <span className="flex items-center gap-2 px-3 text-lg font-semibold">
+                    <span aria-hidden="true" className="h-6 w-6 rounded-md bg-slate-500" />
+                    {{ cookiecutter.project_name }}
+                </span>
+            }
+            // Client-side navigation: intercept the default link's click (it
+            // still closes the mobile drawer); `contents` keeps the nav grid.
+            renderNavItem={(item, { defaultNode }) => (
+                <span
+                    className="contents"
+                    onClickCapture={(event) => {
+                        event.preventDefault();
+                        router.history.push(item.href);
+                    }}
+                >
+                    {defaultNode}
+                </span>
+            )}
+        >
+            <Outlet />
+        </Layout>
+    );
+}

karni_cli/_templates/project/{{cookiecutter.project_slug}}/frontend/src/main.tsx

@@ -0,0 +1,11 @@
+import "@karni/ui/styles.css";
+import "./index.css";
+import React from "react";
+import ReactDOM from "react-dom/client";
+import App from "./App";
+
+ReactDOM.createRoot(document.getElementById("root") as HTMLElement).render(
+    <React.StrictMode>
+        <App />
+    </React.StrictMode>,
+);

karni_cli/_templates/project/{{cookiecutter.project_slug}}/frontend/src/pages/home.tsx

@@ -0,0 +1,28 @@
+import { Page } from "@karni/ui";
+import { useEffect, useState } from "react";
+import { fetchHealth, type Health } from "../api/health";
+
+export default function HomePage() {
+    const [health, setHealth] = useState<Health | "checking">("checking");
+
+    useEffect(() => {
+        void fetchHealth().then(setHealth);
+    }, []);
+
+    return (
+        <Page
+            title="{{ cookiecutter.project_name }}"
+            description="Vite + React dev server. Requests to /api and /health are proxied to Django."
+        >
+            <p className="text-sm">
+                Backend readiness:{" "}
+                <code className="rounded bg-muted px-1.5 py-0.5">{health}</code>
+            </p>
+            <p className="text-sm">
+                <a className="font-medium underline underline-offset-4" href="/api/docs/">
+                    API docs
+                </a>
+            </p>
+        </Page>
+    );
+}

karni_cli/_templates/project/{{cookiecutter.project_slug}}/frontend/src/routes.tsx

@@ -0,0 +1,24 @@
+// Routes (TanStack Router, code-based). `karni make page` registers each new
+// page through the two marker comments below — keep them. Hand-written routes
+// are fine too: import the page and add a createRoute(...) entry to `routes`.
+// Every route renders inside the app shell (./layout.tsx), whose navigation
+// lists the static routes registered here.
+import { createRootRoute, createRoute, createRouter } from "@tanstack/react-router";
+import AppLayout from "./layout";
+import HomePage from "./pages/home";
+// karni:page-imports
+
+const root = createRootRoute({ component: AppLayout });
+
+const routes = [
+    createRoute({ getParentRoute: () => root, path: "/", component: HomePage }),
+    // karni:routes
+];
+
+export const router = createRouter({ routeTree: root.addChildren(routes) });
+
+declare module "@tanstack/react-router" {
+    interface Register {
+        router: typeof router;
+    }
+}

karni_cli/_templates/project/{{cookiecutter.project_slug}}/frontend/src/vite-env.d.ts

@@ -0,0 +1 @@
+/// <reference types="vite/client" />

karni_cli/_templates/project/{{cookiecutter.project_slug}}/frontend/tailwind.config.ts

@@ -0,0 +1,13 @@
+import karniPreset from "@karni/ui/tailwind-preset";
+import type { Config } from "tailwindcss";
+
+// Tailwind v3 + the @karni/ui preset: maps bg-primary, text-muted-foreground,
+// border, rounded-lg, ... onto the --karni-* tokens from @karni/ui/styles.css.
+export default {
+    presets: [karniPreset],
+    content: [
+        "./src/**/*.{ts,tsx}",
+        // So Tailwind sees the classes used inside @karni/ui:
+        "./node_modules/@karni/ui/dist/**/*.js",
+    ],
+} satisfies Config;

karni_cli/_templates/project/{{cookiecutter.project_slug}}/frontend/tsconfig.json

@@ -0,0 +1,19 @@
+{
+    "compilerOptions": {
+        "target": "ES2022",
+        "useDefineForClassFields": true,
+        "lib": ["ES2022", "DOM", "DOM.Iterable"],
+        "module": "ESNext",
+        "moduleResolution": "bundler",
+        "jsx": "react-jsx",
+        "strict": true,
+        "noUnusedLocals": true,
+        "noUnusedParameters": true,
+        "noFallthroughCasesInSwitch": true,
+        "isolatedModules": true,
+        "skipLibCheck": true,
+        "noEmit": true,
+        "types": ["vite/client"]
+    },
+    "include": ["src"]
+}

karni_cli/_templates/project/{{cookiecutter.project_slug}}/frontend/vite.config.ts

@@ -0,0 +1,18 @@
+import react from "@vitejs/plugin-react";
+import { defineConfig } from "vite";
+
+// API and health requests from the dev server are proxied to Django:
+// `karni serve --local` (runserver on 127.0.0.1:8000) by default;
+// docker-compose sets KARNI_API_PROXY=http://django:8000 for its container.
+const target = process.env.KARNI_API_PROXY ?? "http://127.0.0.1:8000";
+const proxy = {
+    "/api": { target, changeOrigin: true },
+    "/health": { target, changeOrigin: true },
+};
+
+export default defineConfig({
+    plugins: [react()],
+    server: { host: true, port: 5173, proxy },
+    // `vite preview` serves the production build the same way (e2e suites, smoke checks).
+    preview: { host: true, port: 4173, proxy },
+});

karni_cli/_templates/project/{{cookiecutter.project_slug}}/manage.py

@@ -0,0 +1,23 @@
+#!/usr/bin/env python
+"""Django's command-line utility for administrative tasks."""
+
+import os
+import sys
+
+
+def main() -> None:
+    """Run administrative tasks."""
+    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "config.settings")
+    try:
+        from django.core.management import execute_from_command_line
+    except ImportError as exc:
+        raise ImportError(
+            "Couldn't import Django. Are you sure it's installed and "
+            "available on your PYTHONPATH environment variable? Did you "
+            "forget to activate a virtual environment?"
+        ) from exc
+    execute_from_command_line(sys.argv)
+
+
+if __name__ == "__main__":
+    main()