langflow-base-nightly 0.5.1.dev2__py3-none-any.whl → 0.5.1.dev4__py3-none-any.whl

langflow/schema/schema.py

@@ -1,117 +1,24 @@
-from collections.abc import Generator
-from enum import Enum
-from typing import Literal
-
-from pydantic import BaseModel
-from typing_extensions import TypedDict
-
-from langflow.schema.data import Data
-from langflow.schema.dataframe import DataFrame
-from langflow.schema.message import Message
-from langflow.serialization.serialization import serialize
-
-INPUT_FIELD_NAME = "input_value"
-
-InputType = Literal["chat", "text", "any"]
-OutputType = Literal["chat", "text", "any", "debug"]
-
-
-class LogType(str, Enum):
-    MESSAGE = "message"
-    DATA = "data"
-    STREAM = "stream"
-    OBJECT = "object"
-    ARRAY = "array"
-    TEXT = "text"
-    UNKNOWN = "unknown"
-
-
-class StreamURL(TypedDict):
-    location: str
-
-
-class ErrorLog(TypedDict):
-    errorMessage: str
-    stackTrace: str
-
-
-class OutputValue(BaseModel):
-    message: ErrorLog | StreamURL | dict | list | str
-    type: str
-
-
-def get_type(payload):
-    result = LogType.UNKNOWN
-    match payload:
-        case Message():
-            result = LogType.MESSAGE
-
-        case Data():
-            result = LogType.DATA
-
-        case dict():
-            result = LogType.OBJECT
-
-        case list() | DataFrame():
-            result = LogType.ARRAY
-
-        case str():
-            result = LogType.TEXT
-
-    if result == LogType.UNKNOWN and (
-        (payload and isinstance(payload, Generator))
-        or (isinstance(payload, Message) and isinstance(payload.text, Generator))
-    ):
-        result = LogType.STREAM
-
-    return result
-
-
-def get_message(payload):
-    message = None
-    if hasattr(payload, "data"):
-        message = payload.data
-
-    elif hasattr(payload, "model_dump"):
-        message = payload.model_dump()
-
-    if message is None and isinstance(payload, dict | str | Data):
-        message = payload.data if isinstance(payload, Data) else payload
-
-    return message or payload
-
-
-def build_output_logs(vertex, result) -> dict:
-    outputs: dict[str, OutputValue] = {}
-    component_instance = result[0]
-    for index, output in enumerate(vertex.outputs):
-        if component_instance.status is None:
-            payload = component_instance._results
-            output_result = payload.get(output["name"])
-        else:
-            payload = component_instance._artifacts
-            output_result = payload.get(output["name"], {}).get("raw")
-        message = get_message(output_result)
-        type_ = get_type(output_result)
-
-        match type_:
-            case LogType.STREAM if "stream_url" in message:
-                message = StreamURL(location=message["stream_url"])
-
-            case LogType.STREAM:
-                message = ""
-
-            case LogType.MESSAGE if hasattr(message, "message"):
-                message = message.message
-
-            case LogType.UNKNOWN:
-                message = ""
-
-            case LogType.ARRAY:
-                if isinstance(message, DataFrame):
-                    message = message.to_dict(orient="records")
-                message = [serialize(item) for item in message]
-        name = output.get("name", f"output_{index}")
-        outputs |= {name: OutputValue(message=message, type=type_).model_dump()}
-
-    return outputs
+# Import from lfx instead of defining here
+from lfx.schema.schema import (
+    INPUT_FIELD_NAME,
+    ErrorLog,
+    InputType,
+    LogType,
+    OutputType,
+    OutputValue,
+    StreamURL,
+    build_output_logs,
+    get_type,
+)
+
+__all__ = [
+    "INPUT_FIELD_NAME",
+    "ErrorLog",
+    "InputType",
+    "LogType",
+    "OutputType",
+    "OutputValue",
+    "StreamURL",
+    "build_output_logs",
+    "get_type",
+]

langflow/serialization/constants.py

@@ -1,2 +1,3 @@
-MAX_TEXT_LENGTH = 6000
-MAX_ITEMS_LENGTH = 1000
+from lfx.serialization.constants import MAX_ITEMS_LENGTH, MAX_TEXT_LENGTH
+
+__all__ = ["MAX_ITEMS_LENGTH", "MAX_TEXT_LENGTH"]

langflow/serialization/serialization.py

@@ -8,10 +8,10 @@ from uuid import UUID
 import numpy as np
 import pandas as pd
 from langchain_core.documents import Document
+from lfx.log.logger import logger
 from pydantic import BaseModel
 from pydantic.v1 import BaseModel as BaseModelV1
 
-from langflow.logging.logger import logger
 from langflow.serialization.constants import MAX_ITEMS_LENGTH, MAX_TEXT_LENGTH
 from langflow.services.deps import get_settings_service
 

langflow/server.py

@@ -4,10 +4,9 @@ import signal
 
 from gunicorn import glogging
 from gunicorn.app.base import BaseApplication
+from lfx.log.logger import InterceptHandler
 from uvicorn.workers import UvicornWorker
 
-from langflow.logging.logger import InterceptHandler
-
 
 class LangflowUvicornWorker(UvicornWorker):
     CONFIG_KWARGS = {"loop": "asyncio"}

langflow/services/__init__.py

@@ -1,4 +1,3 @@
-from .manager import service_manager
 from .schema import ServiceType
 
-__all__ = ["ServiceType", "service_manager"]
+__all__ = ["ServiceType"]

langflow/services/auth/mcp_encryption.py

@@ -3,7 +3,7 @@
 from typing import Any
 
 from cryptography.fernet import InvalidToken
-from loguru import logger
+from lfx.log.logger import logger
 
 from langflow.services.auth import utils as auth_utils
 from langflow.services.deps import get_settings_service

langflow/services/auth/service.py

@@ -5,7 +5,7 @@ from typing import TYPE_CHECKING
 from langflow.services.base import Service
 
 if TYPE_CHECKING:
-    from langflow.services.settings.service import SettingsService
+    from lfx.services.settings.service import SettingsService
 
 
 class AuthService(Service):

langflow/services/auth/utils.py

@@ -10,16 +10,16 @@ from cryptography.fernet import Fernet
 from fastapi import Depends, HTTPException, Request, Security, WebSocketException, status
 from fastapi.security import APIKeyHeader, APIKeyQuery, OAuth2PasswordBearer
 from jose import JWTError, jwt
+from lfx.log.logger import logger
+from lfx.services.settings.service import SettingsService
 from sqlalchemy.exc import IntegrityError
 from sqlmodel.ext.asyncio.session import AsyncSession
 from starlette.websockets import WebSocket
 
-from langflow.logging.logger import logger
 from langflow.services.database.models.api_key.crud import check_key
 from langflow.services.database.models.user.crud import get_user_by_id, get_user_by_username, update_user_last_login_at
 from langflow.services.database.models.user.model import User, UserRead
-from langflow.services.deps import get_db_service, get_session, get_settings_service
-from langflow.services.settings.service import SettingsService
+from langflow.services.deps import get_db_service, get_session, get_settings_service, session_scope
 
 if TYPE_CHECKING:
     from langflow.services.database.models.api_key.model import ApiKey
@@ -48,7 +48,7 @@ async def api_key_security(
     settings_service = get_settings_service()
     result: ApiKey | User | None
 
-    async with get_db_service().with_session() as db:
+    async with session_scope() as db:
         if settings_service.auth_settings.AUTO_LOGIN:
             # Get the first user
             if not settings_service.auth_settings.SUPERUSER:
@@ -93,7 +93,7 @@ async def ws_api_key_security(
     api_key: str | None,
 ) -> UserRead:
     settings = get_settings_service()
-    async with get_db_service().with_session() as db:
+    async with session_scope() as db:
         if settings.auth_settings.AUTO_LOGIN:
             if not settings.auth_settings.SUPERUSER:
                 # internal server misconfiguration

langflow/services/cache/disk.py

@@ -4,10 +4,10 @@ import time
 from typing import Generic
 
 from diskcache import Cache
+from lfx.log.logger import logger
+from lfx.services.cache.utils import CACHE_MISS
 
-from langflow.logging.logger import logger
 from langflow.services.cache.base import AsyncBaseCacheService, AsyncLockType
-from langflow.services.cache.utils import CACHE_MISS
 
 
 class AsyncDiskCache(AsyncBaseCacheService, Generic[AsyncLockType]):

langflow/services/cache/factory.py

@@ -2,15 +2,15 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
+from lfx.log.logger import logger
 from typing_extensions import override
 
-from langflow.logging.logger import logger
 from langflow.services.cache.disk import AsyncDiskCache
 from langflow.services.cache.service import AsyncInMemoryCache, CacheService, RedisCache, ThreadingInMemoryCache
 from langflow.services.factory import ServiceFactory
 
 if TYPE_CHECKING:
-    from langflow.services.settings.service import SettingsService
+    from lfx.services.settings.service import SettingsService
 
 
 class CacheServiceFactory(ServiceFactory):

langflow/services/cache/service.py

@@ -6,9 +6,10 @@ from collections import OrderedDict
 from typing import Generic, Union
 
 import dill
+from lfx.log.logger import logger
+from lfx.services.cache.utils import CACHE_MISS
 from typing_extensions import override
 
-from langflow.logging.logger import logger
 from langflow.services.cache.base import (
     AsyncBaseCacheService,
     AsyncLockType,
@@ -16,7 +17,6 @@ from langflow.services.cache.base import (
     ExternalAsyncBaseCacheService,
     LockType,
 )
-from langflow.services.cache.utils import CACHE_MISS
 
 
 class ThreadingInMemoryCache(CacheService, Generic[LockType]):

langflow/services/cache/utils.py

@@ -18,14 +18,6 @@ CACHE_DIR = user_cache_dir("langflow", "langflow")
 PREFIX = "langflow_cache"
 
 
-class CacheMiss:
-    def __repr__(self) -> str:
-        return "<CACHE_MISS>"
-
-    def __bool__(self) -> bool:
-        return False
-
-
 def create_cache_folder(func):
     def wrapper(*args, **kwargs):
         # Get the destination folder
@@ -164,6 +156,3 @@ def update_build_status(cache_service, flow_id: str, status: "BuildStatus") -> N
     cache_service[flow_id] = cached_flow
     cached_flow["status"] = status
     cache_service[flow_id] = cached_flow
-
-
-CACHE_MISS = CacheMiss()

langflow/services/database/factory.py

@@ -6,7 +6,7 @@ from langflow.services.database.service import DatabaseService
 from langflow.services.factory import ServiceFactory
 
 if TYPE_CHECKING:
-    from langflow.services.settings.service import SettingsService
+    from lfx.services.settings.service import SettingsService
 
 
 class DatabaseServiceFactory(ServiceFactory):

langflow/services/database/models/flow/model.py

@@ -9,12 +9,12 @@ from uuid import UUID, uuid4
 import emoji
 from emoji import purely_emoji
 from fastapi import HTTPException, status
+from lfx.log.logger import logger
 from pydantic import BaseModel, ValidationInfo, field_serializer, field_validator
 from sqlalchemy import Enum as SQLEnum
 from sqlalchemy import Text, UniqueConstraint, text
 from sqlmodel import JSON, Column, Field, Relationship, SQLModel
 
-from langflow.logging.logger import logger
 from langflow.schema.data import Data
 
 if TYPE_CHECKING:

langflow/services/database/models/message/crud.py

@@ -1,8 +1,9 @@
 from uuid import UUID
 
+from lfx.utils.async_helpers import run_until_complete
+
 from langflow.services.database.models.message.model import MessageTable, MessageUpdate
 from langflow.services.deps import session_scope
-from langflow.utils.async_helpers import run_until_complete
 
 
 async def _update_message(message_id: UUID | str, message: MessageUpdate | dict):

langflow/services/database/models/transactions/crud.py

@@ -1,9 +1,9 @@
 from uuid import UUID
 
+from lfx.log.logger import logger
 from sqlmodel import col, delete, select
 from sqlmodel.ext.asyncio.session import AsyncSession
 
-from langflow.logging.logger import logger
 from langflow.services.database.models.transactions.model import (
     TransactionBase,
     TransactionReadResponse,

langflow/services/database/models/user/crud.py

@@ -2,12 +2,12 @@ from datetime import datetime, timezone
 from uuid import UUID
 
 from fastapi import HTTPException, status
+from lfx.log.logger import logger
 from sqlalchemy.exc import IntegrityError
 from sqlalchemy.orm.attributes import flag_modified
 from sqlmodel import select
 from sqlmodel.ext.asyncio.session import AsyncSession
 
-from langflow.logging.logger import logger
 from langflow.services.database.models.user.model import User, UserUpdate
 
 

langflow/services/database/service.py

@@ -13,6 +13,7 @@ import anyio
 import sqlalchemy as sa
 from alembic import command, util
 from alembic.config import Config
+from lfx.log.logger import logger
 from sqlalchemy import event, exc, inspect
 from sqlalchemy.dialects import sqlite as dialect_sqlite
 from sqlalchemy.engine import Engine
@@ -23,7 +24,6 @@ from sqlmodel.ext.asyncio.session import AsyncSession
 from tenacity import retry, stop_after_attempt, wait_fixed
 
 from langflow.initial_setup.constants import STARTER_FOLDER_NAME
-from langflow.logging.logger import logger
 from langflow.services.base import Service
 from langflow.services.database import models
 from langflow.services.database.models.user.crud import get_user_by_username
@@ -33,7 +33,7 @@ from langflow.services.deps import get_settings_service
 from langflow.services.utils import teardown_superuser
 
 if TYPE_CHECKING:
-    from langflow.services.settings.service import SettingsService
+    from lfx.services.settings.service import SettingsService
 
 
 class DatabaseService(Service):

langflow/services/database/utils.py

@@ -5,11 +5,10 @@ from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
 from alembic.util.exc import CommandError
+from lfx.log.logger import logger
 from sqlmodel import text
 from sqlmodel.ext.asyncio.session import AsyncSession
 
-from langflow.logging.logger import logger
-
 if TYPE_CHECKING:
     from langflow.services.database.service import DatabaseService
 

langflow/services/deps.py

@@ -3,12 +3,14 @@ from __future__ import annotations
 from contextlib import asynccontextmanager
 from typing import TYPE_CHECKING
 
-from langflow.logging.logger import logger
+from lfx.log.logger import logger
+
 from langflow.services.schema import ServiceType
 
 if TYPE_CHECKING:
     from collections.abc import AsyncGenerator
 
+    from lfx.services.settings.service import SettingsService
     from sqlmodel.ext.asyncio.session import AsyncSession
 
     from langflow.services.cache.service import AsyncBaseCacheService, CacheService
@@ -16,8 +18,6 @@ if TYPE_CHECKING:
     from langflow.services.database.service import DatabaseService
     from langflow.services.job_queue.service import JobQueueService
     from langflow.services.session.service import SessionService
-    from langflow.services.settings.service import SettingsService
-    from langflow.services.socket.service import SocketIOService
     from langflow.services.state.service import StateService
     from langflow.services.storage.service import StorageService
     from langflow.services.store.service import StoreService
@@ -39,12 +39,16 @@ def get_service(service_type: ServiceType, default=None):
         Any: The service instance.
 
     """
-    from langflow.services.manager import service_manager
+    from lfx.services.manager import get_service_manager
+
+    service_manager = get_service_manager()
 
-    if not service_manager.factories:
+    if not service_manager.are_factories_registered():
         # ! This is a workaround to ensure that the service manager is initialized
         # ! Not optimal, but it works for now
-        service_manager.register_factories()
+        from langflow.services.manager import ServiceManager
+
+        service_manager.register_factories(ServiceManager.get_factories())
     return service_manager.get(service_type, default)
 
 
@@ -81,15 +85,6 @@ def get_state_service() -> StateService:
     return get_service(ServiceType.STATE_SERVICE, StateServiceFactory())
 
 
-def get_socket_service() -> SocketIOService:
-    """Get the SocketIOService instance from the service manager.
-
-    Returns:
-        SocketIOService: The SocketIOService instance.
-    """
-    return get_service(ServiceType.SOCKETIO_SERVICE)  # type: ignore[attr-defined]
-
-
 def get_storage_service() -> StorageService:
     """Retrieves the storage service instance.
 
@@ -124,7 +119,7 @@ def get_settings_service() -> SettingsService:
     Raises:
         ValueError: If the service cannot be retrieved or initialized.
     """
-    from langflow.services.settings.factory import SettingsServiceFactory
+    from lfx.services.settings.factory import SettingsServiceFactory
 
     return get_service(ServiceType.SETTINGS_SERVICE, SettingsServiceFactory())
 
@@ -148,7 +143,7 @@ async def get_session() -> AsyncGenerator[AsyncSession, None]:
         AsyncSession: An async session object.
 
     """
-    async with get_db_service().with_session() as session:
+    async with session_scope() as session:
         yield session
 
 

langflow/services/enhanced_manager.py

@@ -0,0 +1,71 @@
+"""Enhanced ServiceManager that extends lfx's ServiceManager with langflow features."""
+
+from __future__ import annotations
+
+import importlib
+import inspect
+from typing import TYPE_CHECKING
+
+from lfx.log.logger import logger
+from lfx.services.manager import NoFactoryRegisteredError
+from lfx.services.manager import ServiceManager as BaseServiceManager
+from lfx.utils.concurrency import KeyedMemoryLockManager
+
+if TYPE_CHECKING:
+    from langflow.services.base import Service
+    from langflow.services.factory import ServiceFactory
+    from langflow.services.schema import ServiceType
+
+
+__all__ = ["NoFactoryRegisteredError", "ServiceManager"]
+
+
+class ServiceManager(BaseServiceManager):
+    """Enhanced ServiceManager with langflow factory system and dependency injection."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.register_factories()
+        self.keyed_lock = KeyedMemoryLockManager()
+
+    def register_factories(self, factories: list[ServiceFactory] | None = None) -> None:
+        """Register all available service factories."""
+        for factory in factories or self.get_factories():
+            try:
+                self.register_factory(factory)
+            except Exception:  # noqa: BLE001
+                logger.exception(f"Error initializing {factory}")
+
+    def get(self, service_name: ServiceType, default: ServiceFactory | None = None) -> Service:
+        """Get (or create) a service by its name with keyed locking."""
+        with self.keyed_lock.lock(service_name):
+            return super().get(service_name, default)
+
+    @classmethod
+    def get_factories(cls) -> list[ServiceFactory]:
+        """Auto-discover and return all service factories."""
+        from langflow.services.factory import ServiceFactory
+        from langflow.services.schema import ServiceType
+
+        service_names = [ServiceType(service_type).value.replace("_service", "") for service_type in ServiceType]
+        base_module = "langflow.services"
+        factories = []
+
+        for name in service_names:
+            try:
+                base_module = "lfx.services" if name == "settings" else "langflow.services"
+                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:
+                logger.exception(exc)
+                msg = f"Could not initialize services. Please check your settings. Error in {name}."
+                raise RuntimeError(msg) from exc
+
+        return factories

langflow/services/factory.py

@@ -1,26 +1,27 @@
 import importlib
 import inspect
-from typing import TYPE_CHECKING, get_type_hints
+from typing import get_type_hints
 
 from cachetools import LRUCache, cached
+from lfx.log.logger import logger
 
-from langflow.logging.logger import logger
+from langflow.services.base import Service
 from langflow.services.schema import ServiceType
 
-if TYPE_CHECKING:
-    from langflow.services.base import Service
-
 
 class ServiceFactory:
     def __init__(
         self,
-        service_class,
+        service_class: type[Service] | None = None,
     ) -> None:
+        if service_class is None:
+            msg = "service_class is required"
+            raise ValueError(msg)
         self.service_class = service_class
         self.dependencies = infer_service_types(self, import_all_services_into_a_dict())
 
     def create(self, *args, **kwargs) -> "Service":
-        raise self.service_class(*args, **kwargs)
+        return self.service_class(*args, **kwargs)
 
 
 def hash_factory(factory: ServiceFactory) -> str:
@@ -40,7 +41,9 @@ def hash_infer_service_types_args(factory: ServiceFactory, available_services=No
 @cached(cache=LRUCache(maxsize=10), key=hash_infer_service_types_args)
 def infer_service_types(factory: ServiceFactory, available_services=None) -> list["ServiceType"]:
     create_method = factory.create
+
     type_hints = get_type_hints(create_method, globalns=available_services)
+
     service_types = []
     for param_name, param_type in type_hints.items():
         # Skip the return type if it's included in type hints
@@ -85,4 +88,8 @@ def import_all_services_into_a_dict():
             logger.exception(exc)
             msg = "Could not initialize services. Please check your settings."
             raise RuntimeError(msg) from exc
+    # Import settings service from lfx
+    from lfx.services.settings.service import SettingsService
+
+    services["SettingsService"] = SettingsService
     return services

langflow/services/flow/flow_runner.py

@@ -4,20 +4,20 @@ from pathlib import Path
 from uuid import UUID, uuid4
 
 from aiofile import async_open
+from lfx.graph import Graph
+from lfx.graph.vertex.param_handler import ParameterHandler
+from lfx.log.logger import configure, logger
+from lfx.utils.util import update_settings
 from sqlmodel import delete, select, text
 
 from langflow.api.utils import cascade_delete_flow
-from langflow.graph import Graph
-from langflow.graph.vertex.param_handler import ParameterHandler
 from langflow.load.utils import replace_tweaks_with_env
-from langflow.logging.logger import configure, logger
 from langflow.processing.process import process_tweaks, run_graph
 from langflow.services.auth.utils import get_password_hash
 from langflow.services.cache.service import AsyncBaseCacheService
 from langflow.services.database.models import Flow, User, Variable
 from langflow.services.database.utils import initialize_database
 from langflow.services.deps import get_cache_service, get_storage_service, session_scope
-from langflow.utils.util import update_settings
 
 
 class LangflowRunnerExperimental:

langflow/services/job_queue/service.py

@@ -2,8 +2,9 @@ from __future__ import annotations
 
 import asyncio
 
+from lfx.log.logger import logger
+
 from langflow.events.event_manager import EventManager
-from langflow.logging.logger import logger
 from langflow.services.base import Service