pixie-prompts 0.1.8.dev6__tar.gz → 0.1.9__tar.gz

{pixie_prompts-0.1.8.dev6 → pixie_prompts-0.1.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pixie-prompts
-Version: 0.1.8.dev6
+Version: 0.1.9
 Summary: Code-first, type-safe prompt management
 License: MIT
 License-File: LICENSE

{pixie_prompts-0.1.8.dev6 → pixie_prompts-0.1.9}/pixie/prompts/file_watcher.py

@@ -18,6 +18,85 @@ _storage_observer: Observer | None = None  # type: ignore
 _storage_reload_task: asyncio.Task | None = None
 
 
+def _preload_pixie_modules(cwd: Path) -> None:
+    """Pre-load pixie modules from the local source directory.
+
+    This ensures that when dynamically loaded modules import pixie.registry,
+    they get the same module instance as the rest of the application.
+
+    Without this, namespace package collisions can occur when pixie-prompts
+    is installed as a package while pixie-sdk-py is run from source. The
+    dynamic module loading via importlib.util.spec_from_file_location() can
+    create separate module instances, leading to separate _registry dicts.
+
+    Args:
+        cwd: The current working directory to search for pixie modules.
+    """
+    pixie_dir = cwd / "pixie"
+    if not pixie_dir.is_dir():
+        return
+
+    # Find all pixie submodules that exist locally and pre-import them
+    # This ensures they're in sys.modules before any dynamic loading
+    pixie_modules_to_preload = []
+
+    for py_file in pixie_dir.rglob("*.py"):
+        if py_file.name.startswith("_"):
+            continue
+        # Skip if in __pycache__ or similar
+        if "__pycache__" in py_file.parts:
+            continue
+
+        relative_path = py_file.relative_to(cwd)
+        module_name = str(relative_path.with_suffix("")).replace("/", ".")
+        pixie_modules_to_preload.append((module_name, py_file))
+
+    # Sort to ensure parent modules are loaded before children
+    pixie_modules_to_preload.sort(key=lambda x: x[0])
+
+    for module_name, py_file in pixie_modules_to_preload:
+        if module_name in sys.modules:
+            continue
+
+        # Ensure parent packages are in sys.modules
+        parts = module_name.split(".")
+        for i in range(1, len(parts)):
+            parent_name = ".".join(parts[:i])
+            if parent_name not in sys.modules:
+                parent_path = cwd / Path(*parts[:i])
+                init_file = parent_path / "__init__.py"
+                if init_file.exists():
+                    spec = importlib.util.spec_from_file_location(
+                        parent_name, init_file
+                    )
+                    if spec and spec.loader:
+                        module = importlib.util.module_from_spec(spec)
+                        sys.modules[parent_name] = module
+                        try:
+                            spec.loader.exec_module(module)
+                        except Exception:
+                            pass
+                else:
+                    # Create a namespace package
+                    import types
+
+                    ns_module = types.ModuleType(parent_name)
+                    ns_module.__path__ = [str(parent_path)]
+                    sys.modules[parent_name] = ns_module
+
+        # Now load the actual module
+        spec = importlib.util.spec_from_file_location(module_name, py_file)
+        if spec and spec.loader:
+            try:
+                module = importlib.util.module_from_spec(spec)
+                sys.modules[module_name] = module
+                spec.loader.exec_module(module)
+            except Exception:
+                # Don't fail if a module can't be loaded - it might have
+                # dependencies that aren't available yet
+                pass
+
+
 def discover_and_load_modules():
     """Discover and load all Python files that use pixie.prompts.create_prompt, or pixie.create_prompt.
 
@@ -34,6 +113,10 @@ def discover_and_load_modules():
     if str(cwd) not in sys.path:
         sys.path.insert(0, str(cwd))
 
+    # Pre-load pixie modules from local source to avoid namespace package collisions
+    # This ensures dynamically loaded modules use the same pixie.registry instance
+    _preload_pixie_modules(cwd)
+
     loaded_count = 0
     for py_file in python_files:
         # Skip __init__.py, private files, and anything in site-packages/venv
@@ -58,6 +141,12 @@ def discover_and_load_modules():
         # Load the module with a unique name based on path
         relative_path = py_file.relative_to(cwd)
         module_name = str(relative_path.with_suffix("")).replace("/", ".")
+
+        # Skip if module was already loaded (e.g., during preload)
+        if module_name in sys.modules:
+            loaded_count += 1
+            continue
+
         spec = importlib.util.spec_from_file_location(module_name, py_file)
         if spec and spec.loader:
             try:
@@ -309,10 +398,14 @@ async def stop_storage_watcher() -> None:
 
 
 def init_prompt_storage():
+    """Initialize prompt storage and return lifespan context manager.
 
+    Storage directory is read from PIXIE_PROMPT_STORAGE_DIR environment variable,
+    defaulting to '.pixie/prompts'.
+    """
     storage_directory = os.getenv("PIXIE_PROMPT_STORAGE_DIR", ".pixie/prompts")
     try:
-        initialize_prompt_storage(storage_directory)
+        initialize_prompt_storage()
     except PromptLoadError as e:
         for err in e.failures:
             logger.error("Prompt load error: %s", err)
@@ -320,7 +413,6 @@ def init_prompt_storage():
     @asynccontextmanager
     async def lifespan(app: FastAPI):
         try:
-            nonlocal storage_directory
             storage_path = Path(storage_directory)
             watch_interval = float(os.getenv("PIXIE_PROMPT_WATCH_INTERVAL", "1.0"))
             await start_storage_watcher(storage_path, watch_interval)

{pixie_prompts-0.1.8.dev6 → pixie_prompts-0.1.9}/pixie/prompts/graphql.py

@@ -111,6 +111,8 @@ class Query:
         Returns:
             A list of model names supported by the server.
         """
+        if is_demo_mode():
+            return ["openai:gpt-4o-mini"]
         return list(get_args(KnownModelName.__value__))
 
     @strawberry.field

{pixie_prompts-0.1.8.dev6 → pixie_prompts-0.1.9}/pixie/prompts/prompt.py

@@ -2,7 +2,7 @@ from copy import deepcopy
 from dataclasses import dataclass
 import json
 from types import NoneType
-from typing import Any, Generic, Protocol, Self, TypeVar, cast, overload
+from typing import Any, Callable, Generic, Protocol, Self, TypeVar, cast, overload
 from uuid import uuid4
 
 import jinja2
@@ -32,14 +32,14 @@ def get_prompt_by_id(prompt_id: str) -> "BasePrompt":
 
 
 @dataclass(frozen=True)
-class _CompiledPrompt:
+class CompiledPrompt:
     value: str
     prompt: "BasePrompt | OutdatedPrompt"
     version_id: str
     variables: Variables | None
 
 
-_compiled_prompt_registry: dict[int, _CompiledPrompt] = {}
+_compiled_prompt_registry: dict[int, CompiledPrompt] = {}
 """Registry of all compiled prompts.
 
 This is to keep track of every result string returned by BasePrompt.compile().
@@ -68,7 +68,7 @@ def _find_matching_prompt(obj):
         return None
 
 
-def get_compiled_prompt(text: str) -> _CompiledPrompt | None:
+def get_compiled_prompt(text: str) -> CompiledPrompt | None:
     """Find the compiled prompt metadata for a given compiled prompt string."""
     if not _compiled_prompt_registry:
         return None
@@ -86,13 +86,31 @@ def get_compiled_prompt(text: str) -> _CompiledPrompt | None:
         return None
 
 
+_PromptCompilationListener = Callable[[CompiledPrompt], None]
+_prompt_compilation_listeners: list[_PromptCompilationListener] = []
+
+
+def add_prompt_compilation_listener(listener: _PromptCompilationListener) -> None:
+    """Register a listener that will be called whenever a prompt is compiled.
+
+    The listener will be called with the prompt and the compiled prompt metadata.
+    """
+    _prompt_compilation_listeners.append(listener)
+
+
+def remove_prompt_compilation_listener(listener: _PromptCompilationListener) -> None:
+    """Unregister a previously registered prompt compilation listener."""
+    if listener in _prompt_compilation_listeners:
+        _prompt_compilation_listeners.remove(listener)
+
+
 def _mark_compiled_prompts_outdated(
     prompt_id: str, outdated_prompt: "OutdatedPrompt"
 ) -> None:
     for key in list(_compiled_prompt_registry.keys()):
         compiled_prompt = _compiled_prompt_registry[key]
         if compiled_prompt.prompt.id == prompt_id:
-            _compiled_prompt_registry[key] = _CompiledPrompt(
+            _compiled_prompt_registry[key] = CompiledPrompt(
                 value=compiled_prompt.value,
                 version_id=compiled_prompt.version_id,
                 variables=compiled_prompt.variables,
@@ -257,12 +275,18 @@ class BasePrompt(BaseUntypedPrompt, Generic[TPromptVar]):
             ret = template.render(**variables.model_dump(mode="json"))
         else:
             ret = template_txt
-        _compiled_prompt_registry[id(ret)] = _CompiledPrompt(
+        compiled = CompiledPrompt(
             value=ret,
             version_id=version_id,
             prompt=self,
             variables=variables,
         )
+        _compiled_prompt_registry[id(compiled)] = compiled
+        for listener in _prompt_compilation_listeners:
+            try:
+                listener(compiled)
+            except Exception:
+                pass
         return ret
 
     def _update(
@@ -355,7 +379,7 @@ class OutdatedPrompt(BasePrompt[TPromptVar]):
         *,
         versions: str | dict[str, str] | None = None,
         default_version_id: str | None = None,
-    ) -> "OutdatedPrompt[TPromptVar]":
+    ) -> "tuple[Self, OutdatedPrompt[TPromptVar]]":
         raise ValueError("Cannot update an outdated prompt.")
 
     def get_default_version_id(self) -> str:
@@ -366,8 +390,8 @@ class OutdatedPrompt(BasePrompt[TPromptVar]):
 
     def compile(
         self,
-        _variables: TPromptVar | None = None,
+        variables: TPromptVar | None = None,
         *,
-        _version_id: str | None = None,
+        version_id: str | None = None,
     ) -> str:
         raise ValueError("This prompt is outdated and can no longer be used.")

{pixie_prompts-0.1.8.dev6 → pixie_prompts-0.1.9}/pixie/prompts/storage.py

@@ -260,16 +260,39 @@ class _FilePromptStorage(PromptStorage):
 _storage_instance: PromptStorage | None = None
 
 
+def _ensure_storage_initialized() -> PromptStorage:
+    """Ensure storage is initialized, initializing it if necessary.
+
+    Returns:
+        The initialized storage instance.
+    """
+    global _storage_instance
+    if _storage_instance is None:
+        storage_directory = os.getenv("PIXIE_PROMPT_STORAGE_DIR", ".pixie/prompts")
+        _storage_instance = _FilePromptStorage(storage_directory, raise_on_error=False)
+        logger.info(
+            "Auto-initialized prompt storage at directory: %s", storage_directory
+        )
+        if _storage_instance.load_failures:
+            raise PromptLoadError(_storage_instance.load_failures)
+    return _storage_instance
+
+
 # TODO allow other storage types later
-def initialize_prompt_storage(directory: str) -> None:
+def initialize_prompt_storage() -> None:
+    """Initialize prompt storage.
+
+    The storage directory is read from the PIXIE_PROMPT_STORAGE_DIR environment
+    variable, defaulting to '.pixie/prompts'.
+
+    Raises:
+        RuntimeError: If storage has already been initialized.
+        PromptLoadError: If there are failures loading prompts.
+    """
     global _storage_instance
     if _storage_instance is not None:
         raise RuntimeError("Prompt storage has already been initialized.")
-    storage = _FilePromptStorage(directory, raise_on_error=False)
-    _storage_instance = storage
-    logger.info("Initialized prompt storage at directory: %s", directory)
-    if storage.load_failures:
-        raise PromptLoadError(storage.load_failures)
+    _ensure_storage_initialized()
 
 
 class StorageBackedPrompt(Prompt[TPromptVar]):
@@ -296,10 +319,9 @@ class StorageBackedPrompt(Prompt[TPromptVar]):
         return variables_definition_to_schema(self._variables_definition)
 
     def _get_prompt(self) -> BasePrompt[TPromptVar]:
-        if _storage_instance is None:
-            raise RuntimeError("Prompt storage has not been initialized.")
+        storage = _ensure_storage_initialized()
         if self._prompt is None:
-            untyped_prompt = _storage_instance.get(self.id)
+            untyped_prompt = storage.get(self.id)
             self._prompt = BasePrompt.from_untyped(
                 untyped_prompt,
                 variables_definition=self.variables_definition,
@@ -317,8 +339,7 @@ class StorageBackedPrompt(Prompt[TPromptVar]):
         return self
 
     def exists_in_storage(self) -> bool:
-        if _storage_instance is None:
-            raise RuntimeError("Prompt storage has not been initialized.")
+        _ensure_storage_initialized()
         try:
             self.actualize()
             return True
@@ -330,9 +351,8 @@ class StorageBackedPrompt(Prompt[TPromptVar]):
         return prompt.get_versions()
 
     def get_version_creation_time(self, version_id: str) -> float:
-        if _storage_instance is None:
-            raise RuntimeError("Prompt storage has not been initialized.")
-        prompt_with_ctime = _storage_instance.get(self.id)
+        storage = _ensure_storage_initialized()
+        prompt_with_ctime = storage.get(self.id)
         if not prompt_with_ctime:
             raise KeyError(f"Prompt with id '{self.id}' not found in storage.")
         return prompt_with_ctime.get_version_creation_time(version_id)
@@ -364,8 +384,7 @@ class StorageBackedPrompt(Prompt[TPromptVar]):
         content: str,
         set_as_default: bool = False,
     ) -> BasePrompt[TPromptVar]:
-        if _storage_instance is None:
-            raise RuntimeError("Prompt storage has not been initialized.")
+        storage = _ensure_storage_initialized()
         if self.exists_in_storage():
             prompt = self._get_prompt()
             prompt.append_version(
@@ -373,7 +392,7 @@ class StorageBackedPrompt(Prompt[TPromptVar]):
                 content=content,
                 set_as_default=set_as_default,
             )
-            _storage_instance.save(prompt)
+            storage.save(prompt)
             return prompt
         else:
             # it should be safe to assume there's no actualized prompt for this id
@@ -384,16 +403,15 @@ class StorageBackedPrompt(Prompt[TPromptVar]):
                 variables_definition=self.variables_definition,
                 default_version_id=version_id,
             )
-            _storage_instance.save(new_prompt)
+            storage.save(new_prompt)
             return new_prompt
 
     def update_default_version_id(
         self,
         version_id: str,
     ) -> BasePrompt[TPromptVar]:
-        if _storage_instance is None:
-            raise RuntimeError("Prompt storage has not been initialized.")
+        storage = _ensure_storage_initialized()
         prompt = self._get_prompt()
         prompt.update_default_version_id(version_id)
-        _storage_instance.save(prompt)
+        storage.save(prompt)
         return prompt

{pixie_prompts-0.1.8.dev6 → pixie_prompts-0.1.9}/pyproject.toml

@@ -4,7 +4,7 @@ packages = [
     { include = "pixie" },
 ]
 
-version = "0.1.8.dev6"
+version = "0.1.9"
 description = "Code-first, type-safe prompt management"
 authors = ["Yiou Li <yol@gopixie.ai>"]
 license = "MIT"