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

infrakit/scaffolder/ai.py

@@ -58,9 +58,12 @@ utils.llm
 ~~~~~~~~~
 Thin wrapper that boots the infrakit LLM client once and exports it.
 
+Reads all configuration from the project config file (.env / config.yaml /
+config.json) via infrakit.config — no raw os.getenv calls.
+
 The client reads key state from ``~/.infrakit/llm/`` by default, and
 loads quota limits from ``~/.infrakit/llm/quotas.json`` if that file
-exists.  Both paths can be overridden with environment variables.
+exists.  Both paths can be overridden via LLM_STATE_DIR / LLM_QUOTA_FILE.
 
 Usage
 -----
@@ -89,24 +92,38 @@ Usage
 """
 
 import json
-import os
 from pathlib import Path
 
+from infrakit.core.config.loader import load, load_env
 from infrakit.llm import LLMClient, Prompt  # re-export Prompt for convenience
 
+# ── config loading ────────────────────────────────────────────────────────────
+
+def _load_cfg() -> dict:
+    if Path(".env").exists():
+        return load_env(".env", cast_values=True)
+    if Path("config.yaml").exists():
+        return load("config.yaml")
+    if Path("config.json").exists():
+        return load("config.json")
+    return {{}}
+
+
+_cfg = _load_cfg()
+
 # ── key loading ───────────────────────────────────────────────────────────────
-# Keys are read from the environment or from a local keys.json file.
+# Keys are read from the project config or from a local keys.json file.
 # Never commit real API keys — use .env or your secret manager.
 
 def _load_keys() -> dict:
-    keys_file = Path(os.getenv("LLM_KEYS_FILE", "keys.json"))
+    keys_file = Path(_cfg.get("LLM_KEYS_FILE", "keys.json"))
     if keys_file.exists():
         with open(keys_file) as f:
             return json.load(f)
 
-    # fall back to individual env vars
-    openai_key  = os.getenv("OPENAI_API_KEY", "")
-    gemini_key  = os.getenv("GEMINI_API_KEY", "")
+    # fall back to keys declared in the config file
+    openai_key  = _cfg.get("OPENAI_API_KEY", "")
+    gemini_key  = _cfg.get("GEMINI_API_KEY", "")
     return {{
         "openai_keys": [openai_key] if openai_key else [],
         "gemini_keys": [gemini_key] if gemini_key else [],
@@ -118,13 +135,13 @@ def _load_keys() -> dict:
 llm: LLMClient = LLMClient(
     keys=_load_keys(),
     # storage_dir and quota_file default to ~/.infrakit/llm/
-    # override with env vars if needed:
-    storage_dir=os.getenv("LLM_STATE_DIR") or None,
-    quota_file=os.getenv("LLM_QUOTA_FILE") or None,
-    mode=os.getenv("LLM_MODE", "async"),           # "async" | "threaded"
-    max_concurrent=int(os.getenv("LLM_CONCURRENCY", "3")),
-    openai_model=os.getenv("OPENAI_MODEL") or None,
-    gemini_model=os.getenv("GEMINI_MODEL") or None,
+    # override via LLM_STATE_DIR / LLM_QUOTA_FILE in your config file:
+    storage_dir=_cfg.get("LLM_STATE_DIR") or None,
+    quota_file=_cfg.get("LLM_QUOTA_FILE") or None,
+    mode=_cfg.get("LLM_MODE", "async"),            # "async" | "threaded"
+    max_concurrent=int(_cfg.get("LLM_CONCURRENCY", 3)),
+    openai_model=_cfg.get("OPENAI_MODEL") or None,
+    gemini_model=_cfg.get("GEMINI_MODEL") or None,
 )
 
 __all__ = ["llm", "Prompt"]
@@ -474,10 +491,14 @@ def scaffold_ai(
     _write(result, project_dir / "pipelines" / "preprocess.py", _pipeline_preprocess())
     _write(result, project_dir / "pipelines" / "predict.py",   _pipeline_predict())
 
+    # ── prompts ───────────────────────────────────────────────────────────────
+    _write(result, project_dir / "prompts" / "default.txt", _default_prompt())
+
     # ── utils ─────────────────────────────────────────────────────────────────
     _write(result, project_dir / "utils" / "__init__.py", '"""Shared utilities."""\n')
     _write(result, project_dir / "utils" / "logger.py",   _logger_util())
-    _write(result, project_dir / "utils" / "llm.py",      _llm_util(project_name))
+    if include_llm:
+        _write(result, project_dir / "utils" / "llm.py",  _llm_util(project_name))
 
     # ── notebooks ─────────────────────────────────────────────────────────────
     if include_notebooks:
@@ -488,7 +509,7 @@ def scaffold_ai(
     _write(result, project_dir / "tests" / "__init__.py", _tests_init())
 
     # ── config ────────────────────────────────────────────────────────────────
-    cfg_name, cfg_content = _config_content(config_fmt)
+    cfg_name, cfg_content = _config_content(config_fmt, include_llm=include_llm)
     _write(result, project_dir / cfg_name, cfg_content)
 
     # ── keys template (safe placeholder — never contains real keys) ───────────

infrakit/scaffolder/backend.py

@@ -47,7 +47,6 @@ from infrakit.scaffolder.generator import (
     ScaffoldResult,
     _mkdir,
     _write,
-    _config_content,
     _gitignore,
     _logger_util,
     _src_init,
@@ -58,6 +57,107 @@ from infrakit.scaffolder.generator import (
 # ── template content ──────────────────────────────────────────────────────────
 
 
+def _backend_env_config(project_name: str, include_llm: bool) -> str:
+    llm_block = """\
+
+# LLM
+LLM_KEYS_FILE=keys.json
+OPENAI_API_KEY=
+GEMINI_API_KEY=
+LLM_MODE=async
+LLM_CONCURRENCY=3
+# OPENAI_MODEL=gpt-4o
+# GEMINI_MODEL=gemini-2.0-flash
+""" if include_llm else ""
+    return f"""\
+# Application
+APP_NAME={project_name}
+APP_ENV=development
+APP_DEBUG=false
+APP_HOST=0.0.0.0
+APP_PORT=8000
+
+# Database
+DATABASE_URL=sqlite:///./app.db
+
+# Logger
+LOG_DIR=logs
+LOG_STRATEGY=date
+LOG_STREAM=stdout
+LOG_FORMAT=human
+LOG_LEVEL=DEBUG
+{llm_block}"""
+
+
+def _backend_yaml_config(project_name: str, include_llm: bool) -> str:
+    llm_block = """
+
+# LLM
+LLM_KEYS_FILE: keys.json
+OPENAI_API_KEY: ""
+GEMINI_API_KEY: ""
+LLM_MODE: async
+LLM_CONCURRENCY: 3
+# OPENAI_MODEL: gpt-4o
+# GEMINI_MODEL: gemini-2.0-flash
+""" if include_llm else ""
+    return f"""\
+# Application configuration
+app:
+  name: {project_name}
+  env: development
+  debug: false
+  host: 0.0.0.0
+  port: 8000
+
+# Database
+DATABASE_URL: sqlite:///./app.db
+
+# Logger (flat keys — read by utils/logger.py via infrakit.config)
+LOG_DIR: logs
+LOG_STRATEGY: date
+LOG_STREAM: stdout
+LOG_FORMAT: human
+LOG_LEVEL: DEBUG
+{llm_block}"""
+
+
+def _backend_json_config(project_name: str, include_llm: bool) -> str:
+    llm_keys = """,
+  "LLM_KEYS_FILE": "keys.json",
+  "OPENAI_API_KEY": "",
+  "GEMINI_API_KEY": "",
+  "LLM_MODE": "async",
+  "LLM_CONCURRENCY": 3""" if include_llm else ""
+    return f"""\
+{{
+  "app": {{
+    "name": "{project_name}",
+    "env": "development",
+    "debug": false,
+    "host": "0.0.0.0",
+    "port": 8000
+  }},
+  "DATABASE_URL": "sqlite:///./app.db",
+  "LOG_DIR": "logs",
+  "LOG_STRATEGY": "date",
+  "LOG_STREAM": "stdout",
+  "LOG_FORMAT": "human",
+  "LOG_LEVEL": "DEBUG"{llm_keys}
+}}
+"""
+
+
+def _backend_config_content(
+    fmt: str, project_name: str, include_llm: bool
+) -> tuple[str, str]:
+    if fmt == "yaml":
+        return "config.yaml", _backend_yaml_config(project_name, include_llm)
+    if fmt == "json":
+        return "config.json", _backend_json_config(project_name, include_llm)
+    return ".env", _backend_env_config(project_name, include_llm)
+
+
 def _app_init(version: str) -> str:
     return f'__version__ = "{version}"\n'
 
@@ -526,13 +626,17 @@ def scaffold_backend(
     # ── utils ─────────────────────────────────────────────────────────────────
     _write(result, project_dir / "utils" / "__init__.py", '"""Shared utilities."""\n')
     _write(result, project_dir / "utils" / "logger.py",   _logger_util())
+    if include_llm:
+        from infrakit.scaffolder.ai import _llm_util, _keys_json_template
+        _write(result, project_dir / "utils" / "llm.py",  _llm_util(project_name))
+        _write(result, project_dir / "keys.json",          _keys_json_template())
 
     # ── tests ─────────────────────────────────────────────────────────────────
     _write(result, project_dir / "tests" / "__init__.py", _tests_init())
     _write(result, project_dir / "tests" / "test_health.py", _test_health())
 
     # ── config ────────────────────────────────────────────────────────────────
-    cfg_name, cfg_content = _config_content(config_fmt)
+    cfg_name, cfg_content = _backend_config_content(config_fmt, project_name, include_llm)
     _write(result, project_dir / cfg_name, cfg_content)
 
     # ── docker ────────────────────────────────────────────────────────────────

infrakit/scaffolder/cli_tool.py

@@ -366,7 +366,7 @@ def scaffold_cli_tool(
     _write(result, project_dir / "tests" / "test_cli.py",  _test_cli(project_name))
 
     # ── config ────────────────────────────────────────────────────────────────
-    cfg_name, cfg_content = _config_content(config_fmt)
+    cfg_name, cfg_content = _config_content(config_fmt, include_llm=include_llm)
     _write(result, project_dir / cfg_name, cfg_content)
 
     # ── dependency file ───────────────────────────────────────────────────────

infrakit/scaffolder/generator.py

@@ -78,7 +78,7 @@ name        = "{project_name}"
 version     = "{version}"
 description = "{description}"
 readme      = "README.md"
-requires-python = ">=3.10"
+requires-python = ">=3.13"
 authors = [
 {author_line}
 ]
@@ -103,45 +103,95 @@ infrakit
 """
 
 
-def _env_config() -> str:
-    return """\
-# Application configuration
-# Copy this file to .env and fill in the values.
+def _env_config(include_llm: bool = False) -> str:
+    llm_block = """\
+
+# LLM
+LLM_KEYS_FILE=keys.json
+OPENAI_API_KEY=
+GEMINI_API_KEY=
+LLM_MODE=async
+LLM_CONCURRENCY=3
+# OPENAI_MODEL=gpt-4o
+# GEMINI_MODEL=gemini-2.0-flash
+# LLM_STATE_DIR=
+# LLM_QUOTA_FILE=
+""" if include_llm else ""
+    return f"""\
+# Application
 APP_ENV=development
 APP_DEBUG=false
 APP_SECRET=YOUR_VALUE_HERE
-"""
 
-
-def _yaml_config() -> str:
-    return """\
+# Logger
+LOG_DIR=logs
+LOG_STRATEGY=date
+LOG_STREAM=stdout
+LOG_FORMAT=human
+LOG_LEVEL=DEBUG
+{llm_block}"""
+
+
+def _yaml_config(include_llm: bool = False) -> str:
+    llm_block = """
+
+# LLM
+LLM_KEYS_FILE: keys.json
+OPENAI_API_KEY: ""
+GEMINI_API_KEY: ""
+LLM_MODE: async
+LLM_CONCURRENCY: 3
+# OPENAI_MODEL: gpt-4o
+# GEMINI_MODEL: gemini-2.0-flash
+# LLM_STATE_DIR: ""
+# LLM_QUOTA_FILE: ""
+""" if include_llm else ""
+    return f"""\
 # Application configuration
 app:
   env: development
   debug: false
   secret: YOUR_VALUE_HERE
-"""
 
-
-def _json_config() -> str:
-    return """\
-{
-  "app": {
+# Logger (flat keys — read by utils/logger.py via infrakit.config)
+LOG_DIR: logs
+LOG_STRATEGY: date
+LOG_STREAM: stdout
+LOG_FORMAT: human
+LOG_LEVEL: DEBUG
+{llm_block}"""
+
+
+def _json_config(include_llm: bool = False) -> str:
+    llm_keys = """,
+  "LLM_KEYS_FILE": "keys.json",
+  "OPENAI_API_KEY": "",
+  "GEMINI_API_KEY": "",
+  "LLM_MODE": "async",
+  "LLM_CONCURRENCY": 3""" if include_llm else ""
+    return f"""\
+{{
+  "app": {{
     "env": "development",
     "debug": false,
     "secret": "YOUR_VALUE_HERE"
-  }
-}
+  }},
+  "LOG_DIR": "logs",
+  "LOG_STRATEGY": "date",
+  "LOG_STREAM": "stdout",
+  "LOG_FORMAT": "human",
+  "LOG_LEVEL": "DEBUG"{llm_keys}
+}}
 """
 
 
-def _config_content(fmt: str) -> tuple[str, str]:
+def _config_content(fmt: str, *, include_llm: bool = False) -> tuple[str, str]:
     """Return (filename, content) for the chosen config format."""
     if fmt == "yaml":
-        return "config.yaml", _yaml_config()
+        return "config.yaml", _yaml_config(include_llm)
     if fmt == "json":
-        return "config.json", _json_config()
-    return ".env", _env_config()  # default
+        return "config.json", _json_config(include_llm)
+    return ".env", _env_config(include_llm)  # default
 
 
 def _logger_util() -> str:
@@ -151,6 +201,9 @@ utils.logger
 ~~~~~~~~~~~~
 Thin wrapper that boots the infrakit logger once and exports ``get_logger``.
 
+Reads LOG_DIR, LOG_STRATEGY, LOG_STREAM, LOG_FORMAT, and LOG_LEVEL from the
+project config file (.env / config.yaml / config.json) via infrakit.config.
+
 Usage
 -----
     from utils.logger import get_logger
@@ -159,22 +212,34 @@ Usage
     log.info("hello")
 \"\"\"
 
-import os
+from pathlib import Path
+from infrakit.core.config.loader import load, load_env
 from infrakit.core.logger import setup, get_logger  # re-export get_logger
 
 _booted = False
 
 
+def _load_cfg() -> dict:
+    if Path(".env").exists():
+        return load_env(".env", cast_values=True)
+    if Path("config.yaml").exists():
+        return load("config.yaml")
+    if Path("config.json").exists():
+        return load("config.json")
+    return {}
+
+
 def _boot() -> None:
     global _booted
     if _booted:
         return
+    cfg = _load_cfg()
     setup(
-        log_dir=os.getenv("LOG_DIR", "logs"),
-        strategy=os.getenv("LOG_STRATEGY", "date"),
-        stream=os.getenv("LOG_STREAM", "stdout"),
-        fmt=os.getenv("LOG_FORMAT", "human"),
-        level=os.getenv("LOG_LEVEL", "DEBUG"),
+        log_dir=cfg.get("LOG_DIR", "logs"),
+        strategy=cfg.get("LOG_STRATEGY", "date"),
+        stream=cfg.get("LOG_STREAM", "stdout"),
+        fmt=cfg.get("LOG_FORMAT", "human"),
+        level=cfg.get("LOG_LEVEL", "DEBUG"),
     )
     _booted = True
 
@@ -318,7 +383,7 @@ def scaffold_basic(
     _write(result, project_dir / "tests" / "__init__.py", _tests_init())
 
     # ── config file ───────────────────────────────────────────────────────────
-    cfg_name, cfg_content = _config_content(config_fmt)
+    cfg_name, cfg_content = _config_content(config_fmt, include_llm=include_llm)
     _write(result, project_dir / cfg_name, cfg_content)
 
     # ── dependency file ───────────────────────────────────────────────────────

infrakit/scaffolder/pipeline.py

@@ -543,7 +543,7 @@ def scaffold_pipeline(
     _write(result, project_dir / "tests" / "test_pipeline.py", _test_pipeline())
 
     # ── config ────────────────────────────────────────────────────────────────
-    cfg_name, cfg_content = _config_content(config_fmt)
+    cfg_name, cfg_content = _config_content(config_fmt, include_llm=include_llm)
     _write(result, project_dir / cfg_name, cfg_content)
 
     # ── dependency file ───────────────────────────────────────────────────────

python_infrakit_dev-0.1.4.dist-info/METADATA

@@ -0,0 +1,318 @@
+Metadata-Version: 2.4
+Name: python-infrakit-dev
+Version: 0.1.4
+Summary: A comprehensive Python developer infrastructure toolkit
+Project-URL: Homepage, https://github.com/chiragg21/infrakit
+Project-URL: Repository, https://github.com/chiragg21/infrakit
+Requires-Python: >=3.13
+Requires-Dist: google-genai>=1.69.0
+Requires-Dist: isort>=8.0.1
+Requires-Dist: openai>=2.30.0
+Requires-Dist: pydantic>=2.12.5
+Requires-Dist: python-dotenv>=1.2.2
+Requires-Dist: pyyaml>=6.0.3
+Requires-Dist: tqdm>=4.67.3
+Requires-Dist: typer>=0.24.1
+Description-Content-Type: text/markdown
+
+# Infrakit
+
+A modular developer toolkit for Python — project scaffolding, logging, config loading, a multi-provider LLM client, and dependency utilities.
+
+```bash
+pip install infrakit
+```
+
+The CLI is available as `ik`.
+
+---
+
+## Scaffolding
+
+Bootstrap a new project in one command:
+
+```bash
+ik init my-project              # basic layout
+ik init my-api -t backend       # FastAPI service
+ik init my-model -t ai          # AI/ML project with pipelines and notebooks
+ik init my-etl -t pipeline      # ETL/data pipeline
+ik init my-cli -t cli_tool      # distributable CLI app
+```
+
+**All flags:**
+
+| Flag | Values | Default | Description |
+|---|---|---|---|
+| `-t` / `--template` | `basic`, `backend`, `ai`, `pipeline`, `cli_tool` | `basic` | Project template |
+| `-v` / `--version` | e.g. `0.1.0` | `0.1.0` | Starting version string |
+| `--description` | string | `""` | Short description added to pyproject.toml and README |
+| `--author` | string | `""` | Author line in pyproject.toml |
+| `--config` | `env`, `yaml`, `json` | `env` | Config file format to generate |
+| `--deps` | `toml`, `requirements` | `toml` | Dependency file style |
+| `--include-llm` | flag | off | Add `utils/llm.py` wired to `infrakit.llm` |
+
+Every template generates a config file pre-populated with the variables its utilities need (logger settings, LLM keys, app settings). Re-running over an existing directory skips files already present.
+
+---
+
+## Core — Config & Logger
+
+### Config loader
+
+```python
+from infrakit.core.config.loader import load, load_env
+
+cfg = load_env(".env", cast_values=True)   # "true" → bool, "42" → int
+cfg = load("config.yaml")
+cfg = load("config.json")
+
+port = cfg.get("APP_PORT", 8000)
+```
+
+**`load(path, *, ...)`** — load a config file (JSON, YAML, INI, or `.env`), format inferred from extension.
+
+| Parameter | Default | Description |
+|---|---|---|
+| `path` | — | Path to the config file |
+| `env_override` | `False` | Let existing environment variables override file values |
+| `env_file` | `".env"` | `.env` file to merge in alongside the config |
+| `inject_new` | `False` | Add any new keys from the env file into the result |
+| `interpolate` | `True` | Expand `${VAR}` references within values |
+| `cast_values` | `True` | Convert strings to int, float, bool where possible |
+
+**`load_env(path, *, cast_values)`** — convenience wrapper to load a `.env` file directly. `cast_values` defaults to `False`.
+
+---
+
+### Logger
+
+```python
+from infrakit.core.logger import setup, get_logger
+
+setup(log_dir="logs", strategy="date", stream="stdout", fmt="human", level="INFO")
+
+log = get_logger(__name__)
+log.info("started on port %d", 8080)
+```
+
+**`setup(*, ...)`** — configure logging once at startup. All parameters are keyword-only.
+
+| Parameter | Default | Description |
+|---|---|---|
+| `level` | `"DEBUG"` | Minimum log level (`DEBUG`, `INFO`, `WARNING`, `ERROR`) |
+| `fmt` | `"human"` | Console format — `"human"` for readable text, `"json"` for structured |
+| `file_fmt` | `"human"` | Format used in log files (same options as `fmt`) |
+| `strategy` | `"date"` | File rotation strategy — `"date"`, `"date_level"`, or `"single"` |
+| `stream` | `"stdout"` | Where to echo logs — `"stdout"`, `"stderr"`, or `None` to disable |
+| `log_dir` | `"logs"` | Directory where log files are written |
+| `session` | `None` | Label this run — adds a session prefix to log filenames |
+| `retention` | `30` | Days to keep old log files before deletion |
+| `max_bytes` | `10MB` | Max size of a single log file before rotation |
+| `force` | `False` | Re-apply setup even if already configured |
+
+**`get_logger(name)`** — returns a stdlib `Logger`. Always call as `get_logger(__name__)`. Safe to call before `setup()`.
+
+---
+
+## LLM Client
+
+A unified client for **OpenAI** and **Gemini** with key rotation, rate limiting, quota tracking, and async/batch generation.
+
+```python
+from infrakit.llm import LLMClient, Prompt
+
+client = LLMClient(
+    keys={"openai_keys": ["sk-..."], "gemini_keys": ["AIza..."]},
+    storage_dir="./llm_state",  # persists key usage across restarts
+)
+
+response = client.generate(Prompt(user="What is 2+2?"), provider="openai")
+print(response.content)
+```
+
+**`LLMClient(keys, ...)`**
+
+| Parameter | Default | Description |
+|---|---|---|
+| `keys` | — | Dict with `openai_keys` and/or `gemini_keys` lists of API key strings |
+| `storage_dir` | `~/.infrakit/llm` | Directory where key state is persisted across restarts |
+| `quota_file` | `None` | Path to a `quotas.json` file with per-provider/model limits |
+| `mode` | `"async"` | Batch execution mode — `"async"` or `"threaded"` |
+| `max_concurrent` | `3` | Max parallel requests in batch calls |
+| `key_retries` | `3` | How many keys to try before giving up on a request |
+| `schema_retries` | `2` | How many times to retry structured output parsing on schema mismatch |
+| `meta_window` | `200` | Number of recent requests to keep in memory per key |
+| `openai_model` | `"gpt-4o-mini"` | Default OpenAI model |
+| `gemini_model` | `"gemini-2.0-flash"` | Default Gemini model |
+| `show_progress` | `True` | Show a progress bar during batch generation |
+
+---
+
+**`generate(prompt, provider, response_model, **kwargs)`** — blocking single call, safe in any context.
+
+**`async_generate(prompt, provider, response_model, **kwargs)`** — async version, use inside `async` functions.
+
+| Parameter | Default | Description |
+|---|---|---|
+| `prompt` | — | `Prompt(system=..., user=...)` — `system` is optional |
+| `provider` | — | `"openai"` or `"gemini"` |
+| `response_model` | `None` | Pydantic `BaseModel` subclass for structured output parsing |
+
+---
+
+**`batch_generate(prompts, provider, ...)`** — run many prompts; results match input order.
+
+**`async_batch_generate(prompts, provider, ...)`** — async version for use inside `async` functions.
+
+| Parameter | Default | Description |
+|---|---|---|
+| `prompts` | — | List of `Prompt` objects |
+| `provider` | — | `"openai"` or `"gemini"` |
+| `response_model` | `None` | Pydantic model for structured output on every item |
+| `max_concurrent` | client default | Override the client-level concurrency limit for this batch |
+| `show_progress` | client default | Override the client-level progress bar setting |
+
+```python
+batch = client.batch_generate(prompts, provider="openai")
+print(batch.success_count, batch.failure_count, batch.total_tokens)
+for r in batch.results:
+    print(r.content if not r.error else r.error)
+```
+
+---
+
+**Structured output:**
+
+```python
+from pydantic import BaseModel
+
+class Summary(BaseModel):
+    title: str
+    bullets: list[str]
+
+response = client.generate(Prompt(user="Summarise: ..."), provider="openai", response_model=Summary)
+if response.schema_matched:
+    print(response.parsed.bullets)   # typed Summary instance
+```
+
+---
+
+**`set_quota(provider, key_id, quota)`** — set limits for a specific key.
+
+```python
+from infrakit.llm import QuotaConfig
+
+# key-level RPM (applies to all models on this key)
+client.set_quota(provider="openai", key_id="sk-key1", quota=QuotaConfig(rpm_limit=60))
+
+# per-model daily token limit
+client.set_quota(provider="gemini", key_id="AIza-key1", quota=QuotaConfig(model="gemini-2.5-pro", daily_token_limit=250_000))
+```
+
+`QuotaConfig` fields: `model` (None = all models on the key), `rpm_limit`, `daily_token_limit`, `tpm_limit`.
+
+Quota defaults can also be set in a `quotas.json` file — pass the path via `quota_file=` in the constructor.
+
+---
+
+**`status(provider, key_id)`** — return key status as a list of dicts. **`print_status(provider, key_id)`** — same but pretty-printed to stdout.
+
+| Parameter | Default | Description |
+|---|---|---|
+| `provider` | `None` | Filter to `"openai"` or `"gemini"`; `None` returns all |
+| `key_id` | `None` | Filter to a specific key (first 8 chars); `None` returns all |
+
+```python
+rows = client.status(provider="openai")
+# each row: provider, key_id, status, rpm_limit, current_rpm, models
+```
+
+**CLI:**
+
+```bash
+ik llm status --storage-dir ./llm_state
+ik llm quota set --provider openai --key sk-abc --rpm 60 --storage-dir ./llm_state
+```
+
+---
+
+## Other Features
+
+### Dependency management (`infrakit.deps`)
+
+```bash
+ik deps scan .                   # list packages your code actually imports
+ik deps export . --format toml   # sync pyproject.toml / requirements.txt
+ik deps check --packages numpy   # outdated, security, and license checks
+ik deps clean . --dry-run        # find unused installed packages
+ik deps optimise .               # sort and clean imports (isort)
+```
+
+**`scan(root, include_notebooks, use_gitignore)`**
+
+| Parameter | Default | Description |
+|---|---|---|
+| `root` | — | Project root to scan |
+| `include_notebooks` | `False` | Also scan `.ipynb` notebook files |
+| `use_gitignore` | `True` | Skip paths matched by `.gitignore` |
+
+**`export(root, output, inplace, keep_versions, include_notebooks, use_gitignore)`**
+
+| Parameter | Default | Description |
+|---|---|---|
+| `root` | — | Project root to scan |
+| `output` | `None` | Write to this path instead of the detected dependency file |
+| `inplace` | `False` | Update the existing file in place |
+| `keep_versions` | `True` | Preserve pinned version specifiers already in the file |
+| `include_notebooks` | `False` | Also scan `.ipynb` files |
+| `use_gitignore` | `True` | Skip gitignored paths |
+
+**`check(root, packages, outdated, security, licenses)`**
+
+| Parameter | Default | Description |
+|---|---|---|
+| `root` | `None` | Auto-scan this root for packages (used if `packages` is `None`) |
+| `packages` | `None` | Explicit list of package names to check |
+| `outdated` | `True` | Check for newer versions on PyPI |
+| `security` | `True` | Run vulnerability checks |
+| `licenses` | `True` | Check license compatibility |
+
+Returns a `HealthReport` with `.outdated`, `.vulnerable`, `.licenses`, and `.errors` lists.
+
+**`clean(root, protected, dry_run)`**
+
+| Parameter | Default | Description |
+|---|---|---|
+| `root` | — | Project root (used to determine what is actually imported) |
+| `protected` | `None` | Set of package names to never remove |
+| `dry_run` | `True` | Preview only — pass `False` to actually uninstall |
+
+Returns a `CleanResult` with `.to_remove`, `.removed`, `.skipped`, and `.errors` lists.
+
+**`optimise(root, files, convert_to, use_isort, dry_run)`**
+
+| Parameter | Default | Description |
+|---|---|---|
+| `root` | — | Project root |
+| `files` | `None` | Specific files to process; `None` processes all `.py` files |
+| `convert_to` | `None` | Rewrite import style (e.g. `"absolute"`) |
+| `use_isort` | `True` | Run `isort` on each file |
+| `dry_run` | `False` | Preview changes without writing files |
+
+---
+
+### Profiling (`infrakit.time`)
+
+```bash
+ik time run script.py
+```
+
+```python
+from infrakit.time import pipeline_profiler, track
+
+@pipeline_profiler("My Pipeline")
+def main(): ...
+
+@track(name="Load Step")
+def load_data(): ...
+```

{python_infrakit_dev-0.1.2.dist-info → python_infrakit_dev-0.1.4.dist-info}/RECORD

@@ -38,15 +38,15 @@ infrakit/llm/providers/base.py,sha256=SglgqSIGm_jHsxj7gXvha4CsKb0L9Q8TXBXcUaVXK5
 infrakit/llm/providers/gemini.py,sha256=rVI5seLpmb_R1AqcP9B6Hp9WvyTmWeDdCVttyCH05mI,5552
 infrakit/llm/providers/openai.py,sha256=qAZ1iXRbEilvqOvYXkUh3rS-PhQVp_fQFXiUNk-vers,5469
 infrakit/scaffolder/__init__.py,sha256=VBsYgmzomi4abMF0G7xtto3vecKqKBVgKtguugtmzkQ,1132
-infrakit/scaffolder/ai.py,sha256=rHCISnrTooe1B2rquOagfYkBfOMyqGYwW6SDYq10xxY,15602
-infrakit/scaffolder/backend.py,sha256=cq7Vj8fsbOAsPSyt1S0ApSZkazbR_rwOxszOYeSyzBA,16224
-infrakit/scaffolder/cli_tool.py,sha256=jFjAZj7bbozWWPZluMtxt9VJTr95mQbFPHcwrAYSHSU,12031
-infrakit/scaffolder/generator.py,sha256=9FF3ju8JS_Z4F2CxRKZDIE7DM9GGnnzPcFHBJ02zELM,9829
-infrakit/scaffolder/pipeline.py,sha256=9Mq8biVHj9ywOQWSwK42H4SO-2iq8KlcZGk6UOXhA1Q,17081
+infrakit/scaffolder/ai.py,sha256=otj0YjPApBfLwXTc1EwA-t-ePTefe6bhIKskk4TcZTk,16679
+infrakit/scaffolder/backend.py,sha256=Ty_uEPzT-qMi2c5Kb8HM32dQC9kTRhgJHYycTSvrJ08,18725
+infrakit/scaffolder/cli_tool.py,sha256=QOgqtTqi-OASowIh8ezQWFPMZLMcamz4gt7tK7i9qeg,12056
+infrakit/scaffolder/generator.py,sha256=DrkFFRkePuie5VyGx-dEYs7dUX6S-JIrrbxLCViFots,11558
+infrakit/scaffolder/pipeline.py,sha256=HeBkreiso0fYIHrObkaPKRB3XewU3UgQevrrcWHY_wI,17106
 infrakit/scaffolder/registry.py,sha256=TqZetmDChmXD_oW6kl10A0SbN6ADm4xi7NdK2m9GNGI,3802
 infrakit/time/__init__.py,sha256=R-o_F3XkqaC-QWtfMJ8TCUKnCqLycFl2WQHs20e8ElI,1206
 infrakit/time/profiler.py,sha256=bfM-UCFULr1cA4Y6fgBWdQ7d4tNgdY_YJowohhVH-So,16075
-python_infrakit_dev-0.1.2.dist-info/METADATA,sha256=cddNHaIIySzMjPeMcLrr0p1ErZFnwvfLTsyelufjyaw,4481
-python_infrakit_dev-0.1.2.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-python_infrakit_dev-0.1.2.dist-info/entry_points.txt,sha256=9uBSvx5accKf026gAQijwUkkN_eL37RBWlCO3e_9Iz4,80
-python_infrakit_dev-0.1.2.dist-info/RECORD,,
+python_infrakit_dev-0.1.4.dist-info/METADATA,sha256=RdoayVeTCtHJmwJImyLOXnq3ITFLQb85_DMznw2Srnw,11484
+python_infrakit_dev-0.1.4.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+python_infrakit_dev-0.1.4.dist-info/entry_points.txt,sha256=9uBSvx5accKf026gAQijwUkkN_eL37RBWlCO3e_9Iz4,80
+python_infrakit_dev-0.1.4.dist-info/RECORD,,

python_infrakit_dev-0.1.2.dist-info/METADATA

@@ -1,124 +0,0 @@
-Metadata-Version: 2.4
-Name: python-infrakit-dev
-Version: 0.1.2
-Summary: A comprehensive Python developer infrastructure toolkit
-Project-URL: Homepage, https://github.com/chiragg21/infrakit
-Project-URL: Repository, https://github.com/chiragg21/infrakit
-Requires-Python: >=3.13
-Requires-Dist: google-genai>=1.69.0
-Requires-Dist: isort>=8.0.1
-Requires-Dist: openai>=2.30.0
-Requires-Dist: pydantic>=2.12.5
-Requires-Dist: python-dotenv>=1.2.2
-Requires-Dist: pyyaml>=6.0.3
-Requires-Dist: tqdm>=4.67.3
-Requires-Dist: typer>=0.24.1
-Description-Content-Type: text/markdown
-
-# Infrakit
-
-Infrakit is a comprehensive, modular developer infrastructure toolkit for Python projects. It provides CLI utilities, rich project scaffolding, a robust multi-provider LLM client, dependency management, profiling, and core utilities for logging and configuration.
-
-## Installation
-
-Install via pip:
-
-```bash
-pip install infrakit
-# or if using uv
-uv pip install infrakit
-```
-
-The CLI is exposed as `infrakit` and conveniently aliased as `ik`.
-
-## Key Features
-
-### 1. Project Scaffolding (`ik init`)
-
-Quickly bootstrap new Python projects with standardized layouts, ready-to-use boilerplate, and optional LLM integration. Existing files are safely skipped if you re-run over a directory.
-
-```bash
-ik init my-project -t basic
-ik init my-fastapi-app -t backend -v 0.1.0
-ik init my-ai-tool -t ai --include-llm
-```
-
-**Available Templates**:
-- **`basic`**: Minimal template (src, utils, tests).
-- **`backend`**: FastAPI service (app, routes, middleware, Dockerfile, docker-compose).
-- **`cli_tool`**: Distributable CLI application using Typer.
-- **`pipeline`**: Data pipeline / ETL template (extract, transform, load, enrich).
-- **`ai`**: AI/ML project optimized for notebooks and pipelines.
-
-### 2. Multi-provider LLM Client (`infrakit.llm`)
-
-A unified LLM client interface supporting **OpenAI** and **Gemini**. Built natively for robust production use cases, particularly when navigating free-tier API quotas.
-
-**Features:**
-- Seamless key rotation and persistent storage tracking.
-- Local rate limiting (RPM/TPM gates).
-- Async and multi-threaded batch generation.
-- Structured output parsing and schema validation using `pydantic.BaseModel`.
-
-**Quick Start:**
-```python
-from infrakit.llm import LLMClient, Prompt
-
-client = LLMClient(keys={"openai_keys": ["sk-..."], "gemini_keys": ["AIza..."]}, storage_dir="./logs")
-response = client.generate(Prompt(user="What is the capital of France?"), provider="openai")
-print(response.content)
-```
-
-**LLM CLI tools:**
-Monitor and control limits right from the CLI.
-- `ik llm status --storage-dir ./logs`
-- `ik llm quota set --provider openai --key sk-abc --rpm 60 --storage-dir ./logs`
-
-### 3. Dependency Management (`infrakit.deps`)
-
-In-depth Python dependency tools available under `ik deps` (or programmatically via `infrakit.deps`) to clean, health-check, scan, and optimize dependencies.
-
-**Features:**
-- `scan(root)`: Scan your project for actual Python dependencies used in code.
-- `export()`: Export used dependencies to update `requirements.txt` or `pyproject.toml` automatically.
-- `check(packages)`: Run health, security, and outdated checks on packages.
-- `clean()`: Find and remove unused packages from the virtual environment.
-- `optimise()`: Optimize and format imports across the project (integrates with `isort`).
-
-### 4. Code Profiling (`infrakit.time`)
-
-Lightweight timing and execution profiling for your Python projects.
-
-**CLI Usage:**
-Profile any script instantly to detect performance bottlenecks.
-```bash
-ik time run script.py --max-functions 30 --min-time 1.0
-```
-
-**Decorator Usage:**
-Track specific pipeline steps inside your code:
-```python
-from infrakit.time import pipeline_profiler, track
-
-@pipeline_profiler("Data Processing Pipeline")
-def main():
-    load_data()
-    transform_data()
-
-@track(name="Load Step")
-def load_data(): pass
-```
-
-### 5. Core Utilities (`infrakit.core`)
-
-Convenient implementations for common application needs.
-
-- **Config Loader** (`infrakit.core.config.loader`): Multi-format configuration loader supporting JSON, YAML, INI, and `.env`. Automatically resolves variables using `python-dotenv` and converts types properly natively.
-- **Logger** (`infrakit.core.logger`): Unified logging setups for consistent output across applications.
-```python
-from infrakit.core.logger import setup, get_logger
-
-setup(level="INFO", strategy="date_level", stream="stdout")
-log = get_logger(__name__)
-log.info("Ready")
-```