aird 0.4.23.dev12__tar.gz → 0.4.23.dev17__tar.gz

{aird-0.4.23.dev12 → aird-0.4.23.dev17}/MANIFEST.in

@@ -4,3 +4,4 @@ recursive-include aird/static/js *.js
 recursive-include aird/static/img *
 include aird/static/favicon.png
 include aird/static/favicon.ico
+include aird/static/favicon.svg

{aird-0.4.23.dev12/aird.egg-info → aird-0.4.23.dev17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aird
-Version: 0.4.23.dev12
+Version: 0.4.23.dev17
 Summary: Aird - A lightweight web-based file browser, editor, and streamer with real-time capabilities
 Home-page: https://github.com/blinkerbit/aird
 Author: Viswantha Srinivas P

{aird-0.4.23.dev12 → aird-0.4.23.dev17}/aird/constants/__init__.py

@@ -2,6 +2,7 @@
 
 import os
 import sys
+from pathlib import Path
 
 sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "../..")))
 from aird.cloud import CloudManager
@@ -100,6 +101,8 @@ UPLOAD_ALLOWED_EXTENSIONS = set(ALLOWED_UPLOAD_EXTENSIONS)
 # Mmap constants
 MMAP_MIN_SIZE = 1 * 1024 * 1024  # 1 MB
 CHUNK_SIZE = 64 * 1024  # 64 KB
+# WebSocket binary frame size (stay under Cloudflare ~1 MiB message limit)
+WS_TRANSFER_FRAME_BYTES = 768 * 1024
 
 # Network share manager (set at startup)
 NETWORK_SHARE_MANAGER = None
@@ -141,3 +144,42 @@ def _read_app_version() -> str:
 
 
 APP_VERSION = _read_app_version()
+
+_UI_PACKAGE_SUFFIXES = frozenset(
+    {".html", ".css", ".js", ".png", ".ico", ".svg", ".jpg", ".jpeg", ".webp", ".gif"}
+)
+_PKG_ROOT = Path(__file__).resolve().parent.parent
+_static_version_cache: tuple[float, str] | None = None
+_STATIC_VERSION_TTL = 2.0
+
+
+def _ui_fingerprint() -> str:
+    """Hex fingerprint from latest mtime among shipped UI package-data files."""
+    latest = 0
+    for sub in ("static", "templates"):
+        base = _PKG_ROOT / sub
+        if not base.is_dir():
+            continue
+        for path in base.rglob("*"):
+            if not path.is_file():
+                continue
+            if path.suffix.lower() not in _UI_PACKAGE_SUFFIXES:
+                continue
+            try:
+                latest = max(latest, path.stat().st_mtime_ns)
+            except OSError:
+                pass
+    return format(latest, "x")
+
+
+def get_static_version() -> str:
+    """Cache-bust query value: package version plus UI file fingerprint."""
+    import time
+
+    global _static_version_cache
+    now = time.monotonic()
+    if _static_version_cache and now - _static_version_cache[0] < _STATIC_VERSION_TTL:
+        return _static_version_cache[1]
+    version = f"{APP_VERSION}-{_ui_fingerprint()}"
+    _static_version_cache = (now, version)
+    return version

aird-0.4.23.dev17/aird/core/folder_size.py

@@ -0,0 +1,101 @@
+"""Incremental folder size calculation (sum of file sizes)."""
+
+from __future__ import annotations
+
+import os
+
+
+# Files processed per batch before yielding back to the event loop.
+FOLDER_SIZE_BATCH_FILES = 250
+
+
+class FolderSizeWalker:
+    """Walk a directory tree in batches without loading all paths at once."""
+
+    def __init__(self, root_abspath: str) -> None:
+        self._walk_gen = os.walk(root_abspath)
+        self._current_dir: str | None = None
+        self._pending_files: list[str] = []
+        self.total_bytes = 0
+        self.file_count = 0
+        self.done = False
+
+    def step(self, batch_size: int = FOLDER_SIZE_BATCH_FILES) -> tuple[int, int, bool]:
+        """Process up to *batch_size* files. Returns (total_bytes, file_count, done)."""
+        if self.done:
+            return self.total_bytes, self.file_count, True
+
+        processed = 0
+        while processed < batch_size and not self.done:
+            if not self._pending_files:
+                try:
+                    self._current_dir, _dirnames, filenames = next(self._walk_gen)
+                    self._pending_files = list(filenames)
+                except StopIteration:
+                    self.done = True
+                    break
+
+            while self._pending_files and processed < batch_size:
+                fname = self._pending_files.pop()
+                if not self._current_dir:
+                    continue
+                fpath = os.path.join(self._current_dir, fname)
+                try:
+                    if os.path.isfile(fpath):
+                        self.total_bytes += os.path.getsize(fpath)
+                except OSError:
+                    pass
+                self.file_count += 1
+                processed += 1
+
+        return self.total_bytes, self.file_count, self.done
+
+
+def norm_rel_path(rel_path: str) -> str:
+    return rel_path.replace("\\", "/").strip().strip("/")
+
+
+def resolve_folder_abspath(user_root: str, rel_path: str) -> str | None:
+    """Return absolute folder path or None if invalid / not a directory."""
+    from aird.core.security import is_within_root
+
+    rel = norm_rel_path(rel_path)
+    if not rel or ".." in rel.split("/"):
+        return None
+    abs_path = os.path.abspath(os.path.join(user_root, rel))
+    if not is_within_root(abs_path, user_root) or not os.path.isdir(abs_path):
+        return None
+    return abs_path
+
+
+def compute_folder_size(root_abspath: str) -> tuple[int, int]:
+    """Sum file sizes under *root_abspath*. Returns (total_bytes, file_count)."""
+    walker = FolderSizeWalker(root_abspath)
+    while not walker.done:
+        walker.step(FOLDER_SIZE_BATCH_FILES)
+    return walker.total_bytes, walker.file_count
+
+
+def norm_rel_path(rel_path: str) -> str:
+    return rel_path.replace("\\", "/").strip().strip("/")
+
+
+def resolve_folder_abspath(user_root: str, rel_path: str) -> str | None:
+    """Return absolute folder path or None if invalid / not a directory."""
+    from aird.core.security import is_within_root
+
+    rel = norm_rel_path(rel_path)
+    if not rel or ".." in rel.split("/"):
+        return None
+    abs_path = os.path.abspath(os.path.join(user_root, rel))
+    if not is_within_root(abs_path, user_root) or not os.path.isdir(abs_path):
+        return None
+    return abs_path
+
+
+def compute_folder_size(root_abspath: str) -> tuple[int, int]:
+    """Sum file sizes under *root_abspath*. Returns (total_bytes, file_count)."""
+    walker = FolderSizeWalker(root_abspath)
+    while not walker.done:
+        walker.step(FOLDER_SIZE_BATCH_FILES)
+    return walker.total_bytes, walker.file_count

{aird-0.4.23.dev12 → aird-0.4.23.dev17}/aird/core/mmap_handler.py

@@ -25,20 +25,50 @@ def _read_chunks_sync(
     return chunks
 
 
-def _read_chunks_mmap(
-    file_path: str, start: int, end: int | None, file_size: int, chunk_size: int
-) -> list[bytes]:
-    """Read file chunks using mmap."""
-    chunks = []
-    with open(file_path, "rb") as f:
-        with mmap.mmap(f.fileno(), 0, access=mmap.ACCESS_READ) as mm:
-            actual_end = min(end or file_size - 1, file_size - 1)
-            current = start
-            while current <= actual_end:
-                chunk_end = min(current + chunk_size, actual_end + 1)
-                chunks.append(mm[current:chunk_end])
-                current = chunk_end
-    return chunks
+class _SyncChunkReader:
+    """Read one chunk at a time from disk (mmap or plain file)."""
+
+    def __init__(
+        self,
+        file_path: str,
+        start: int,
+        end: int | None,
+        file_size: int,
+        chunk_size: int,
+        use_mmap: bool,
+    ) -> None:
+        self._file_path = file_path
+        self._pos = start
+        self._end = min(end if end is not None else file_size - 1, file_size - 1)
+        self._chunk_size = chunk_size
+        self._use_mmap = use_mmap
+        self._file = None
+        self._mm = None
+
+    def open(self) -> None:
+        self._file = open(self._file_path, "rb")
+        if self._use_mmap:
+            self._mm = mmap.mmap(self._file.fileno(), 0, access=mmap.ACCESS_READ)
+
+    def read_next(self) -> bytes | None:
+        if self._pos > self._end:
+            return None
+        chunk_end = min(self._pos + self._chunk_size, self._end + 1)
+        if self._mm is not None:
+            chunk = self._mm[self._pos : chunk_end]
+        else:
+            self._file.seek(self._pos)
+            chunk = self._file.read(chunk_end - self._pos)
+        self._pos = chunk_end
+        return chunk if chunk else None
+
+    def close(self) -> None:
+        if self._mm is not None:
+            self._mm.close()
+            self._mm = None
+        if self._file is not None:
+            self._file.close()
+            self._file = None
 
 
 class MMapFileHandler:
@@ -53,12 +83,11 @@ class MMapFileHandler:
     async def serve_file_chunk(
         file_path: str, start: int = 0, end: int = None, chunk_size: int = CHUNK_SIZE
     ):
-        """Serve file chunks using mmap for efficient memory usage"""
+        """Serve file chunks; only one chunk is held in memory at a time."""
         try:
             file_size = await asyncio.to_thread(os.path.getsize, file_path)
 
             if not MMapFileHandler.should_use_mmap(file_size):
-                # Use async file API for small files
                 remaining = (end - start + 1) if end is not None else file_size - start
                 async with aiofiles.open(file_path, "rb") as f:
                     await f.seek(start)
@@ -70,21 +99,33 @@ class MMapFileHandler:
                         remaining -= len(chunk)
                 return
 
-            # Use mmap for large files (run in thread pool - mmap requires sync fd)
-            chunks = await asyncio.to_thread(
-                _read_chunks_mmap, file_path, start, end, file_size, chunk_size
+            reader = _SyncChunkReader(
+                file_path, start, end, file_size, chunk_size, use_mmap=True
             )
-            for chunk in chunks:
-                yield chunk
+            try:
+                await asyncio.to_thread(reader.open)
+                while True:
+                    chunk = await asyncio.to_thread(reader.read_next)
+                    if not chunk:
+                        break
+                    yield chunk
+            finally:
+                await asyncio.to_thread(reader.close)
 
         except (OSError, ValueError):
-            # Fallback to traditional method on mmap errors (run in thread pool)
             file_size = await asyncio.to_thread(os.path.getsize, file_path)
-            chunks = await asyncio.to_thread(
-                _read_chunks_sync, file_path, start, end, file_size, chunk_size
+            reader = _SyncChunkReader(
+                file_path, start, end, file_size, chunk_size, use_mmap=False
             )
-            for chunk in chunks:
-                yield chunk
+            try:
+                await asyncio.to_thread(reader.open)
+                while True:
+                    chunk = await asyncio.to_thread(reader.read_next)
+                    if not chunk:
+                        break
+                    yield chunk
+            finally:
+                await asyncio.to_thread(reader.close)
 
     @staticmethod
     def find_line_offsets(file_path: str, max_lines: int = None) -> list[int]:

{aird-0.4.23.dev12 → aird-0.4.23.dev17}/aird/handlers/api_handlers.py

@@ -336,6 +336,59 @@ class FileStreamHandler(ManagedWebSocketMixin, tornado.websocket.WebSocketHandle
         return is_valid_websocket_origin(self, origin)
 
 
+class FolderSizeAPIHandler(BaseHandler):
+    """GET /api/folder-size?path= — recursive folder byte total (on demand)."""
+
+    @tornado.web.authenticated
+    async def get(self):
+        from aird.core.folder_size import (
+            compute_folder_size,
+            norm_rel_path,
+            resolve_folder_abspath,
+        )
+        from aird.utils.util import format_size
+
+        path = self.get_argument("path", "").strip()
+        norm_path = norm_rel_path(path)
+        decision = self.check_access("file.list", resource_path=norm_path)
+        if decision is not None and decision.is_deny:
+            self.set_status(403)
+            self.set_header("Content-Type", "application/json")
+            self.write(json.dumps({"error": decision.reason or "Access denied"}))
+            return
+
+        user_root = get_user_root(self)
+        abs_path = resolve_folder_abspath(user_root, path)
+        if not abs_path:
+            self.set_status(404)
+            self.set_header("Content-Type", "application/json")
+            self.write(json.dumps({"error": "Folder not found"}))
+            return
+
+        try:
+            total_bytes, file_count = await asyncio.to_thread(
+                compute_folder_size, abs_path
+            )
+        except Exception:
+            logging.exception("Folder size calculation failed for %s", norm_path)
+            self.set_status(500)
+            self.set_header("Content-Type", "application/json")
+            self.write(json.dumps({"error": "Folder size calculation failed"}))
+            return
+
+        self.set_header("Content-Type", "application/json")
+        self.write(
+            json.dumps(
+                {
+                    "path": norm_path,
+                    "bytes": total_bytes,
+                    "files": file_count,
+                    "size_str": format_size(total_bytes),
+                }
+            )
+        )
+
+
 class FileListAPIHandler(BaseHandler):
     @tornado.web.authenticated
     @require_action("file.list", resource_arg="path")

{aird-0.4.23.dev12 → aird-0.4.23.dev17}/aird/handlers/base_handler.py

@@ -897,7 +897,7 @@ class BaseHandler(tornado.web.RequestHandler):
         namespace.setdefault("nav_title", "")
         namespace.setdefault("show_admin_link", False)
         namespace.setdefault("ldap_enabled", self.settings.get("ldap_server") is not None)
-        namespace.setdefault("static_version", constants_module.APP_VERSION)
+        namespace.setdefault("static_version", constants_module.get_static_version())
         return namespace
 
     def get_current_user(self):

{aird-0.4.23.dev12 → aird-0.4.23.dev17}/aird/handlers/transfer_ws_handlers.py

@@ -21,6 +21,7 @@ from aird.constants.file_ops import (
     FILE_UPLOAD_DISABLED,
     UPLOAD_SAVE_FAILED,
 )
+from aird.constants import WS_TRANSFER_FRAME_BYTES
 from aird.core.mmap_handler import MMapFileHandler
 from aird.core.security import is_valid_websocket_origin, is_within_root
 from aird.handlers.base_handler import (
@@ -108,7 +109,8 @@ class FileTransferWebSocketHandler(
         super().__init__(application, request, **kwargs)
         self._upload: dict | None = None
         self._upload_buffer: deque[bytes] = deque()
-        self._upload_writing = False
+        self._upload_buffer_event = asyncio.Event()
+        self._upload_writer_done = False
         self._upload_writer_task: asyncio.Task | None = None
         self._cancelled = False
         self._download_task: asyncio.Task | None = None
@@ -199,6 +201,9 @@ class FileTransferWebSocketHandler(
             "temp_path": temp_path,
             "aiofile": aiofile,
         }
+        self._upload_writer_done = False
+        self._upload_buffer_event.clear()
+        self._upload_writer_task = asyncio.create_task(self._upload_writer_loop())
         await self._send_json({"type": "upload_started", "total_size": total_size})
 
     async def _handle_upload_binary(self, data: bytes) -> None:
@@ -212,31 +217,40 @@ class FileTransferWebSocketHandler(
             return
 
         self._upload_buffer.append(data)
-        if not self._upload_writing:
-            self._upload_writing = True
-            self._upload_writer_task = asyncio.create_task(self._drain_upload_buffer())
+        self._upload_buffer_event.set()
 
-    async def _drain_upload_buffer(self) -> None:
+    async def _upload_writer_loop(self) -> None:
+        """Drain the upload buffer continuously until signalled to stop."""
         try:
-            while self._upload_buffer and self._upload:
-                chunk = self._upload_buffer.popleft()
-                await self._upload["aiofile"].write(chunk)
-            if self._upload:
-                await self._upload["aiofile"].flush()
-        finally:
-            self._upload_writing = False
+            while True:
+                await self._upload_buffer_event.wait()
+                self._upload_buffer_event.clear()
+                while self._upload_buffer and self._upload:
+                    chunk = self._upload_buffer.popleft()
+                    await self._upload["aiofile"].write(chunk)
+                if self._upload:
+                    await self._upload["aiofile"].flush()
+                if self._upload_writer_done:
+                    return
+        except asyncio.CancelledError:
+            pass
+        except Exception:
+            logger.debug("WS upload writer loop failed", exc_info=True)
 
     async def _finalize_upload_writer(self) -> None:
+        self._upload_writer_done = True
+        self._upload_buffer_event.set()
         if self._upload_writer_task is not None:
             try:
                 await self._upload_writer_task
             except Exception:
-                logging.debug("WS upload writer await failed", exc_info=True)
+                logger.debug("WS upload writer await failed", exc_info=True)
+            self._upload_writer_task = None
         if self._upload and self._upload.get("aiofile"):
             try:
                 await self._upload["aiofile"].close()
             except Exception:
-                logging.debug("WS upload file close failed", exc_info=True)
+                logger.debug("WS upload file close failed", exc_info=True)
             self._upload["aiofile"] = None
 
     async def _abort_upload(self, message: str | None = None) -> None:
@@ -339,12 +353,16 @@ class FileTransferWebSocketHandler(
                     "filename": filename,
                     "content_type": content_type,
                     "size": file_size,
+                    "chunk_size": WS_TRANSFER_FRAME_BYTES,
                 }
             )
-            async for chunk in MMapFileHandler.serve_file_chunk(abs_path):
+            async for chunk in MMapFileHandler.serve_file_chunk(
+                abs_path, chunk_size=WS_TRANSFER_FRAME_BYTES
+            ):
                 if self._cancelled:
                     return
                 await self.write_message(chunk, binary=True)
+                await asyncio.sleep(0)
             await self._send_json({"type": "download_end"})
         except asyncio.CancelledError:
             raise

{aird-0.4.23.dev12 → aird-0.4.23.dev17}/aird/handlers/view_handlers.py

@@ -506,18 +506,31 @@ class TaggedFilesHandler(BaseHandler):
         patterns = [r["glob_pattern"] for r in rules if r.get("tag") == tag_name]
         all_tags = sorted({r["tag"] for r in rules if r.get("tag")})
 
-        files: list[str] = []
+        entries: list[dict] = []
+        file_count = 0
+        folder_count = 0
         if patterns:
             root = constants_module.ROOT_DIR
-            files = get_files_by_tag_patterns(patterns, root)
+            for path in get_files_by_tag_patterns(patterns, root):
+                is_dir = path.endswith("/")
+                if is_dir:
+                    folder_count += 1
+                    name = path.rstrip("/")
+                else:
+                    file_count += 1
+                    name = path
+                entries.append({"path": path, "name": name, "is_dir": is_dir})
 
         self.render(
             "tagged_files.html",
             tag_name=tag_name,
             patterns=patterns,
-            files=files,
+            entries=entries,
+            file_count=file_count,
+            folder_count=folder_count,
             all_tags=all_tags,
             user=self.current_user,
+            get_file_icon=get_file_icon,
         )
 
 

{aird-0.4.23.dev12 → aird-0.4.23.dev17}/aird/main.py

@@ -89,6 +89,7 @@ from aird.handlers.api_handlers import (
     FeatureFlagAPIHandler,
     FeatureFlagSocketHandler,
     FileListAPIHandler,
+    FolderSizeAPIHandler,
     FileStreamHandler,
     ShareDetailsAPIHandler,
     ShareDetailsByIdAPIHandler,
@@ -105,7 +106,6 @@ from aird.handlers.auth_handlers import (
     MandatoryPasswordHandler,
     ProfileHandler,
 )
-from aird.handlers.folder_size_ws_handlers import FolderSizeWebSocketHandler
 from aird.handlers.transfer_ws_handlers import FileTransferWebSocketHandler
 from aird.handlers.file_op_handlers import (
     CloudUploadHandler,
@@ -237,7 +237,7 @@ def make_app(
         (r"/ws/policy-decisions", PolicyDecisionsWebSocket),
         (r"/stream/(.*)", FileStreamHandler),
         (r"/ws/file-transfer", FileTransferWebSocketHandler),
-        (r"/ws/folder-sizes", FolderSizeWebSocketHandler),
+        (r"/api/folder-size", FolderSizeAPIHandler),
         (r"/features", FeatureFlagSocketHandler),
         (r"/api/features", FeatureFlagAPIHandler),
         (r"/upload", UploadHandler),