synth-ai 0.2.14__py3-none-any.whl → 0.2.17__py3-none-any.whl

synth_ai/utils/cli.py

@@ -0,0 +1,131 @@
+from collections.abc import Sequence
+from typing import Any, cast
+
+import click
+
+
+class PromptedChoiceType(click.Choice):
+    """`click.Choice` variant that reprompts with an interactive menu on failure.
+
+    Example
+    -------
+    ```python
+    import click
+
+    from synth_ai.utils.cli import PromptedChoiceType, PromptedChoiceOption
+
+
+    @click.command()
+    @click.option(
+        "--mode",
+        cls=PromptedChoiceOption,
+        type=PromptedChoiceType(["sft", "rl"]),
+        required=True,
+    )
+    def train(mode: str) -> None:
+        click.echo(f"Selected mode: {mode}")
+    ```
+    """
+
+    def convert(
+        self,
+        value: Any,
+        param: click.Parameter | None,
+        ctx: click.Context | None,
+    ) -> str:
+        """Validate *value*; prompt for a replacement when it is missing or invalid."""
+        if param is None:
+            raise RuntimeError("Invalid parameter")
+        if ctx is None:
+            raise RuntimeError("Invalid context")
+        if value in (None, ""):
+            return self._prompt_user(param, ctx)
+        try:
+            return super().convert(value, param, ctx)
+        except click.BadParameter:
+            cmd_name = self._get_cmd_name(ctx)
+            if getattr(param, "opts", None):
+                click.echo(f'\n[{cmd_name}] Invalid value "{value}" for {self._get_arg_name(param)}')
+            else:
+                click.echo(f'\n[{cmd_name}] Invalid value "{value}"')
+            return self._prompt_user(param, ctx)
+
+    def _prompt_user(
+        self,
+        param: click.Parameter,
+        ctx: click.Context | None,
+    ) -> str:
+        """Render a numbered picker and return the user’s selection."""
+        arg_name = self._get_arg_name(param)
+        click.echo(f"\n[{self._get_cmd_name(ctx)}] Please choose a value for {arg_name}")
+        for index, choice in enumerate(self.choices, 1):
+            click.echo(f" [{index}] {choice}")
+        while True:
+            selection = click.prompt("> ", type=int)
+            if 1 <= selection <= len(self.choices):
+                return cast(str, self.choices[selection - 1])
+            click.echo(f"Invalid selection for {arg_name}, please try again")
+
+    def _get_cmd_name(self, ctx: click.Context | None) -> str:
+        """Safely extract the current command name for diagnostic output."""
+        cmd = getattr(ctx, "command", None) if ctx is not None else None
+        if cmd is None:
+            return "?"
+        name = getattr(cmd, "name", None)
+        return name or "?"
+
+    def _get_arg_name(self, param: click.Parameter) -> str:
+        """Return the most human-friendly identifier for the parameter."""
+        opts = getattr(param, "opts", None)
+        if opts:
+            return opts[-1]
+        name = getattr(param, "name", None)
+        if name:
+            return name
+        human_name = getattr(param, "human_readable_name", None)
+        if human_name:
+            return human_name
+        return "?"
+
+
+class PromptedChoiceOption(click.Option):
+    """`click.Option` subclass that triggers the interactive picker when missing.
+
+    Example
+    -------
+    ```python
+    import click
+
+    from synth_ai.utils.cli import PromptedChoiceType, PromptedChoiceOption
+
+
+    @click.command()
+    @click.option(
+        "--mode",
+        cls=PromptedChoiceOption,
+        type=PromptedChoiceType(["sft", "rl"]),
+        required=True,
+    )
+    def train(mode: str) -> None:
+        click.echo(f"Selected mode: {mode}")
+    ```
+    """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        kwargs.setdefault("prompt", True)
+        kwargs.setdefault("prompt_required", True)
+        super().__init__(*args, **kwargs)
+
+    def prompt_for_value(self, ctx: click.Context) -> Any:
+        """Invoke the choice picker when the option was omitted."""
+        option_type = getattr(self, "type", None)
+        if isinstance(option_type, PromptedChoiceType):
+            return option_type._prompt_user(self, ctx)
+        return super().prompt_for_value(ctx)
+    
+
+def print_next_step(message: str, lines: Sequence[str]) -> None:
+    print(f"\n➡️  Next, {message}:")
+    for line in lines:
+        print(f"   {line}")
+    print("")

synth_ai/utils/env.py

@@ -0,0 +1,294 @@
+import json
+import os
+import string
+from pathlib import Path
+
+import click
+
+_ENV_SAFE_CHARS = set(string.ascii_letters + string.digits + "_-./:@+=")
+
+
+def _format_env_value(value: str) -> str:
+    if value == "":
+        return '""'
+    if all(char in _ENV_SAFE_CHARS for char in value):
+        return value
+    return json.dumps(value)
+
+
+def _strip_inline_comment(value: str) -> str:
+    in_single = False
+    in_double = False
+    escaped = False
+    for idx, char in enumerate(value):
+        if escaped:
+            escaped = False
+            continue
+        if char == "\\":
+            escaped = True
+            continue
+        if char == "'" and not in_double:
+            in_single = not in_single
+            continue
+        if char == '"' and not in_single:
+            in_double = not in_double
+            continue
+        if char == '#' and not in_single and not in_double:
+            return value[:idx].rstrip()
+    return value.rstrip()
+
+
+def _parse_env_assignment(line: str) -> tuple[str, str] | None:
+    stripped = line.strip()
+    if not stripped or stripped.startswith('#'):
+        return None
+    if stripped.lower().startswith("export "):
+        stripped = stripped[7:].lstrip()
+    if '=' not in stripped:
+        return None
+    key_part, value_part = stripped.split('=', 1)
+    key = key_part.strip()
+    if not key:
+        return None
+    value_candidate = _strip_inline_comment(value_part.strip())
+    if not value_candidate:
+        return key, ""
+    if (
+        len(value_candidate) >= 2
+        and value_candidate[0] in {'"', "'"}
+        and value_candidate[-1] == value_candidate[0]
+    ):
+        value = value_candidate[1:-1]
+    else:
+        value = value_candidate
+    return key, value
+
+
+def _prompt_manual_env_value(key: str) -> str:
+    while True:
+        value = click.prompt(
+            f"Enter value for {key}",
+            hide_input=False,
+            default="",
+            show_default=False,
+            type=str,
+        ).strip()
+        if value:
+            return value
+        if click.confirm("Save empty value?", default=False):
+            return ""
+        click.echo("Empty value discarded; enter a value or confirm empty to continue")
+
+
+def mask_str(input: str, position: int = 3) -> str:
+    return input[:position] + "..." + input[-position:] if len(input) > position * 2 else "***"
+
+
+def get_env_file_paths(base_dir: str | Path = '.') -> list[Path]:
+    base = Path(base_dir).resolve()
+    return [path for path in base.rglob(".env*") if path.is_file()]
+
+
+def get_synth_config_file_paths() -> list[Path]:
+    dir = Path.home() / ".synth-ai"
+    if not dir.exists():
+        return []
+    return [path for path in dir.glob("*.json") if path.is_file()]
+
+
+def filter_env_files_by_key(key: str, paths: list[Path]) -> list[tuple[Path, str]]:
+    matches: list[tuple[Path, str]] = []
+    for path in paths:
+        try:
+            with path.open('r', encoding="utf-8") as file:
+                for line in file:
+                    parsed = _parse_env_assignment(line)
+                    if parsed is None:
+                        continue
+                    parsed_key, value = parsed
+                    if parsed_key == key:
+                        matches.append((path, value))
+                        break
+        except (OSError, UnicodeDecodeError):
+            continue
+    return matches
+
+
+def filter_json_files_by_key(key: str, paths: list[Path]) -> list[tuple[Path, str]]:
+    matches: list[tuple[Path, str]] = []
+    for path in paths:
+        try:
+            with path.open('r', encoding="utf-8") as file:
+                data = json.load(file)
+                if key in data and isinstance(data[key], str):
+                    matches.append((path, data[key]))
+        except (OSError, UnicodeDecodeError, json.JSONDecodeError):
+            continue
+    return matches
+
+
+def ensure_env_var(key: str, expected_value: str) -> None:
+    actual_value = os.getenv(key)
+    if expected_value != actual_value:
+        raise ValueError(f"Expected: {key}={expected_value}\nActual: {key}={actual_value}")
+
+
+def resolve_env_var(key: str) -> str:
+    env_value = os.getenv(key)
+    if env_value is not None:
+        click.echo(f"Using {key}={mask_str(env_value)} from process environment")
+        return env_value
+
+    value: str = ""
+
+    env_file_paths = filter_env_files_by_key(key, get_env_file_paths())
+    synth_file_paths = filter_json_files_by_key(key, get_synth_config_file_paths())
+
+    options: list[tuple[str, str]] = []
+    for path, value in env_file_paths:
+        resolved_path = path.resolve()
+        try:
+            rel_path = str(resolved_path.relative_to(Path.cwd()))
+        except ValueError:
+            rel_path = str(resolved_path)
+        label = f"({rel_path})  {mask_str(value)}"
+        options.append((label, value))
+    for path, value in synth_file_paths:
+        label = f"({path})  {mask_str(value)}"
+        options.append((label, value))
+
+    if options:
+        click.echo(f"\nFound the following options for {key}")
+        for i, (label, _) in enumerate(options, start=1):
+            click.echo(f" [{i}] {label}")
+        click.echo(" [m] Enter value manually")
+        click.echo()
+
+        while True:
+            try:
+                choice = click.prompt(
+                    "Select option",
+                    default=1,
+                    type=str,
+                    show_choices=False,
+                ).strip()
+            except click.Abort:
+                raise
+            if choice.lower() == 'm':
+                value = _prompt_manual_env_value(key)
+                break
+
+            try:
+                index = int(choice)
+            except ValueError:
+                click.echo('Invalid selection. Enter a number or "m".')
+                continue
+
+            if 1 <= index <= len(options):
+                _, value = options[index - 1]
+                break
+
+            click.echo(f"Invalid selection. Enter a number between 1 and {len(options)} or 'm'.")
+
+    else:
+        print(f"No value found for {key}")
+        value = _prompt_manual_env_value(key)
+    
+    os.environ[key] = value
+    ensure_env_var(key, value)
+    print(f"Loaded {key}={mask_str(value)} into process environment")
+    return value
+
+
+def write_env_var_to_dotenv(
+    key: str,
+    value: str,
+    output_file_path: str | Path | None = None,
+) -> None:
+    path = Path(".env") if output_file_path is None else Path(output_file_path)
+    path = path.expanduser()
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+    encoded_value = _format_env_value(value)
+
+    lines: list[str] = []
+    key_written = False
+
+    if path.is_file():
+        try:
+            with path.open('r', encoding="utf-8") as handle:
+                lines = handle.readlines()
+        except OSError as exc:
+            raise RuntimeError(f"Failed to read {path}: {exc}") from exc
+
+        for index, line in enumerate(lines):
+            parsed = _parse_env_assignment(line)
+            if parsed is None or parsed[0] != key:
+                continue
+
+            leading_len = len(line) - len(line.lstrip(' \t'))
+            leading = line[:leading_len]
+            stripped = line.lstrip()
+            has_export = stripped.lower().startswith('export ')
+            newline = '\n' if line.endswith('\n') else ''
+            prefix = 'export ' if has_export else ''
+            lines[index] = f"{leading}{prefix}{key}={encoded_value}{newline}"
+            key_written = True
+            break
+
+    if not key_written:
+        if lines and not lines[-1].endswith('\n'):
+            lines[-1] = f"{lines[-1]}\n"
+        lines.append(f"{key}={encoded_value}\n")
+
+    try:
+        with path.open('w', encoding="utf-8") as handle:
+            handle.writelines(lines)
+    except OSError as exc:
+        raise RuntimeError(f"Failed to write {path}: {exc}") from exc
+
+    print(f"Wrote {key}={mask_str(value)} to {path.resolve()}")
+
+
+def write_env_var_to_json(
+    key: str,
+    value: str,
+    output_file_path: str | Path,
+) -> None:
+    path = Path(output_file_path).expanduser()
+    if path.exists() and not path.is_file():
+        raise RuntimeError(f"{path} exists and is not a file")
+
+    data: dict[str, str] = {}
+
+    if path.is_file():
+        try:
+            with path.open('r', encoding="utf-8") as handle:
+                existing = json.load(handle)
+        except json.JSONDecodeError as exc:
+            raise RuntimeError(f"Invalid JSON in {path}: {exc}") from exc
+        except OSError as exc:
+            raise RuntimeError(f"Failed to read {path}: {exc}") from exc
+
+        if not isinstance(existing, dict):
+            raise RuntimeError(f"Expected JSON object in {path}")
+
+        for existing_key, existing_value in existing.items():
+            if existing_key == key:
+                continue
+            data[str(existing_key)] = (
+                existing_value if isinstance(existing_value, str) else str(existing_value)
+            )
+
+    data[key] = value
+
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+    try:
+        with path.open('w', encoding="utf-8") as handle:
+            json.dump(data, handle, indent=2, sort_keys=True)
+            handle.write('\n')
+    except OSError as exc:
+        raise RuntimeError(f"Failed to write {path}: {exc}") from exc
+
+    print(f"Wrote {key}={mask_str(value)} to {path}")

synth_ai/utils/http.py

@@ -0,0 +1,172 @@
+from __future__ import annotations
+
+import asyncio
+import os
+from dataclasses import dataclass
+from typing import Any
+
+import aiohttp
+
+__all__ = ["HTTPError", "AsyncHttpClient", "http_request", "sleep"]
+
+
+@dataclass
+class HTTPError(Exception):
+    status: int
+    url: str
+    message: str
+    body_snippet: str | None = None
+    detail: Any | None = None
+
+    def __str__(self) -> str:  # pragma: no cover - trivial
+        base = f"HTTP {self.status} for {self.url}: {self.message}"
+        if self.body_snippet:
+            base += f" | body[0:200]={self.body_snippet[:200]}"
+        return base
+
+
+class AsyncHttpClient:
+    def __init__(self, base_url: str, api_key: str, timeout: float = 30.0) -> None:
+        self._base_url = base_url.rstrip("/")
+        self._api_key = api_key
+        self._timeout = aiohttp.ClientTimeout(total=timeout)
+        self._session: aiohttp.ClientSession | None = None
+
+    async def __aenter__(self) -> AsyncHttpClient:
+        if self._session is None:
+            headers = {
+                "authorization": f"Bearer {self._api_key}",
+                "accept": "application/json",
+            }
+            user_id = os.getenv("SYNTH_USER_ID") or os.getenv("X_USER_ID") or os.getenv("USER_ID")
+            if user_id:
+                headers["X-User-ID"] = user_id
+            org_id = os.getenv("SYNTH_ORG_ID") or os.getenv("X_ORG_ID") or os.getenv("ORG_ID")
+            if org_id:
+                headers["X-Org-ID"] = org_id
+            self._session = aiohttp.ClientSession(headers=headers, timeout=self._timeout)
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb) -> None:  # noqa: ANN001
+        if self._session is not None:
+            await self._session.close()
+            self._session = None
+
+    def _abs(self, path: str) -> str:
+        if path.startswith("http://") or path.startswith("https://"):
+            return path
+        if self._base_url.endswith("/api") and path.startswith("/api"):
+            path = path[4:]
+        return f"{self._base_url}/{path.lstrip('/')}"
+
+    async def get(
+        self,
+        path: str,
+        *,
+        params: dict[str, Any] | None = None,
+        headers: dict[str, str] | None = None,
+    ) -> Any:
+        url = self._abs(path)
+        assert self._session is not None, "AsyncHttpClient must be used as an async context manager"
+        async with self._session.get(url, params=params, headers=headers) as resp:
+            return await self._handle_response(resp, url)
+
+    async def post_json(
+        self, path: str, *, json: dict[str, Any], headers: dict[str, str] | None = None
+    ) -> Any:
+        url = self._abs(path)
+        assert self._session is not None, "AsyncHttpClient must be used as an async context manager"
+        async with self._session.post(url, json=json, headers=headers) as resp:
+            return await self._handle_response(resp, url)
+
+    async def post_multipart(
+        self,
+        path: str,
+        *,
+        data: dict[str, Any],
+        files: dict[str, tuple[str, bytes, str | None]],
+        headers: dict[str, str] | None = None,
+    ) -> Any:
+        url = self._abs(path)
+        assert self._session is not None, "AsyncHttpClient must be used as an async context manager"
+        form = aiohttp.FormData()
+        for k, v in data.items():
+            form.add_field(k, str(v))
+        for field, (filename, content, content_type) in files.items():
+            form.add_field(
+                field,
+                content,
+                filename=filename,
+                content_type=content_type or "application/octet-stream",
+            )
+        async with self._session.post(url, data=form, headers=headers) as resp:
+            return await self._handle_response(resp, url)
+
+    async def delete(self, path: str, *, headers: dict[str, str] | None = None) -> Any:
+        url = self._abs(path)
+        assert self._session is not None, "AsyncHttpClient must be used as an async context manager"
+        async with self._session.delete(url, headers=headers) as resp:
+            return await self._handle_response(resp, url)
+
+    async def _handle_response(self, resp: aiohttp.ClientResponse, url: str) -> Any:
+        text = await resp.text()
+        body_snippet = text[:200] if text else None
+        if 200 <= resp.status < 300:
+            ctype = resp.headers.get("content-type", "")
+            if "application/json" in ctype:
+                try:
+                    return await resp.json()
+                except Exception:
+                    return text
+            return text
+        detail: Any | None = None
+        try:
+            detail = await resp.json()
+        except Exception:
+            detail = None
+        raise HTTPError(
+            status=resp.status,
+            url=url,
+            message="request_failed",
+            body_snippet=body_snippet,
+            detail=detail,
+        )
+
+
+def http_request(
+    method: str, url: str, headers: dict[str, str] | None = None, body: dict[str, Any] | None = None
+) -> tuple[int, dict[str, Any] | str]:
+    import json as _json
+    import ssl
+    import urllib.error
+    import urllib.request
+
+    data = None
+    if body is not None:
+        data = _json.dumps(body).encode("utf-8")
+    req = urllib.request.Request(url, method=method, headers=headers or {}, data=data)
+    try:
+        ctx = ssl._create_unverified_context()
+        if os.getenv("SYNTH_SSL_VERIFY", "0") == "1":
+            ctx = None
+        with urllib.request.urlopen(req, timeout=60, context=ctx) as resp:
+            code = getattr(resp, "status", 200)
+            txt = resp.read().decode("utf-8", errors="ignore")
+            try:
+                return int(code), _json.loads(txt)
+            except Exception:
+                return int(code), txt
+    except urllib.error.HTTPError as exc:  # Capture 4xx/5xx bodies
+        txt = exc.read().decode("utf-8", errors="ignore")
+        try:
+            return int(exc.code or 0), _json.loads(txt)
+        except Exception:
+            return int(exc.code or 0), txt
+    except Exception as exc:
+        return 0, str(exc)
+
+
+async def sleep(seconds: float) -> None:
+    """Small async sleep helper preserved for backwards compatibility."""
+
+    await asyncio.sleep(max(float(seconds or 0.0), 0.0))