wishful 0.2.1__py3-none-any.whl

wishful/__init__.py

@@ -0,0 +1,99 @@
+"""wishful - Just-in-Time code generation via import hooks."""
+
+from __future__ import annotations
+
+import importlib
+import sys
+from typing import List
+
+from wishful.cache import manager as cache
+from wishful.config import configure, reset_defaults, settings
+from wishful.core.discovery import set_context_radius as _set_context_radius
+from wishful.core.finder import install as install_finder
+from wishful.llm.client import GenerationError
+from wishful.safety.validator import SecurityError
+from wishful.types import type as type_decorator
+
+# Install on import so `import magic.xyz` is intercepted immediately.
+install_finder()
+
+__all__ = [
+    "configure",
+    "clear_cache",
+    "inspect_cache",
+    "regenerate",
+    "reimport",
+    "set_context_radius",
+    "settings",
+    "reset_defaults",
+    "SecurityError",
+    "GenerationError",
+    "type",
+]
+
+# Alias for cleaner API
+type = type_decorator
+
+
+def clear_cache() -> None:
+    """Delete all generated files from the cache directory."""
+
+    cache.clear_cache()
+    # Remove generated namespaces so they regenerate on next import.
+    for name in list(sys.modules):
+        if name.startswith("wishful.static") or name.startswith("wishful.dynamic"):
+            sys.modules.pop(name, None)
+    # Keep root wishful module to retain settings/logging; re-importer can handle children.
+
+
+def inspect_cache() -> List[str]:
+    """Return a list of cached module file paths as strings."""
+
+    return [str(p) for p in cache.inspect_cache()]
+
+
+def regenerate(module_name: str) -> None:
+    """Force regeneration of a module on next import.
+    
+    Accepts module names with or without the wishful.static prefix.
+    Example: regenerate('users') or regenerate('wishful.static.users')
+    """
+    # Ensure it has the wishful prefix
+    if not module_name.startswith("wishful"):
+        # Default to static namespace for backward compatibility
+        module_name = f"wishful.static.{module_name}"
+    
+    cache.delete_cached(module_name)
+    sys.modules.pop(module_name, None)
+    importlib.invalidate_caches()
+
+
+def set_context_radius(radius: int) -> None:
+    """Adjust how many surrounding lines are sent as context to the LLM."""
+    _set_context_radius(radius)
+
+
+def reimport(module_path: str):
+    """Force a fresh import by clearing the module from cache.
+    
+    This is especially useful for wishful.dynamic.* imports in loops,
+    where you want the LLM to regenerate with fresh context on each iteration.
+    
+    Args:
+        module_path: The full module path (e.g., 'wishful.dynamic.story')
+    
+    Returns:
+        The freshly imported module
+    
+    Example:
+        >>> story = wishful.reimport('wishful.dynamic.story')
+        >>> next_line = story.cosmic_horror_next_sentence(current_text)
+    """
+    # Clear from Python's module cache
+    sys.modules.pop(module_path, None)
+    
+    # Import fresh (this triggers wishful's import hook if it's a wishful.* module)
+    return importlib.import_module(module_path)
+
+
+__version__ = "0.1.0"

wishful/__main__.py

@@ -0,0 +1,72 @@
+"""Command-line interface for wishful."""
+
+import sys
+
+import wishful
+
+
+def _print_usage() -> None:
+    print("wishful - Just-in-time Python module generation")
+    print("\nUsage:")
+    print("  python -m wishful inspect         Show cached modules")
+    print("  python -m wishful clear           Clear all cache")
+    print("  python -m wishful regen <module>  Regenerate a module")
+    print("\nExamples:")
+    print("  python -m wishful inspect")
+    print("  python -m wishful regen wishful.text")
+    print("  python -m wishful clear")
+
+
+def _cmd_inspect() -> None:
+    cached = wishful.inspect_cache()
+    if not cached:
+        print("No cached modules found in", wishful.settings.cache_dir)
+        return
+    print(f"Cached modules in {wishful.settings.cache_dir}:")
+    for path in cached:
+        print(f"  {path}")
+
+
+def _cmd_clear() -> None:
+    wishful.clear_cache()
+    print(f"Cleared all cached modules from {wishful.settings.cache_dir}")
+
+
+def _cmd_regen(args: list[str]) -> None:
+    if not args:
+        raise ValueError("'regen' requires a module name")
+    module_name = args[0]
+    wishful.regenerate(module_name)
+    print(f"Regenerated {module_name} (will be re-created on next import)")
+
+
+def main() -> None:
+    """Main CLI entry point."""
+    args = sys.argv[1:]
+    if not args:
+        _print_usage()
+        sys.exit(0)
+
+    command, *rest = args
+    handlers = {
+        "inspect": _cmd_inspect,
+        "clear": _cmd_clear,
+        "regen": lambda: _cmd_regen(rest),
+    }
+
+    handler = handlers.get(command)
+    if handler is None:
+        print(f"Unknown command: {command}")
+        print("Use 'python -m wishful' for help")
+        sys.exit(1)
+
+    try:
+        handler()
+    except ValueError as exc:
+        print(f"Error: {exc}")
+        print("Usage: python -m wishful regen <module>")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

wishful/cache/__init__.py

@@ -0,0 +1,23 @@
+"""Cache utilities for wishful."""
+
+from .manager import (
+    clear_cache,
+    delete_cached,
+    ensure_cache_dir,
+    has_cached,
+    inspect_cache,
+    module_path,
+    read_cached,
+    write_cached,
+)
+
+__all__ = [
+    "read_cached",
+    "write_cached",
+    "clear_cache",
+    "inspect_cache",
+    "module_path",
+    "ensure_cache_dir",
+    "delete_cached",
+    "has_cached",
+]

wishful/cache/manager.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+import shutil
+from pathlib import Path
+from typing import List, Optional
+
+from wishful.config import settings
+
+
+def module_path(fullname: str) -> Path:
+    # Strip leading namespace "wishful" (and static/dynamic) and map dots to directories.
+    parts = fullname.split(".")
+    if parts[0] == "wishful":
+        parts = parts[1:]
+    # Also strip 'static' or 'dynamic' if present
+    if parts and parts[0] in ("static", "dynamic"):
+        parts = parts[1:]
+    relative = Path(*parts) if parts else Path("__init__")
+    return settings.cache_dir / relative.with_suffix(".py")
+
+
+def dynamic_snapshot_path(fullname: str) -> Path:
+    """Path for storing dynamic-generation snapshots without affecting cache."""
+    parts = fullname.split(".")
+    if parts[0] == "wishful":
+        parts = parts[1:]
+    if parts and parts[0] in ("static", "dynamic"):
+        parts = parts[1:]
+    relative = Path(*parts) if parts else Path("__init__")
+    return settings.cache_dir / "_dynamic" / relative.with_suffix(".py")
+
+
+def ensure_cache_dir() -> Path:
+    settings.cache_dir.mkdir(parents=True, exist_ok=True)
+    return settings.cache_dir
+
+
+def read_cached(fullname: str) -> Optional[str]:
+    path = module_path(fullname)
+    if path.exists():
+        return path.read_text()
+    return None
+
+
+def write_cached(fullname: str, source: str) -> Path:
+    path = module_path(fullname)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(source)
+    return path
+
+
+def write_dynamic_snapshot(fullname: str, source: str) -> Path:
+    path = dynamic_snapshot_path(fullname)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(source)
+    return path
+
+
+def delete_cached(fullname: str) -> None:
+    path = module_path(fullname)
+    if path.exists():
+        path.unlink()
+
+
+def clear_cache() -> None:
+    if settings.cache_dir.exists():
+        shutil.rmtree(settings.cache_dir)
+
+
+def inspect_cache() -> List[Path]:
+    if not settings.cache_dir.exists():
+        return []
+    return sorted(settings.cache_dir.rglob("*.py"))
+
+
+def has_cached(fullname: str) -> bool:
+    return module_path(fullname).exists()

wishful/config.py

@@ -0,0 +1,175 @@
+from __future__ import annotations
+
+import os
+import builtins
+from dataclasses import dataclass, field
+from pathlib import Path
+from textwrap import dedent
+from typing import Optional
+
+from dotenv import load_dotenv
+
+# Load environment variables from a local .env if present so users don't need to
+# export them manually when running examples.
+load_dotenv()
+
+
+_DEFAULT_MODEL = os.getenv("DEFAULT_MODEL", os.getenv("WISHFUL_MODEL", "azure/gpt-4.1"))
+_DEFAULT_SYSTEM_PROMPT = os.getenv(
+    "WISHFUL_SYSTEM_PROMPT",
+    dedent(
+        """
+        You are a Python code generator. Output ONLY executable Python code.
+        - Do not wrap code in markdown fences.
+        - You may use any Python libraries available in the environment.
+        - Prefer simple, readable implementations.
+        - Avoid network calls, filesystem writes, subprocess, or shell execution.
+        - Include docstrings and type hints where helpful.
+        """
+    ).strip(),
+)
+_DEFAULT_LOG_LEVEL = os.getenv("WISHFUL_LOG_LEVEL", "WARNING").upper()
+_DEFAULT_LOG_TO_FILE = os.getenv("WISHFUL_LOG_TO_FILE", "1") != "0"
+
+
+@dataclass
+class Settings:
+    """Runtime configuration for wishful.
+
+    Values are mutable at runtime via :func:`configure` to make tests and user
+    code ergonomics-friendly. Defaults are sourced from environment variables.
+    """
+
+    model: str = _DEFAULT_MODEL
+    cache_dir: Path = field(default_factory=lambda: Path(os.getenv("WISHFUL_CACHE_DIR", ".wishful")))
+    review: bool = os.getenv("WISHFUL_REVIEW", "0") == "1"
+    debug: bool = os.getenv("WISHFUL_DEBUG", "0") == "1"
+    allow_unsafe: bool = os.getenv("WISHFUL_UNSAFE", "0") == "1"
+    spinner: bool = os.getenv("WISHFUL_SPINNER", "1") != "0"
+    max_tokens: int = int(os.getenv("WISHFUL_MAX_TOKENS", "4096"))
+    temperature: float = float(os.getenv("WISHFUL_TEMPERATURE", "1"))
+    system_prompt: str = _DEFAULT_SYSTEM_PROMPT
+    log_level: str = _DEFAULT_LOG_LEVEL
+    log_to_file: bool = _DEFAULT_LOG_TO_FILE
+
+    def copy(self) -> "Settings":
+        return Settings(
+            model=self.model,
+            cache_dir=self.cache_dir,
+            review=self.review,
+            debug=self.debug,
+            allow_unsafe=self.allow_unsafe,
+            spinner=self.spinner,
+            max_tokens=self.max_tokens,
+            temperature=self.temperature,
+            system_prompt=self.system_prompt,
+            log_level=self.log_level,
+            log_to_file=self.log_to_file,
+        )
+
+
+# Persist the settings object across module reloads (tests deliberately purge
+# wishful.* modules). Stash it on `builtins` so all imports share the same
+# instance even after sys.modules churn.
+if getattr(builtins, "_wishful_settings", None) is None:
+    builtins._wishful_settings = Settings()
+settings = builtins._wishful_settings  # type: ignore[attr-defined]
+
+
+# Internal helper to load logging module robustly (handles altered sys.modules)
+def _load_logging_module():
+    try:
+        from wishful import logging as logging_mod  # type: ignore
+        return logging_mod
+    except Exception:
+        pass
+    try:
+        import importlib.util
+        import sys
+        path = Path(__file__).parent / "logging.py"
+        spec = importlib.util.spec_from_file_location("wishful.logging", path)
+        if spec and spec.loader:
+            logging_mod = importlib.util.module_from_spec(spec)
+            sys.modules["wishful.logging"] = logging_mod
+            spec.loader.exec_module(logging_mod)  # type: ignore[arg-type]
+            return logging_mod
+    except Exception:
+        return None
+    return None
+
+
+def configure(
+    *,
+    model: Optional[str] = None,
+    cache_dir: Optional[str | Path] = None,
+    review: Optional[bool] = None,
+    debug: Optional[bool] = None,
+    allow_unsafe: Optional[bool] = None,
+    spinner: Optional[bool] = None,
+    temperature: Optional[float] = None,
+    max_tokens: Optional[int] = None,
+    system_prompt: Optional[str] = None,
+    log_level: Optional[str] = None,
+    log_to_file: Optional[bool] = None,
+) -> None:
+    """Update global settings in-place.
+
+    All parameters are optional; only provided values overwrite current
+    settings. Accepts both strings and :class:`pathlib.Path` for `cache_dir`.
+    """
+
+    updates = {
+        "model": model,
+        "cache_dir": Path(cache_dir) if cache_dir is not None else None,
+        "review": review,
+        "debug": debug,
+        "allow_unsafe": allow_unsafe,
+        "spinner": spinner,
+        "temperature": temperature,
+        "max_tokens": max_tokens,
+        "system_prompt": system_prompt,
+        "log_level": log_level.upper() if isinstance(log_level, str) else log_level,
+        "log_to_file": log_to_file,
+    }
+
+    # If debug explicitly enabled, default to DEBUG level and file logging unless
+    # caller provided overrides.
+    if debug is True:
+        if updates["log_level"] is None:
+            updates["log_level"] = "DEBUG"
+        if updates["log_to_file"] is None:
+            updates["log_to_file"] = True
+        # Spinners and heavy debug output don't mix nicely
+        if updates["spinner"] is None:
+            updates["spinner"] = False
+
+    for attr, value in updates.items():
+        if value is not None:
+            setattr(settings, attr, value)
+
+    # Reconfigure logging after updates (lazy import to avoid cycles during init)
+    logging_mod = _load_logging_module()
+    if logging_mod:
+        logging_mod.configure_logging(force=True)
+
+
+def reset_defaults() -> None:
+    """Reset settings to environment-driven defaults (useful for tests)."""
+    # Create new defaults and copy to existing settings object
+    # This ensures all existing references to settings get updated
+    defaults = Settings()
+    settings.model = defaults.model
+    settings.cache_dir = defaults.cache_dir
+    settings.review = defaults.review
+    settings.debug = defaults.debug
+    settings.allow_unsafe = defaults.allow_unsafe
+    settings.spinner = defaults.spinner
+    settings.max_tokens = defaults.max_tokens
+    settings.temperature = defaults.temperature
+    settings.system_prompt = defaults.system_prompt
+    settings.log_level = defaults.log_level
+    settings.log_to_file = defaults.log_to_file
+
+    logging_mod = _load_logging_module()
+    if logging_mod:
+        logging_mod.configure_logging(force=True)

wishful/core/__init__.py

@@ -0,0 +1,6 @@
+"""Core import machinery for wishful."""
+
+from .finder import MagicFinder, install
+from .loader import MagicLoader
+
+__all__ = ["MagicFinder", "MagicLoader", "install"]