remdb 0.3.114__py3-none-any.whl → 0.3.127__py3-none-any.whl

rem/utils/schema_loader.py

@@ -195,7 +195,7 @@ def load_agent_schema(
     """
     Load agent schema from YAML file with unified search logic and caching.
 
-    Schema names are case-invariant - "Siggy", "siggy", "SIGGY" all resolve to the same schema.
+    Schema names are case-invariant - "Rem", "rem", "REM" all resolve to the same schema.
 
     Filesystem schemas are cached indefinitely (immutable, versioned with code).
     Database schemas (future) will be cached with TTL for invalidation.
@@ -271,10 +271,20 @@ def load_agent_schema(
     # 2. Normalize name for package resource search (lowercase)
     base_name = cache_key
 
-    # 3. Try custom schema paths (from registry + SCHEMA__PATHS env var)
+    # 3. Try custom schema paths (from registry + SCHEMA__PATHS env var + auto-detected)
     from ..registry import get_schema_paths
 
     custom_paths = get_schema_paths()
+
+    # Auto-detect local folders if they exist (convention over configuration)
+    auto_detect_folders = ["./agents", "./schemas", "./evaluators"]
+    for auto_folder in auto_detect_folders:
+        auto_path = Path(auto_folder)
+        if auto_path.exists() and auto_path.is_dir():
+            resolved = str(auto_path.resolve())
+            if resolved not in custom_paths:
+                custom_paths.insert(0, resolved)
+                logger.debug(f"Auto-detected schema directory: {auto_folder}")
     for custom_dir in custom_paths:
         # Try various patterns within each custom directory
         for pattern in [
@@ -400,9 +410,20 @@ async def load_agent_schema_async(
 
     base_name = cache_key
 
-    # Try custom schema paths
+    # Try custom schema paths (from registry + SCHEMA__PATHS env var + auto-detected)
     from ..registry import get_schema_paths
     custom_paths = get_schema_paths()
+
+    # Auto-detect local folders if they exist (convention over configuration)
+    auto_detect_folders = ["./agents", "./schemas", "./evaluators"]
+    for auto_folder in auto_detect_folders:
+        auto_path = Path(auto_folder)
+        if auto_path.exists() and auto_path.is_dir():
+            resolved = str(auto_path.resolve())
+            if resolved not in custom_paths:
+                custom_paths.insert(0, resolved)
+                logger.debug(f"Auto-detected schema directory: {auto_folder}")
+
     for custom_dir in custom_paths:
         for pattern in [f"{base_name}.yaml", f"{base_name}.yml", f"agents/{base_name}.yaml"]:
             custom_path = Path(custom_dir) / pattern
@@ -490,3 +511,73 @@ def validate_agent_schema(schema: dict[str, Any]) -> bool:
 
     logger.debug("Schema validation passed")
     return True
+
+
+def get_evaluator_schema_path(evaluator_name: str) -> Path | None:
+    """
+    Find the file path to an evaluator schema.
+
+    Searches standard locations for the evaluator schema YAML file:
+    - ./evaluators/{name}.yaml (local project)
+    - Custom schema paths from registry
+    - Package resources: schemas/evaluators/{name}.yaml
+
+    Args:
+        evaluator_name: Name of the evaluator (e.g., "mental-health-classifier")
+
+    Returns:
+        Path to the evaluator schema file, or None if not found
+
+    Example:
+        >>> path = get_evaluator_schema_path("mental-health-classifier")
+        >>> if path:
+        ...     print(f"Found evaluator at: {path}")
+    """
+    from ..registry import get_schema_paths
+
+    base_name = evaluator_name.lower().replace('.yaml', '').replace('.yml', '')
+
+    # 1. Try custom schema paths (from registry + auto-detected)
+    custom_paths = get_schema_paths()
+
+    # Auto-detect local folders
+    auto_detect_folders = ["./evaluators", "./schemas", "./agents"]
+    for auto_folder in auto_detect_folders:
+        auto_path = Path(auto_folder)
+        if auto_path.exists() and auto_path.is_dir():
+            resolved = str(auto_path.resolve())
+            if resolved not in custom_paths:
+                custom_paths.insert(0, resolved)
+
+    for custom_dir in custom_paths:
+        # Try various patterns within each custom directory
+        for pattern in [
+            f"{base_name}.yaml",
+            f"{base_name}.yml",
+            f"evaluators/{base_name}.yaml",
+        ]:
+            custom_path = Path(custom_dir) / pattern
+            if custom_path.exists():
+                logger.debug(f"Found evaluator schema: {custom_path}")
+                return custom_path
+
+    # 2. Try package resources
+    evaluator_search_paths = [
+        f"schemas/evaluators/{base_name}.yaml",
+        f"schemas/evaluators/rem/{base_name}.yaml",
+    ]
+
+    for search_path in evaluator_search_paths:
+        try:
+            schema_ref = importlib.resources.files("rem") / search_path
+            schema_path = Path(str(schema_ref))
+
+            if schema_path.exists():
+                logger.debug(f"Found evaluator schema in package: {schema_path}")
+                return schema_path
+        except Exception as e:
+            logger.debug(f"Could not check {search_path}: {e}")
+            continue
+
+    logger.warning(f"Evaluator schema not found: {evaluator_name}")
+    return None

rem/utils/sql_paths.py

@@ -0,0 +1,146 @@
+"""Utilities for resolving SQL file paths.
+
+Handles package SQL directory resolution and user migrations.
+
+Convention for user migrations:
+    Place custom SQL files in `./sql/migrations/` relative to your project root.
+    Files should be numbered (e.g., `100_custom_table.sql`) to control execution order.
+    Package migrations (001-099) run first, then user migrations (100+).
+"""
+
+from pathlib import Path
+from typing import List, Optional
+import importlib.resources
+
+# Convention: Default location for user-maintained migrations
+USER_SQL_DIR_CONVENTION = "sql"
+
+
+def get_package_sql_dir() -> Path:
+    """Get the SQL directory from the installed rem package.
+
+    Returns:
+        Path to the package's sql directory
+
+    Raises:
+        FileNotFoundError: If the SQL directory cannot be found
+    """
+    try:
+        # Use importlib.resources for Python 3.9+
+        sql_ref = importlib.resources.files("rem") / "sql"
+        package_sql = Path(str(sql_ref))
+        if package_sql.exists():
+            return package_sql
+    except (AttributeError, TypeError):
+        pass
+
+    # Fallback: use __file__ to find package location
+    try:
+        import rem
+        package_sql = Path(rem.__file__).parent / "sql"
+        if package_sql.exists():
+            return package_sql
+    except (ImportError, AttributeError):
+        pass
+
+    # Development fallback: check relative to cwd
+    dev_sql = Path("src/rem/sql")
+    if dev_sql.exists():
+        return dev_sql
+
+    raise FileNotFoundError(
+        "Could not locate rem SQL directory. "
+        "Ensure remdb is properly installed or run from the source directory."
+    )
+
+
+def get_package_migrations_dir() -> Path:
+    """Get the migrations directory from the installed rem package.
+
+    Returns:
+        Path to the package's migrations directory
+    """
+    return get_package_sql_dir() / "migrations"
+
+
+def get_user_sql_dir() -> Optional[Path]:
+    """Get the conventional user SQL directory if it exists.
+
+    Looks for `./sql/` relative to the current working directory.
+    This follows the convention for user-maintained migrations.
+
+    Returns:
+        Path to user sql directory if it exists, None otherwise
+    """
+    user_sql = Path.cwd() / USER_SQL_DIR_CONVENTION
+    if user_sql.exists() and user_sql.is_dir():
+        return user_sql
+    return None
+
+
+def list_package_migrations() -> List[Path]:
+    """List all migration files in the package.
+
+    Returns:
+        Sorted list of migration file paths
+    """
+    try:
+        migrations_dir = get_package_migrations_dir()
+        if migrations_dir.exists():
+            return sorted(
+                f for f in migrations_dir.glob("*.sql")
+                if f.name[0].isdigit()  # Only numbered migrations
+            )
+    except FileNotFoundError:
+        pass
+
+    return []
+
+
+def list_user_migrations() -> List[Path]:
+    """List all migration files in the user's sql/migrations directory.
+
+    Returns:
+        Sorted list of user migration file paths
+    """
+    user_sql = get_user_sql_dir()
+    if user_sql:
+        migrations_dir = user_sql / "migrations"
+        if migrations_dir.exists():
+            return sorted(
+                f for f in migrations_dir.glob("*.sql")
+                if f.name[0].isdigit()  # Only numbered migrations
+            )
+    return []
+
+
+def list_all_migrations() -> List[Path]:
+    """List all migration files from package and user directories.
+
+    Collects migrations from:
+    1. Package migrations directory
+    2. User directory (./sql/migrations/) if it exists
+
+    Files are sorted by name, so use numbered prefixes to control order:
+    - 001-099: Reserved for package migrations
+    - 100+: Recommended for user migrations
+
+    Returns:
+        Sorted list of all migration file paths (by filename)
+    """
+    all_migrations = []
+    seen_names = set()
+
+    # Package migrations first
+    for f in list_package_migrations():
+        if f.name not in seen_names:
+            all_migrations.append(f)
+            seen_names.add(f.name)
+
+    # User migrations second
+    for f in list_user_migrations():
+        if f.name not in seen_names:
+            all_migrations.append(f)
+            seen_names.add(f.name)
+
+    return sorted(all_migrations, key=lambda p: p.name)

rem/workers/__init__.py

@@ -1,5 +1,7 @@
 """Background workers for processing tasks."""
 
+from .db_listener import DBListener
 from .sqs_file_processor import SQSFileProcessor
+from .unlogged_maintainer import UnloggedMaintainer
 
-__all__ = ["SQSFileProcessor"]
+__all__ = ["DBListener", "SQSFileProcessor", "UnloggedMaintainer"]