noswag-cli 0.1.0__tar.gz

noswag_cli-0.1.0/.gitignore

@@ -0,0 +1,5 @@
+dist/
+*.egg-info/
+__pycache__/
+.mypy_cache/
+.pytest_cache/

noswag_cli-0.1.0/PKG-INFO

@@ -0,0 +1,58 @@
+Metadata-Version: 2.5
+Name: noswag-cli
+Version: 0.1.0
+Summary: Generate repository-native tests with NoSwag
+Project-URL: Homepage, https://noswag.io
+Project-URL: Repository, https://github.com/noswag/noswag
+Author: NoSwag
+License: MIT
+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
+Requires-Python: >=3.10
+Requires-Dist: keyring<27,>=25
+Requires-Dist: pyyaml<7,>=6
+Requires-Dist: typing-extensions<5,>=4.6
+Provides-Extra: dev
+Requires-Dist: mypy<3,>=1.10; extra == 'dev'
+Requires-Dist: types-pyyaml<7,>=6; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# NoSwag Python CLI
+
+The `noswag` package authenticates through the NoSwag device flow, packages a
+bounded snapshot of the current Git repository, requests repository-native
+tests, and previews or safely writes the returned artifact.
+
+```bash
+python -m pip install noswag-cli
+noswag auth login
+noswag init
+noswag gentest                 # repository-aware dry-run
+noswag gentest --spec openapi.yaml  # contract tests from a spec
+noswag gentest --write         # guarded write
+```
+
+`--spec` accepts a repository-relative JSON or YAML OpenAPI/Swagger file and
+includes it even when the Git diff has no source changes. Generated contract
+checks use `NOSWAG_BASE_URL` at execution time and optionally
+`NOSWAG_API_TOKEN`, `NOSWAG_API_KEY`, `NOSWAG_PATH_*`, and `NOSWAG_QUERY_*`.
+
+Tokens are stored through the operating system credential store. Set
+`NOSWAG_API_URL` for staging/local use. CI can use a platform API key via
+`NOSWAG_API_KEY` (or the backwards-compatible `NOSWAG_TOKEN`) without writing
+a credential file. Platform keys carry their workspace, so
+`NOSWAG_WORKSPACE_ID` is optional. The key can also be passed with
+`--api-key`.
+Interactive login stores a rotating refresh token in the OS credential store;
+the short-lived access token is refreshed automatically and logout revokes the
+refresh family.
+
+Repository verification commands run only when `verify.enabled: true` is
+committed in `.noswag.yml` or `--verify` is supplied, and only together with
+`--write`. No detected command is executed implicitly.
+
+Exit codes: `2` authentication, `3` quota/license, `4` generation, `5`
+validation, and `6` write conflict.

noswag_cli-0.1.0/README.md

@@ -0,0 +1,36 @@
+# NoSwag Python CLI
+
+The `noswag` package authenticates through the NoSwag device flow, packages a
+bounded snapshot of the current Git repository, requests repository-native
+tests, and previews or safely writes the returned artifact.
+
+```bash
+python -m pip install noswag-cli
+noswag auth login
+noswag init
+noswag gentest                 # repository-aware dry-run
+noswag gentest --spec openapi.yaml  # contract tests from a spec
+noswag gentest --write         # guarded write
+```
+
+`--spec` accepts a repository-relative JSON or YAML OpenAPI/Swagger file and
+includes it even when the Git diff has no source changes. Generated contract
+checks use `NOSWAG_BASE_URL` at execution time and optionally
+`NOSWAG_API_TOKEN`, `NOSWAG_API_KEY`, `NOSWAG_PATH_*`, and `NOSWAG_QUERY_*`.
+
+Tokens are stored through the operating system credential store. Set
+`NOSWAG_API_URL` for staging/local use. CI can use a platform API key via
+`NOSWAG_API_KEY` (or the backwards-compatible `NOSWAG_TOKEN`) without writing
+a credential file. Platform keys carry their workspace, so
+`NOSWAG_WORKSPACE_ID` is optional. The key can also be passed with
+`--api-key`.
+Interactive login stores a rotating refresh token in the OS credential store;
+the short-lived access token is refreshed automatically and logout revokes the
+refresh family.
+
+Repository verification commands run only when `verify.enabled: true` is
+committed in `.noswag.yml` or `--verify` is supplied, and only together with
+`--write`. No detected command is executed implicitly.
+
+Exit codes: `2` authentication, `3` quota/license, `4` generation, `5`
+validation, and `6` write conflict.

noswag_cli-0.1.0/pyproject.toml

@@ -0,0 +1,47 @@
+[build-system]
+requires = ["hatchling>=1.25"]
+build-backend = "hatchling.build"
+
+[project]
+name = "noswag-cli"
+version = "0.1.0"
+description = "Generate repository-native tests with NoSwag"
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.10"
+authors = [{ name = "NoSwag" }]
+dependencies = [
+  "keyring>=25,<27",
+  "PyYAML>=6,<7",
+  "typing-extensions>=4.6,<5",
+]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+]
+
+[project.optional-dependencies]
+dev = [
+  "mypy>=1.10,<3",
+  "types-PyYAML>=6,<7",
+]
+
+[project.scripts]
+noswag = "noswag.cli:main"
+
+[project.urls]
+Homepage = "https://noswag.io"
+Repository = "https://github.com/noswag/noswag"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/noswag"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.mypy]
+python_version = "3.10"
+strict = true

noswag_cli-0.1.0/src/noswag/__init__.py

@@ -0,0 +1,3 @@
+"""NoSwag public Python client."""
+
+__version__ = "0.1.0"

noswag_cli-0.1.0/src/noswag/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+raise SystemExit(main())

noswag_cli-0.1.0/src/noswag/api.py

@@ -0,0 +1,134 @@
+from __future__ import annotations
+
+import json
+import urllib.error
+import urllib.parse
+import urllib.request
+from typing import Any
+
+from .errors import ApiError, ValidationError
+
+
+class NoSwagClient:
+    def __init__(
+        self,
+        base_url: str,
+        token: str | None = None,
+        workspace_id: str | None = None,
+        timeout: float = 30,
+    ) -> None:
+        if not base_url.startswith(("http://", "https://")):
+            raise ValidationError("API URL must use HTTP or HTTPS")
+        self.base_url = base_url.rstrip("/")
+        self.token = token
+        self.workspace_id = workspace_id
+        self.timeout = timeout
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        body: dict[str, Any] | None = None,
+        *,
+        idempotency_key: str | None = None,
+        authenticated: bool = True,
+    ) -> dict[str, Any]:
+        headers = {
+            "Accept": "application/json",
+            "User-Agent": "noswag-python/0.1.0",
+        }
+        if body is not None:
+            headers["Content-Type"] = "application/json"
+        if authenticated:
+            if not self.token:
+                raise ValidationError("No authentication token is configured")
+            headers["Authorization"] = f"Bearer {self.token}"
+        if self.workspace_id:
+            headers["X-Workspace-Id"] = self.workspace_id
+        if idempotency_key:
+            headers["Idempotency-Key"] = idempotency_key
+        request = urllib.request.Request(
+            f"{self.base_url}{path}",
+            data=(
+                json.dumps(body, separators=(",", ":")).encode()
+                if body is not None
+                else None
+            ),
+            headers=headers,
+            method=method,
+        )
+        try:
+            with urllib.request.urlopen(request, timeout=self.timeout) as response:
+                payload = json.loads(response.read().decode())
+        except urllib.error.HTTPError as error:
+            try:
+                payload = json.loads(error.read().decode())
+                detail = payload.get("error", {})
+            except (json.JSONDecodeError, UnicodeDecodeError):
+                detail = {}
+            raise ApiError(
+                error.code,
+                str(detail.get("code", "http_error")),
+                str(detail.get("message", f"NoSwag API returned HTTP {error.code}")),
+            ) from None
+        except urllib.error.URLError as error:
+            raise ApiError(0, "network_error", f"Could not reach NoSwag API: {error.reason}") from None
+        if not isinstance(payload, dict) or payload.get("success") is not True:
+            raise ApiError(0, "invalid_response", "NoSwag API returned an invalid response")
+        data = payload.get("data")
+        if not isinstance(data, dict):
+            raise ApiError(0, "invalid_response", "NoSwag API response has no data object")
+        return data
+
+    def issue_device_code(self) -> dict[str, Any]:
+        return self.request(
+            "POST",
+            "/v1/auth/device/code",
+            {
+                "client_name": "NoSwag Python CLI",
+                "scopes": [
+                    "repository:read",
+                    "repository:write",
+                    "generation:create",
+                    "generation:read",
+                    "usage:read",
+                ],
+            },
+            authenticated=False,
+        )
+
+    def exchange_device_code(self, device_code: str) -> dict[str, Any]:
+        return self.request(
+            "POST",
+            "/v1/auth/device/token",
+            {"device_code": device_code},
+            authenticated=False,
+        )
+
+    def refresh_access_token(self, refresh_token: str) -> dict[str, Any]:
+        return self.request(
+            "POST",
+            "/v1/auth/token/refresh",
+            {"refresh_token": refresh_token},
+            authenticated=False,
+        )
+
+    def revoke_refresh_token(self, refresh_token: str) -> dict[str, Any]:
+        return self.request(
+            "POST",
+            "/v1/auth/token/revoke",
+            {"refresh_token": refresh_token},
+            authenticated=False,
+        )
+
+    def get(self, path: str) -> dict[str, Any]:
+        return self.request("GET", path)
+
+    def post(
+        self,
+        path: str,
+        body: dict[str, Any],
+        *,
+        idempotency_key: str | None = None,
+    ) -> dict[str, Any]:
+        return self.request("POST", path, body, idempotency_key=idempotency_key)

noswag_cli-0.1.0/src/noswag/cli.py

@@ -0,0 +1,312 @@
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+import time
+import webbrowser
+from pathlib import Path
+from typing import Any, cast
+
+from . import __version__
+from .api import NoSwagClient
+from .config import DEFAULT_CONFIG, load_config
+from .credentials import Credential, KeyringCredentialStore
+from .errors import ApiError, GenerationError, NoSwagError, ValidationError
+from .repository import (
+    build_context,
+    config_hash,
+    find_git_root,
+    idempotency_key,
+    repository_identity,
+)
+from .writer import apply_artifact
+from .verification import plan_verification, run_verification
+
+DEFAULT_API_URL = "https://api.noswag.io"
+TERMINAL = {"completed", "failed", "cancelled", "timed_out"}
+
+
+def _api_url(args: argparse.Namespace) -> str:
+    return str(args.api_url or os.environ.get("NOSWAG_API_URL", DEFAULT_API_URL)).rstrip("/")
+
+
+def _client(args: argparse.Namespace) -> NoSwagClient:
+    url = _api_url(args)
+    configured_token = (
+        args.api_key
+        or os.environ.get("NOSWAG_API_KEY")
+        or os.environ.get("NOSWAG_TOKEN")
+    )
+    store = KeyringCredentialStore()
+    credential = None if configured_token else store.load(url)
+    if (
+        credential
+        and credential.refresh_token
+        and credential.expires_at
+        and credential.expires_at <= time.time() + 30
+        and not configured_token
+    ):
+        result = NoSwagClient(url).refresh_access_token(
+            credential.refresh_token
+        )
+        credential = Credential(
+            token=str(result["access_token"]),
+            workspace_id=str(result["workspace_id"]),
+            refresh_token=str(result["refresh_token"]),
+            expires_at=time.time() + int(result["expires_in"]),
+        )
+        store.save(url, credential)
+    token = configured_token or (credential.token if credential else None)
+    workspace = os.environ.get("NOSWAG_WORKSPACE_ID") or (
+        credential.workspace_id if credential else None
+    )
+    if not token or (not workspace and not token.startswith("nsw_")):
+        raise ValidationError("Not authenticated; run `noswag auth login` or set NOSWAG_API_KEY (platform keys do not need NOSWAG_WORKSPACE_ID)")
+    return NoSwagClient(url, token, workspace)
+
+
+def _emit(value: Any, json_output: bool) -> None:
+    if json_output:
+        print(json.dumps(value, separators=(",", ":"), sort_keys=True))
+    elif isinstance(value, str):
+        print(value)
+    else:
+        print(json.dumps(value, indent=2, sort_keys=True))
+
+
+def auth_login(args: argparse.Namespace) -> dict[str, Any]:
+    url = _api_url(args)
+    client = NoSwagClient(url)
+    issued = client.issue_device_code()
+    print(f"Enter code {issued['user_code']} at {issued['verification_uri']}", file=sys.stderr)
+    if not args.no_browser:
+        webbrowser.open(str(issued.get("verification_uri_complete") or issued["verification_uri"]))
+    deadline = time.monotonic() + int(issued["expires_in"])
+    interval = max(1, int(issued["interval"]))
+    while time.monotonic() < deadline:
+        time.sleep(interval)
+        try:
+            result = client.exchange_device_code(str(issued["device_code"]))
+        except ApiError as error:
+            if error.code == "authorization_pending":
+                continue
+            if error.code == "slow_down":
+                interval += 5
+                continue
+            raise
+        credential = Credential(
+            token=str(result["access_token"]),
+            workspace_id=str(result["workspace_id"]),
+            refresh_token=str(result["refresh_token"]),
+            expires_at=time.time() + int(result["expires_in"]),
+        )
+        KeyringCredentialStore().save(url, credential)
+        return {"authenticated": True, "workspace_id": credential.workspace_id}
+    raise ValidationError("Device authorization expired")
+
+
+def auth_status(args: argparse.Namespace) -> dict[str, Any]:
+    return _client(args).get("/v1/me")
+
+
+def auth_logout(args: argparse.Namespace) -> dict[str, Any]:
+    url = _api_url(args)
+    store = KeyringCredentialStore()
+    credential = store.load(url)
+    if credential and credential.refresh_token:
+        try:
+            NoSwagClient(url).revoke_refresh_token(
+                credential.refresh_token
+            )
+        except ApiError:
+            pass
+    store.delete(url)
+    return {"authenticated": False}
+
+
+def init_repo(args: argparse.Namespace) -> dict[str, Any]:
+    root = find_git_root()
+    target = root / ".noswag.yml"
+    if target.exists() and not args.force:
+        raise ValidationError(".noswag.yml already exists; use --force to replace it")
+    target.write_text(DEFAULT_CONFIG)
+    return {"repository_root": str(root), "config": str(target)}
+
+
+def doctor(args: argparse.Namespace) -> dict[str, Any]:
+    root = find_git_root()
+    config = load_config(root, args.config)
+    client = _client(args)
+    me = client.get("/v1/me")
+    context = build_context(root, config, args.base, args.head)
+    return {
+        "ok": True,
+        "repository_root": str(root),
+        "workspace_id": client.workspace_id,
+        "principal": me.get("principal"),
+        "context_files": len(context.files),
+        "changed_files": len(context.changed_files),
+        "head_sha": context.head_sha,
+    }
+
+
+def _repository(client: NoSwagClient, root: Path, config: Any) -> dict[str, Any]:
+    owner, name = repository_identity(root)
+    listed = client.get("/v1/repositories").get("repositories", [])
+    if not isinstance(listed, list):
+        raise ValidationError("Repository list response is invalid")
+    for value in listed:
+        if not isinstance(value, dict):
+            continue
+        repository = cast(dict[str, Any], value)
+        if repository.get("owner") == owner and repository.get("name") == name:
+            return repository
+    created = client.post(
+        "/v1/repositories",
+        {
+            "provider": "local",
+            "owner": owner,
+            "name": name,
+            "default_branch": "main",
+            "policy": {
+                "mode": config.scope,
+                "languages": list(config.languages),
+                "frameworks": list(config.frameworks),
+                "max_files": config.limits.max_generated_files,
+                "allow_new_dependencies": config.allow_new_dependencies,
+            },
+        },
+    )
+    created_repository = created.get("repository")
+    if not isinstance(created_repository, dict):
+        raise ValidationError("Repository response is invalid")
+    return created_repository
+
+
+def gentest(args: argparse.Namespace) -> dict[str, Any]:
+    root = find_git_root()
+    config = load_config(root, args.config)
+    verification_commands = plan_verification(
+        configured=config.verify_enabled,
+        requested=bool(args.verify),
+        write=bool(args.write),
+        commands=config.verify_commands,
+    )
+    context = build_context(root, config, args.base, args.head, args.spec)
+    client = _client(args)
+    repository = _repository(client, root, config)
+    write = bool(args.write)
+    key = idempotency_key(root, context, config, "py")
+    created = client.post(
+        "/v1/generations",
+        {
+            "repository_id": repository["id"],
+            "trigger_type": "cli_python",
+            "client_version": __version__,
+            "base_sha": context.base_sha,
+            "head_sha": context.head_sha,
+            "policy_config_hash": repository.get("policy", {}).get("config_hash") or config_hash(config),
+            "delivery_mode": "commit" if write else "preview",
+        },
+        idempotency_key=key,
+    )
+    run_id = created["generation"]["id"]
+    client.post(
+        f"/v1/generations/{run_id}/context",
+        {
+            "files": context.files,
+            "change": {"files": context.changed_files, "diff": context.diff},
+        },
+    )
+    deadline = time.monotonic() + args.timeout
+    generation: dict[str, Any] = {}
+    while time.monotonic() < deadline:
+        generation = client.get(f"/v1/generations/{run_id}")["generation"]
+        if generation["status"] in TERMINAL:
+            break
+        time.sleep(args.poll_interval)
+    if generation.get("status") != "completed":
+        raise GenerationError(
+            f"Generation {run_id} ended with status {generation.get('status', 'timeout')}"
+        )
+    artifact = client.get(f"/v1/generations/{run_id}/artifact")["artifact"]
+    report = apply_artifact(root, artifact, write)
+    verification = run_verification(root, verification_commands)
+    if not args.json and report.diff:
+        print(report.diff)
+    return {
+        "run_id": run_id,
+        "status": generation["status"],
+        "mode": "write" if write else "dry-run",
+        "repository_root": str(root),
+        "generated": report.generated,
+        "modified": report.modified,
+        "skipped": report.skipped,
+        "conflicted": report.conflicted,
+        "verification": verification,
+        "diff": report.diff if args.json else None,
+    }
+
+
+def status(args: argparse.Namespace) -> dict[str, Any]:
+    return _client(args).get(f"/v1/generations/{args.run_id}")
+
+
+def usage(args: argparse.Namespace) -> dict[str, Any]:
+    return _client(args).get("/v1/usage")
+
+
+def parser() -> argparse.ArgumentParser:
+    root = argparse.ArgumentParser(prog="noswag")
+    root.add_argument("--api-url")
+    root.add_argument("--api-key")
+    root.add_argument("--json", action="store_true")
+    root.add_argument("--version", action="version", version=__version__)
+    commands = root.add_subparsers(dest="command", required=True)
+    auth = commands.add_parser("auth")
+    auth_commands = auth.add_subparsers(dest="auth_command", required=True)
+    login = auth_commands.add_parser("login")
+    login.add_argument("--no-browser", action="store_true")
+    login.set_defaults(handler=auth_login)
+    auth_commands.add_parser("status").set_defaults(handler=auth_status)
+    auth_commands.add_parser("logout").set_defaults(handler=auth_logout)
+    init = commands.add_parser("init")
+    init.add_argument("--force", action="store_true")
+    init.set_defaults(handler=init_repo)
+    doctor_command = commands.add_parser("doctor")
+    doctor_command.add_argument("--config", default=".noswag.yml")
+    doctor_command.add_argument("--base")
+    doctor_command.add_argument("--head", default="HEAD")
+    doctor_command.set_defaults(handler=doctor)
+    generate = commands.add_parser("gentest")
+    generate.add_argument("--config", default=".noswag.yml")
+    generate.add_argument("--spec", help="Generate contract tests from a repository-relative OpenAPI/Swagger file")
+    generate.add_argument("--base")
+    generate.add_argument("--head", default="HEAD")
+    generate.add_argument("--dry-run", action="store_true")
+    generate.add_argument("--write", action="store_true")
+    generate.add_argument("--verify", action="store_true")
+    generate.add_argument("--timeout", type=float, default=300)
+    generate.add_argument("--poll-interval", type=float, default=2)
+    generate.set_defaults(handler=gentest)
+    status_command = commands.add_parser("status")
+    status_command.add_argument("run_id")
+    status_command.set_defaults(handler=status)
+    commands.add_parser("usage").set_defaults(handler=usage)
+    return root
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = parser().parse_args(argv)
+    try:
+        result = args.handler(args)
+        _emit(result, args.json)
+        return 0
+    except NoSwagError as error:
+        if args.json:
+            _emit({"error": {"message": str(error), "type": type(error).__name__}}, True)
+        else:
+            print(f"error: {error}", file=sys.stderr)
+        return error.exit_code