vibetuner 2.7.0__tar.gz → 2.8.0__tar.gz

{vibetuner-2.7.0 → vibetuner-2.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: vibetuner
-Version: 2.7.0
+Version: 2.8.0
 Summary: Blessed Python dependencies for Vibetuner projects
 Requires-Dist: aioboto3>=15.5.0
 Requires-Dist: arel>=0.4.0
@@ -44,5 +44,5 @@ Requires-Dist: types-aioboto3[s3,ses]>=15.5.0 ; extra == 'dev'
 Requires-Dist: types-authlib>=1.6.5.20251005 ; extra == 'dev'
 Requires-Dist: types-pyyaml>=6.0.12.20250915 ; extra == 'dev'
 Requires-Dist: uv-bump>=0.3.1 ; extra == 'dev'
-Requires-Python: >=3.10
+Requires-Python: >=3.11
 Provides-Extra: dev

{vibetuner-2.7.0 → vibetuner-2.8.0}/pyproject.toml

@@ -1,8 +1,8 @@
 [project]
 name = "vibetuner"
 description = "Blessed Python dependencies for Vibetuner projects"
-version = "2.7.0"
-requires-python = ">=3.10"
+version = "2.8.0"
+requires-python = ">=3.11"
 dependencies = [
     # These are the base dependencies of AllTuner's blessed stack
     "aioboto3>=15.5.0",

{vibetuner-2.7.0 → vibetuner-2.8.0}/src/vibetuner/config.py

@@ -17,14 +17,19 @@ from pydantic import (
 from pydantic_extra_types.language_code import LanguageAlpha2
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
-from vibetuner.paths import config_vars as config_vars_path
-from vibetuner.versioning import version
+from .paths import config_vars as config_vars_path
+from .versioning import version
 
 
 current_year: int = datetime.now().year
 
 
 def _load_project_config() -> "ProjectConfiguration":
+    if config_vars_path is None:
+        raise RuntimeError(
+            "Project root not detected. Cannot load project configuration. "
+            "Ensure you're running from within a project directory with .copier-answers.yml"
+        )
     if not config_vars_path.exists():
         return ProjectConfiguration()
     return ProjectConfiguration(

{vibetuner-2.7.0 → vibetuner-2.8.0}/src/vibetuner/frontend/__init__.py

@@ -21,8 +21,8 @@ def register_router(router: APIRouter) -> None:
 
 
 try:
-    import app.frontend.oauth as _app_oauth  # noqa: F401
-    import app.frontend.routes as _app_routes  # noqa: F401
+    import app.frontend.oauth as _app_oauth  # noqa: F401  # type: ignore[unresolved-import]
+    import app.frontend.routes as _app_routes  # noqa: F401  # type: ignore[unresolved-import]
 except (ImportError, ModuleNotFoundError):
     pass
 

{vibetuner-2.7.0 → vibetuner-2.8.0}/src/vibetuner/frontend/middleware.py

@@ -66,7 +66,7 @@ def user_preference_selector(conn: HTTPConnection) -> str | None:
 
 
 shared_translator = get_translator()
-if locales_path.exists() and locales_path.is_dir():
+if locales_path is not None and locales_path.exists() and locales_path.is_dir():
     # Load translations from the locales directory
     shared_translator.load_from_directories([locales_path])
 

{vibetuner-2.7.0 → vibetuner-2.8.0}/src/vibetuner/frontend/routes/health.py

@@ -22,6 +22,10 @@ def health_ping():
 @router.get("/id")
 def health_instance_id():
     """Instance identification endpoint for distinguishing app instances"""
+    if root_path is None:
+        raise RuntimeError(
+            "Project root not detected. Cannot provide instance information."
+        )
     return {
         "app": settings.project.project_slug,
         "port": int(os.environ.get("PORT", 8000)),

{vibetuner-2.7.0 → vibetuner-2.8.0}/src/vibetuner/mongo.py

@@ -1,8 +1,8 @@
 from beanie import init_beanie
 from pymongo import AsyncMongoClient
 
-from vibetuner.config import settings
-from vibetuner.models.registry import get_all_models
+from .config import settings
+from .models.registry import get_all_models
 
 
 async def init_models() -> None:

vibetuner-2.8.0/src/vibetuner/paths.py

@@ -0,0 +1,229 @@
+from importlib.resources import files
+from pathlib import Path
+from typing import Self
+
+from pydantic import computed_field, model_validator
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+# Package-relative paths (for bundled templates in the vibetuner package)
+_package_files = files("vibetuner")
+_package_templates_traversable = _package_files / "templates"
+
+
+def _get_package_templates_path() -> Path:
+    """Get package templates path, works for both installed and editable installs."""
+    try:
+        return Path(str(_package_templates_traversable))
+    except (TypeError, ValueError):
+        raise RuntimeError(
+            "Package templates are in a non-filesystem location. "
+            "This is not yet supported."
+        ) from None
+
+
+# Package templates always available
+package_templates = _get_package_templates_path()
+core_templates = package_templates  # Alias for backwards compatibility
+
+
+class PathSettings(BaseSettings):
+    """Path settings with lazy auto-detection of project root."""
+
+    model_config = SettingsConfigDict(
+        case_sensitive=False,
+        extra="ignore",
+        validate_default=True,
+    )
+
+    root: Path | None = None
+    fallback_path: str = "defaults"
+
+    @model_validator(mode="after")
+    def detect_project_root(self) -> Self:
+        """Auto-detect project root if not explicitly set."""
+        if self.root is None:
+            detected = self._find_project_root()
+            if detected is not None:
+                self.root = detected
+        return self
+
+    @staticmethod
+    def _find_project_root() -> Path | None:
+        """Find project root by searching for marker files."""
+        markers = [".copier-answers.yml", "pyproject.toml", ".git"]
+        current = Path.cwd()
+
+        for parent in [current, *current.parents]:
+            if any((parent / marker).exists() for marker in markers):
+                return parent
+
+        return None
+
+    # Project-specific paths (only available if root is set)
+    @computed_field
+    @property
+    def templates(self) -> Path | None:
+        """Project templates directory."""
+        return self.root / "templates" if self.root else None
+
+    @computed_field
+    @property
+    def app_templates(self) -> Path | None:
+        """Deprecated: use templates instead."""
+        return self.templates
+
+    @computed_field
+    @property
+    def locales(self) -> Path | None:
+        """Project locales directory."""
+        return self.root / "locales" if self.root else None
+
+    @computed_field
+    @property
+    def config_vars(self) -> Path | None:
+        """Copier answers file."""
+        return self.root / ".copier-answers.yml" if self.root else None
+
+    @computed_field
+    @property
+    def assets(self) -> Path | None:
+        """Project assets directory."""
+        return self.root / "assets" if self.root else None
+
+    @computed_field
+    @property
+    def statics(self) -> Path | None:
+        """Project static assets directory."""
+        return self.root / "assets" / "statics" if self.root else None
+
+    @computed_field
+    @property
+    def css(self) -> Path | None:
+        """Project CSS directory."""
+        return self.root / "assets" / "statics" / "css" if self.root else None
+
+    @computed_field
+    @property
+    def js(self) -> Path | None:
+        """Project JavaScript directory."""
+        return self.root / "assets" / "statics" / "js" if self.root else None
+
+    @computed_field
+    @property
+    def favicons(self) -> Path | None:
+        """Project favicons directory."""
+        return self.root / "assets" / "statics" / "favicons" if self.root else None
+
+    @computed_field
+    @property
+    def img(self) -> Path | None:
+        """Project images directory."""
+        return self.root / "assets" / "statics" / "img" if self.root else None
+
+    # Template paths (always return a list, project + package)
+    @computed_field
+    @property
+    def frontend_templates(self) -> list[Path]:
+        """Frontend template search paths (project overrides, then package)."""
+        paths = []
+        if self.root:
+            project_path = self.root / "templates" / "frontend"
+            if project_path.exists():
+                paths.append(project_path)
+        paths.append(package_templates / "frontend")
+        return paths
+
+    @computed_field
+    @property
+    def email_templates(self) -> list[Path]:
+        """Email template search paths (project overrides, then package)."""
+        paths = []
+        if self.root:
+            project_path = self.root / "templates" / "email"
+            if project_path.exists():
+                paths.append(project_path)
+        paths.append(package_templates / "email")
+        return paths
+
+    @computed_field
+    @property
+    def markdown_templates(self) -> list[Path]:
+        """Markdown template search paths (project overrides, then package)."""
+        paths = []
+        if self.root:
+            project_path = self.root / "templates" / "markdown"
+            if project_path.exists():
+                paths.append(project_path)
+        paths.append(package_templates / "markdown")
+        return paths
+
+    def set_root(self, project_root: Path) -> None:
+        """Explicitly set project root (overrides auto-detection)."""
+        self.root = project_root
+
+    def to_template_path_list(self, path: Path) -> list[Path]:
+        """Convert path to list with fallback."""
+        return [path, path / self.fallback_path]
+
+    def fallback_static_default(self, static_type: str, file_name: str) -> Path:
+        """Return a fallback path for a static file."""
+        if self.statics is None:
+            raise RuntimeError(
+                "Project root not detected. Cannot access static assets."
+            )
+
+        paths_to_check = [
+            self.statics / static_type / file_name,
+            self.statics / self.fallback_path / static_type / file_name,
+        ]
+
+        for path in paths_to_check:
+            if path.exists():
+                return path
+
+        raise FileNotFoundError(
+            f"Could not find {file_name} in any of the fallback paths: {paths_to_check}"
+        )
+
+
+# Global settings instance with lazy auto-detection
+_settings = PathSettings()
+
+
+# Backwards-compatible module-level API
+def set_project_root(project_root: Path) -> None:
+    """Set the project root directory explicitly."""
+    _settings.set_root(project_root)
+
+
+def to_template_path_list(path: Path) -> list[Path]:
+    """Convert path to list with fallback."""
+    return _settings.to_template_path_list(path)
+
+
+def fallback_static_default(static_type: str, file_name: str) -> Path:
+    """Return a fallback path for a static file."""
+    return _settings.fallback_static_default(static_type, file_name)
+
+
+# Expose settings instance for direct access
+paths = _settings
+
+# Module-level variables that delegate to settings (backwards compatibility)
+# Access like: from vibetuner.paths import frontend_templates
+# Or better: from vibetuner.paths import paths; paths.frontend_templates
+root = _settings.root
+templates = _settings.templates
+app_templates = _settings.app_templates
+locales = _settings.locales
+config_vars = _settings.config_vars
+assets = _settings.assets
+statics = _settings.statics
+css = _settings.css
+js = _settings.js
+favicons = _settings.favicons
+img = _settings.img
+frontend_templates = _settings.frontend_templates
+email_templates = _settings.email_templates
+markdown_templates = _settings.markdown_templates

{vibetuner-2.7.0 → vibetuner-2.8.0}/src/vibetuner/templates.py

@@ -3,13 +3,7 @@ from typing import Any, Dict, Optional
 
 from jinja2 import Environment, FileSystemLoader, TemplateNotFound
 
-from .paths import (
-    app_templates,
-    core_templates,
-    email_templates,
-    frontend_templates,
-    markdown_templates,
-)
+from . import paths
 
 
 def _get_base_paths_for_namespace(
@@ -22,19 +16,19 @@ def _get_base_paths_for_namespace(
 
     # Map known namespaces to their predefined paths
     if namespace == "email":
-        return email_templates
+        return paths.email_templates
     if namespace == "markdown":
-        return markdown_templates
+        return paths.markdown_templates
     if namespace == "frontend":
-        return frontend_templates
+        return paths.frontend_templates
 
     # Default for unknown or None namespace
     # Only include app_templates if project root has been set
-    paths = []
-    if app_templates is not None:
-        paths.append(app_templates)
-    paths.append(core_templates)
-    return paths
+    path_list = []
+    if paths.app_templates is not None:
+        path_list.append(paths.app_templates)
+    path_list.append(paths.core_templates)
+    return path_list
 
 
 def _build_search_paths(

vibetuner-2.7.0/src/vibetuner/paths.py

@@ -1,112 +0,0 @@
-from importlib.resources import files
-from pathlib import Path
-
-# Package-relative paths (for bundled templates in the vibetuner package)
-_package_files = files("vibetuner")
-_package_templates_traversable = _package_files / "templates"
-
-# Convert to Path when actually used (handles both filesystem and zip-based packages)
-def _get_package_templates_path() -> Path:
-    """Get package templates path, works for both installed and editable installs."""
-    # For most cases, we can convert directly to Path
-    # For zip files, importlib.resources handles extraction automatically
-    try:
-        return Path(str(_package_templates_traversable))
-    except (TypeError, ValueError):
-        # If we can't convert to Path, we're in a zip or similar
-        # In this case, we'll need to use as_file() context manager when accessing
-        # For now, raise an error - we can enhance this later if needed
-        raise RuntimeError(
-            "Package templates are in a non-filesystem location. "
-            "This is not yet supported."
-        )
-
-
-package_templates = _get_package_templates_path()
-
-# Project root (set at runtime by the application using vibetuner)
-# When None, only package templates are available
-root: Path | None = None
-fallback_path = "defaults"
-
-
-def set_project_root(project_root: Path) -> None:
-    """Set the project root directory for the application using vibetuner.
-
-    This enables access to project-specific templates, assets, and locales.
-    Must be called before accessing project-specific paths.
-    """
-    global root, templates, app_templates, locales, config_vars
-    global assets, statics, css, js, favicons, img
-    global frontend_templates, email_templates, markdown_templates
-
-    root = project_root
-
-    # Update project-specific paths
-    templates = root / "templates"
-    app_templates = templates  # Deprecated: projects now use templates/ directly
-    locales = root / "locales"
-    config_vars = root / ".copier-answers.yml"
-
-    # Update asset paths
-    assets = root / "assets"
-    statics = assets / "statics"
-    css = statics / "css"
-    js = statics / "js"
-    favicons = statics / "favicons"
-    img = statics / "img"
-
-    # Update template lists to include project overrides
-    frontend_templates = [templates / "frontend", package_templates / "frontend"]
-    email_templates = [templates / "email", package_templates / "email"]
-    markdown_templates = [templates / "markdown", package_templates / "markdown"]
-
-
-def to_template_path_list(path: Path) -> list[Path]:
-    return [
-        path,
-        path / fallback_path,
-    ]
-
-
-def fallback_static_default(static_type: str, file_name: str) -> Path:
-    """Return a fallback path for a file."""
-    if root is None:
-        raise RuntimeError(
-            "Project root not set. Call set_project_root() before accessing assets."
-        )
-
-    paths_to_check = [
-        statics / static_type / file_name,
-        statics / fallback_path / static_type / file_name,
-    ]
-
-    for path in paths_to_check:
-        if path.exists():
-            return path
-
-    raise FileNotFoundError(
-        f"Could not find {file_name} in any of the fallback paths: {paths_to_check}"
-    )
-
-
-# Core templates point to package (always available)
-core_templates = package_templates
-
-# Template paths - initially only package templates, updated when set_project_root() is called
-frontend_templates = [package_templates / "frontend"]
-email_templates = [package_templates / "email"]
-markdown_templates = [package_templates / "markdown"]
-
-# Project-specific paths - will be None until set_project_root() is called
-# These get updated by set_project_root()
-templates: Path | None = None
-app_templates: Path | None = None
-locales: Path | None = None
-config_vars: Path | None = None
-assets: Path | None = None
-statics: Path | None = None
-css: Path | None = None
-js: Path | None = None
-favicons: Path | None = None
-img: Path | None = None