lfx-nightly 0.1.11.dev0__py3-none-any.whl

lfx/services/manager.py

@@ -0,0 +1,172 @@
+"""ServiceManager extracted from langflow for lfx package.
+
+This maintains the same API and most of the functionality, but removes
+langflow-specific auto-discovery to break dependencies.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import importlib
+import inspect
+import threading
+from typing import TYPE_CHECKING
+
+from lfx.log.logger import logger
+from lfx.services.schema import ServiceType
+
+if TYPE_CHECKING:
+    from lfx.services.base import Service
+    from lfx.services.factory import ServiceFactory
+
+
+class NoFactoryRegisteredError(Exception):
+    pass
+
+
+class ServiceManager:
+    """Manages the creation of different services."""
+
+    def __init__(self) -> None:
+        self.services: dict[str, Service] = {}
+        self.factories: dict[str, ServiceFactory] = {}
+        self._lock = threading.RLock()
+        self.factory_registered = False
+        from lfx.services.settings.factory import SettingsServiceFactory
+
+        self.register_factory(SettingsServiceFactory())
+
+    def register_factories(self, factories: list[ServiceFactory] | None = None) -> None:
+        """Register all available service factories."""
+        if factories is None:
+            return
+        for factory in factories:
+            try:
+                self.register_factory(factory)
+            except Exception:  # noqa: BLE001
+                logger.exception(f"Error initializing {factory}")
+        self.set_factory_registered()
+
+    def are_factories_registered(self) -> bool:
+        """Check if the factory is registered."""
+        return self.factory_registered
+
+    def set_factory_registered(self) -> None:
+        """Set the factory registered flag."""
+        self.factory_registered = True
+
+    def register_factory(
+        self,
+        service_factory: ServiceFactory,
+    ) -> None:
+        """Registers a new factory with dependencies."""
+        service_name = service_factory.service_class.name
+        self.factories[service_name] = service_factory
+
+    def get(self, service_name: ServiceType, default: ServiceFactory | None = None) -> Service:
+        """Get (or create) a service by its name."""
+        with self._lock:
+            if service_name not in self.services:
+                self._create_service(service_name, default)
+            return self.services[service_name]
+
+    def _create_service(self, service_name: ServiceType, default: ServiceFactory | None = None) -> None:
+        """Create a new service given its name, handling dependencies."""
+        logger.debug(f"Create service {service_name}")
+        self._validate_service_creation(service_name, default)
+
+        if service_name == ServiceType.SETTINGS_SERVICE:
+            from lfx.services.settings.factory import SettingsServiceFactory
+
+            factory = SettingsServiceFactory()
+            if factory not in self.factories:
+                self.register_factory(factory)
+        else:
+            factory = self.factories.get(service_name)
+
+        # Create dependencies first
+        if factory is None and default is not None:
+            self.register_factory(default)
+            factory = default
+        if factory is None:
+            msg = f"No factory registered for {service_name}"
+            raise NoFactoryRegisteredError(msg)
+        for dependency in factory.dependencies:
+            if dependency not in self.services:
+                self._create_service(dependency)
+
+        # Collect the dependent services
+        dependent_services = {dep.value: self.services[dep] for dep in factory.dependencies}
+
+        # Create the actual service
+        self.services[service_name] = self.factories[service_name].create(**dependent_services)
+        self.services[service_name].set_ready()
+
+    def _validate_service_creation(self, service_name: ServiceType, default: ServiceFactory | None = None) -> None:
+        """Validate whether the service can be created."""
+        if service_name == ServiceType.SETTINGS_SERVICE:
+            return
+        if service_name not in self.factories and default is None:
+            msg = f"No factory registered for the service class '{service_name.name}'"
+            raise NoFactoryRegisteredError(msg)
+
+    def update(self, service_name: ServiceType) -> None:
+        """Update a service by its name."""
+        if service_name in self.services:
+            logger.debug(f"Update service {service_name}")
+            self.services.pop(service_name, None)
+            self.get(service_name)
+
+    async def teardown(self) -> None:
+        """Teardown all the services."""
+        for service in list(self.services.values()):
+            if service is None:
+                continue
+            logger.debug(f"Teardown service {service.name}")
+            try:
+                teardown_result = service.teardown()
+                if asyncio.iscoroutine(teardown_result):
+                    await teardown_result
+            except Exception as exc:  # noqa: BLE001
+                logger.debug(f"Error in teardown of {service.name}", exc_info=exc)
+        self.services = {}
+        self.factories = {}
+
+    @classmethod
+    def get_factories(cls) -> list[ServiceFactory]:
+        """Auto-discover and return all service factories."""
+        from lfx.services.factory import ServiceFactory
+        from lfx.services.schema import ServiceType
+
+        service_names = [ServiceType(service_type).value.replace("_service", "") for service_type in ServiceType]
+        base_module = "lfx.services"
+        factories = []
+
+        for name in service_names:
+            try:
+                module_name = f"{base_module}.{name}.factory"
+                module = importlib.import_module(module_name)
+
+                # Find all classes in the module that are subclasses of ServiceFactory
+                for _, obj in inspect.getmembers(module, inspect.isclass):
+                    if issubclass(obj, ServiceFactory) and obj is not ServiceFactory:
+                        factories.append(obj())
+                        break
+
+            except Exception as exc:  # noqa: BLE001
+                logger.debug(
+                    f"Could not initialize services. Please check your settings. Error in {name}.", exc_info=exc
+                )
+
+        return factories
+
+
+# Global service manager instance
+_service_manager = None
+
+
+def get_service_manager():
+    global _service_manager  # noqa: PLW0603
+    if _service_manager is None:
+        _service_manager = ServiceManager()
+    return _service_manager

lfx/services/schema.py

@@ -0,0 +1,20 @@
+"""Service schema definitions for lfx package."""
+
+from enum import Enum
+
+
+class ServiceType(str, Enum):
+    DATABASE_SERVICE = "database_service"
+    STORAGE_SERVICE = "storage_service"
+    SETTINGS_SERVICE = "settings_service"
+    VARIABLE_SERVICE = "variable_service"
+    CACHE_SERVICE = "cache_service"
+    TELEMETRY_SERVICE = "telemetry_service"
+    TRACING_SERVICE = "tracing_service"
+    STATE_SERVICE = "state_service"
+    SESSION_SERVICE = "session_service"
+    CHAT_SERVICE = "chat_service"
+    TASK_SERVICE = "task_service"
+    STORE_SERVICE = "store_service"
+    JOB_QUEUE_SERVICE = "job_queue_service"
+    SHARED_COMPONENT_CACHE_SERVICE = "shared_component_cache_service"

lfx/services/session.py

@@ -0,0 +1,82 @@
+"""Lightweight session implementations for lfx package."""
+
+
+class NoopSession:
+    """No-operation session that implements the database session interface.
+
+    This provides a complete database session API but all operations are no-ops.
+    Perfect for testing or when no real database is available.
+    """
+
+    class NoopBind:
+        class NoopConnect:
+            async def __aenter__(self):
+                return self
+
+            async def __aexit__(self, exc_type, exc, tb):
+                pass
+
+            async def run_sync(self, fn, *args, **kwargs):  # noqa: ARG002
+                return None
+
+        def connect(self):
+            return self.NoopConnect()
+
+    bind = NoopBind()
+
+    async def add(self, *args, **kwargs):
+        pass
+
+    async def commit(self):
+        pass
+
+    async def rollback(self):
+        pass
+
+    async def execute(self, *args, **kwargs):  # noqa: ARG002
+        return None
+
+    async def query(self, *args, **kwargs):  # noqa: ARG002
+        return []
+
+    async def close(self):
+        pass
+
+    async def refresh(self, *args, **kwargs):
+        pass
+
+    async def delete(self, *args, **kwargs):
+        pass
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb):
+        pass
+
+    async def get(self, *args, **kwargs):  # noqa: ARG002
+        return None
+
+    async def exec(self, *args, **kwargs):  # noqa: ARG002
+        class _NoopResult:
+            def first(self):
+                return None
+
+            def all(self):
+                return []
+
+            def one_or_none(self):
+                return None
+
+        return _NoopResult()
+
+    @property
+    def no_autoflush(self):
+        """Context manager that disables autoflush (no-op implementation)."""
+        return self
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc, tb):
+        pass

lfx/services/settings/__init__.py

@@ -0,0 +1,3 @@
+from . import factory, service
+
+__all__ = ["factory", "service"]

lfx/services/settings/auth.py

@@ -0,0 +1,130 @@
+import secrets
+from pathlib import Path
+from typing import Literal
+
+from passlib.context import CryptContext
+from pydantic import Field, SecretStr, field_validator
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+from lfx.log.logger import logger
+from lfx.services.settings.constants import DEFAULT_SUPERUSER, DEFAULT_SUPERUSER_PASSWORD
+from lfx.services.settings.utils import read_secret_from_file, write_secret_to_file
+
+
+class AuthSettings(BaseSettings):
+    # Login settings
+    CONFIG_DIR: str
+    SECRET_KEY: SecretStr = Field(
+        default=SecretStr(""),
+        description="Secret key for JWT. If not provided, a random one will be generated.",
+        frozen=False,
+    )
+    ALGORITHM: str = "HS256"
+    ACCESS_TOKEN_EXPIRE_SECONDS: int = 60 * 60  # 1 hour
+    REFRESH_TOKEN_EXPIRE_SECONDS: int = 60 * 60 * 24 * 7  # 7 days
+
+    # API Key to execute /process endpoint
+    API_KEY_ALGORITHM: str = "HS256"
+    API_V1_STR: str = "/api/v1"
+
+    AUTO_LOGIN: bool = Field(
+        default=True,  # TODO: Set to False in v1.6
+        description=(
+            "Enable automatic login with default credentials. "
+            "SECURITY WARNING: This bypasses authentication and should only be used in development environments. "
+            "Set to False in production."
+        ),
+    )
+    """If True, the application will attempt to log in automatically as a super user."""
+    skip_auth_auto_login: bool = True
+    """If True, the application will skip authentication when AUTO_LOGIN is enabled.
+    This will be removed in v1.6"""
+
+    WEBHOOK_AUTH_ENABLE: bool = False
+    """If True, webhook endpoints will require API key authentication.
+    If False, webhooks run as flow owner without authentication."""
+
+    ENABLE_SUPERUSER_CLI: bool = Field(
+        default=True,
+        description="Allow creation of superusers via CLI. Set to False in production for security.",
+    )
+    """If True, allows creation of superusers via the CLI 'langflow superuser' command."""
+
+    NEW_USER_IS_ACTIVE: bool = False
+    SUPERUSER: str = DEFAULT_SUPERUSER
+    SUPERUSER_PASSWORD: str = DEFAULT_SUPERUSER_PASSWORD
+
+    REFRESH_SAME_SITE: Literal["lax", "strict", "none"] = "none"
+    """The SameSite attribute of the refresh token cookie."""
+    REFRESH_SECURE: bool = True
+    """The Secure attribute of the refresh token cookie."""
+    REFRESH_HTTPONLY: bool = True
+    """The HttpOnly attribute of the refresh token cookie."""
+    ACCESS_SAME_SITE: Literal["lax", "strict", "none"] = "lax"
+    """The SameSite attribute of the access token cookie."""
+    ACCESS_SECURE: bool = False
+    """The Secure attribute of the access token cookie."""
+    ACCESS_HTTPONLY: bool = False
+    """The HttpOnly attribute of the access token cookie."""
+
+    COOKIE_DOMAIN: str | None = None
+    """The domain attribute of the cookies. If None, the domain is not set."""
+
+    pwd_context: CryptContext = CryptContext(schemes=["bcrypt"], deprecated="auto")
+
+    model_config = SettingsConfigDict(validate_assignment=True, extra="ignore", env_prefix="LANGFLOW_")
+
+    def reset_credentials(self) -> None:
+        self.SUPERUSER = DEFAULT_SUPERUSER
+        self.SUPERUSER_PASSWORD = DEFAULT_SUPERUSER_PASSWORD
+
+    # If autologin is true, then we need to set the credentials to
+    # the default values
+    # so we need to validate the superuser and superuser_password
+    # fields
+    @field_validator("SUPERUSER", "SUPERUSER_PASSWORD", mode="before")
+    @classmethod
+    def validate_superuser(cls, value, info):
+        if info.data.get("AUTO_LOGIN"):
+            if value != DEFAULT_SUPERUSER:
+                value = DEFAULT_SUPERUSER
+                logger.debug("Resetting superuser to default value")
+            if info.data.get("SUPERUSER_PASSWORD") != DEFAULT_SUPERUSER_PASSWORD:
+                info.data["SUPERUSER_PASSWORD"] = DEFAULT_SUPERUSER_PASSWORD
+                logger.debug("Resetting superuser password to default value")
+
+            return value
+
+        return value
+
+    @field_validator("SECRET_KEY", mode="before")
+    @classmethod
+    def get_secret_key(cls, value, info):
+        config_dir = info.data.get("CONFIG_DIR")
+
+        if not config_dir:
+            logger.debug("No CONFIG_DIR provided, not saving secret key")
+            return value or secrets.token_urlsafe(32)
+
+        secret_key_path = Path(config_dir) / "secret_key"
+
+        if value:
+            logger.debug("Secret key provided")
+            secret_value = value.get_secret_value() if isinstance(value, SecretStr) else value
+            write_secret_to_file(secret_key_path, secret_value)
+        else:
+            logger.debug("No secret key provided, generating a random one")
+
+            if secret_key_path.exists():
+                value = read_secret_from_file(secret_key_path)
+                logger.debug("Loaded secret key")
+                if not value:
+                    value = secrets.token_urlsafe(32)
+                    write_secret_to_file(secret_key_path, value)
+                    logger.debug("Saved secret key")
+            else:
+                value = secrets.token_urlsafe(32)
+                write_secret_to_file(secret_key_path, value)
+                logger.debug("Saved secret key")
+
+        return value if isinstance(value, SecretStr) else SecretStr(value).get_secret_value()