synth-ai 0.2.16__py3-none-any.whl → 0.2.19__py3-none-any.whl

synth_ai/utils/env.py

@@ -5,6 +5,8 @@ from pathlib import Path
 
 import click
 
+from .paths import get_env_file_paths, get_home_config_file_paths
+
 _ENV_SAFE_CHARS = set(string.ascii_letters + string.digits + "_-./:@+=")
 
 
@@ -84,18 +86,6 @@ 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:
@@ -127,18 +117,31 @@ def filter_json_files_by_key(key: str, paths: list[Path]) -> list[tuple[Path, st
     return matches
 
 
-def resolve_env_var(key: str) -> None:
+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,
+    override_process_env: bool = False
+) -> str:
     env_value = os.getenv(key)
-    if env_value is not None:
+    if env_value is not None and not override_process_env:
         click.echo(f"Using {key}={mask_str(env_value)} from process environment")
-        return
+        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())
+    synth_file_paths = filter_json_files_by_key(key, get_home_config_file_paths(".synth-ai"))
 
     options: list[tuple[str, str]] = []
+    if env_value is not None:
+        if not override_process_env:
+            return env_value
+        options.append((f"(process environment)  {mask_str(env_value)}", env_value))
     for path, value in env_file_paths:
         resolved_path = path.resolve()
         try:
@@ -161,14 +164,13 @@ def resolve_env_var(key: str) -> None:
         while True:
             try:
                 choice = click.prompt(
-                    "Select option",
+                    "Select an option",
                     default=1,
                     type=str,
                     show_choices=False,
                 ).strip()
             except click.Abort:
-                return
-
+                raise
             if choice.lower() == 'm':
                 value = _prompt_manual_env_value(key)
                 break
@@ -186,20 +188,24 @@ def resolve_env_var(key: str) -> None:
             click.echo(f"Invalid selection. Enter a number between 1 and {len(options)} or 'm'.")
 
     else:
-        click.echo(f"No value found for {key}")
+        print(f"No value found for {key}")
         value = _prompt_manual_env_value(key)
     
     os.environ[key] = value
-    click.echo(f"Loaded {key}={mask_str(value)} into process environment")
-    return
+    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,
+    output_file_path: str | Path | None = None,
+    print_msg: bool = True,
+    mask_msg: bool = True
 ) -> None:
-    path = Path(output_file_path).expanduser()
+    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)
@@ -212,7 +218,7 @@ def write_env_var_to_dotenv(
             with path.open('r', encoding="utf-8") as handle:
                 lines = handle.readlines()
         except OSError as exc:
-            raise click.ClickException(f"Failed to read {path}: {exc}") from exc
+            raise RuntimeError(f"Failed to read {path}: {exc}") from exc
 
         for index, line in enumerate(lines):
             parsed = _parse_env_assignment(line)
@@ -238,9 +244,10 @@ def write_env_var_to_dotenv(
         with path.open('w', encoding="utf-8") as handle:
             handle.writelines(lines)
     except OSError as exc:
-        raise click.ClickException(f"Failed to write {path}: {exc}") from exc
+        raise RuntimeError(f"Failed to write {path}: {exc}") from exc
 
-    click.echo(f"Wrote {key}={mask_str(value)} to {path}")
+    if print_msg:
+        print(f"Wrote {key}={mask_str(value) if mask_msg else value} to {path.resolve()}")
 
 
 def write_env_var_to_json(
@@ -250,7 +257,7 @@ def write_env_var_to_json(
 ) -> None:
     path = Path(output_file_path).expanduser()
     if path.exists() and not path.is_file():
-        raise click.ClickException(f"{path} exists and is not a file")
+        raise RuntimeError(f"{path} exists and is not a file")
 
     data: dict[str, str] = {}
 
@@ -259,12 +266,12 @@ def write_env_var_to_json(
             with path.open('r', encoding="utf-8") as handle:
                 existing = json.load(handle)
         except json.JSONDecodeError as exc:
-            raise click.ClickException(f"Invalid JSON in {path}: {exc}") from exc
+            raise RuntimeError(f"Invalid JSON in {path}: {exc}") from exc
         except OSError as exc:
-            raise click.ClickException(f"Failed to read {path}: {exc}") from exc
+            raise RuntimeError(f"Failed to read {path}: {exc}") from exc
 
         if not isinstance(existing, dict):
-            raise click.ClickException(f"Expected JSON object in {path}")
+            raise RuntimeError(f"Expected JSON object in {path}")
 
         for existing_key, existing_value in existing.items():
             if existing_key == key:
@@ -282,6 +289,6 @@ def write_env_var_to_json(
             json.dump(data, handle, indent=2, sort_keys=True)
             handle.write('\n')
     except OSError as exc:
-        raise click.ClickException(f"Failed to write {path}: {exc}") from exc
+        raise RuntimeError(f"Failed to write {path}: {exc}") from exc
 
-    click.echo(f"Wrote {key}={mask_str(value)} to {path}")
+    print(f"Wrote {key}={mask_str(value)} to {path}")

synth_ai/utils/http.py

@@ -34,7 +34,10 @@ class AsyncHttpClient:
 
     async def __aenter__(self) -> AsyncHttpClient:
         if self._session is None:
-            headers = {"authorization": f"Bearer {self._api_key}"}
+            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

synth_ai/utils/json.py

@@ -0,0 +1,72 @@
+import json
+from pathlib import Path
+
+
+def strip_json_comments(raw: str) -> str:
+    """Remove // and /* */ comments from JSONC text."""
+    result: list[str] = []
+    in_string = False
+    in_line_comment = False
+    in_block_comment = False
+    escape = False
+    i = 0
+    length = len(raw)
+    while i < length:
+        char = raw[i]
+        next_char = raw[i + 1] if i + 1 < length else ""
+
+        if in_line_comment:
+            if char == "\n":
+                in_line_comment = False
+                result.append(char)
+            i += 1
+            continue
+
+        if in_block_comment:
+            if char == "*" and next_char == "/":
+                in_block_comment = False
+                i += 2
+            else:
+                i += 1
+            continue
+
+        if in_string:
+            result.append(char)
+            if char == "\"" and not escape:
+                in_string = False
+            escape = (char == "\\") and not escape
+            i += 1
+            continue
+
+        if char == "/" and next_char == "/":
+            in_line_comment = True
+            i += 2
+            continue
+
+        if char == "/" and next_char == "*":
+            in_block_comment = True
+            i += 2
+            continue
+
+        if char == "\"":
+            in_string = True
+            escape = False
+
+        result.append(char)
+        i += 1
+
+    return "".join(result)
+
+
+def create_and_write_json(path: Path, content: dict) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(content, indent=2) + "\n")
+
+
+def load_json_to_dict(path: Path) -> dict:
+    if not path.exists():
+        return {}
+    try:
+        return json.loads(strip_json_comments(path.read_text()))
+    except (json.JSONDecodeError, OSError):
+        return {}

synth_ai/utils/modal.py

@@ -1,16 +1,25 @@
+import ast
 import contextlib
 import json
 import os
+import re
+import shlex
 import shutil
+import subprocess
 import sys
+import tempfile
+import textwrap
 from pathlib import Path
-from typing import Any, cast
+from typing import Any
 from urllib.parse import urlparse, urlunparse
 
+import click
+from modal.config import config
 from synth_ai.demos import core as demo_core
 from synth_ai.demos.core import DEFAULT_TASK_APP_SECRET_NAME, DemoEnv
+from synth_ai.task_app_cfgs import ModalTaskAppConfig
 
-from .env import mask_str
+from .env import mask_str, resolve_env_var, write_env_var_to_dotenv
 from .http import http_request
 from .process import popen_capture
 from .user_config import load_user_config
@@ -25,6 +34,279 @@ __all__ = [
 ]
 
 
+REPO_ROOT = Path(__file__).resolve().parents[2]
+
+START_DIV = f"{'-' * 31} Modal start {'-' * 31}"
+END_DIV = f"{'-' * 32} Modal end {'-' * 32}"
+MODAL_URL_REGEX = re.compile(r"https?://[^\s]+modal\.run[^\s]*")
+
+
+def get_default_modal_bin_path() -> Path | None:
+    resolved = shutil.which("modal")
+    return Path(resolved) if resolved else None
+
+
+def ensure_py_file_defines_modal_app(file_path: Path) -> None:
+    if file_path.suffix != ".py":
+        raise TypeError()
+    try:
+        tree = ast.parse(file_path.read_text(encoding="utf-8"), filename=str(file_path))
+    except OSError as exc:
+        raise OSError() from exc
+
+    app_aliases: set[str] = set()
+    modal_aliases: set[str] = set()
+
+    def literal_name(call: ast.Call) -> str | None:
+        for kw in call.keywords:
+            if (
+                kw.arg in {"name", "app_name"}
+                and isinstance(kw.value, ast.Constant)
+                and isinstance(kw.value.value, str)
+            ):
+                return kw.value.value
+        if call.args:
+            first = call.args[0]
+            if isinstance(first, ast.Constant) and isinstance(first.value, str):
+                return first.value
+        return None
+
+    for node in ast.walk(tree):
+        if isinstance(node, ast.ImportFrom) and node.module == "modal":
+            for alias in node.names:
+                if alias.name == "App":
+                    app_aliases.add(alias.asname or alias.name)
+        elif isinstance(node, ast.Import):
+            for alias in node.names:
+                if alias.name == "modal":
+                    modal_aliases.add(alias.asname or alias.name)
+        elif isinstance(node, ast.Call):
+            func = node.func
+            if isinstance(func, ast.Name) and func.id in app_aliases:
+                if literal_name(node):
+                    return None
+            elif (
+                isinstance(func, ast.Attribute)
+                and func.attr == "App"
+                and isinstance(func.value, ast.Name)
+                and func.value.id in modal_aliases
+                and literal_name(node)
+            ):
+                return None
+    raise ValueError()
+
+
+def run_modal_setup(modal_bin_path: Path) -> None:
+    
+    print("\n🌐 Connecting to your Modal account via https://modal.com")
+    print(START_DIV)
+    cmd = [str(modal_bin_path), "setup"]
+    try:
+        subprocess.run(cmd, check=True)
+    except subprocess.CalledProcessError as exc:
+        print(END_DIV)
+        raise RuntimeError(
+            f"`{' '.join(cmd)}` exited with status {exc.returncode}"
+            f"Run `{' '.join(cmd)} manually to inspect output"
+        ) from exc
+    print(END_DIV)
+    print("✅ Connected to your Modal account")
+
+
+def ensure_modal_config() -> None:
+    token_id = os.environ.get("MODAL_TOKEN_ID") \
+        or config.get("token_id") \
+        or ''
+    token_secret = os.environ.get("MODAL_TOKEN_SECRET") \
+        or config.get("token_secret") \
+        or ''
+    if token_id and token_secret:
+        print(f"Found Modal token_id={mask_str(token_id)}")
+        print(f"Found Modal token_secret={mask_str(token_secret)}")
+        return
+    
+    modal_bin_path = get_default_modal_bin_path()
+    if not modal_bin_path:
+        raise RuntimeError("Modal CLI not found on PATH")
+    run_modal_setup(modal_bin_path)
+
+
+def deploy_modal_app(cfg: ModalTaskAppConfig) -> None:
+    ensure_py_file_defines_modal_app(cfg.modal_app_path)
+    ensure_modal_config()
+    
+    py_paths: list[str] = []
+
+    source_dir = cfg.modal_app_path.parent.resolve()
+    py_paths.append(str(source_dir))
+    if (source_dir / "__init__.py").exists():  # if the modal app lives in a package, ensure the parent package is importable
+        py_paths.append(str(source_dir.parent.resolve()))
+
+    py_paths.append(str(REPO_ROOT))
+    
+    env_api_key = resolve_env_var("ENVIRONMENT_API_KEY")
+    if not os.environ["ENVIRONMENT_API_KEY"]:
+        raise RuntimeError()
+    
+    env_copy = os.environ.copy()
+    existing_python_path = env_copy.get("PYTHONPATH")
+    if existing_python_path:
+        py_paths.append(existing_python_path)
+    unique_python_paths = list(dict.fromkeys(py_paths))
+    env_copy["PYTHONPATH"] = os.pathsep.join(unique_python_paths)
+    if "PYTHONPATH" in env_copy: # ensure wrapper has access to synth source for intra-repo imports
+        env_copy["PYTHONPATH"] = os.pathsep.join(
+            [str(REPO_ROOT)] + env_copy["PYTHONPATH"].split(os.pathsep)
+        )
+    else:
+        env_copy["PYTHONPATH"] = str(REPO_ROOT)
+
+    modal_app_dir = cfg.modal_app_path.parent.resolve()
+    tmp_root = Path(tempfile.mkdtemp(prefix="synth_modal_app"))
+    wrapper_src = textwrap.dedent(f"""
+        from importlib import util as _util
+        from pathlib import Path as _Path
+        import sys as _sys
+
+        _source_dir = _Path({str(modal_app_dir)!r}).resolve()
+        _module_path = _source_dir / {cfg.modal_app_path.name!r}
+        _package_name = _source_dir.name
+        _repo_root = _Path({str(REPO_ROOT)!r}).resolve()
+        _synth_dir = _repo_root / "synth_ai"
+
+        for _path in (str(_source_dir), str(_source_dir.parent), str(_repo_root)):
+            if _path not in _sys.path:
+                _sys.path.insert(0, _path)
+
+        _spec = _util.spec_from_file_location("_synth_modal_target", str(_module_path))
+        if _spec is None or _spec.loader is None:
+            raise SystemExit("Unable to load modal task app from {cfg.modal_app_path}")
+        _module = _util.module_from_spec(_spec)
+        _sys.modules.setdefault("_synth_modal_target", _module)
+        _spec.loader.exec_module(_module)
+
+        try:
+            from modal import App as _ModalApp
+            from modal import Image as _ModalImage
+        except Exception:
+            _ModalApp = None  # type: ignore[assignment]
+            _ModalImage = None  # type: ignore[assignment]
+
+        def _apply_local_mounts(image):
+            if _ModalImage is None or not isinstance(image, _ModalImage):
+                return image
+            mounts = [
+                (str(_source_dir), f"/root/{{_package_name}}"),
+                (str(_synth_dir), "/root/synth_ai"),
+            ]
+            for local_path, remote_path in mounts:
+                try:
+                    image = image.add_local_dir(local_path, remote_path=remote_path)
+                except Exception:
+                    pass
+            return image
+
+        if hasattr(_module, "image"):
+            _module.image = _apply_local_mounts(getattr(_module, "image"))
+
+        _candidate = getattr(_module, "app", None)
+        if _ModalApp is None or not isinstance(_candidate, _ModalApp):
+            candidate_modal_app = getattr(_module, "modal_app", None)
+            if _ModalApp is not None and isinstance(candidate_modal_app, _ModalApp):
+                _candidate = candidate_modal_app
+                setattr(_module, "app", _candidate)
+
+        if _ModalApp is not None and not isinstance(_candidate, _ModalApp):
+            raise SystemExit(
+                "Modal task app must expose an 'app = modal.App(...)' (or modal_app) attribute."
+            )
+
+        try:
+            from modal import Secret as _Secret
+        except Exception:
+            _Secret = None
+
+        for remote_path in ("/root/synth_ai", f"/root/{{_package_name}}"):
+            if remote_path not in _sys.path:
+                _sys.path.insert(0, remote_path)
+
+        globals().update({{k: v for k, v in vars(_module).items() if not k.startswith("__")}})
+        app = getattr(_module, "app")
+        _ENVIRONMENT_API_KEY = {env_api_key!r}
+        if _Secret is not None and _ENVIRONMENT_API_KEY:
+            try:
+                _inline_secret = _Secret.from_dict({{"ENVIRONMENT_API_KEY": _ENVIRONMENT_API_KEY}})
+            except Exception:
+                _inline_secret = None
+            if _inline_secret is not None:
+                try:
+                    _decorators = list(getattr(app, "_function_decorators", []))
+                except Exception:
+                    _decorators = []
+                for _decorator in _decorators:
+                    _existing = getattr(_decorator, "secrets", None)
+                    if not _existing:
+                        continue
+                    try:
+                        if _inline_secret not in _existing:
+                            _decorator.secrets = list(_existing) + [_inline_secret]
+                    except Exception:
+                        pass
+    """).strip()
+    wrapper_path = tmp_root / "__modal_wrapper__.py"
+    wrapper_path.write_text(wrapper_src + '\n', encoding="utf-8")
+    wrapper_info = (wrapper_path, tmp_root)
+
+    cmd = [str(cfg.modal_bin_path), cfg.cmd_arg, str(wrapper_path)]
+    if cfg.task_app_name and cfg.cmd_arg == "deploy":
+        cmd.extend(["--name", cfg.task_app_name])
+    
+    msg = " ".join(shlex.quote(c) for c in cmd)
+    if cfg.dry_run:
+        print("Dry run:\n", msg)
+        return
+    print(f"Running:\n{msg}")
+
+    try:
+        process = subprocess.Popen(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            bufsize=1,
+            env=env_copy
+        )
+        task_app_url = None
+        assert process.stdout is not None
+        print(START_DIV)
+        for line in process.stdout:
+            click.echo(line, nl=False)
+            if task_app_url is None:
+                match = MODAL_URL_REGEX.search(line)
+                if match:
+                    task_app_url = match.group(0).rstrip(".,")
+                    if task_app_url:
+                        write_env_var_to_dotenv(
+                            "TASK_APP_URL",
+                            task_app_url,
+                            print_msg=True,
+                            mask_msg=False,
+                        )
+        print(END_DIV)
+        rc = process.wait()
+        if rc != 0:
+            raise subprocess.CalledProcessError(rc, cmd)
+    except subprocess.CalledProcessError as exc:
+        raise click.ClickException(
+            f"modal {cfg.cmd_arg} failed with exit code: {exc.returncode}"
+        ) from exc
+    finally:
+        if wrapper_info is not None:
+            wrapper_path, tmp_root = wrapper_info
+            wrapper_path.unlink(missing_ok=True)
+        shutil.rmtree(tmp_root, ignore_errors=True)
+
+
 def is_modal_public_url(url: str | None) -> bool:
     try:
         candidate = (url or "").strip().lower()
@@ -63,7 +345,7 @@ def normalize_endpoint_url(url: str) -> str:
                     creds += f":{parsed.password}"
                 netloc = f"{creds}@{netloc}"
             parsed = parsed._replace(netloc=netloc)
-            return cast(str, urlunparse(parsed))
+            return urlunparse(parsed)
     except Exception:
         pass
     return url

synth_ai/utils/paths.py

@@ -0,0 +1,48 @@
+import shutil
+from pathlib import Path
+
+
+def find_bin_path(name: str) -> Path | None:
+    path = shutil.which(name)
+    if not path:
+        return None
+    return Path(path)
+
+
+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_home_config_file_paths(
+    dir_name: str,
+    file_extension: str = "json"
+) -> list[Path]:
+    dir = Path.home() / dir_name
+    if not dir.exists():
+        return []
+    return [path for path in dir.glob(f"*.{file_extension}") if path.is_file()]
+
+
+def find_config_path(
+    bin_path: Path,
+    home_subdir: str,
+    filename: str,
+) -> Path | None:
+    """
+    Return a config file located in the user's home directory or alongside the binary.
+
+    Args:
+        bin_path: Resolved path to the executable.
+        home_subdir: Directory under the user's home to inspect (e.g., ".codex").
+        filename: Name of the config file to locate.
+    """
+    home_candidate = Path.home() / home_subdir / filename
+    if home_candidate.exists():
+        return home_candidate
+
+    local_candidate = Path(bin_path).parent / home_subdir / filename
+    if local_candidate.exists():
+        return local_candidate
+
+    return None