flaxcloud 0.3.0__py3-none-any.whl

flaxcloud/cli.py

@@ -0,0 +1,385 @@
+"""`flax` — the Flax Cloud command-line interface, built on the Python SDK.
+
+Run `flax --help` for the full command list. Credentials resolve in this order: `--key` flag,
+`$FLAX_API_KEY`, then `~/.config/flax/config.json` (written by `flax login`).
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+from typing import Optional
+
+from . import __version__
+from .client import DEFAULT_BASE_URL, FlaxClient
+from .errors import FlaxError
+
+
+# ------------------------------- config storage -------------------------------
+def _config_path() -> str:
+    base = os.environ.get("XDG_CONFIG_HOME") or os.path.expanduser("~/.config")
+    return os.path.join(base, "flax", "config.json")
+
+
+def _load_config() -> dict:
+    try:
+        with open(_config_path(), "r", encoding="utf-8") as fh:
+            return json.load(fh)
+    except (OSError, ValueError):
+        return {}
+
+
+def _save_config(cfg: dict) -> None:
+    path = _config_path()
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    with open(path, "w", encoding="utf-8") as fh:
+        json.dump(cfg, fh, indent=2)
+    try:
+        os.chmod(path, 0o600)  # the key is a secret
+    except OSError:
+        pass
+
+
+def _resolve_key(args: argparse.Namespace) -> Optional[str]:
+    return getattr(args, "key", None) or os.environ.get("FLAX_API_KEY") or _load_config().get("api_key")
+
+
+def _resolve_base_url(args: argparse.Namespace) -> str:
+    return (
+        getattr(args, "url", None)
+        or os.environ.get("FLAX_BASE_URL")
+        or _load_config().get("base_url")
+        or DEFAULT_BASE_URL
+    )
+
+
+def _client(args: argparse.Namespace) -> FlaxClient:
+    key = _resolve_key(args)
+    if not key:
+        _die("not logged in. Run `flax login` or set FLAX_API_KEY.")
+    return FlaxClient(api_key=key, base_url=_resolve_base_url(args))
+
+
+def _die(message: str, code: int = 1) -> "None":
+    print(f"error: {message}", file=sys.stderr)
+    raise SystemExit(code)
+
+
+def _print_rows(headers: list[str], rows: list[list[str]]) -> None:
+    widths = [len(h) for h in headers]
+    for row in rows:
+        for i, cell in enumerate(row):
+            widths[i] = max(widths[i], len(str(cell)))
+    fmt = "  ".join(f"{{:<{w}}}" for w in widths)
+    print(fmt.format(*headers))
+    for row in rows:
+        print(fmt.format(*[str(c) for c in row]))
+
+
+# ----------------------------------- commands ---------------------------------
+def cmd_login(args: argparse.Namespace) -> int:
+    key = args.key or os.environ.get("FLAX_API_KEY")
+    if not key:
+        try:
+            import getpass
+
+            key = getpass.getpass("Flax API key (flax_live_...): ").strip()
+        except (EOFError, KeyboardInterrupt):
+            print()
+            return 1
+    if not key:
+        _die("no API key provided")
+    base_url = args.url or _load_config().get("base_url") or DEFAULT_BASE_URL
+    # Validate the key before saving.
+    try:
+        me = FlaxClient(api_key=key, base_url=base_url).me()
+    except FlaxError as exc:
+        _die(f"login failed: {exc}")
+    _save_config({"api_key": key, "base_url": base_url})
+    print(f"Logged in as {me.get('email', 'unknown')} ({me.get('plan', '?')} plan).")
+    print(f"Saved credentials to {_config_path()}")
+    return 0
+
+
+def cmd_whoami(args: argparse.Namespace) -> int:
+    me = _client(args).me()
+    print(f"{me.get('email')}  ·  plan={me.get('plan')}  ·  id={me.get('id')}")
+    return 0
+
+
+def cmd_sandbox_create(args: argparse.Namespace) -> int:
+    sb = _client(args).create_sandbox(
+        template=args.template,
+        memory_mb=args.memory,
+        network_mode=args.network,
+        startup_command=args.startup,
+    )
+    print(sb.id)
+    if not args.quiet:
+        print(f"status={sb.status} template={sb.template}", file=sys.stderr)
+    return 0
+
+
+def cmd_sandbox_ls(args: argparse.Namespace) -> int:
+    sandboxes = _client(args).list_sandboxes()
+    if not sandboxes:
+        print("No sandboxes.")
+        return 0
+    rows = [[s.id, s.status, s.template, s.network_mode] for s in sandboxes]
+    _print_rows(["ID", "STATUS", "TEMPLATE", "NETWORK"], rows)
+    return 0
+
+
+def cmd_sandbox_rm(args: argparse.Namespace) -> int:
+    client = _client(args)
+    for sid in args.ids:
+        client.get_sandbox(sid).destroy()
+        print(f"destroyed {sid}")
+    return 0
+
+
+def cmd_sandbox_stop(args: argparse.Namespace) -> int:
+    sb = _client(args).get_sandbox(args.id).stop()
+    print(f"{sb.id} -> {sb.status}")
+    return 0
+
+
+def cmd_sandbox_resume(args: argparse.Namespace) -> int:
+    sb = _client(args).get_sandbox(args.id).resume()
+    print(f"{sb.id} -> {sb.status}")
+    return 0
+
+
+def cmd_run(args: argparse.Namespace) -> int:
+    sb = _client(args).get_sandbox(args.id)
+    command = " ".join(args.command)
+    if args.stream:
+        stream = sb.run_stream(command, timeout=args.timeout)
+        for chunk in stream:
+            sys.stdout.write(chunk)
+            sys.stdout.flush()
+        return 0 if (stream.exit_code or 0) == 0 else (stream.exit_code or 1)
+    cmd = sb.run(command, timeout=args.timeout, background=args.background)
+    if args.background:
+        print(cmd.id)
+        print(f"running in background; poll with `flax logs {args.id} {cmd.id}`", file=sys.stderr)
+        return 0
+    if cmd.stdout:
+        sys.stdout.write(cmd.stdout)
+    if cmd.stderr:
+        sys.stderr.write(cmd.stderr)
+    return 0 if cmd.ok else (cmd.exit_code or 1)
+
+
+def cmd_logs(args: argparse.Namespace) -> int:
+    sb = _client(args).get_sandbox(args.id)
+    cmd = sb.get_command(args.command_id)
+    if cmd.stdout:
+        sys.stdout.write(cmd.stdout)
+    if cmd.stderr:
+        sys.stderr.write(cmd.stderr)
+    print(f"[{cmd.status}{'' if cmd.exit_code is None else f', exit {cmd.exit_code}'}]", file=sys.stderr)
+    return 0
+
+
+def cmd_ls(args: argparse.Namespace) -> int:
+    entries = _client(args).get_sandbox(args.id).list_files(args.path)
+    if not entries:
+        print("(empty)")
+        return 0
+    for e in sorted(entries, key=lambda x: (not x.is_dir, x.name)):
+        suffix = "/" if e.is_dir else ""
+        size = "" if e.is_dir else f"  {e.size_bytes}"
+        print(f"{e.name}{suffix}{size}")
+    return 0
+
+
+def _parse_remote(spec: str) -> Optional[tuple]:
+    # "sbx_xxx:/path" -> (id, path); returns None for a local path.
+    if ":" in spec:
+        head, _, tail = spec.partition(":")
+        if head.startswith("sbx_"):
+            return head, tail or "/workspace"
+    return None
+
+
+def cmd_cp(args: argparse.Namespace) -> int:
+    client = _client(args)
+    src_remote = _parse_remote(args.src)
+    dst_remote = _parse_remote(args.dst)
+    if src_remote and not dst_remote:  # download
+        sid, remote = src_remote
+        client.get_sandbox(sid).download_file(remote, args.dst)
+        print(f"downloaded {sid}:{remote} -> {args.dst}")
+    elif dst_remote and not src_remote:  # upload
+        sid, remote = dst_remote
+        client.get_sandbox(sid).upload_file(args.src, remote)
+        print(f"uploaded {args.src} -> {sid}:{remote}")
+    else:
+        _die("cp needs exactly one remote side, e.g. `flax cp ./a.txt sbx_x:/workspace/a.txt`")
+    return 0
+
+
+def cmd_startup(args: argparse.Namespace) -> int:
+    sb = _client(args).get_sandbox(args.id)
+    if args.set is not None:
+        st = sb.set_startup(args.set)
+        print(f"startup command {'set' if args.set else 'cleared'}")
+    if args.run:
+        st = sb.run_startup()
+        print("startup launched")
+    if args.set is None and not args.run:
+        st = sb.startup()
+    print(f"configured={st.configured} status={st.status} source={st.source}")
+    if st.effective_command:
+        print(f"command: {st.effective_command}")
+    if args.show_logs and st.logs:
+        print("--- logs ---")
+        print(st.logs)
+    return 0
+
+
+def cmd_session(args: argparse.Namespace) -> int:
+    client = _client(args)
+    if args.session_cmd == "create":
+        s = client.get_sandbox(args.id).create_session()
+        print(s.id)
+        return 0
+    if args.session_cmd == "ls":
+        sessions = client.get_sandbox(args.id).sessions()
+        if not sessions:
+            print("No sessions.")
+            return 0
+        _print_rows(["ID", "CWD"], [[s.id, s.cwd] for s in sessions])
+        return 0
+    if args.session_cmd == "rm":
+        from .sandbox import Session
+
+        Session(client, {"id": args.session_id, "sandbox_id": "", "cwd": "/workspace"}).delete()
+        print(f"deleted {args.session_id}")
+        return 0
+    if args.session_cmd == "exec":
+        from .sandbox import Session
+
+        s = Session(client, {"id": args.session_id, "sandbox_id": "", "cwd": "/workspace"})
+        res = s.run(" ".join(args.command), timeout=args.timeout)
+        if res.stdout:
+            sys.stdout.write(res.stdout)
+        if res.stderr:
+            sys.stderr.write(res.stderr)
+        print(f"[cwd={res.cwd} exit={res.exit_code}]", file=sys.stderr)
+        return 0 if res.ok else (res.exit_code or 1)
+    return 0
+
+
+def cmd_preview(args: argparse.Namespace) -> int:
+    link = _client(args).get_sandbox(args.id).create_preview_link(args.port)
+    if link.url:
+        print(link.url)
+    else:
+        print(f"preview link active on port {link.port} (URL shown only at creation)")
+    return 0
+
+
+# ------------------------------------ parser ----------------------------------
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(prog="flax", description="Flax Cloud CLI — isolated cloud sandboxes.")
+    p.add_argument("--version", action="version", version=f"flax {__version__}")
+    p.add_argument("--key", help="API key (overrides env/config)")
+    p.add_argument("--url", help="API base URL (default: https://flaxcloud.com)")
+    sub = p.add_subparsers(dest="cmd", required=True)
+
+    sp = sub.add_parser("login", help="save and verify your API key")
+    sp.set_defaults(func=cmd_login)
+
+    sub.add_parser("whoami", help="show the authenticated account").set_defaults(func=cmd_whoami)
+
+    sbx = sub.add_parser("sandbox", help="manage sandboxes")
+    sbx_sub = sbx.add_subparsers(dest="sandbox_cmd", required=True)
+    c = sbx_sub.add_parser("create", help="create a sandbox")
+    c.add_argument("--template", default="blank", help="blank | python | node")
+    c.add_argument("--memory", type=int, help="memory limit (MB)")
+    c.add_argument("--network", choices=["bridge", "none"], help="network mode")
+    c.add_argument("--startup", help="startup command (auto-run on create/resume)")
+    c.add_argument("-q", "--quiet", action="store_true", help="print only the sandbox id")
+    c.set_defaults(func=cmd_sandbox_create)
+    sbx_sub.add_parser("ls", help="list sandboxes").set_defaults(func=cmd_sandbox_ls)
+    rm = sbx_sub.add_parser("rm", help="destroy sandbox(es)")
+    rm.add_argument("ids", nargs="+")
+    rm.set_defaults(func=cmd_sandbox_rm)
+    st = sbx_sub.add_parser("stop", help="stop a sandbox")
+    st.add_argument("id")
+    st.set_defaults(func=cmd_sandbox_stop)
+    rs = sbx_sub.add_parser("resume", help="resume a sandbox")
+    rs.add_argument("id")
+    rs.set_defaults(func=cmd_sandbox_resume)
+
+    run = sub.add_parser("run", help="run a command in a sandbox")
+    run.add_argument("id")
+    run.add_argument("command", nargs=argparse.REMAINDER, help="the command to run")
+    run.add_argument("--timeout", type=int, help="command timeout (seconds)")
+    run.add_argument("--background", "--async", action="store_true", dest="background")
+    run.add_argument("--stream", action="store_true", help="stream output live as it runs")
+    run.set_defaults(func=cmd_run)
+
+    se = sub.add_parser("session", help="stateful sessions (cwd/env persist across commands)")
+    se_sub = se.add_subparsers(dest="session_cmd", required=True)
+    sc = se_sub.add_parser("create", help="create a session in a sandbox")
+    sc.add_argument("id")
+    sc.set_defaults(func=cmd_session)
+    sls = se_sub.add_parser("ls", help="list a sandbox's sessions")
+    sls.add_argument("id")
+    sls.set_defaults(func=cmd_session)
+    sex = se_sub.add_parser("exec", help="run a command in a session")
+    sex.add_argument("session_id")
+    sex.add_argument("command", nargs=argparse.REMAINDER, help="the command to run")
+    sex.add_argument("--timeout", type=int, help="command timeout (seconds)")
+    sex.set_defaults(func=cmd_session)
+    srm = se_sub.add_parser("rm", help="delete a session")
+    srm.add_argument("session_id")
+    srm.set_defaults(func=cmd_session)
+
+    lg = sub.add_parser("logs", help="show a command's output/status")
+    lg.add_argument("id")
+    lg.add_argument("command_id")
+    lg.set_defaults(func=cmd_logs)
+
+    ls = sub.add_parser("ls", help="list files in a sandbox")
+    ls.add_argument("id")
+    ls.add_argument("path", nargs="?", default="/workspace")
+    ls.set_defaults(func=cmd_ls)
+
+    cp = sub.add_parser("cp", help="copy files to/from a sandbox (use sbx_id:/path)")
+    cp.add_argument("src")
+    cp.add_argument("dst")
+    cp.set_defaults(func=cmd_cp)
+
+    su = sub.add_parser("startup", help="view/set/run a sandbox's startup command")
+    su.add_argument("id")
+    su.add_argument("--set", help="set the startup command (empty string clears it)")
+    su.add_argument("--run", action="store_true", help="launch the startup command now")
+    su.add_argument("--show-logs", action="store_true", help="print the startup log tail")
+    su.set_defaults(func=cmd_startup)
+
+    pv = sub.add_parser("preview", help="create/print a shareable preview link")
+    pv.add_argument("id")
+    pv.add_argument("port", type=int)
+    pv.set_defaults(func=cmd_preview)
+
+    return p
+
+
+def main(argv: Optional[list] = None) -> int:
+    args = build_parser().parse_args(argv)
+    try:
+        return args.func(args)
+    except FlaxError as exc:
+        _die(str(exc))
+    except BrokenPipeError:  # e.g. piping into `head`
+        return 0
+
+
+if __name__ == "__main__":  # pragma: no cover
+    raise SystemExit(main())

flaxcloud/client.py

@@ -0,0 +1,204 @@
+"""The Flax Cloud API client."""
+
+from __future__ import annotations
+
+import os
+import random
+import time
+from typing import Any, Optional
+
+import httpx
+
+from .errors import FlaxAuthError, FlaxConnectionError, FlaxError, error_from_response
+from .sandbox import Sandbox
+
+DEFAULT_BASE_URL = "https://flaxcloud.com"
+
+# Methods safe to retry after a server/network error without risking duplicate side effects.
+_IDEMPOTENT = frozenset({"GET", "HEAD", "OPTIONS", "PUT", "DELETE"})
+# Transient server statuses worth retrying.
+_RETRY_STATUSES = frozenset({429, 502, 503, 504})
+
+
+def _user_agent() -> str:
+    from . import __version__
+
+    return f"flaxcloud-python/{__version__} httpx/{httpx.__version__}"
+
+
+class FlaxClient:
+    """Entry point for talking to Flax Cloud.
+
+    ```python
+    from flaxcloud import FlaxClient
+
+    flax = FlaxClient()  # reads FLAX_API_KEY from the environment
+    sb = flax.create_sandbox(template="python")
+    print(sb.run("python3 -c 'print(6*7)'").stdout)
+    sb.destroy()
+    ```
+
+    The API key is read from `api_key`, else `$FLAX_API_KEY`. `base_url` defaults to
+    `$FLAX_BASE_URL` or https://flaxcloud.com.
+    """
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        *,
+        base_url: Optional[str] = None,
+        timeout: float = 60.0,
+        max_retries: int = 2,
+        http_client: Optional[httpx.Client] = None,
+    ) -> None:
+        self._api_key = api_key or os.environ.get("FLAX_API_KEY")
+        if not self._api_key:
+            raise FlaxAuthError(
+                "no API key: pass api_key=... or set the FLAX_API_KEY environment variable"
+            )
+        base_url = base_url or os.environ.get("FLAX_BASE_URL") or DEFAULT_BASE_URL
+        self._max_retries = max(0, int(max_retries))
+        # An injected client (e.g. an ASGI transport in tests) is used as-is; auth is added
+        # per request so the caller doesn't have to wire headers.
+        self._http = http_client or httpx.Client(base_url=base_url.rstrip("/"), timeout=timeout)
+        self._owns_client = http_client is None
+        self.base_url = base_url.rstrip("/")
+
+    # --------------------------- low-level request ---------------------------
+    def request(self, method: str, path: str, **kwargs: Any) -> Any:
+        """Send an authenticated request (with retries) and return parsed JSON (or None)."""
+        headers = dict(kwargs.pop("headers", {}))
+        headers["Authorization"] = f"Bearer {self._api_key}"
+        headers.setdefault("User-Agent", _user_agent())
+        method = method.upper()
+
+        attempt = 0
+        while True:
+            try:
+                resp = self._http.request(method, path, headers=headers, **kwargs)
+            except httpx.ConnectError as exc:
+                # The request never reached the server, so retrying is always safe.
+                if attempt < self._max_retries:
+                    self._sleep_backoff(attempt)
+                    attempt += 1
+                    continue
+                raise FlaxConnectionError(f"could not reach Flax Cloud: {exc}") from exc
+            except httpx.HTTPError as exc:
+                if method in _IDEMPOTENT and attempt < self._max_retries:
+                    self._sleep_backoff(attempt)
+                    attempt += 1
+                    continue
+                raise FlaxConnectionError(f"could not reach Flax Cloud: {exc}") from exc
+
+            if (
+                resp.status_code in _RETRY_STATUSES
+                and method in _IDEMPOTENT
+                and attempt < self._max_retries
+            ):
+                self._sleep_backoff(attempt, resp.headers.get("Retry-After"))
+                attempt += 1
+                continue
+
+            return self._parse(resp)
+
+    @staticmethod
+    def _sleep_backoff(attempt: int, retry_after: Optional[str] = None) -> None:
+        if retry_after:
+            try:
+                time.sleep(min(float(retry_after), 30.0))
+                return
+            except (TypeError, ValueError):
+                pass
+        # Exponential backoff with jitter: ~0.25s, 0.5s, 1s, ...
+        time.sleep(min(0.25 * (2 ** attempt), 5.0) * (0.5 + random.random()))
+
+    @staticmethod
+    def _parse(resp: httpx.Response) -> Any:
+        if resp.status_code >= 400:
+            code = None
+            message = resp.text or resp.reason_phrase
+            try:
+                payload = resp.json()
+                if isinstance(payload, dict) and isinstance(payload.get("error"), dict):
+                    code = payload["error"].get("code")
+                    message = payload["error"].get("message", message)
+            except ValueError:
+                pass
+            raise error_from_response(resp.status_code, code, message)
+
+        if resp.status_code == 204 or not resp.content:
+            return None
+        return resp.json()
+
+    # ------------------------------- sandboxes -------------------------------
+    def create_sandbox(
+        self,
+        template: str = "blank",
+        *,
+        memory_mb: Optional[int] = None,
+        timeout_seconds: Optional[int] = None,
+        network_mode: Optional[str] = None,
+        env: Optional[dict] = None,
+        startup_command: Optional[str] = None,
+        restore_from: Optional[str] = None,
+        metadata: Optional[dict] = None,
+    ) -> Sandbox:
+        body: dict[str, Any] = {"template": template}
+        if memory_mb is not None:
+            body["memory_mb"] = memory_mb
+        if timeout_seconds is not None:
+            body["timeout_seconds"] = timeout_seconds
+        if network_mode is not None:
+            body["network_mode"] = network_mode
+        if env is not None:
+            body["env"] = env
+        if startup_command is not None:
+            body["startup_command"] = startup_command
+        if restore_from is not None:
+            body["restore_from"] = restore_from
+        if metadata is not None:
+            body["metadata"] = metadata
+        data = self.request("POST", "/v1/sandboxes", json=body)
+        return Sandbox(self, data)
+
+    def get_sandbox(self, sandbox_id: str) -> Sandbox:
+        data = self.request("GET", f"/v1/sandboxes/{sandbox_id}")
+        return Sandbox(self, data)
+
+    def list_sandboxes(self) -> list[Sandbox]:
+        data = self.request("GET", "/v1/sandboxes")
+        return [Sandbox(self, d) for d in data.get("data", [])]
+
+    def me(self) -> dict:
+        """Return the authenticated account (id, email, plan, …)."""
+        return self.request("GET", "/v1/me")
+
+    def usage(self) -> dict:
+        """Return current usage and plan limits for the account."""
+        return self.request("GET", "/v1/usage")
+
+    # ------------------------------- API keys --------------------------------
+    def list_api_keys(self) -> list[dict]:
+        data = self.request("GET", "/v1/keys")
+        return data.get("data", []) if isinstance(data, dict) else data
+
+    def create_api_key(self, name: str = "default") -> dict:
+        """Create a new API key. The full key is returned once, in the `key` field."""
+        return self.request("POST", "/v1/keys", json={"name": name})
+
+    def delete_api_key(self, key_id: str) -> None:
+        self.request("DELETE", f"/v1/keys/{key_id}")
+
+    # ------------------------------- lifecycle -------------------------------
+    def close(self) -> None:
+        if self._owns_client:
+            self._http.close()
+
+    def __enter__(self) -> "FlaxClient":
+        return self
+
+    def __exit__(self, *exc: object) -> None:
+        self.close()
+
+
+__all__ = ["FlaxClient", "FlaxError"]

flaxcloud/errors.py

@@ -0,0 +1,65 @@
+"""Typed exceptions for the Flax Cloud SDK.
+
+Every API error envelope (`{"error": {"code", "message"}}`) is mapped to a `FlaxError`
+subclass so callers can branch on the failure type instead of parsing strings.
+"""
+
+from __future__ import annotations
+
+
+class FlaxError(Exception):
+    """Base class for all SDK errors."""
+
+    def __init__(self, message: str, *, code: str | None = None, status: int | None = None):
+        super().__init__(message)
+        self.message = message
+        self.code = code
+        self.status = status
+
+    def __str__(self) -> str:  # pragma: no cover - cosmetic
+        parts = [self.message]
+        if self.code:
+            parts.append(f"(code={self.code})")
+        return " ".join(parts)
+
+
+class FlaxAuthError(FlaxError):
+    """Missing/invalid API key or session (HTTP 401)."""
+
+
+class FlaxNotFoundError(FlaxError):
+    """The requested resource does not exist or isn't yours (HTTP 404)."""
+
+
+class FlaxQuotaError(FlaxError):
+    """A plan limit/quota was exceeded (HTTP 402)."""
+
+
+class FlaxConflictError(FlaxError):
+    """The resource is in a state that doesn't allow this action (HTTP 409)."""
+
+
+class FlaxBadRequestError(FlaxError):
+    """The request was rejected (HTTP 4xx)."""
+
+
+class FlaxServerError(FlaxError):
+    """The server failed to handle the request (HTTP 5xx)."""
+
+
+class FlaxConnectionError(FlaxError):
+    """The client could not reach the API at all."""
+
+
+def error_from_response(status: int, code: str | None, message: str) -> FlaxError:
+    if status == 401:
+        return FlaxAuthError(message, code=code, status=status)
+    if status == 402:
+        return FlaxQuotaError(message, code=code, status=status)
+    if status == 404:
+        return FlaxNotFoundError(message, code=code, status=status)
+    if status == 409:
+        return FlaxConflictError(message, code=code, status=status)
+    if 400 <= status < 500:
+        return FlaxBadRequestError(message, code=code, status=status)
+    return FlaxServerError(message, code=code, status=status)