ailands 0.5.2__py3-none-any.whl

ailands/__init__.py

@@ -0,0 +1,6 @@
+"""The Ailands developer CLI: sign in, scaffold, publish to the Ailands store.
+
+The API an agent's code imports is the kernel's, `aipelago.sdk`, the same on every
+distribution, so an agent written for Ailands runs wherever that kernel runs.
+`pip install ailands` brings it in as a dependency (`aipelago-sdk`).
+"""

ailands/cli.py

@@ -0,0 +1,428 @@
+"""The `ailands` command — a developer's whole loop, from their own machine.
+
+    ailands login                sign in with your Ailands account
+    ailands init my-agent        start from a working skeleton
+    ailands publish .            upload it as a draft (only you can take it)
+    ailands submit weather 1.0   ask for review
+    ailands status               where everything stands
+
+It talks to the developer platform over HTTPS and never to a kernel. That is why
+it can be public while the kernel is not: publishing needs an account and a
+signature, neither of which requires the thing that runs agents.
+"""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+import json
+import secrets
+import sys
+import time
+from collections.abc import Iterator
+from contextlib import suppress
+from pathlib import Path
+
+import click
+import httpx
+
+from ailands import config
+from ailands.pack import PackError, build
+
+_TIMEOUT = 60.0
+
+
+def _pkce_pair() -> tuple[str, str]:
+    """A PKCE `(verifier, challenge)` for the device flow.
+
+    An identity provider may require proof of key exchange from a public client
+    even on the device flow (RFC 7636); one that does not ask ignores these two
+    parameters.
+    """
+    verifier = secrets.token_urlsafe(64)
+    digest = hashlib.sha256(verifier.encode("ascii")).digest()
+    return verifier, base64.urlsafe_b64encode(digest).rstrip(b"=").decode("ascii")
+
+
+def _refresh() -> bool:
+    """Spend the stored refresh token on a new access token. True if it worked.
+
+    The access token is short-lived; the refresh token outlives it so that an
+    expiry mid-build renews silently instead of asking you to sign in again.
+    """
+    creds = config.load_credentials()
+    token = str(creds.get("refresh_token") or "")
+    if not token:
+        return False
+    try:
+        info = _api("GET", "/v1/platform", auth=False)
+        issuer, client_id = info.get("oidc_issuer", ""), info.get("oidc_client_id", "")
+        if not issuer or not client_id:
+            return False
+        meta = httpx.get(f"{issuer}/.well-known/openid-configuration", timeout=_TIMEOUT).json()
+        resp = httpx.post(
+            meta["token_endpoint"],
+            data={
+                "grant_type": "refresh_token",
+                "refresh_token": token,
+                "client_id": client_id,
+            },
+            timeout=_TIMEOUT,
+        )
+    except (httpx.HTTPError, KeyError, click.ClickException):
+        # An unreachable IdP is not a bad refresh token: say nothing here and let
+        # the caller report the 401 it already has.
+        return False
+    if resp.status_code != 200:
+        return False
+    config.save_credentials(resp.json())
+    return True
+
+
+def _api(method: str, path: str, *, auth: bool = True, _retried: bool = False, **kwargs) -> dict:
+    headers = dict(kwargs.pop("headers", {}))
+    if auth:
+        token = config.access_token()
+        if not token:
+            raise click.ClickException("not signed in — run `ailands login`")
+        headers["Authorization"] = f"Bearer {token}"
+    url = f"{config.platform_url()}{path}"
+    try:
+        resp = httpx.request(
+            method, url, headers=headers, timeout=_TIMEOUT, follow_redirects=True, **kwargs
+        )
+    except httpx.HTTPError as exc:
+        raise click.ClickException(f"cannot reach {config.platform_url()}: {exc}") from exc
+    if resp.status_code == 401:
+        # Once, and only on an authenticated call: a second 401 after a fresh
+        # access token is a real refusal, not an expiry, and retrying it forever
+        # would turn "you may not do that" into a hang.
+        if auth and not _retried and _refresh():
+            return _api(method, path, auth=auth, _retried=True, **kwargs)
+        raise click.ClickException("your session has expired — run `ailands login` again")
+    if resp.status_code >= 400:
+        detail = resp.text
+        # A non-JSON error body is still the best thing to show a person.
+        with suppress(json.JSONDecodeError, ValueError):
+            detail = resp.json().get("detail", detail)
+        raise click.ClickException(f"{resp.status_code}: {detail}")
+    return resp.json() if resp.content else {}
+
+
+def _pages(path: str, key: str) -> Iterator[dict]:
+    """Every row of a paged list, one request per page: the platform sends a
+    list a page at a time with `next` as the cursor for the following one."""
+    after = None
+    while True:
+        page = _api("GET", path, params={"after": after} if after else None)
+        yield from page.get(key, [])
+        after = page.get("next")
+        if not after:
+            return
+
+
+def _my_publishers(me: dict) -> list[dict]:
+    """All of `/v1/me`'s publishers: its first page, then the rest."""
+    publishers = list(me.get("publishers", []))
+    if me.get("publishers_next"):
+        after = me["publishers_next"]
+        while after:
+            page = _api("GET", "/v1/me/publishers", params={"after": after})
+            publishers += page.get("publishers", [])
+            after = page.get("next")
+    return publishers
+
+
+@click.group()
+@click.version_option(package_name="ailands")
+def main() -> None:
+    """Build and publish agents for Ailands."""
+
+
+# ─── signing in ──────────────────────────────────────────────────────────────
+@main.command()
+def login() -> None:
+    """Sign in with your Ailands account.
+
+    The OAuth device flow, so the browser step happens where a browser already
+    is: this works over SSH and inside a container, where a redirect to
+    `localhost` would not.
+    """
+    info = _api("GET", "/v1/platform", auth=False)
+    issuer, client_id = info.get("oidc_issuer", ""), info.get("oidc_client_id", "")
+    if not issuer or not client_id:
+        raise click.ClickException(
+            f"{config.platform_url()} is not accepting logins (it publishes no identity provider)"
+        )
+    try:
+        meta = httpx.get(f"{issuer}/.well-known/openid-configuration", timeout=_TIMEOUT).json()
+        device_endpoint = meta["device_authorization_endpoint"]
+        token_endpoint = meta["token_endpoint"]
+        verifier, challenge = _pkce_pair()
+        start = httpx.post(
+            device_endpoint,
+            data={
+                "client_id": client_id,
+                "scope": "openid email profile",
+                "code_challenge": challenge,
+                "code_challenge_method": "S256",
+            },
+            timeout=_TIMEOUT,
+        )
+        start.raise_for_status()
+        device = start.json()
+    except (httpx.HTTPError, KeyError) as exc:
+        raise click.ClickException(f"could not start sign-in: {exc}") from exc
+
+    click.echo(f"\n  Open: {device.get('verification_uri_complete') or device['verification_uri']}")
+    click.echo(f"  Code: {device['user_code']}\n")
+
+    deadline = time.monotonic() + int(device.get("expires_in", 600))
+    interval = int(device.get("interval", 5))
+    while time.monotonic() < deadline:
+        time.sleep(interval)
+        resp = httpx.post(
+            token_endpoint,
+            data={
+                "grant_type": "urn:ietf:params:oauth:grant-type:device_code",
+                "device_code": device["device_code"],
+                "client_id": client_id,
+                # The other half of the pair sent above. Omitting it here fails at
+                # the very last step, after the person has already approved.
+                "code_verifier": verifier,
+            },
+            timeout=_TIMEOUT,
+        )
+        if resp.status_code == 200:
+            config.save_credentials(resp.json())
+            me = _api("GET", "/v1/me")
+            click.echo(f"Signed in as {me.get('email') or me['subject']}.")
+            names = [p["name"] for p in _my_publishers(me)]
+            click.echo(
+                f"Publishers: {', '.join(names)}"
+                if names
+                else "You act for no publisher yet — run `ailands publisher create <name>`."
+            )
+            return
+        error = resp.json().get("error", "")
+        if error == "authorization_pending":
+            continue
+        if error == "slow_down":
+            interval += 5
+            continue
+        raise click.ClickException(f"sign-in failed: {error or resp.text}")
+    raise click.ClickException("sign-in timed out")
+
+
+@main.command()
+def whoami() -> None:
+    """Who this machine is signed in as, and what it may publish under."""
+    me = _api("GET", "/v1/me")
+    click.echo(f"{me.get('email') or me['subject']}")
+    for pub in _my_publishers(me):
+        mark = "verified" if pub["verified"] else "unverified"
+        key = "key registered" if pub["public_key"] else "NO KEY — run `ailands publisher key`"
+        click.echo(f"  {pub['name']}  ({mark}, {key})")
+    if me.get("is_reviewer"):
+        click.echo("  (platform reviewer)")
+
+
+# ─── publishers ──────────────────────────────────────────────────────────────
+@main.group()
+def publisher() -> None:
+    """The name your agents are published under."""
+
+
+@publisher.command("create")
+@click.argument("name")
+@click.option("--display-name", default="", help="what users see on a listing")
+@click.option("--contact", default="", help="where users can reach you for support")
+def publisher_create(name: str, display_name: str, contact: str) -> None:
+    """Claim a publisher name and register this machine's signing key.
+
+    The name is what users see on a listing, and it is first-come. Agents are
+    published under it, so it is the thing people will hold you to.
+    """
+    _api(
+        "POST",
+        "/v1/publishers",
+        json={"name": name, "display_name": display_name, "contact": contact},
+    )
+    click.echo(f"Publisher {name!r} is yours. Registering this machine's signing key…")
+    publisher_key.callback(name)  # type: ignore[misc]
+
+
+@publisher.command("key")
+@click.argument("name")
+def publisher_key(name: str) -> None:
+    """Register this machine's public signing key for a publisher."""
+    _, public = config.signing_key()
+    _api("PUT", f"/v1/publishers/{name}/key", json={"public_key": public})
+    click.echo(f"Key registered for {name}. The private half stays in {config.home()}.")
+
+
+@publisher.command("add-member")
+@click.argument("name")
+@click.argument("subject")
+def publisher_add_member(name: str, subject: str) -> None:
+    """Let another person publish under this publisher (their account subject)."""
+    _api("POST", f"/v1/publishers/{name}/members", json={"subject": subject})
+    click.echo(f"{subject} can now publish as {name}.")
+
+
+# ─── the loop ────────────────────────────────────────────────────────────────
+_SKELETON_MANIFEST = """\
+id: {agent_id}
+version: "0.1.0"
+publisher: {publisher}
+
+# The lowest Ailands version this agent runs on. Leave it out and it runs
+# anywhere; set it once you rely on something a newer Ailands added.
+# requires:
+#   min_platform_version: "2.0"
+
+provides:
+  personas:
+    - id: web
+      prompt_file: personas/web.md
+"""
+
+_SKELETON_PROMPT = """\
+You are {agent_id}. Say what you are for in one sentence, then help.
+"""
+
+_SKELETON_STRINGS = """\
+agent:
+  name: "{agent_id}"
+  description: "An agent."
+  icon: "🌱"
+"""
+
+
+@main.command()
+@click.argument("directory")
+@click.option("--publisher", "publisher_name", default="", help="publisher to publish under")
+def init(directory: str, publisher_name: str) -> None:
+    """Create a working agent skeleton in DIRECTORY."""
+    root = Path(directory)
+    if root.exists() and any(root.iterdir()):
+        raise click.ClickException(f"{root} already exists and is not empty")
+    agent_id = root.name.replace("-", "_")
+    if not publisher_name:
+        publishers = _api("GET", "/v1/me").get("publishers", [])
+        if not publishers:
+            raise click.ClickException(
+                "you act for no publisher — run `ailands publisher create <name>` first"
+            )
+        publisher_name = publishers[0]["name"]
+    (root / "personas").mkdir(parents=True)
+    (root / "strings").mkdir(parents=True)
+    (root / "manifest.yaml").write_text(
+        _SKELETON_MANIFEST.format(agent_id=agent_id, publisher=publisher_name), encoding="utf-8"
+    )
+    (root / "personas" / "web.md").write_text(
+        _SKELETON_PROMPT.format(agent_id=agent_id), encoding="utf-8"
+    )
+    (root / "strings" / "en.yaml").write_text(
+        _SKELETON_STRINGS.format(agent_id=agent_id), encoding="utf-8"
+    )
+    click.echo(f"Created {root}. Next: edit personas/web.md, then `ailands publish {root}`.")
+
+
+@main.command()
+@click.argument("directory", default=".")
+@click.option("--out", default="", help="write the bundle here instead of publishing")
+def pack(directory: str, out: str) -> None:
+    """Build and sign a bundle without uploading it."""
+    private, _ = config.signing_key()
+    try:
+        tarball, meta = build(directory, private)
+    except PackError as exc:
+        raise click.ClickException(str(exc)) from exc
+    target = Path(out or f"{meta['id']}-{meta['version']}.tar.gz")
+    target.write_bytes(tarball)
+    click.echo(f"{target}  ({len(tarball) / 1024:.0f} KB, signed as {meta['publisher']})")
+
+
+@main.command()
+@click.argument("directory", default=".")
+def publish(directory: str) -> None:
+    """Upload a bundle as a DRAFT.
+
+    A draft is live for exactly one person: you. Take it on your own island, try
+    it against the real thing, publish again over the same version as often as you
+    like — then `ailands submit` when it is worth someone's time to review.
+    """
+    private, _ = config.signing_key()
+    try:
+        tarball, meta = build(directory, private)
+    except PackError as exc:
+        raise click.ClickException(str(exc)) from exc
+    result = _api(
+        "POST",
+        "/v1/agents/publish",
+        files={"tarball": (f"{meta['id']}.tar.gz", tarball, "application/gzip")},
+    )
+    click.echo(
+        f"{result['agent_id']}@{result['version']} is a draft — only you can take it.\n"
+        f"  ailands submit {result['agent_id']} {result['version']}"
+    )
+
+
+@main.command()
+@click.argument("agent_id")
+@click.argument("version")
+def submit(agent_id: str, version: str) -> None:
+    """Send a draft for review."""
+    result = _api("POST", f"/v1/agents/{agent_id}/versions/{version}/submit")
+    click.echo(f"{agent_id}@{version} is {result['state']}. `ailands status` to follow it.")
+
+
+@main.command()
+@click.option("--publisher", "publisher_name", default="", help="limit to one publisher")
+def status(publisher_name: str) -> None:
+    """Where every version you have published stands."""
+    me = _api("GET", "/v1/me")
+    names = [publisher_name] if publisher_name else [p["name"] for p in _my_publishers(me)]
+    if not names:
+        click.echo("You act for no publisher yet.")
+        return
+    for name in names:
+        click.echo(f"\n{name}")
+        shown = 0
+        for v in _pages(f"/v1/publishers/{name}/versions", "versions"):
+            note = f"  — {v['review_note']}" if v.get("review_note") else ""
+            click.echo(f"  {v['agent_id']}@{v['version']:<10} {v['state']}{note}")
+            shown += 1
+        if not shown:
+            click.echo("  (nothing published yet)")
+
+
+@main.command()
+@click.argument("directory", default=".")
+@click.option("--interval", default=2.0, help="seconds between checks")
+def watch(directory: str, interval: float) -> None:
+    """Republish the draft whenever a file changes — the inner loop.
+
+    Polling rather than an OS watcher: one dependency fewer, and the loop that
+    matters is bounded by the upload anyway.
+    """
+    root = Path(directory)
+    click.echo(f"Watching {root.resolve()} — Ctrl-C to stop.")
+    last: float | None = None
+    while True:
+        newest = max(
+            (p.stat().st_mtime for p in root.rglob("*") if p.is_file()),
+            default=0.0,
+        )
+        if last is None or newest > last:
+            last = newest
+            try:
+                publish.callback(directory)  # type: ignore[misc]
+            except click.ClickException as exc:
+                click.echo(f"  ! {exc.format_message()}", err=True)
+        time.sleep(interval)
+
+
+if __name__ == "__main__":  # pragma: no cover
+    sys.exit(main())

ailands/config.py

@@ -0,0 +1,103 @@
+"""Where the CLI keeps a developer's credentials and signing key.
+
+One directory, `~/.config/ailands` (`$XDG_CONFIG_HOME/ailands`; `$AILANDS_HOME`
+overrides it), with two things in it: the token this machine signed in with, and
+the Ed25519 private key it signs bundles with.
+
+The private key is generated here and never leaves — the platform only ever sees
+the public half. That is what makes "who published this" a question with an
+answer: a key the platform generated for you would be a key the platform could
+also sign with.
+"""
+
+from __future__ import annotations
+
+import base64
+import json
+import os
+import stat
+from pathlib import Path
+
+import click
+
+DEFAULT_PLATFORM = "https://developers.ailands.app"
+
+
+def home() -> Path:
+    env = os.environ.get("AILANDS_HOME")
+    if env:
+        root = Path(env).expanduser()
+    else:
+        # The XDG spec ignores a relative XDG_CONFIG_HOME.
+        xdg = os.environ.get("XDG_CONFIG_HOME", "")
+        root = (Path(xdg) if os.path.isabs(xdg) else Path.home() / ".config") / "ailands"
+        _adopt_legacy_home(root)
+    root.mkdir(parents=True, exist_ok=True)
+    root.chmod(stat.S_IRWXU)
+    return root
+
+
+def _adopt_legacy_home(root: Path) -> None:
+    """Move a pre-0.4.0 `~/.ailands` into place. Moved, not copied or ignored: the
+    signing key in it is the one the platform knows this publisher by, and a fresh
+    key would publish as someone the platform has never seen."""
+    legacy = Path.home() / ".ailands"
+    if not legacy.is_dir():
+        return
+    if root.exists():
+        raise click.ClickException(
+            f"both {legacy} and {root} exist; keep the one whose signing-key your publisher "
+            "registered and remove the other"
+        )
+    root.parent.mkdir(parents=True, exist_ok=True)
+    legacy.rename(root)
+
+
+def platform_url() -> str:
+    return os.environ.get("AILANDS_PLATFORM", DEFAULT_PLATFORM).rstrip("/")
+
+
+def _credentials_path() -> Path:
+    return home() / "credentials.json"
+
+
+def save_credentials(data: dict) -> None:
+    path = _credentials_path()
+    path.write_text(json.dumps(data, indent=2), encoding="utf-8")
+    path.chmod(stat.S_IRUSR | stat.S_IWUSR)
+
+
+def load_credentials() -> dict:
+    path = _credentials_path()
+    if not path.exists():
+        return {}
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except json.JSONDecodeError:
+        return {}
+
+
+def access_token() -> str:
+    return str(load_credentials().get("access_token") or "")
+
+
+def signing_key() -> tuple[str, str]:
+    """This machine's (private_b64, public_b64), generating one on first use.
+
+    Generated rather than prompted for: a key the developer has to create by hand
+    is a key most people will skip, and the whole publisher-attribution chain
+    rests on there being one. Written 0600 and never uploaded.
+    """
+    from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey
+
+    path = home() / "signing-key"
+    if path.exists():
+        private = Ed25519PrivateKey.from_private_bytes(base64.b64decode(path.read_text().strip()))
+    else:
+        private = Ed25519PrivateKey.generate()
+        path.write_text(base64.b64encode(private.private_bytes_raw()).decode(), encoding="utf-8")
+        path.chmod(stat.S_IRUSR | stat.S_IWUSR)
+    return (
+        base64.b64encode(private.private_bytes_raw()).decode(),
+        base64.b64encode(private.public_key().public_bytes_raw()).decode(),
+    )

ailands/pack.py

@@ -0,0 +1,86 @@
+"""Turning a directory into a publishable, signed bundle.
+
+The format is a gzipped tar of the agent directory with a detached
+`manifest.yaml.sig` at its root — the same bytes the platform verifies on publish
+and the same layout a kernel unpacks on install. Deliberately boring: an author
+should be able to look at what they are shipping.
+"""
+
+from __future__ import annotations
+
+import base64
+import io
+import tarfile
+from pathlib import Path
+
+#: Never ship these. Not a security control — a bundle is signed and reviewed —
+#: but a build that silently packed a `.venv` or a `.git` would produce a
+#: hundred-megabyte upload and a rejection nobody could explain.
+_SKIP_DIRS = {
+    ".git",
+    ".venv",
+    "venv",
+    "__pycache__",
+    "node_modules",
+    ".mypy_cache",
+    ".pytest_cache",
+}
+_SKIP_SUFFIXES = {".pyc", ".pyo"}
+
+
+class PackError(Exception):
+    """The directory is not a publishable agent."""
+
+
+def _included(path: Path, root: Path) -> bool:
+    rel = path.relative_to(root)
+    if any(part in _SKIP_DIRS for part in rel.parts):
+        return False
+    return path.suffix not in _SKIP_SUFFIXES
+
+
+def sign_manifest(manifest_bytes: bytes, private_key_b64: str) -> str:
+    from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey
+
+    private = Ed25519PrivateKey.from_private_bytes(base64.b64decode(private_key_b64))
+    return base64.b64encode(private.sign(manifest_bytes)).decode()
+
+
+def build(agent_dir: str | Path, private_key_b64: str) -> tuple[bytes, dict]:
+    """Sign the manifest and return `(tarball, {id, version, publisher})`.
+
+    The manifest is read as BYTES and signed as bytes, never re-serialized from
+    parsed YAML: a round trip through a parser can reorder keys or normalize
+    quoting, and then the signature covers text nobody will ever see again.
+    """
+    root = Path(agent_dir).resolve()
+    manifest_path = root / "manifest.yaml"
+    if not manifest_path.is_file():
+        raise PackError(f"{root} has no manifest.yaml — is this an agent directory?")
+    manifest_bytes = manifest_path.read_bytes()
+
+    import yaml
+
+    try:
+        parsed = yaml.safe_load(manifest_bytes.decode("utf-8")) or {}
+    except yaml.YAMLError as exc:
+        raise PackError(f"manifest.yaml does not parse: {exc}") from exc
+    for required in ("id", "version", "publisher"):
+        if not parsed.get(required):
+            raise PackError(f"manifest.yaml must declare `{required}` before publishing")
+
+    signature = sign_manifest(manifest_bytes, private_key_b64)
+    buf = io.BytesIO()
+    with tarfile.open(fileobj=buf, mode="w:gz") as tar:
+        for path in sorted(root.rglob("*")):
+            if path.is_file() and _included(path, root):
+                tar.add(path, arcname=str(path.relative_to(root)))
+        raw = signature.encode("utf-8")
+        info = tarfile.TarInfo(name="manifest.yaml.sig")
+        info.size = len(raw)
+        tar.addfile(info, io.BytesIO(raw))
+    return buf.getvalue(), {
+        "id": str(parsed["id"]),
+        "version": str(parsed["version"]),
+        "publisher": str(parsed["publisher"]),
+    }

ailands-0.5.2.dist-info/METADATA

@@ -0,0 +1,44 @@
+Metadata-Version: 2.4
+Name: ailands
+Version: 0.5.2
+Summary: Build and publish agents for Ailands.
+Project-URL: Homepage, https://developers.ailands.app
+Author-email: Jiaan Liu <jiaanliux@gmail.com>
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: agent,ai,ailands
+Requires-Python: >=3.11
+Requires-Dist: aipelago-sdk==0.6.1
+Requires-Dist: click==8.1.8
+Requires-Dist: cryptography==44.0.0
+Requires-Dist: httpx==0.28.1
+Requires-Dist: pyyaml==6.0.2
+Description-Content-Type: text/markdown
+
+# ailands
+
+Build and publish agents for [Ailands](https://ailands.app).
+
+```bash
+pip install ailands
+ailands login
+ailands publisher create acme
+ailands init my-agent
+ailands publish my-agent      # a draft — live for you alone
+ailands submit my_agent 0.1.0 # ask for review
+ailands status
+```
+
+And in your agent's code (`pip install ailands` brings in the `aipelago-sdk` it
+imports from):
+
+```python
+from aipelago.sdk import tool, ToolContext
+
+@tool("my_agent.hello")
+async def hello(ctx: ToolContext, args: dict) -> dict:
+    return {"text": "hi"}
+```
+
+A **draft** is installable by you and nobody else, so you can iterate against the
+real platform before anyone reviews it. `ailands watch` republishes on save.

ailands-0.5.2.dist-info/RECORD

@@ -0,0 +1,9 @@
+ailands/__init__.py,sha256=1XpWvz8ErU3AGb7M6df3Z1DDyX6TfQ9kdaIGSIwutXo,314
+ailands/cli.py,sha256=GLWxRcHc6HOyQLFRL1d4B4BuGJ1YWfCJopWCfkU9oRk,16534
+ailands/config.py,sha256=lRoF4YFnjEBpgrONLL83rvkSg3tE4iSvUSXYo3LNNa8,3433
+ailands/pack.py,sha256=q5bc2L7uzI3jfPlZbBMId7rQrHqtzPCEUmnjFcbdnNc,3102
+ailands-0.5.2.dist-info/METADATA,sha256=JHufQgPxuhI0RsT2ndTFY7V_T95QgYv4-u9zlMeHn8w,1216
+ailands-0.5.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+ailands-0.5.2.dist-info/entry_points.txt,sha256=PoibeKbpqBOKy0OnG5OX4B1dApUqEEgg6Bcst16aK90,45
+ailands-0.5.2.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+ailands-0.5.2.dist-info/RECORD,,

ailands-0.5.2.dist-info/WHEEL

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

ailands-0.5.2.dist-info/entry_points.txt

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

ailands-0.5.2.dist-info/licenses/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.