python-infrakit-dev 0.1.4__py3-none-any.whl → 0.1.6__py3-none-any.whl

infrakit/llm/providers/groq.py

@@ -0,0 +1,167 @@
+"""
+infrakit.llm.providers.groq
+-----------------------------
+Groq provider — wraps the groq Python SDK.
+
+Install dependency::
+
+    pip install groq
+
+Supported models (default): llama-3.3-70b-versatile
+"""
+
+from __future__ import annotations
+
+import time
+from typing import Any, Optional, Type
+
+from pydantic import BaseModel
+
+from ..models import LLMResponse, Prompt
+from .base import BaseProvider
+
+
+class GroqProvider(BaseProvider):
+    """
+    Provider for Groq's Chat Completions API.
+
+    Parameters
+    ----------
+    model       Model string to use. Defaults to ``llama-3.3-70b-versatile``.
+    """
+
+    DEFAULT_MODEL = "llama-3.3-70b-versatile"
+    PROVIDER_NAME = "groq"
+
+    def __init__(self, model: Optional[str] = None) -> None:
+        super().__init__(model)
+        self._check_sdk()
+
+    # ── public interface ───────────────────────────────────────────────────
+
+    async def async_generate(
+        self,
+        prompt: Prompt,
+        api_key: str,
+        response_model: Optional[Type[BaseModel]] = None,
+        schema_retries: int = 2,
+        **kwargs: Any,
+    ) -> LLMResponse:
+        """Async generate using groq.AsyncGroq."""
+        from groq import AsyncGroq
+
+        client = AsyncGroq(api_key=api_key)
+        messages = self._build_messages(prompt)
+        t0 = time.perf_counter()
+
+        response = await client.chat.completions.create(
+            model=self.model,
+            messages=messages,
+            **kwargs,
+        )
+
+        latency_ms = (time.perf_counter() - t0) * 1000
+        return self._build_response(response, latency_ms, response_model, schema_retries, api_key)
+
+    def sync_generate(
+        self,
+        prompt: Prompt,
+        api_key: str,
+        response_model: Optional[Type[BaseModel]] = None,
+        schema_retries: int = 2,
+        **kwargs: Any,
+    ) -> LLMResponse:
+        """Sync generate using groq.Groq (the blocking SDK client)."""
+        from groq import Groq
+
+        client = Groq(api_key=api_key)
+        messages = self._build_messages(prompt)
+        t0 = time.perf_counter()
+
+        response = client.chat.completions.create(
+            model=self.model,
+            messages=messages,
+            **kwargs,
+        )
+
+        latency_ms = (time.perf_counter() - t0) * 1000
+        return self._build_response(response, latency_ms, response_model, schema_retries, api_key)
+
+    # ── internal helpers ───────────────────────────────────────────────────
+
+    @staticmethod
+    def _build_messages(prompt: Prompt) -> list[dict]:
+        messages = []
+        if prompt.system:
+            messages.append({"role": "system", "content": prompt.system})
+        messages.append({"role": "user", "content": prompt.user})
+        return messages
+
+    def _build_response(
+        self,
+        response: Any,
+        latency_ms: float,
+        response_model: Optional[Type[BaseModel]],
+        schema_retries: int,
+        api_key: str,
+    ) -> LLMResponse:
+        choice = response.choices[0]
+        content = choice.message.content or ""
+
+        usage = response.usage
+        input_tokens = usage.prompt_tokens if usage else 0
+        output_tokens = usage.completion_tokens if usage else 0
+        total_tokens = usage.total_tokens if usage else 0
+
+        parsed = None
+        schema_matched = False
+
+        if response_model is not None:
+            parsed, schema_matched = self._validate_schema(
+                content, response_model, schema_retries
+            )
+
+        return LLMResponse(
+            content=content,
+            parsed=parsed,
+            schema_matched=schema_matched,
+            provider=self.PROVIDER_NAME,
+            model=self.model,
+            key_id=api_key[:8],
+            input_tokens=input_tokens,
+            output_tokens=output_tokens,
+            total_tokens=total_tokens,
+            latency_ms=latency_ms,
+        )
+
+    @staticmethod
+    def _check_sdk() -> None:
+        try:
+            import groq  # noqa: F401
+        except ImportError as exc:
+            raise ImportError(
+                "groq package is required for GroqProvider. "
+                "Install it with: pip install groq"
+            ) from exc
+
+    @staticmethod
+    def _is_quota_error(exc: Exception) -> bool:
+        """
+        Groq-specific quota/auth HTTP status codes.
+
+        429 with "rate_limit_exceeded" is *transient* (burst limit) and should
+        be retried with backoff — NOT treated as a permanent quota exhaustion.
+        Only 401/402 and 429 with "quota" or "billing" in the message warrant
+        immediate model deactivation.
+        """
+        try:
+            from groq import APIStatusError
+            if isinstance(exc, APIStatusError):
+                if exc.status_code in (401, 402):
+                    return True
+                if exc.status_code == 429:
+                    msg = str(exc).lower()
+                    return "quota" in msg or "billing" in msg
+        except ImportError:
+            pass
+        return BaseProvider._is_quota_error(exc)

infrakit/scaffolder/ai.py

@@ -40,6 +40,8 @@ from infrakit.scaffolder.generator import (
     _write,
     _config_content,
     _gitignore,
+    _infrakit_dep,
+    _pkg_dep,
     _logger_util,
     _src_init,
     _tests_init,
@@ -124,9 +126,11 @@ def _load_keys() -> dict:
     # fall back to keys declared in the config file
     openai_key  = _cfg.get("OPENAI_API_KEY", "")
     gemini_key  = _cfg.get("GEMINI_API_KEY", "")
+    groq_key    = _cfg.get("GROQ_API_KEY", "")
     return {{
         "openai_keys": [openai_key] if openai_key else [],
         "gemini_keys": [gemini_key] if gemini_key else [],
+        "groq_keys":   [groq_key]   if groq_key   else [],
     }}
 
 
@@ -142,6 +146,7 @@ llm: LLMClient = LLMClient(
     max_concurrent=int(_cfg.get("LLM_CONCURRENCY", 3)),
     openai_model=_cfg.get("OPENAI_MODEL") or None,
     gemini_model=_cfg.get("GEMINI_MODEL") or None,
+    groq_model=_cfg.get("GROQ_MODEL") or None,
 )
 
 __all__ = ["llm", "Prompt"]
@@ -316,7 +321,8 @@ def _keys_json_template() -> str:
 {
   "_comment": "Fill in your API keys. Never commit this file — it is in .gitignore.",
   "openai_keys": [],
-  "gemini_keys":  []
+  "gemini_keys": [],
+  "groq_keys":   []
 }
 """
 
@@ -401,6 +407,12 @@ pytest
 
 def _ai_pyproject(project_name: str, version: str, description: str, author: str) -> str:
     author_line = f'    "{author}",' if author else '    # "Your Name <you@example.com>",'
+    infrakit_dep = _infrakit_dep()
+    openai_dep   = _pkg_dep("openai")
+    genai_dep    = _pkg_dep("google-genai")
+    groq_dep     = _pkg_dep("groq")
+    pydantic_dep = _pkg_dep("pydantic")
+    tqdm_dep     = _pkg_dep("tqdm")
     return f"""\
 [project]
 name        = "{project_name}"
@@ -413,11 +425,12 @@ authors = [
 ]
 
 dependencies = [
-    "infrakit",
-    "openai",
-    "google-genai",
-    "pydantic>=2.0",
-    "tqdm",
+    {infrakit_dep},
+    "{openai_dep}",
+    "{genai_dep}",
+    "{groq_dep}",
+    "{pydantic_dep}",
+    "{tqdm_dep}",
 ]
 
 [project.optional-dependencies]

infrakit/scaffolder/backend.py

@@ -48,6 +48,8 @@ from infrakit.scaffolder.generator import (
     _mkdir,
     _write,
     _gitignore,
+    _infrakit_dep,
+    _pkg_dep,
     _logger_util,
     _src_init,
     _tests_init,
@@ -64,10 +66,12 @@ def _backend_env_config(project_name: str, include_llm: bool) -> str:
 LLM_KEYS_FILE=keys.json
 OPENAI_API_KEY=
 GEMINI_API_KEY=
+GROQ_API_KEY=
 LLM_MODE=async
 LLM_CONCURRENCY=3
 # OPENAI_MODEL=gpt-4o
 # GEMINI_MODEL=gemini-2.0-flash
+# GROQ_MODEL=llama-3.3-70b-versatile
 """ if include_llm else ""
     return f"""\
 # Application
@@ -96,10 +100,12 @@ def _backend_yaml_config(project_name: str, include_llm: bool) -> str:
 LLM_KEYS_FILE: keys.json
 OPENAI_API_KEY: ""
 GEMINI_API_KEY: ""
+GROQ_API_KEY: ""
 LLM_MODE: async
 LLM_CONCURRENCY: 3
 # OPENAI_MODEL: gpt-4o
 # GEMINI_MODEL: gemini-2.0-flash
+# GROQ_MODEL: llama-3.3-70b-versatile
 """ if include_llm else ""
     return f"""\
 # Application configuration
@@ -127,6 +133,7 @@ def _backend_json_config(project_name: str, include_llm: bool) -> str:
   "LLM_KEYS_FILE": "keys.json",
   "OPENAI_API_KEY": "",
   "GEMINI_API_KEY": "",
+  "GROQ_API_KEY": "",
   "LLM_MODE": "async",
   "LLM_CONCURRENCY": 3""" if include_llm else ""
     return f"""\
@@ -195,6 +202,7 @@ class Settings(BaseSettings):
     # optional: LLM keys (override ~/.infrakit/llm/ defaults)
     openai_api_key: str  = ""
     gemini_api_key: str  = ""
+    groq_api_key: str    = ""
     llm_mode: str        = "async"
     llm_concurrency: int = 3
 
@@ -448,7 +456,16 @@ services:
 def _backend_pyproject(
     project_name: str, version: str, description: str, author: str
 ) -> str:
-    author_line = f'    "{author}",' if author else '    # "Your Name <you@example.com>",'
+    author_line  = f'    "{author}",' if author else '    # "Your Name <you@example.com>",'
+    infrakit_dep = _infrakit_dep()
+    fastapi_dep  = _pkg_dep("fastapi")
+    uvicorn_dep  = _pkg_dep("uvicorn")
+    pydantic_dep = _pkg_dep("pydantic")
+    pydset_dep   = _pkg_dep("pydantic-settings")
+    openai_dep   = _pkg_dep("openai")
+    genai_dep    = _pkg_dep("google-genai")
+    groq_dep     = _pkg_dep("groq")
+    tqdm_dep     = _pkg_dep("tqdm")
     return f"""\
 [project]
 name        = "{project_name}"
@@ -461,14 +478,15 @@ authors = [
 ]
 
 dependencies = [
-    "infrakit",
-    "fastapi>=0.110",
-    "uvicorn[standard]",
-    "pydantic>=2.0",
-    "pydantic-settings",
-    "openai",
-    "google-generativeai",
-    "tqdm",
+    {infrakit_dep},
+    "{fastapi_dep}",
+    "{uvicorn_dep}[standard]",
+    "{pydantic_dep}",
+    "{pydset_dep}",
+    "{openai_dep}",
+    "{genai_dep}",
+    "{groq_dep}",
+    "{tqdm_dep}",
 ]
 
 [project.optional-dependencies]

infrakit/scaffolder/cli_tool.py

@@ -40,6 +40,8 @@ from infrakit.scaffolder.generator import (
     _write,
     _config_content,
     _gitignore,
+    _infrakit_dep,
+    _pkg_dep,
     _logger_util,
     _src_init,
     _tests_init,
@@ -199,13 +201,21 @@ def test_hello_name():
 def _cli_pyproject(
     project_name: str, version: str, description: str, author: str, include_llm: bool
 ) -> str:
-    author_line = f'    "{author}",' if author else '    # "Your Name <you@example.com>",'
-    cmd         = project_name.replace("_", "-")
-    llm_deps    = """\
-    "openai",
-    "google-generativeai",
-    "tqdm",
-""" if include_llm else ""
+    author_line  = f'    "{author}",' if author else '    # "Your Name <you@example.com>",'
+    cmd          = project_name.replace("_", "-")
+    infrakit_dep = _infrakit_dep()
+    typer_dep    = _pkg_dep("typer")
+    pydantic_dep = _pkg_dep("pydantic")
+    openai_dep   = _pkg_dep("openai")
+    genai_dep    = _pkg_dep("google-genai")
+    groq_dep     = _pkg_dep("groq")
+    tqdm_dep     = _pkg_dep("tqdm")
+    llm_deps     = f'''\
+    "{openai_dep}",
+    "{genai_dep}",
+    "{groq_dep}",
+    "{tqdm_dep}",
+''' if include_llm else ""
     return f"""\
 [project]
 name        = "{project_name}"
@@ -218,9 +228,9 @@ authors = [
 ]
 
 dependencies = [
-    "infrakit",
-    "typer[all]",
-    "pydantic>=2.0",
+    {infrakit_dep},
+    "{typer_dep}[all]",
+    "{pydantic_dep}",
 {llm_deps}]
 
 [project.optional-dependencies]

infrakit/scaffolder/generator.py

@@ -63,6 +63,58 @@ def _mkdir(result: ScaffoldResult, path: Path) -> None:
     result.entries.append(ScaffoldEntry(path=path, status="created", kind="dir"))
 
 
+# ── helpers ───────────────────────────────────────────────────────────────────
+
+_version_cache: dict[str, str] = {}
+
+
+def _get_package_version(pkg_name: str) -> str:
+    """
+    Return the installed or latest-PyPI version of *pkg_name*.
+
+    Tries ``importlib.metadata`` first (fast, no network), then falls back
+    to a PyPI API call.  Results are cached in-process.
+    """
+    if pkg_name in _version_cache:
+        return _version_cache[pkg_name]
+
+    ver = ""
+    try:
+        from importlib.metadata import version
+        ver = version(pkg_name)
+    except Exception:
+        pass
+
+    if not ver:
+        try:
+            import json
+            import urllib.request
+            url = f"https://pypi.org/pypi/{pkg_name}/json"
+            with urllib.request.urlopen(url, timeout=5) as resp:  # noqa: S310
+                ver = json.loads(resp.read())["info"]["version"]
+        except Exception:
+            pass
+
+    _version_cache[pkg_name] = ver
+    return ver
+
+
+def _get_infrakit_version() -> str:
+    return _get_package_version("python-infrakit-dev")
+
+
+def _infrakit_dep() -> str:
+    """Return the versioned dependency string for python-infrakit-dev."""
+    ver = _get_infrakit_version()
+    return f'"python-infrakit-dev>={ver}"' if ver else '"python-infrakit-dev"'
+
+
+def _pkg_dep(pkg_name: str) -> str:
+    """Return a versioned dep string like ``openai>=1.2.3`` or just ``openai``."""
+    ver = _get_package_version(pkg_name)
+    return f"{pkg_name}>={ver}" if ver else pkg_name
+
+
 # ── template content ──────────────────────────────────────────────────────────
 
 def _pyproject_toml(
@@ -72,6 +124,7 @@ def _pyproject_toml(
     author: str,
 ) -> str:
     author_line = f'    "{author}",' if author else '    # "Your Name <you@example.com>",'
+    infrakit_dep = _infrakit_dep()
     return f"""\
 [project]
 name        = "{project_name}"
@@ -84,7 +137,7 @@ authors = [
 ]
 
 dependencies = [
-    "infrakit",
+    {infrakit_dep},
 ]
 
 [project.optional-dependencies]
@@ -96,10 +149,12 @@ dev = [
 
 
 def _requirements_txt(project_name: str) -> str:
+    ver = _get_infrakit_version()
+    dep = f"python-infrakit-dev>={ver}" if ver else "python-infrakit-dev"
     return f"""\
 # requirements.txt — {project_name}
 # Add your dependencies below.
-infrakit
+{dep}
 """
 
 
@@ -110,10 +165,12 @@ def _env_config(include_llm: bool = False) -> str:
 LLM_KEYS_FILE=keys.json
 OPENAI_API_KEY=
 GEMINI_API_KEY=
+GROQ_API_KEY=
 LLM_MODE=async
 LLM_CONCURRENCY=3
 # OPENAI_MODEL=gpt-4o
 # GEMINI_MODEL=gemini-2.0-flash
+# GROQ_MODEL=llama-3.3-70b-versatile
 # LLM_STATE_DIR=
 # LLM_QUOTA_FILE=
 """ if include_llm else ""
@@ -139,10 +196,12 @@ def _yaml_config(include_llm: bool = False) -> str:
 LLM_KEYS_FILE: keys.json
 OPENAI_API_KEY: ""
 GEMINI_API_KEY: ""
+GROQ_API_KEY: ""
 LLM_MODE: async
 LLM_CONCURRENCY: 3
 # OPENAI_MODEL: gpt-4o
 # GEMINI_MODEL: gemini-2.0-flash
+# GROQ_MODEL: llama-3.3-70b-versatile
 # LLM_STATE_DIR: ""
 # LLM_QUOTA_FILE: ""
 """ if include_llm else ""
@@ -167,6 +226,7 @@ def _json_config(include_llm: bool = False) -> str:
   "LLM_KEYS_FILE": "keys.json",
   "OPENAI_API_KEY": "",
   "GEMINI_API_KEY": "",
+  "GROQ_API_KEY": "",
   "LLM_MODE": "async",
   "LLM_CONCURRENCY": 3""" if include_llm else ""
     return f"""\

infrakit/scaffolder/pipeline.py

@@ -49,6 +49,8 @@ from infrakit.scaffolder.generator import (
     _write,
     _config_content,
     _gitignore,
+    _infrakit_dep,
+    _pkg_dep,
     _logger_util,
     _src_init,
     _tests_init,
@@ -374,12 +376,19 @@ def test_runner_returns_all_stages():
 def _pipeline_pyproject(
     project_name: str, version: str, description: str, author: str, include_llm: bool
 ) -> str:
-    author_line = f'    "{author}",' if author else '    # "Your Name <you@example.com>",'
-    llm_deps = """\
-    "openai",
-    "google-generativeai",
-    "tqdm",
-""" if include_llm else ""
+    author_line  = f'    "{author}",' if author else '    # "Your Name <you@example.com>",'
+    infrakit_dep = _infrakit_dep()
+    pydantic_dep = _pkg_dep("pydantic")
+    openai_dep   = _pkg_dep("openai")
+    genai_dep    = _pkg_dep("google-genai")
+    groq_dep     = _pkg_dep("groq")
+    tqdm_dep     = _pkg_dep("tqdm")
+    llm_deps     = f'''\
+    "{openai_dep}",
+    "{genai_dep}",
+    "{groq_dep}",
+    "{tqdm_dep}",
+''' if include_llm else ""
     return f"""\
 [project]
 name        = "{project_name}"
@@ -392,8 +401,8 @@ authors = [
 ]
 
 dependencies = [
-    "infrakit",
-    "pydantic>=2.0",
+    {infrakit_dep},
+    "{pydantic_dep}",
 {llm_deps}]
 
 [project.optional-dependencies]