djangocloud-cli 0.1.1__py3-none-any.whl

djangocloud_cli/__init__.py

@@ -0,0 +1,6 @@
+"""Command-line client for DjangoCloud."""
+
+try:
+    from ._version import __version__  # written at build time from the git tag
+except ImportError:  # running from a checkout that was never built
+    __version__ = "0.0.0+unknown"

djangocloud_cli/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '0.1.1'
+__version_tuple__ = version_tuple = (0, 1, 1)
+
+__commit_id__ = commit_id = None

djangocloud_cli/api.py

@@ -0,0 +1,48 @@
+"""Minimal JSON client for the DjangoCloud API (urllib: no HTTP dependency to conflict with)."""
+
+import json
+import urllib.error
+import urllib.request
+
+from . import __version__
+
+TIMEOUT = 30
+
+
+class ApiError(Exception):
+    def __init__(self, status: int, code: str, message: str):
+        super().__init__(message)
+        self.status, self.code, self.message = status, code, message
+
+
+class Client:
+    def __init__(self, base_url: str, token: str | None = None):
+        self.base_url = base_url.rstrip("/")
+        self.token = token
+
+    def request(self, method: str, path: str, data: dict | None = None) -> dict:
+        headers = {"Accept": "application/json", "User-Agent": f"djangocloud-cli/{__version__}"}
+        body = None
+        if data is not None:
+            body = json.dumps(data).encode()
+            headers["Content-Type"] = "application/json"
+        if self.token:
+            headers["Authorization"] = f"Bearer {self.token}"
+        req = urllib.request.Request(self.base_url + path, data=body, headers=headers, method=method)
+        try:
+            with urllib.request.urlopen(req, timeout=TIMEOUT) as response:
+                return json.loads(response.read() or b"{}")
+        except urllib.error.HTTPError as exc:
+            try:
+                payload = json.loads(exc.read())
+            except ValueError:
+                payload = {}
+            raise ApiError(exc.code, payload.get("error", "http_error"), payload.get("message", exc.reason)) from None
+        except (urllib.error.URLError, TimeoutError) as exc:
+            raise ApiError(0, "unreachable", f"Couldn't reach {self.base_url}: {getattr(exc, 'reason', exc)}") from None
+
+    def get(self, path: str) -> dict:
+        return self.request("GET", path)
+
+    def post(self, path: str, data: dict | None = None) -> dict:
+        return self.request("POST", path, data or {})

djangocloud_cli/auth.py

@@ -0,0 +1,37 @@
+"""`djangocloud login`: the device-code flow. No passwords or keys are typed into the terminal."""
+
+import time
+import webbrowser
+
+from . import config
+from .api import ApiError, Client
+from .ui import console
+
+
+def login(client: Client, *, sleep=time.sleep, open_browser=webbrowser.open, client_name: str = "cloud CLI") -> str:
+    started = client.post("/auth/device", {"client_name": client_name})
+    url, code = started["verification_uri_complete"], started["user_code"]
+    console.print(f"\nOpen [link={url}]{url}[/link]\nand check that the code is [bold]{code}[/bold].\n")
+    try:
+        open_browser(url)
+    except Exception:  # noqa: BLE001 - no browser (SSH, CI) is fine: the URL is printed above
+        pass
+
+    interval = started.get("interval", 5)
+    deadline = time.monotonic() + started.get("expires_in", 600)
+    with console.status("Waiting for you to approve in the browser…"):
+        while time.monotonic() < deadline:
+            sleep(interval)
+            try:
+                token = client.post("/auth/token", {"device_code": started["device_code"]})["access_token"]
+            except ApiError as exc:
+                if exc.code == "authorization_pending":
+                    continue
+                if exc.code == "slow_down":
+                    interval += 5
+                    continue
+                raise
+            config.save_token(token)
+            client.token = token
+            return token
+    raise ApiError(400, "expired_token", "That login expired. Run the login command again.")

djangocloud_cli/cli.py

@@ -0,0 +1,233 @@
+"""`djangocloud` command: one parser shared by the standalone script and `manage.py djangocloud`."""
+
+import argparse
+import sys
+
+from . import __version__, auth, config, link
+from .api import ApiError, Client
+from .ui import NotInteractive, confirm, console, err, interactive, no_input, select, set_no_input, text
+
+STANDALONE = "djangocloud"
+MANAGE_PY = "python manage.py djangocloud"
+_prog = MANAGE_PY  # what messages tell people to type; set by run() to match how we were invoked
+
+
+def say(command: str) -> str:
+    """The command as the user types it, e.g. 'python manage.py djangocloud login'."""
+    return f"{_prog} {command}"
+
+
+COMING_SOON = "'{command}' isn't available yet: the build and deploy pipeline is still being built."
+
+
+def build_parser(prog: str = STANDALONE) -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog=prog, description="Deploy your Django app.")
+    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+    parser.add_argument(
+        "--no-input",
+        action="store_true",
+        help="Never prompt or open a browser (for CI). Needs DJANGOCLOUD_TOKEN and a linked folder or --project",
+    )
+    sub = parser.add_subparsers(dest="command", metavar="<command>")
+
+    sub.add_parser("login", help="Sign in (approve a code in your browser)")
+    sub.add_parser("logout", help="Forget the stored token")
+    sub.add_parser("whoami", help="Show who you are signed in as")
+
+    linkers = (
+        ("deploy", "Link this folder to a project, then deploy it"),
+        ("link", "Pick or create the project this folder deploys to"),
+    )
+    for name, helptext in linkers:
+        cmd = sub.add_parser(name, help=helptext)
+        cmd.add_argument("--project", help="Use this existing project (slug) without prompting")
+        cmd.add_argument("--name", help="Create a new project with this name without prompting")
+        cmd.add_argument("--size", help="Server size for a new project, e.g. nano")
+        cmd.add_argument("-y", "--yes", action="store_true", help="Don't ask for confirmation")
+    sub.add_parser("unlink", help="Detach this folder from its project")
+    sub.add_parser("status", help="Show the current release and its state")
+
+    logs = sub.add_parser("logs", help="Show a project's logs")
+    logs.add_argument("-f", "--follow", action="store_true", help="Keep streaming new lines")
+    logs.add_argument("--source", choices=["app", "build", "release"], help="Only this kind of log line")
+    logs.add_argument("--since", metavar="DURATION", help="Only lines newer than this, e.g. 2h")
+
+    helper = sub.add_parser("help", help="Show this help")
+    helper.add_argument("topic", nargs="?", help="A command to get help for")
+    return parser
+
+
+class CliError(Exception):
+    pass
+
+
+def make_client() -> Client:
+    return Client(config.api_url(), config.load_token())
+
+
+def ensure_login(client: Client) -> None:
+    """Make sure the client holds a token the server accepts, signing in if it doesn't."""
+    if client.token:
+        try:
+            client.get("/me")
+            return
+        except ApiError as exc:
+            if exc.code != "unauthorized":
+                raise
+    if not interactive():
+        raise CliError(
+            "Not signed in. In CI set DJANGOCLOUD_TOKEN (create one at /dashboard/cli/); "
+            f"on your own machine run '{say('login')}'."
+        )
+    console.print("You're not signed in yet.")
+    auth.login(client)
+    console.print(f"[green]✓[/green] Signed in as {client.get('/me')['email']}")
+
+
+def _price(cents: int) -> str:
+    return f"${cents / 100:,.0f}" if cents % 100 == 0 else f"${cents / 100:,.2f}"
+
+
+def _size_label(size: dict) -> str:
+    specs = f"{size['vcpu']:g} vCPU, {size['ram_gb']:g} GB RAM"
+    return f"{size['label']:<8} {specs:<22} {_price(size['price_cents'])}/month"
+
+
+def ensure_linked(client: Client, root, args, *, force: bool = False) -> dict:
+    existing = None if force else link.load(root)
+    if existing:
+        return existing
+
+    projects = client.get("/projects")["projects"]
+    if args.project:
+        match = next((p for p in projects if p["slug"] == args.project), None)
+        if match is None:
+            raise CliError(f"No project {args.project!r} on your account.")
+        project = match
+    else:
+        choice = args.name or select(
+            "Which project is this?",
+            [("Create a new project", None)] + [(f"{p['name'] or p['slug']}  ({p['slug']})", p) for p in projects],
+        )
+        project = choice if isinstance(choice, dict) else create_project(client, root, args)
+    path = link.save(root, project, config.api_url())
+    console.print(f"[green]✓[/green] Linked to [bold]{project['slug']}[/bold] ({path.relative_to(root)})")
+    return project
+
+
+def create_project(client: Client, root, args) -> dict:
+    name = args.name or text("Project name", default=root.name)
+    sizes = client.get("/sizes")["sizes"]
+    if args.size:
+        size = next((s for s in sizes if s["power"] == args.size), None)
+        if size is None:
+            raise CliError(f"Unknown size {args.size!r}. Choose from: {', '.join(s['power'] for s in sizes)}.")
+    else:
+        size = select("Server size", [(_size_label(s), s) for s in sizes])
+    monthly = _price(size["price_cents"])
+    if not (args.yes or no_input()) and not confirm(f"This will cost {monthly} per month. Continue?"):
+        raise CliError("Cancelled. Nothing was created.")
+    try:
+        return client.post("/projects", {"name": name, "power": size["power"]})
+    except ApiError as exc:
+        if exc.code == "payment_required":
+            raise CliError(f"{exc.message}") from None
+        raise
+
+
+def cmd_login(args, root) -> int:
+    if not interactive():
+        raise CliError(f"'{say('login')}' needs a browser. In CI use a DJANGOCLOUD_TOKEN instead.")
+    client = make_client()
+    auth.login(client)
+    console.print(f"[green]✓[/green] Signed in as {client.get('/me')['email']}")
+    return 0
+
+
+def cmd_whoami(args, root) -> int:
+    client = make_client()
+    if not client.token:
+        console.print(f"Not signed in. Run [bold]{say('login')}[/bold].")
+        return 1
+    try:
+        me = client.get("/me")
+    except ApiError as exc:
+        if exc.code != "unauthorized":
+            raise
+        console.print(f"Your token is no longer valid. Run [bold]{say('login')}[/bold].")
+        return 1
+    console.print(f"Signed in as [bold]{me['email']}[/bold]")
+    linked = link.load(root)
+    if linked:
+        console.print(f"This folder deploys to [bold]{linked['slug']}[/bold].")
+    return 0
+
+
+def cmd_logout(args, root) -> int:
+    console.print("Signed out." if config.clear_token() else "You weren't signed in.")
+    return 0
+
+
+def cmd_link(args, root) -> int:
+    client = make_client()
+    ensure_login(client)
+    ensure_linked(client, root, args, force=True)
+    return 0
+
+
+def cmd_unlink(args, root) -> int:
+    console.print("Unlinked." if link.remove(root) else "This folder isn't linked.")
+    return 0
+
+
+def cmd_deploy(args, root) -> int:
+    client = make_client()
+    ensure_login(client)
+    project = ensure_linked(client, root, args)
+    console.print(f"Ready to deploy [bold]{project['slug']}[/bold].")
+    err.print(COMING_SOON.format(command=say("deploy")))
+    err.print("Your project is linked, so the next release will pick it up.")
+    return 2
+
+
+COMMANDS = {
+    "login": cmd_login,
+    "logout": cmd_logout,
+    "whoami": cmd_whoami,
+    "link": cmd_link,
+    "unlink": cmd_unlink,
+    "deploy": cmd_deploy,
+}
+
+
+def run(argv: list[str] | None = None, prog: str = STANDALONE) -> int:
+    global _prog
+    _prog = prog
+    parser = build_parser(prog)
+    args = parser.parse_args(argv)
+    set_no_input(getattr(args, "no_input", False))
+
+    if args.command in (None, "help"):
+        topic = getattr(args, "topic", None)
+        if topic:
+            return run([topic, "--help"], prog)  # argparse prints the sub-command's help, then exits
+        parser.print_help()
+        return 0
+    handler = COMMANDS.get(args.command)
+    if handler is None:
+        err.print(COMING_SOON.format(command=say(args.command)))
+        return 2
+    try:
+        return handler(args, link.find_root())
+    except (CliError, NotInteractive) as exc:
+        err.print(f"[red]Error:[/red] {exc}")
+    except ApiError as exc:
+        err.print(f"[red]Error:[/red] {exc.message}")
+    except KeyboardInterrupt:
+        err.print("\nCancelled.")
+        return 130
+    return 1
+
+
+def main() -> None:
+    sys.exit(run(sys.argv[1:]))

djangocloud_cli/config.py

@@ -0,0 +1,52 @@
+"""Where the CLI keeps its API token, and how it finds one.
+
+Order: the DJANGOCLOUD_TOKEN environment variable (CI), then the credentials file written by
+`djangocloud login`. The token is a bearer secret, so the file is created readable by its owner only.
+"""
+
+import json
+import os
+import stat
+from pathlib import Path
+
+TOKEN_ENV = "DJANGOCLOUD_TOKEN"
+API_ENV = "DJANGOCLOUD_API"
+DEFAULT_API = "https://djangocloud.dev/api/v1"
+
+
+def credentials_path() -> Path:
+    base = Path(os.environ.get("XDG_CONFIG_HOME") or Path.home() / ".config")
+    return base / "djangocloud" / "credentials.json"
+
+
+def api_url() -> str:
+    return os.environ.get(API_ENV, DEFAULT_API).rstrip("/")
+
+
+def load_token() -> str | None:
+    token = os.environ.get(TOKEN_ENV)
+    if token:
+        return token
+    try:
+        return json.loads(credentials_path().read_text()).get("token")
+    except (OSError, ValueError):
+        return None
+
+
+def save_token(token: str) -> Path:
+    path = credentials_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    # Create with 0600 from the start so the token is never briefly world-readable.
+    fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, stat.S_IRUSR | stat.S_IWUSR)
+    with os.fdopen(fd, "w") as handle:
+        json.dump({"token": token}, handle)
+    os.chmod(path, stat.S_IRUSR | stat.S_IWUSR)
+    return path
+
+
+def clear_token() -> bool:
+    try:
+        credentials_path().unlink()
+    except FileNotFoundError:
+        return False
+    return True

djangocloud_cli/link.py

@@ -0,0 +1,51 @@
+"""The link between a folder and a DjangoCloud project: `.djangocloud/config.json`.
+
+Written by the CLI, holds no secrets, and is git-ignored by a `.gitignore` inside the folder, so it
+can't be committed by accident. The API token lives in the user's config directory, not here.
+"""
+
+import json
+from pathlib import Path
+
+DIR = ".djangocloud"
+FILE = "config.json"
+
+
+def find_root(start: Path | None = None) -> Path:
+    """The nearest folder already linked, else the one holding manage.py, else where we are."""
+    start = (start or Path.cwd()).resolve()
+    for folder in (start, *start.parents):
+        if (folder / DIR / FILE).is_file():
+            return folder
+    for folder in (start, *start.parents):
+        if (folder / "manage.py").is_file():
+            return folder
+    return start
+
+
+def load(root: Path) -> dict | None:
+    try:
+        data = json.loads((root / DIR / FILE).read_text())
+    except (OSError, ValueError):
+        return None
+    if not isinstance(data, dict) or not data.get("project"):
+        return None
+    # Same shape the API returns for a project, so callers treat both alike.
+    return {"id": data.get("project_id"), "slug": data["project"], "api": data.get("api", "")}
+
+
+def save(root: Path, project: dict, api: str) -> Path:
+    folder = root / DIR
+    folder.mkdir(exist_ok=True)
+    (folder / ".gitignore").write_text("*\n")
+    path = folder / FILE
+    path.write_text(json.dumps({"project_id": project["id"], "project": project["slug"], "api": api}, indent=2) + "\n")
+    return path
+
+
+def remove(root: Path) -> bool:
+    path = root / DIR / FILE
+    if not path.exists():
+        return False
+    path.unlink()
+    return True

djangocloud_cli/management/commands/djangocloud.py

@@ -0,0 +1,16 @@
+"""`python manage.py djangocloud <command>`: the same CLI, run inside the user's Django project."""
+
+from django.core.management.base import BaseCommand
+
+from djangocloud_cli.cli import MANAGE_PY, run
+
+
+class Command(BaseCommand):
+    help = "Deploy this project: login | deploy | logs | status | help (run with no arguments for details)"
+
+    def add_arguments(self, parser):
+        parser.add_argument("args", nargs="*")  # handed to the shared parser untouched
+
+    def run_from_argv(self, argv):
+        # Skip Django's own option parsing so flags like -f and --since reach our parser.
+        raise SystemExit(run(argv[2:], prog=MANAGE_PY))

djangocloud_cli/ui.py

@@ -0,0 +1,64 @@
+"""Terminal output and prompts. Prompts need a terminal: scripts must pass flags instead."""
+
+import os
+import sys
+
+import questionary
+from rich.console import Console
+
+console = Console()
+err = Console(stderr=True)
+
+
+class NotInteractive(Exception):
+    pass
+
+
+NO_INPUT_ENV = "DJANGOCLOUD_NO_INPUT"
+_no_input = False
+
+
+def set_no_input(value: bool) -> None:
+    """--no-input (or DJANGOCLOUD_NO_INPUT=1): never prompt, never open a browser. For CI."""
+    global _no_input
+    _no_input = value
+
+
+def no_input() -> bool:
+    return _no_input or os.environ.get(NO_INPUT_ENV, "") not in ("", "0", "false")
+
+
+def interactive() -> bool:
+    return not no_input() and sys.stdin.isatty() and sys.stdout.isatty()
+
+
+def _need_terminal(what: str) -> None:
+    if not interactive():
+        raise NotInteractive(
+            f"Can't ask for {what} without a terminal (or with --no-input). "
+            "Pass it as a flag, e.g. --project, --name, --size, --yes."
+        )
+
+
+def ask(question: questionary.Question):
+    answer = question.ask()
+    if answer is None:  # Ctrl-C inside a prompt
+        raise KeyboardInterrupt
+    return answer
+
+
+def text(message: str, default: str = "") -> str:
+    _need_terminal(message.lower())
+    return ask(questionary.text(message, default=default))
+
+
+def confirm(message: str, default: bool = True) -> bool:
+    _need_terminal("confirmation")
+    return ask(questionary.confirm(message, default=default))
+
+
+def select(message: str, choices: list[tuple[str, object]]):
+    """Arrow-key menu over (label, value) pairs; returns the chosen value."""
+    _need_terminal(message.lower())
+    options = [questionary.Choice(title=label, value=value) for label, value in choices]
+    return ask(questionary.select(message, choices=options))

djangocloud_cli-0.1.1.dist-info/METADATA

@@ -0,0 +1,93 @@
+Metadata-Version: 2.5
+Name: djangocloud-cli
+Version: 0.1.1
+Summary: Deploy a Django app from the command line: djangocloud login, djangocloud deploy, djangocloud logs.
+Project-URL: Homepage, https://djangocloud.dev
+Project-URL: Source, https://github.com/two-trick-pony-NL/djangocloud-cli
+Project-URL: Issues, https://github.com/two-trick-pony-NL/djangocloud-cli/issues
+Author-email: Peter van Doorn <peter@petervandoorn.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: aws,cli,deploy,django,lightsail
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 4.2
+Classifier: Framework :: Django :: 5.0
+Classifier: Framework :: Django :: 5.1
+Classifier: Framework :: Django :: 5.2
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development
+Requires-Python: >=3.10
+Requires-Dist: questionary>=2.0
+Requires-Dist: rich>=13
+Description-Content-Type: text/markdown
+
+# djangocloud-cli
+
+Command-line client for DjangoCloud. Standard library only.
+
+```
+pip install djangocloud-cli          # then add "djangocloud_cli" to INSTALLED_APPS
+python manage.py djangocloud login
+python manage.py djangocloud deploy
+python manage.py djangocloud logs -f
+python manage.py djangocloud help
+```
+
+A standalone `djangocloud` script is installed too (same commands, no `manage.py`), for when your settings won't load.
+
+**Status:** early. `help`, `login`, `logout`, `whoami`, `link`, `unlink` and the interactive setup in `deploy` work
+(they need the DjangoCloud API). Uploading, building and deploying, `logs` and `status` are next.
+
+## First run
+
+```
+$ python manage.py djangocloud deploy
+You're not signed in yet.
+Open https://djangocloud.dev/dashboard/cli/?code=ABCD-EFGH and check that the code is ABCD-EFGH.
+✓ Signed in as you@example.com
+? Which project is this?  (arrow keys)
+? Server size  Nano  0.25 vCPU, 0.5 GB RAM  $10/month
+? This will cost $10 per month. Continue? Yes
+✓ Linked to my-shop (.djangocloud/config.json)
+```
+
+`.djangocloud/config.json` says which project this folder deploys to. It holds no secrets and is git-ignored by a
+`.gitignore` inside the folder. Later runs skip every prompt.
+
+## CI (GitHub Actions)
+
+Create a token under **Command line → Token for CI** in the dashboard and store it as the repository secret
+`DJANGOCLOUD_TOKEN`. `--no-input` makes the CLI fail with a clear message instead of ever prompting or opening a browser.
+
+```yaml
+- run: pip install djangocloud-cli
+- run: python manage.py djangocloud deploy --no-input --project my-shop
+  env:
+    DJANGOCLOUD_TOKEN: ${{ secrets.DJANGOCLOUD_TOKEN }}
+```
+
+## Configuration
+
+| Variable | Purpose |
+|---|---|
+| `DJANGOCLOUD_TOKEN` | API token for CI; takes precedence over the stored login |
+| `DJANGOCLOUD_NO_INPUT` | Same as `--no-input` (set it to `1`) |
+| `DJANGOCLOUD_API` | API base URL (default `https://djangocloud.dev/api/v1`) |
+
+The token from `login` is stored in `~/.config/djangocloud/credentials.json` (mode 600).
+
+## Development
+
+```
+uv sync
+uv run pytest
+uv run ruff check
+```

djangocloud_cli-0.1.1.dist-info/RECORD

@@ -0,0 +1,16 @@
+djangocloud_cli/__init__.py,sha256=bW6IVL54sMH5jro61y1lLpJZNNwBUFqwhdIrFioxljA,231
+djangocloud_cli/_version.py,sha256=mEr1FdwwZVMovyM6vpPg2W8zwa1u1f4KdymTrLcqf9U,520
+djangocloud_cli/api.py,sha256=Bp2yUANAD-ZdUniGsJQbdAlM1njOwnxBKhn7m9Pplvg,1878
+djangocloud_cli/auth.py,sha256=SyV-7vyO_5luj4WNCMpDY2LDDT82QSK5CykybJ3S7Qw,1539
+djangocloud_cli/cli.py,sha256=bAKWeq6xkFZcRoig2VQCP3CP0y1Nj9DKUK9aEoHbJuE,8557
+djangocloud_cli/config.py,sha256=olHIM0qbzEkcJ2mUrNXNBwbt6sgpNgGVBemkzWiP8Hg,1500
+djangocloud_cli/link.py,sha256=rMrly2_U5vWKBNCQcshEIIuYvtowwoZQPiJ_Yj-QA_Y,1679
+djangocloud_cli/ui.py,sha256=Jg1u9MpcICAJAUTl7WdAWnjku-bI4PjrzEOsfvVn3jc,1764
+djangocloud_cli/management/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+djangocloud_cli/management/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+djangocloud_cli/management/commands/djangocloud.py,sha256=qPvns74-mb-Tf1TfsPF2r_r78hFKkCc55EhPY5wOE1Y,647
+djangocloud_cli-0.1.1.dist-info/METADATA,sha256=9ABQNhVs1PoDLOmgUUNSE1kajlfySHiKRZOVcCnhMoQ,3394
+djangocloud_cli-0.1.1.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+djangocloud_cli-0.1.1.dist-info/entry_points.txt,sha256=2SmBlcQIHSQxVJoqn9dFN0MeCn4y2m252MjYsCNM8Xc,57
+djangocloud_cli-0.1.1.dist-info/licenses/LICENSE,sha256=9JBaP5jj-a_qIFMHTXkCD-6dpP2VmwUZpNgWHLS9Kiw,1072
+djangocloud_cli-0.1.1.dist-info/RECORD,,

djangocloud_cli-0.1.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

djangocloud_cli-0.1.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+djangocloud = djangocloud_cli.cli:main

djangocloud_cli-0.1.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Peter van Doorn
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.