devlift-cli 0.1.0__py3-none-any.whl

devlift_cli/render/output.py

@@ -0,0 +1,75 @@
+"""Rendering: table on a terminal, json when piped, yaml on request.
+
+`emit(data, fmt, table=…)`: `data` is what -o json prints, byte for byte the
+server's shape plus whatever the command adds. `table` is a callable that
+turns the same data into a Rich renderable; it is only called for table
+output, so json never depends on presentation code.
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from typing import Any, Callable, Iterable
+
+import yaml
+from rich.console import Console
+from rich.markup import escape
+from rich.table import Table
+
+FORMATS = ("table", "json", "yaml")
+
+console = Console()
+err_console = Console(stderr=True)
+
+
+def resolve_format(requested: str | None, profile_default: str) -> str:
+    if requested:
+        return requested
+    if not sys.stdout.isatty():
+        return "json"
+    return profile_default if profile_default in FORMATS else "table"
+
+
+def emit(data: Any, fmt: str, table: Callable[[Any], Any] | None = None) -> None:
+    if fmt == "json":
+        print(json.dumps(data, indent=2, default=str))
+    elif fmt == "yaml":
+        print(yaml.safe_dump(data, sort_keys=False, default_flow_style=False), end="")
+    else:
+        if table is None:
+            print(json.dumps(data, indent=2, default=str))
+        else:
+            console.print(table(data))
+
+
+def kv_table(rows: Iterable[tuple[str, Any]], title: str | None = None) -> Table:
+    t = Table(title=title, show_header=False, box=None, pad_edge=False)
+    t.add_column("key", style="bold")
+    t.add_column("value")
+    for key, value in rows:
+        # Values are data, never markup: a branch list rendered as "[main]"
+        # would otherwise be swallowed as a Rich style tag.
+        t.add_row(escape(str(key)), "" if value is None else escape(str(value)))
+    return t
+
+
+def rows_table(columns: list[str], rows: Iterable[Iterable[Any]], title: str | None = None) -> Table:
+    t = Table(title=title, header_style="bold")
+    for col in columns:
+        t.add_column(col)
+    for row in rows:
+        t.add_row(*("" if v is None else escape(str(v)) for v in row))
+    return t
+
+
+def info(message: str) -> None:
+    err_console.print(message)
+
+
+def warn(message: str) -> None:
+    err_console.print(f"[yellow]{message}[/yellow]")
+
+
+def success(message: str) -> None:
+    err_console.print(f"[green]{message}[/green]")

devlift_cli/resolve/allowlist.py

@@ -0,0 +1,192 @@
+"""Placement allowlist: what each product, environment and region really offers.
+
+The backend returns every region for every application, which is wider than
+what exists. `data/placement/{tenant}.json` records the truth, in the shape
+
+    {"<workspace>": {"<product>": {"<env>": {"<aws region>": ["s3", "sqs", ...]}}}}
+
+and is the same file the chatbot carries under its own data directory;
+keep the two in step. The dashboard carries its own, coarser copy.
+
+A file is found by its name, `{tenant}.json`, or by listing the tenant in its
+own `_tenants` key, which is how one customer known by several tenant codes
+gets one file instead of a copy per code. Keys beginning with `_` are metadata
+and are never read as workspaces.
+
+Matching is on LABELS, never on codes: the config is written in human terms
+(product `core`, environment `stage`, region `ap-south-1`) while the API
+speaks opaque codes, so the config only ever decides which API rows survive.
+
+Safety stance: this filter fails CLOSED. If matching goes wrong the user is
+told there is no placement rather than handed one that does not exist — a
+refusal is recoverable, a bucket in the wrong region is not. Filtering is
+opt-in per tenant: a tenant with no config file is left unfiltered.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+_DIR = Path(__file__).resolve().parent.parent / "data" / "placement"
+
+# The service key each command's resources use in the config's leaf lists.
+SERVICE_S3 = "s3"
+SERVICE_SQS = "sqs"
+SERVICE_DYNAMODB = "dynamo"
+SERVICE_EKS = "eks"
+SERVICE_GATEWAY = "gateway"
+
+# AWS region code -> the city name the API uses as a region label.
+REGION_CITY = {
+    "ap-south-1": "mumbai", "ap-southeast-1": "singapore", "ap-northeast-1": "tokyo",
+    "eu-west-1": "ireland", "eu-west-2": "london", "eu-central-1": "frankfurt",
+    "us-east-1": "virginia", "us-east-2": "ohio", "us-west-2": "oregon",
+    "ca-central-1": "canada",
+}
+
+_cache: dict[str, dict | None] = {}
+
+
+def _norm(text) -> str:
+    return str(text or "").strip().casefold()
+
+
+def _read(path: Path) -> dict | None:
+    """The raw JSON at `path`, or None if it is missing or unreadable."""
+    try:
+        raw = json.loads(path.read_text())
+    except (OSError, ValueError):
+        return None
+    return raw if isinstance(raw, dict) else None
+
+
+def _serves(raw: dict, tenant: str) -> bool:
+    """Does this file's `_tenants` list name the tenant?
+
+    One customer can appear under more than one tenant code. The codes are
+    listed in the file itself rather than mapped in here, so every name
+    belonging to a customer stays in that customer's own data file and none
+    is compiled into the CLI.
+    """
+    declared = raw.get("_tenants")
+    return isinstance(declared, list) and any(_norm(t) == tenant for t in declared)
+
+
+def _locate(tenant: str) -> dict | None:
+    """The raw config for this tenant: its own file, else one that claims it."""
+    raw = _read(_DIR / f"{tenant}.json")
+    if raw is not None:
+        return raw
+    try:
+        candidates = sorted(_DIR.glob("*.json"))
+    except OSError:
+        return None
+    for path in candidates:
+        other = _read(path)
+        if other is not None and _serves(other, tenant):
+            return other
+    return None
+
+
+def load(tenant_code: str) -> dict | None:
+    """The tenant's config, or None when it has none (then nothing is filtered)."""
+    tenant = _norm(tenant_code)
+    if tenant not in _cache:
+        raw = _locate(tenant)
+        # `_`-prefixed keys are metadata (`_tenants`, notes), never workspaces.
+        _cache[tenant] = (
+            {k: v for k, v in raw.items() if not str(k).startswith("_")} if raw else None
+        ) or None
+    return _cache[tenant]
+
+
+def _products(config: dict) -> dict:
+    """Collapse the workspace envelope: the CLI has no workspace selector."""
+    products: dict = {}
+    for workspace in config.values():
+        if isinstance(workspace, dict):
+            products.update(workspace)
+    return products
+
+
+def _matches_region(config_region: str, row: dict) -> bool:
+    """Does an API placement row correspond to a config region code?"""
+    label, value = _norm(row.get("region")), _norm(row.get("geo_loc_mst_code"))
+    code = _norm(config_region)
+    city = REGION_CITY.get(code, "")
+    if code and (code == label or code == value):
+        return True
+    return bool(city) and (city == label or city in value)
+
+
+def allowed_regions(config: dict, product: str, environment: str, service: str) -> list[str]:
+    """The config's region codes offering `service` for this product and environment."""
+    products = _products(config)
+    key = next((k for k in products if _norm(k) == _norm(product)), None)
+    if key is None:
+        return []
+    envs = products[key] or {}
+    env_key = next((k for k in envs if _norm(k) == _norm(environment)), None)
+    if env_key is None:
+        return []
+    return [r for r, services in (envs[env_key] or {}).items()
+            if isinstance(services, list) and service in services]
+
+
+def any_regions(config: dict, product: str, environment: str) -> list[str]:
+    """Every region the config lists for this product and environment, whatever
+    the service. This is what "does this placement exist at all" means."""
+    products = _products(config)
+    key = next((k for k in products if _norm(k) == _norm(product)), None)
+    if key is None:
+        return []
+    envs = products[key] or {}
+    env_key = next((k for k in envs if _norm(k) == _norm(environment)), None)
+    if env_key is None:
+        return []
+    return [r for r, services in (envs[env_key] or {}).items() if services]
+
+
+def filter_placements(rows: list[dict], tenant_code: str, service: str | None = None) -> list[dict]:
+    """Keep only the placement rows this tenant really has.
+
+    `rows` are the flattened placement options (product, environment, region,
+    geo_loc_mst_code). With `service`, only placements offering that service
+    survive; without one, any placement the config lists at all. Returns the
+    rows unchanged when the tenant has no config.
+    """
+    config = load(tenant_code)
+    if not config:
+        return rows
+    kept = []
+    for row in rows:
+        product, environment = row.get("product", ""), row.get("environment", "")
+        allowed = (allowed_regions(config, product, environment, service) if service
+                   else any_regions(config, product, environment))
+        if any(_matches_region(r, row) for r in allowed):
+            kept.append(row)
+    return kept
+
+
+def filter_applications(apps: list[dict], rows: list[dict], tenant_code: str) -> list[dict]:
+    """Keep only the applications that have at least one real placement."""
+    if not load(tenant_code):
+        return apps
+    codes = {r.get("application_code") for r in filter_placements(rows, tenant_code)}
+    return [a for a in apps if a.get("application_code") in codes]
+
+
+def describe(tenant_code: str, service: str | None) -> str:
+    """One line naming what the config does offer, for an error message."""
+    config = load(tenant_code) if service else None
+    if not config:
+        return ""
+    bits = []
+    for product, envs in _products(config).items():
+        for env, regions in (envs or {}).items():
+            names = [REGION_CITY.get(_norm(r), r).title() for r, s in (regions or {}).items()
+                     if isinstance(s, list) and service in s]
+            if names:
+                bits.append(f"{product}/{env}: {', '.join(sorted(names))}")
+    return "; ".join(sorted(bits))

devlift_cli/resolve/names.py

@@ -0,0 +1,179 @@
+"""Names in, codes out.
+
+Users say `--app core --env stage --region mumbai --service demo-api`; the
+API wants `application_code`, `EnvironmentEnum`, `geo_loc_mst_code`,
+`service_code`. Matching is case-insensitive against name AND code, exact
+first, then unique prefix. Ambiguity is an InputError that lists the
+candidates; nothing is ever guessed.
+
+Catalog responses are cached per profile+backend for a few minutes so a
+command that resolves three names does not pay three round trips every time.
+`--no-cache` (or DEVLIFT_NO_CACHE=1) bypasses it.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Callable
+
+from devlift_cli.api import catalog
+from devlift_cli.api.client import ApiClient
+from devlift_cli.config import CONFIG_DIR
+from devlift_cli.errors import EXIT_NOT_FOUND, CliError, InputError
+
+CACHE_TTL_SECONDS = 600
+ENVIRONMENTS = ("dev", "stage", "qa", "prod")
+_ENV_ALIASES = {"staging": "stage", "production": "prod", "development": "dev"}
+
+
+@dataclass
+class Placement:
+    application_code: str
+    application_name: str
+    environment: str
+    geo_loc_mst_code: str
+    region_name: str
+
+
+class Cache:
+    def __init__(self, profile_name: str, base_url: str, enabled: bool = True):
+        key = hashlib.sha1(f"{profile_name}|{base_url}".encode()).hexdigest()[:12]
+        self.path = CONFIG_DIR / "cache" / f"{key}.json"
+        self.enabled = enabled and not os.environ.get("DEVLIFT_NO_CACHE")
+        self._data: dict | None = None
+
+    def _load(self) -> dict:
+        if self._data is None:
+            try:
+                self._data = json.loads(self.path.read_text())
+            except (FileNotFoundError, ValueError):
+                self._data = {}
+        return self._data
+
+    def get(self, name: str, fetch: Callable[[], list]) -> list:
+        data = self._load()
+        entry = data.get(name)
+        if self.enabled and entry and time.time() - entry.get("at", 0) < CACHE_TTL_SECONDS:
+            return entry["value"]
+        value = fetch()
+        if self.enabled:
+            data[name] = {"at": time.time(), "value": value}
+            try:
+                self.path.parent.mkdir(parents=True, exist_ok=True)
+                tmp = self.path.with_suffix(".tmp")
+                tmp.write_text(json.dumps(data))
+                tmp.chmod(0o600)
+                tmp.replace(self.path)
+            except OSError:
+                pass
+        return value
+
+    def clear(self) -> None:
+        try:
+            self.path.unlink()
+        except FileNotFoundError:
+            pass
+        self._data = {}
+
+
+def _match(items: list[dict], wanted: str, *keys: str, what: str) -> dict:
+    needle = wanted.strip().lower()
+    exact = [i for i in items if any(str(i.get(k) or "").lower() == needle for k in keys)]
+    if len(exact) == 1:
+        return exact[0]
+    if len(exact) > 1:
+        raise InputError(f"'{wanted}' matches more than one {what}: " + ", ".join(_label(i, keys) for i in exact))
+    prefix = [i for i in items if any(str(i.get(k) or "").lower().startswith(needle) for k in keys)]
+    if len(prefix) == 1:
+        return prefix[0]
+    if len(prefix) > 1:
+        raise InputError(f"'{wanted}' is ambiguous for {what}: " + ", ".join(_label(i, keys) for i in prefix))
+    known = ", ".join(sorted({str(i.get(keys[0]) or "") for i in items})) or "none"
+    raise CliError(f"No {what} named '{wanted}'. Known: {known}", EXIT_NOT_FOUND)
+
+
+def _label(item: dict, keys: tuple[str, ...]) -> str:
+    return str(item.get(keys[0]) or item.get(keys[-1]) or "?")
+
+
+class Resolver:
+    def __init__(self, api: ApiClient, profile_name: str, use_cache: bool = True):
+        self.api = api
+        self.cache = Cache(profile_name, api.profile.base_url, enabled=use_cache)
+
+    # ── raw lists (cached) ───────────────────────────────────────────────
+    def applications(self) -> list[dict]:
+        return self.cache.get("applications", lambda: catalog.list_applications(self.api))
+
+    def services(self) -> list[dict]:
+        return self.cache.get("services", lambda: catalog.list_services(self.api))
+
+    def tenant_code(self) -> str:
+        """The signed-in tenant, which keys the placement allowlist."""
+        from devlift_cli.api.context import get_context
+
+        return self.cache.get("tenant", lambda: [get_context(self.api).tenant_code])[0]
+
+    def placements(self) -> list[dict]:
+        return self.cache.get("placements", lambda: catalog.placement_rows(catalog.placement_options(self.api)))
+
+    def resource_groups(self) -> list[dict]:
+        return self.cache.get("resource_groups", lambda: catalog.list_resource_groups(self.api))
+
+    def infrastructure_types(self) -> list[dict]:
+        return self.cache.get("infrastructure_types", lambda: catalog.list_infrastructure_types(self.api))
+
+    # ── resolutions ──────────────────────────────────────────────────────
+    def application(self, name_or_code: str) -> dict:
+        return _match(self.applications(), name_or_code, "application_name", "application_code", what="application")
+
+    def environment(self, name: str) -> str:
+        value = _ENV_ALIASES.get(name.strip().lower(), name.strip().lower())
+        if value not in ENVIRONMENTS:
+            raise InputError(f"Unknown environment '{name}'. One of: {', '.join(ENVIRONMENTS)}")
+        return value
+
+    def service(self, name_or_code: str) -> dict:
+        return _match(self.services(), name_or_code, "service_name", "service_code", what="service")
+
+    def resource_group(self, name_or_code: str, application_code: str | None = None) -> dict:
+        groups = self.resource_groups()
+        if application_code:
+            groups = [g for g in groups if g.get("applications_mst_code") == application_code] or groups
+        return _match(groups, name_or_code, "name", "code", what="resource group")
+
+    def infrastructure_type(self, name_or_code: str) -> dict:
+        return _match(self.infrastructure_types(), name_or_code, "name", "code", what="resource type")
+
+    def placement(self, app: str, env: str, region: str) -> Placement:
+        """The one (product, environment, region) row the user means, or why not."""
+        application = self.application(app)
+        environment = self.environment(env)
+        rows = [r for r in self.placements() if r["application_code"] == application["application_code"]]
+        if not rows:
+            raise CliError(f"Application '{application['application_name']}' has no placements configured.", EXIT_NOT_FOUND)
+        in_env = [r for r in rows if r["environment"] == environment]
+        if not in_env:
+            envs = ", ".join(sorted({r["environment"] for r in rows}))
+            raise InputError(f"'{application['application_name']}' is not set up for {environment}. Environments: {envs}")
+        row = _match(in_env, region, "region", "geo_loc_mst_code", what=f"region for {application['application_name']}/{environment}")
+        return Placement(
+            application_code=application["application_code"],
+            application_name=application["application_name"],
+            environment=environment,
+            geo_loc_mst_code=row["geo_loc_mst_code"],
+            region_name=row["region"],
+        )
+
+    def regions_for(self, application_code: str | None = None, environment: str | None = None) -> list[dict]:
+        rows = self.placements()
+        if application_code:
+            rows = [r for r in rows if r["application_code"] == application_code]
+        if environment:
+            rows = [r for r in rows if r["environment"] == environment]
+        return rows

devlift_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: devlift-cli
+Version: 0.1.0
+Summary: DevLift command-line tool: create, change, review and deploy DevLift resources from the terminal.
+License: Proprietary
+Keywords: devlift,devops,deployment,infrastructure,cli
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: Other/Proprietary License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Topic :: System :: Systems Administration
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: typer>=0.15
+Requires-Dist: rich>=13
+Requires-Dist: httpx>=0.27
+Requires-Dist: keyring>=25
+Requires-Dist: pydantic>=2
+Requires-Dist: pyyaml>=6
+
+# devlift-cli
+
+DevLift from the terminal, in the style of the AWS CLI:
+
+```
+devlift <group> <operation> [flags]
+```
+
+Every command is a fixed sequence of calls to the DevLift backend's REST API,
+the same endpoints the web dashboard uses. Nothing here talks to an LLM.
+
+## Install
+
+```
+pip install devlift-cli
+```
+
+Or, to keep it in its own environment and off your system Python:
+
+```
+pipx install devlift-cli
+```
+
+Upgrade with `pip install -U devlift-cli` (or `pipx upgrade devlift-cli`).
+Your profile and sign-in live in `~/.config/devlift` and survive upgrades.
+
+Then:
+
+```
+devlift configure --base-url <your DevLift backend> --default
+devlift login
+devlift whoami
+devlift man
+```
+
+Requires Python 3.11 or newer. To remove it: `pip uninstall devlift-cli`
+(or `pipx uninstall devlift-cli`). That leaves `~/.config/devlift`, so delete
+that too if you want your profiles and sign-in gone as well.
+
+Several backends? `devlift profile list`, `devlift profile use <name>` and
+`devlift profile show` switch between them and say which one is active.
+
+## Manual
+
+The full command reference ships inside the package: `devlift man` pages
+through it like `man`, and `devlift manual s3` prints one section.
+
+## What it covers
+
+- Resources: `s3`, `sqs`, `dynamodb` create / list / describe, `s3` and `sqs` update.
+- Services: `eks create / edit / show / diff / deploy / status`, `kong route add / remove / rename`, `kong plugin add`.
+- Review lane: `request submit / withdraw / discard / list / show`, `approval approve / request-changes / reject / revoke / list`.
+- Deployments: `deployment list / status`, `queue list`.
+- Discovery: applications, environments, regions, resource groups, services, repositories, branches, languages.
+
+Variables and secrets stay in the dashboard by design.
+
+## Scripting
+
+- `-o json` prints only JSON on stdout (the default when stdout is not a terminal).
+- `--yes` answers confirmations, `--no-input` fails instead of prompting.
+- `DEVLIFT_TOKEN` skips the stored login. `DEVLIFT_PROFILE`, `DEVLIFT_BASE_URL` override the profile.
+- Exit codes: 0 ok · 1 error · 2 not signed in · 3 bad input · 4 permission · 5 confirmation needed · 6 not found · 7 conflict.
+
+## Claude skill
+
+`skills/devlift/` teaches Claude (Claude Code or any Agent Skills host) to
+drive this CLI non-interactively. Install with:
+
+```
+ln -s "$(pwd)/skills/devlift" ~/.claude/skills/devlift      # personal
+# or copy it into a project's .claude/skills/devlift
+```
+
+## Development
+
+Building, testing and cutting a release: see `CONTRIBUTING.md` in the source
+repository. It is deliberately not part of the published package.

devlift_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,56 @@
+devlift_cli/MANUAL.md,sha256=D3GEU-Kqll9ePcLnkUVdcr7bMvc39YPLov32VnSQthw,47823
+devlift_cli/__init__.py,sha256=ZGNQ5xyfg1UJc1q5_m9CSn-S5WuOV2Bezi-hUmuvTgA,56
+devlift_cli/__main__.py,sha256=Tmx64_6dPMuxUtDmEC3FOa3KQbW-agv1fwAUkUtHhaY,72
+devlift_cli/app.py,sha256=KBvRt-_05-Q-r3HnZA9IH9KKepsWLXXqVZpQSadx-Ik,6962
+devlift_cli/config.py,sha256=sfcJI24GvT-oq-WcKnaFhAbQcwoYreXUilIzOvx2rRA,2958
+devlift_cli/context.py,sha256=xXICnB0sVOaT5W_hWs2DgW4SrrL0wvQk6P0aUTz92Js,3857
+devlift_cli/errors.py,sha256=_wo50KhVsN7smvVc4n7MNNwnXtlxpKClWT4ld9k1NY0,1620
+devlift_cli/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+devlift_cli/api/approvals.py,sha256=yuYBDCf62wrHq1o7cMWl5QcT90-PLJqYNhK8oX-ixvw,2413
+devlift_cli/api/catalog.py,sha256=jcAKUFMPtZjqvaHMzXn_aFFOGwI9Tx-0iUBBL_5N9uk,3791
+devlift_cli/api/client.py,sha256=FTVVzsU-BA3xXiVweil4FAFl1hxcGJzBIEnINqFFvkU,4777
+devlift_cli/api/context.py,sha256=3m9DOz08H4DtUwHHqALfrnL5vtVLmT0XY6ox7tTtivE,542
+devlift_cli/api/deployments.py,sha256=F7Lqh0767wv-oiMHpBBEPhSYjKjJ5MfC7dz1cA9nL_8,1442
+devlift_cli/api/infra.py,sha256=FxPYWlH17NVHT868oKae2opb7gG4Xlub4gitehJAl0A,3553
+devlift_cli/api/infra_list.py,sha256=-XAQKvHeh_Ux57MrAyd_eFHc9FJIJWFs23Jt153EA2A,1955
+devlift_cli/api/kong.py,sha256=1m8XOiWdsASecP7ubrmzaBH4VAAhdwD3ZpqLjzVriYU,1358
+devlift_cli/api/services.py,sha256=yiZaRHwKNkh1Axm-UQQGZFM1Mxt703vy2VXceG1bDo0,3593
+devlift_cli/api/vpc.py,sha256=Cj4JLa1Cmcibckr9RP7qN6gLMLKgc67dG2vTGY_wIjs,1050
+devlift_cli/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+devlift_cli/auth/oauth.py,sha256=xbyqpE0Yq3YS9Z1UTJXMqLJ3Dnhm-5pPqPX1AMF75Mc,10475
+devlift_cli/auth/session.py,sha256=g25N6nVUOBBsLUmETIQPcfo4kmqD9dhXGH22__EDWHI,2342
+devlift_cli/auth/storage.py,sha256=fKnWEdZ80dUQwmuQdYlgcyIH8xttYQilfvR9P_sVvdg,3594
+devlift_cli/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+devlift_cli/commands/approval.py,sha256=ZbwJ1XnYmZ4ZqSASlqCHDUTR4G0H-vm4Q5EkUAyarq4,2889
+devlift_cli/commands/auth.py,sha256=RZfzC0rku3Gnun-j34eUzlUPVCjCxQeIaG6SG756VVI,7684
+devlift_cli/commands/catalog.py,sha256=JaUDqER81fMhhWmOrKIVdLEevsrr4KdDgAS825W2bFY,10075
+devlift_cli/commands/clusters.py,sha256=Z9NMeeR-M5LVz9qGZau_QsWUqHX5WRnmLaacN99FnW0,4944
+devlift_cli/commands/deployment.py,sha256=-H-2NN_kRZZCYsTLNKKOaAUvL0y11dDJ3fNUkUMhOy4,3299
+devlift_cli/commands/dynamodb.py,sha256=p2WJGCPR9Gwg52o3C1kmYWVcCCfauTHzsdpzVOckRao,5517
+devlift_cli/commands/eks.py,sha256=hZkyv72iKDzdbTqzAHCwS4rmDFfO2o-yMG5PI2X-Fiw,18129
+devlift_cli/commands/kong.py,sha256=aP1NbJu_Z5sO3-rdRdVM9G45sYlltR1li9jvbDAomD4,6671
+devlift_cli/commands/languages.py,sha256=H5fBgeFOBJBDxmnj31K2bJ5q9KQM-cPPLcpb4_lpY3U,1507
+devlift_cli/commands/manual.py,sha256=iy6vld-xMq86GCnr-Wmi__WWHuXFuxZg65zeltZgj1Q,3220
+devlift_cli/commands/repositories.py,sha256=LuEDc8093y1A6FybexJi_9GaTL_iAjYOM_Wg25zYSNc,1862
+devlift_cli/commands/request.py,sha256=ZSqv4oobqyPADFc62AgzYkuTSzZHm7-xVpWC5zv0JVA,4533
+devlift_cli/commands/s3.py,sha256=h_i-jitna6bXd06XgoviSeMb3p5oPGUcKgqiTjxr_WM,9163
+devlift_cli/commands/sqs.py,sha256=wAPxNM9mBYANywahHtMAE7CeLJxWOBYPMjYUTEjZt2Y,10944
+devlift_cli/data/placement/vance.json,sha256=e9yIZkcTiJwa-oH_KZ9lfMD2Xum9cM6oKhighHEqsUg,330
+devlift_cli/ops/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+devlift_cli/ops/approvals.py,sha256=XjjbjSor3MmSp8sUO4OsLvkOsYk2WQ2WdVIYMk9fzAc,17406
+devlift_cli/ops/eks.py,sha256=tW8gq2f8c6WOnhvK6dDZyam05UnVbxWvGZNe1p9eIsI,43808
+devlift_cli/ops/kong.py,sha256=DIcNB8-3BCkO5vog4aYOsTulqpKHMgtltW-9LD_ydHg,16652
+devlift_cli/ops/placement.py,sha256=CWkinGOSNJ3opgwYqeBbvX-FYVKyqBX08VL3fn_5QlQ,5900
+devlift_cli/ops/resources.py,sha256=Te_MGia6a9qEHxUTZbwoSjFe06bxclWhaYWhfvT6Ry8,18171
+devlift_cli/ops/status.py,sha256=l1AahuXHw1k7TZUI9SI8ilHibAe0wMqwJIFnkqSfLb8,7211
+devlift_cli/ops/wait.py,sha256=Q0c1XITipLUAWxxG306kIAuasNiAPr_QGNElMnVQmdo,3493
+devlift_cli/render/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+devlift_cli/render/output.py,sha256=NlRFHfEvvV1gdktl6JbP-jDKFNqSxnpo1V4ze56jahc,2339
+devlift_cli/resolve/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+devlift_cli/resolve/allowlist.py,sha256=wlnLOoY6g7G5UDC3ZRJVkpSzyXBAQ-G1XL-_7BV88uI,7534
+devlift_cli/resolve/names.py,sha256=xHOiYHnDcLS22SLw0CtmRihqKc97IdsZFqwzta4ywpI,7849
+devlift_cli-0.1.0.dist-info/METADATA,sha256=RbQDUkTXTii8Znqt--4EFNtWyEAgw2zHxCzPkQy-nLk,3696
+devlift_cli-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+devlift_cli-0.1.0.dist-info/entry_points.txt,sha256=QRD_aXcdHOAbbsh7j5Z6WYo0dnnw0XQyv68hJcq70IM,75
+devlift_cli-0.1.0.dist-info/top_level.txt,sha256=uabaGJ5Bj1mSyc99HXldIoegI_rzU2S3-pNtwN7_iSk,12
+devlift_cli-0.1.0.dist-info/RECORD,,

devlift_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

devlift_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+devlift = devlift_cli.app:main
+dl = devlift_cli.app:main

devlift_cli-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+devlift_cli