langflow-base-nightly 1.7.0.dev19__py3-none-any.whl → 1.7.0.dev21__py3-none-any.whl

langflow/services/deps.py

@@ -1,12 +1,8 @@
 from __future__ import annotations
 
 from contextlib import asynccontextmanager
-from http import HTTPStatus
 from typing import TYPE_CHECKING
 
-from fastapi import HTTPException
-from lfx.log.logger import logger
-
 from langflow.services.schema import ServiceType
 
 if TYPE_CHECKING:
@@ -150,14 +146,8 @@ def get_db_service() -> DatabaseService:
 
 
 async def get_session() -> AsyncGenerator[AsyncSession, None]:
-    """Retrieves an async session from the database service.
-
-    Yields:
-        AsyncSession: An async session object.
-
-    """
-    async with session_scope() as session:
-        yield session
+    msg = "get_session is deprecated, use session_scope instead"
+    raise NotImplementedError(msg)
 
 
 @asynccontextmanager
@@ -175,27 +165,10 @@ async def session_scope() -> AsyncGenerator[AsyncSession, None]:
         Exception: If an error occurs during the session scope.
 
     """
-    db_service = get_db_service()
-    async with db_service.with_session() as session:
-        try:
-            yield session
-            await session.commit()
-        except Exception as e:
-            await session.rollback()
-
-            # Log at appropriate level based on error type
-            if isinstance(e, HTTPException):
-                if HTTPStatus.BAD_REQUEST.value <= e.status_code < HTTPStatus.INTERNAL_SERVER_ERROR.value:
-                    # Client errors (4xx) - log at info level
-                    await logger.ainfo(f"Client error during session scope: {e.status_code}: {e.detail}")
-                else:
-                    # Server errors (5xx) or other - log at error level
-                    await logger.aexception("An error occurred during the session scope.", exception=e)
-            else:
-                # Non-HTTP exceptions - log at error level
-                await logger.aexception("An error occurred during the session scope.", exception=e)
-
-            raise
+    from lfx.services.deps import session_scope as lfx_session_scope
+
+    async with lfx_session_scope() as session:
+        yield session
 
 
 def get_cache_service() -> CacheService | AsyncBaseCacheService:

langflow/services/flow/flow_runner.py

@@ -169,7 +169,7 @@ class LangflowRunnerExperimental:
             user_id = str(uuid4())
             user = User(id=user_id, username=user_id, password=get_password_hash(str(uuid4())), is_active=True)
             session.add(user)
-            await session.commit()
+            await session.flush()
             await session.refresh(user)
             return user
 
@@ -180,7 +180,6 @@ class LangflowRunnerExperimental:
                 name=flow_dict.get("name"), id=UUID(flow_dict["id"]), data=flow_dict.get("data", {}), user_id=user_id
             )
             session.add(flow_db)
-            await session.commit()
 
     @staticmethod
     async def run_graph(

langflow/services/storage/__init__.py

@@ -0,0 +1,5 @@
+from .local import LocalStorageService
+from .s3 import S3StorageService
+from .service import StorageService
+
+__all__ = ["LocalStorageService", "S3StorageService", "StorageService"]

langflow/services/storage/local.py

@@ -1,29 +1,69 @@
-import anyio
+"""Local file-based storage service for langflow."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
 from aiofile import async_open
-from lfx.log.logger import logger
 
-from .service import StorageService
+from langflow.logging.logger import logger
+from langflow.services.storage.service import StorageService
+
+if TYPE_CHECKING:
+    from langflow.services.session.service import SessionService
+    from langflow.services.settings.service import SettingsService
+
+# Constants for path parsing
+EXPECTED_PATH_PARTS = 2  # Path format: "flow_id/filename"
 
 
 class LocalStorageService(StorageService):
-    """A service class for handling local storage operations without aiofiles."""
+    """A service class for handling local file storage operations."""
+
+    def __init__(
+        self,
+        session_service: SessionService,
+        settings_service: SettingsService,
+    ) -> None:
+        """Initialize the local storage service.
 
-    def __init__(self, session_service, settings_service) -> None:
-        """Initialize the local storage service with session and settings services."""
+        Args:
+            session_service: Session service instance
+            settings_service: Settings service instance containing configuration
+        """
+        # Initialize base class with services
         super().__init__(session_service, settings_service)
-        self.set_ready()
+        # Base class already sets self.data_dir as anyio.Path from settings_service.settings.config_dir
+
+    def resolve_component_path(self, logical_path: str) -> str:
+        """Convert logical path to absolute filesystem path for local storage.
+
+        Args:
+            logical_path: Path in format "flow_id/filename"
+        Returns:
+            str: Absolute filesystem path
+        """
+        # Split the logical path into flow_id and filename
+        parts = logical_path.split("/", 1)
+        if len(parts) != EXPECTED_PATH_PARTS:
+            # Handle edge case - return as-is if format is unexpected
+            return logical_path
+
+        flow_id, file_name = parts
+        return self.build_full_path(flow_id, file_name)
 
     def build_full_path(self, flow_id: str, file_name: str) -> str:
         """Build the full path of a file in the local storage."""
         return str(self.data_dir / flow_id / file_name)
 
-    async def save_file(self, flow_id: str, file_name: str, data: bytes) -> None:
+    async def save_file(self, flow_id: str, file_name: str, data: bytes, *, append: bool = False) -> None:
         """Save a file in the local storage.
 
         Args:
             flow_id: The identifier for the flow.
             file_name: The name of the file to be saved.
             data: The byte content of the file.
+            append: If True, append to existing file; if False, overwrite.
 
         Raises:
             FileNotFoundError: If the specified flow does not exist.
@@ -35,9 +75,11 @@ class LocalStorageService(StorageService):
         file_path = folder_path / file_name
 
         try:
-            async with async_open(str(file_path), "wb") as f:
+            mode = "ab" if append else "wb"
+            async with async_open(str(file_path), mode) as f:
                 await f.write(data)
-            await logger.ainfo(f"File {file_name} saved successfully in flow {flow_id}.")
+            action = "appended to" if append else "saved"
+            await logger.ainfo(f"File {file_name} {action} successfully in flow {flow_id}.")
         except Exception:
             logger.exception(f"Error saving file {file_name} in flow {flow_id}")
             raise
@@ -67,40 +109,56 @@ class LocalStorageService(StorageService):
         logger.debug(f"File {file_name} retrieved successfully from flow {flow_id}.")
         return content
 
-    async def list_files(self, flow_id: str):
-        """List all files in a specified flow.
+    async def get_file_stream(self, flow_id: str, file_name: str, chunk_size: int = 8192):
+        """Retrieve a file from storage as a stream."""
+        file_path = self.data_dir / flow_id / file_name
+        if not await file_path.exists():
+            await logger.awarning(f"File {file_name} not found in flow {flow_id}.")
+            msg = f"File {file_name} not found in flow {flow_id}"
+            raise FileNotFoundError(msg)
+
+        async with async_open(str(file_path), "rb") as f:
+            while True:
+                chunk = await f.read(chunk_size)
+                if not chunk:
+                    break
+                yield chunk
+
+    async def list_files(self, flow_id: str) -> list[str]:
+        """List all files in a specific flow directory.
 
         Args:
             flow_id: The identifier for the flow.
 
         Returns:
-            A list of file names.
-
-        Raises:
-            FileNotFoundError: If the flow directory does not exist.
+            List of file names in the flow directory.
         """
         if not isinstance(flow_id, str):
             flow_id = str(flow_id)
+
         folder_path = self.data_dir / flow_id
         if not await folder_path.exists() or not await folder_path.is_dir():
             await logger.awarning(f"Flow {flow_id} directory does not exist.")
-            msg = f"Flow {flow_id} directory does not exist."
-            raise FileNotFoundError(msg)
-
-        files = [
-            file.name
-            async for file in await anyio.to_thread.run_sync(folder_path.iterdir)
-            if await anyio.Path(file).is_file()
-        ]
+            return []
 
-        await logger.ainfo(f"Listed {len(files)} files in flow {flow_id}.")
-        return files
+        try:
+            files = [p.name async for p in folder_path.iterdir() if await p.is_file()]
+        except Exception:  # noqa: BLE001
+            logger.exception(f"Error listing files in flow {flow_id}")
+            return []
+        else:
+            await logger.ainfo(f"Listed {len(files)} files in flow {flow_id}.")
+            return files
 
     async def delete_file(self, flow_id: str, file_name: str) -> None:
         """Delete a file from the local storage.
 
-        :param flow_id: The identifier for the flow.
-        :param file_name: The name of the file to be deleted.
+        Args:
+            flow_id: The identifier for the flow.
+            file_name: The name of the file to be deleted.
+
+        Raises:
+            FileNotFoundError: If the file does not exist.
         """
         file_path = self.data_dir / flow_id / file_name
         if await file_path.exists():
@@ -109,18 +167,33 @@ class LocalStorageService(StorageService):
         else:
             await logger.awarning(f"Attempted to delete non-existent file {file_name} in flow {flow_id}.")
 
-    async def teardown(self) -> None:
-        """Perform any cleanup operations when the service is being torn down."""
-        # No specific teardown actions required for local
+    async def get_file_size(self, flow_id: str, file_name: str) -> int:
+        """Get the size of a file in bytes.
+
+        Args:
+            flow_id: The identifier for the flow.
+            file_name: The name of the file.
 
-    async def get_file_size(self, flow_id: str, file_name: str):
-        """Get the size of a file in the local storage."""
-        # Get the file size from the file path
+        Returns:
+            The size of the file in bytes.
+
+        Raises:
+            FileNotFoundError: If the file does not exist.
+        """
         file_path = self.data_dir / flow_id / file_name
         if not await file_path.exists():
             await logger.awarning(f"File {file_name} not found in flow {flow_id}.")
             msg = f"File {file_name} not found in flow {flow_id}"
             raise FileNotFoundError(msg)
 
-        file_size_stat = await file_path.stat()
-        return file_size_stat.st_size
+        try:
+            file_size_stat = await file_path.stat()
+        except Exception:
+            logger.exception(f"Error getting size of file {file_name} in flow {flow_id}")
+            raise
+        else:
+            return file_size_stat.st_size
+
+    async def teardown(self) -> None:
+        """Perform any cleanup operations when the service is being torn down."""
+        # No specific teardown actions required for local