flock-core 0.4.543__py3-none-any.whl → 0.5.0__py3-none-any.whl

flock/webapp/app/config.py

@@ -1,104 +0,0 @@
-import os
-import random  # Added for random theme selection
-from pathlib import Path
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from flock.core.flock import Flock
-
-from flock.core.logging.formatters.themes import OutputTheme
-
-FLOCK_FILES_DIR = Path(os.getenv("FLOCK_FILES_DIR", "./.flock_ui_projects"))
-FLOCK_FILES_DIR.mkdir(parents=True, exist_ok=True)
-
-# --- Shared Links Database Configuration ---
-# Default path is relative to the .flock/ directory in the workspace root if FLOCK_ROOT is not set
-# or if .flock is not a sibling of FLOCK_BASE_DIR.
-# More robustly, place it inside a user-specific or project-specific data directory.
-_default_shared_links_db_parent = Path(os.getenv("FLOCK_ROOT", ".")) / ".flock"
-SHARED_LINKS_DB_PATH = Path(
-    os.getenv(
-        "SHARED_LINKS_DB_PATH",
-        str(_default_shared_links_db_parent / "shared_links.db")
-    )
-)
-# Ensure the directory for the DB exists, though the store will also do this.
-SHARED_LINKS_DB_PATH.parent.mkdir(parents=True, exist_ok=True)
-
-# --- Theme Configuration ---
-# Calculate themes directory relative to this config file's location, assuming structure:
-# src/flock/webapp/app/config.py
-# src/flock/themes/
-CONFIG_FILE_PATH = Path(__file__).resolve() # src/flock/webapp/app/config.py
-FLOCK_WEBAPP_DIR = CONFIG_FILE_PATH.parent.parent # src/flock/webapp/
-FLOCK_BASE_DIR = FLOCK_WEBAPP_DIR.parent # src/flock/
-THEMES_DIR = FLOCK_BASE_DIR / "themes"
-
-# Global state for MVP - NOT SUITABLE FOR PRODUCTION/MULTI-USER
-CURRENT_FLOCK_INSTANCE: "Flock | None" = None
-CURRENT_FLOCK_FILENAME: str | None = None
-
-DEFAULT_THEME_NAME = OutputTheme.ciapre.value # Default if random fails or invalid theme specified
-
-def list_available_themes() -> list[str]:
-    """Scans the THEMES_DIR for .toml files and returns their names (without .toml)."""
-    if not THEMES_DIR.exists() or not THEMES_DIR.is_dir():
-        return []
-    return sorted([p.stem for p in THEMES_DIR.glob("*.toml") if p.is_file()])
-
-# Initialize CURRENT_THEME_NAME
-_initial_theme_from_env = os.environ.get("FLOCK_WEB_THEME")
-_resolved_initial_theme = DEFAULT_THEME_NAME
-
-if _initial_theme_from_env:
-    if _initial_theme_from_env.lower() == "random":
-        available_themes = list_available_themes()
-        if available_themes:
-            _resolved_initial_theme = random.choice(available_themes)
-            print(f"Config: Initial theme from FLOCK_WEB_THEME='random' resolved to: {_resolved_initial_theme}")
-        else:
-            print(f"Warning: FLOCK_WEB_THEME='random' specified, but no themes found in {THEMES_DIR}. Using default: {DEFAULT_THEME_NAME}")
-            _resolved_initial_theme = DEFAULT_THEME_NAME
-    elif _initial_theme_from_env in [t.value for t in OutputTheme] or _initial_theme_from_env in list_available_themes():
-        _resolved_initial_theme = _initial_theme_from_env
-        print(f"Config: Initial theme set from FLOCK_WEB_THEME env var: {_resolved_initial_theme}")
-    else:
-        print(f"Warning: Invalid theme name '{_initial_theme_from_env}' in FLOCK_WEB_THEME. Using default: {DEFAULT_THEME_NAME}")
-        _resolved_initial_theme = DEFAULT_THEME_NAME
-
-CURRENT_THEME_NAME: str = _resolved_initial_theme
-
-def set_current_theme_name(theme_name: str | None):
-    """Sets the globally accessible current theme name.
-    If 'random' is passed, a random theme is chosen.
-    """
-    global CURRENT_THEME_NAME
-    resolved_theme = DEFAULT_THEME_NAME # Default to start
-
-    if theme_name:
-        if theme_name.lower() == "random":
-            available = list_available_themes()
-            if available:
-                resolved_theme = random.choice(available)
-                print(f"Config: Theme 'random' resolved to: {resolved_theme}")
-            else:
-                print(f"Warning: Theme 'random' specified, but no themes found in {THEMES_DIR}. Using default: {DEFAULT_THEME_NAME}")
-                # resolved_theme remains DEFAULT_THEME_NAME
-        elif theme_name in list_available_themes():
-            resolved_theme = theme_name
-        else:
-            print(f"Warning: Invalid theme name provided ('{theme_name}'). Using default: {DEFAULT_THEME_NAME}")
-            # resolved_theme remains DEFAULT_THEME_NAME
-    else: # theme_name is None
-        # resolved_theme remains DEFAULT_THEME_NAME (set at the beginning of function)
-        pass
-
-    CURRENT_THEME_NAME = resolved_theme
-    # Ensure the theme name is set in the environment if we want other processes to see it,
-    # though this might be better handled by the calling process (e.g. CLI)
-    # os.environ["FLOCK_WEB_THEME"] = CURRENT_THEME_NAME
-    print(f"Config: Current theme explicitly set to: {CURRENT_THEME_NAME}")
-
-def get_current_theme_name() -> str:
-    """Gets the globally accessible current theme name."""
-    return CURRENT_THEME_NAME

flock/webapp/app/dependencies.py

@@ -1,117 +0,0 @@
-# src/flock/webapp/app/dependencies.py
-from collections.abc import Sequence
-from typing import TYPE_CHECKING, Optional
-
-# Import FlockEndpoint for type hinting
-from flock.core.api.custom_endpoint import FlockEndpoint
-
-if TYPE_CHECKING:
-    from flock.core.api.run_store import RunStore
-    from flock.core.flock import Flock
-    from flock.webapp.app.services.sharing_store import SharedLinkStoreInterface
-
-
-# These will be set once when the FastAPI app starts, via set_global_flock_services
-_flock_instance: Optional["Flock"] = None
-_run_store_instance: Optional["RunStore"] = None
-_shared_link_store_instance: Optional["SharedLinkStoreInterface"] = None
-
-# Global-like variable (scoped to this module) to temporarily store custom endpoints
-# before the app is fully configured and the lifespan event runs.
-_pending_custom_endpoints: list[FlockEndpoint] = []
-
-
-def add_pending_custom_endpoints(endpoints: Sequence[FlockEndpoint] | None):
-    """Temporarily stores custom endpoints. Called by `start_unified_server`
-    before the FastAPI app's lifespan event can process them.
-    """
-    global _pending_custom_endpoints
-    if endpoints:
-        # Ensure we are adding FlockEndpoint instances
-        for ep in endpoints:
-            if not isinstance(ep, FlockEndpoint):
-                # If it's a dict, try to convert it, assuming it was the old format
-                if isinstance(ep, dict) and "path" in ep and "callback" in ep:
-                    try:
-                        # Attempt to create FlockEndpoint from dict - assumes correct keys
-                        # This is a basic conversion; more robust parsing might be needed
-                        # if the dict structure is very different.
-                        _pending_custom_endpoints.append(FlockEndpoint(**ep)) # type: ignore
-                    except Exception as e:
-                        print(f"Warning: Could not convert custom endpoint dict to FlockEndpoint: {ep}. Error: {e}")
-                else:
-                    print(f"Warning: Custom endpoint is not a FlockEndpoint instance and cannot be automatically converted: {type(ep)}")
-            else:
-                _pending_custom_endpoints.append(ep)
-        print(f"Dependencies: Added {len(endpoints)} pending custom endpoints.")
-
-
-def get_pending_custom_endpoints_and_clear() -> list[FlockEndpoint]:
-    """Retrieves and clears pending custom endpoints.
-    Called by the FastAPI app's lifespan event manager in `webapp/app/main.py`.
-    """
-    global _pending_custom_endpoints
-    endpoints_to_add = _pending_custom_endpoints[:] # Create a copy
-    _pending_custom_endpoints = [] # Clear the pending list
-    if endpoints_to_add:
-        print(f"Dependencies: Retrieved {len(endpoints_to_add)} pending custom endpoints for app registration.")
-    return endpoints_to_add
-
-
-def set_global_flock_services(flock: Optional["Flock"], run_store: "RunStore"):
-    """Called once at application startup to set the global Flock and RunStore.
-    This is typically invoked by the server startup script (e.g., in webapp/run.py).
-    """
-    global _flock_instance, _run_store_instance
-    from flock.core.logging.logging import (
-        get_logger,  # Local import to avoid circularity at module level
-    )
-    logger = get_logger("dependencies")
-
-    if _flock_instance is not None or _run_store_instance is not None:
-        logger.warning("Global Flock services are being re-initialized in dependencies.py.")
-
-    _flock_instance = flock
-    _run_store_instance = run_store
-    logger.info(f"Global services set in dependencies: Flock='{flock.name if flock else 'None'}', RunStore type='{type(run_store)}'")
-
-
-def set_global_shared_link_store(store: "SharedLinkStoreInterface"):
-    """Called once at application startup to set the global SharedLinkStore."""
-    global _shared_link_store_instance
-    from flock.core.logging.logging import get_logger
-    logger = get_logger("dependencies")
-
-    if _shared_link_store_instance is not None:
-        logger.warning("Global SharedLinkStore is being re-initialized in dependencies.py.")
-
-    _shared_link_store_instance = store
-    logger.info(f"Global SharedLinkStore set in dependencies: Store type='{type(store)}'")
-
-
-def get_flock_instance() -> "Flock":
-    """FastAPI dependency to get the globally available Flock instance."""
-    if _flock_instance is None:
-        # This can happen if accessed before `set_global_flock_services` or if it was cleared.
-        # The application should handle this gracefully, e.g. by redirecting to a setup page.
-        raise RuntimeError("Flock instance has not been initialized or is not currently available for DI.")
-    return _flock_instance
-
-def get_optional_flock_instance() -> Optional["Flock"]:
-    """FastAPI dependency to optionally get the Flock instance. Returns None if not set."""
-    return _flock_instance
-
-
-def get_run_store() -> "RunStore":
-    """FastAPI dependency to get the globally available RunStore instance."""
-    if _run_store_instance is None:
-        # Similar to Flock instance, should be initialized at app startup.
-        raise RuntimeError("RunStore instance has not been initialized in the application.")
-    return _run_store_instance
-
-
-def get_shared_link_store() -> "SharedLinkStoreInterface":
-    """FastAPI dependency to get the globally available SharedLinkStore instance."""
-    if _shared_link_store_instance is None:
-        raise RuntimeError("SharedLinkStore instance has not been initialized in the application.")
-    return _shared_link_store_instance