aird 0.4.23.dev22__tar.gz → 0.4.25.dev1__tar.gz

{aird-0.4.23.dev22/aird.egg-info → aird-0.4.25.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aird
-Version: 0.4.23.dev22
+Version: 0.4.25.dev1
 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
@@ -19,11 +19,11 @@ Requires-Dist: aiofiles>=23.0.0
 Requires-Dist: argon2-cffi>=23.1.0
 Requires-Dist: requests>=2.31.0
 Requires-Dist: chardet<6.0.0,>=5.0.0
-Requires-Dist: pysmbserver>=0.1.0; python_version >= "3.13"
-Requires-Dist: wsgidav>=4.3.0
-Requires-Dist: cheroot>=10.0.0
 Requires-Dist: pyasn1>=0.6.2
 Requires-Dist: webauthn>=2.0.0
+Provides-Extra: compress
+Requires-Dist: zstandard>=0.22.0; extra == "compress"
+Requires-Dist: brotli>=1.1.0; extra == "compress"
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier
@@ -32,6 +32,7 @@ Dynamic: description-content-type
 Dynamic: home-page
 Dynamic: license
 Dynamic: license-file
+Dynamic: provides-extra
 Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary

{aird-0.4.23.dev22 → aird-0.4.25.dev1}/aird/cli/session.py

@@ -14,10 +14,16 @@ from urllib.parse import quote, urljoin
 import requests
 
 from aird.cli.config import ensure_config_dir, get_authelia_url, get_server_url, session_path
+from aird.cli.transfer_http import (
+    DEFAULT_CONCURRENCY,
+    download_file_ranged,
+    upload_file_ranged,
+)
 
 logger = logging.getLogger(__name__)
 
 XSRF_COOKIE = "_xsrf"
+LARGE_CLI_TRANSFER_BYTES = 100 * 1024 * 1024
 
 
 def _remote_url(base_path: str, remote_path: str) -> str:
@@ -266,10 +272,26 @@ class AirdClient:
                 size = int(entry.get("size_bytes") or entry.get("size") or 0)
                 yield child, size
 
-    def download_file(self, remote_path: str, local_path: Path) -> None:
+    def download_file(self, remote_path: str, local_path: Path, *, workers: int = 2) -> None:
         self.ensure_auth()
         url = self._url(_remote_url("/files", remote_path)) + "?download=1"
         local_path.parent.mkdir(parents=True, exist_ok=True)
+        head = self.http.head(url, timeout=120)
+        if head.status_code >= 400:
+            raise AirdAPIError(
+                f"Download failed for {remote_path} (HTTP {head.status_code})",
+                head.status_code,
+            )
+        total = int(head.headers.get("Content-Length") or 0)
+        if total >= LARGE_CLI_TRANSFER_BYTES:
+            download_file_ranged(
+                self.http,
+                self.server.rstrip("/"),
+                remote_path,
+                local_path,
+                workers=max(1, workers or DEFAULT_CONCURRENCY),
+            )
+            return
         with self.http.get(url, stream=True, timeout=300) as r:
             if r.status_code >= 400:
                 raise AirdAPIError(
@@ -281,6 +303,41 @@ class AirdClient:
                     if chunk:
                         f.write(chunk)
 
+    def upload_file(
+        self, local_path: Path, remote_dir: str = "", *, workers: int = 2
+    ) -> None:
+        self.ensure_auth()
+        if not local_path.is_file():
+            raise FileNotFoundError(local_path)
+        remote_dir = remote_dir.strip("/")
+        filename = local_path.name
+        size = local_path.stat().st_size
+        if size >= LARGE_CLI_TRANSFER_BYTES:
+            upload_file_ranged(
+                self.http,
+                self.server.rstrip("/"),
+                self._xsrf_header(),
+                local_path,
+                remote_dir,
+                workers=max(1, workers or DEFAULT_CONCURRENCY),
+            )
+            return
+        r = self.http.post(
+            self._url("/upload"),
+            params={"upload_dir": remote_dir, "upload_filename": filename},
+            data=local_path.read_bytes(),
+            headers={
+                **self._xsrf_header(),
+                "Content-Type": "application/octet-stream",
+            },
+            timeout=600,
+        )
+        if r.status_code >= 400:
+            raise AirdAPIError(
+                f"Upload failed for {filename} (HTTP {r.status_code})",
+                r.status_code,
+            )
+
     def download_tree(
         self,
         remote_dir: str,
@@ -314,27 +371,6 @@ class AirdClient:
                     on_progress(path)
         return count
 
-    def upload_file(self, local_path: Path, remote_dir: str = "") -> None:
-        self.ensure_auth()
-        if not local_path.is_file():
-            raise FileNotFoundError(local_path)
-        remote_dir = remote_dir.strip("/")
-        filename = local_path.name
-        r = self.http.post(
-            self._url("/upload"),
-            params={"upload_dir": remote_dir, "upload_filename": filename},
-            data=local_path.read_bytes(),
-            headers={
-                **self._xsrf_header(),
-                "Content-Type": "application/octet-stream",
-            },
-            timeout=600,
-        )
-        if r.status_code >= 400:
-            raise AirdAPIError(
-                f"Upload failed for {filename} (HTTP {r.status_code})",
-                r.status_code,
-            )
 
     def upload_tree(
         self,

aird-0.4.25.dev1/aird/cli/transfer_http.py

@@ -0,0 +1,175 @@
+"""Parallel HTTP Range upload/download for aird-cli."""
+
+from __future__ import annotations
+
+import math
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from pathlib import Path
+from typing import Any, Callable
+
+import requests
+
+
+DEFAULT_CHUNK = 32 * 1024 * 1024
+DEFAULT_CONCURRENCY = 4
+
+
+def _clone_session(http: requests.Session) -> requests.Session:
+    s = requests.Session()
+    s.cookies.update(http.cookies)
+    s.headers.update(getattr(http, "headers", {}))
+    return s
+
+
+def _range_session(
+    http: requests.Session,
+    base_url: str,
+    xsrf_header: dict[str, str],
+    upload_dir: str,
+    filename: str,
+    total_size: int,
+) -> str:
+    r = http.post(
+        f"{base_url}/api/upload/range/session",
+        json={
+            "upload_dir": upload_dir.strip("/"),
+            "filename": filename,
+            "total_size": total_size,
+        },
+        headers={"Content-Type": "application/json", **xsrf_header},
+        timeout=120,
+    )
+    if r.status_code >= 400:
+        raise RuntimeError(f"Range session failed ({r.status_code}): {r.text}")
+    return r.json()["upload_id"]
+
+
+def _put_chunk(
+    http: requests.Session,
+    base_url: str,
+    xsrf_header: dict[str, str],
+    upload_id: str,
+    data: bytes,
+    start: int,
+    end: int,
+    total_size: int,
+) -> bool:
+    r = http.put(
+        f"{base_url}/api/upload/range/{upload_id}",
+        data=data,
+        headers={
+            "Content-Type": "application/octet-stream",
+            "Content-Range": f"bytes {start}-{end}/{total_size}",
+            **xsrf_header,
+        },
+        timeout=600,
+    )
+    if r.status_code == 201:
+        return True
+    if r.status_code not in (200, 201):
+        raise RuntimeError(f"Chunk upload failed ({r.status_code}): {r.text}")
+    return False
+
+
+def upload_file_ranged(
+    http: requests.Session,
+    base_url: str,
+    xsrf_header: dict[str, str],
+    local_path: Path,
+    remote_dir: str = "",
+    *,
+    chunk_size: int = DEFAULT_CHUNK,
+    workers: int = DEFAULT_CONCURRENCY,
+    on_progress: Callable[[int, int], None] | None = None,
+) -> None:
+    total = local_path.stat().st_size
+    filename = local_path.name
+    upload_id = _range_session(
+        http, base_url, xsrf_header, remote_dir, filename, total
+    )
+    total_chunks = math.ceil(total / chunk_size)
+    done_bytes = 0
+    lock = __import__("threading").Lock()
+
+    def _job(idx: int) -> bool:
+        start = idx * chunk_size
+        end = min(start + chunk_size, total) - 1
+        with local_path.open("rb") as f:
+            f.seek(start)
+            data = f.read(end - start + 1)
+        return _put_chunk(
+            _clone_session(http),
+            base_url,
+            xsrf_header,
+            upload_id,
+            data,
+            start,
+            end,
+            total,
+        )
+
+    finished = False
+    with ThreadPoolExecutor(max_workers=max(1, workers)) as pool:
+        futures = {pool.submit(_job, i): i for i in range(total_chunks)}
+        for fut in as_completed(futures):
+            if fut.result():
+                finished = True
+            with lock:
+                done_bytes = min(total, done_bytes + chunk_size)
+                if on_progress:
+                    on_progress(min(done_bytes, total), total)
+    if not finished and done_bytes < total:
+        raise RuntimeError("Ranged upload did not complete")
+
+
+def download_file_ranged(
+    http: requests.Session,
+    base_url: str,
+    remote_path: str,
+    local_path: Path,
+    *,
+    chunk_size: int = DEFAULT_CHUNK,
+    workers: int = DEFAULT_CONCURRENCY,
+    on_progress: Callable[[int, int], None] | None = None,
+) -> None:
+    enc = "/".join(requests.utils.quote(p) for p in remote_path.strip("/").split("/") if p)
+    url = f"{base_url}/files/{enc}?download=1" if enc else f"{base_url}/files/?download=1"
+    head = http.head(url, timeout=120)
+    if head.status_code >= 400:
+        raise RuntimeError(f"HEAD failed ({head.status_code})")
+    total = int(head.headers.get("Content-Length") or 0)
+    if total <= 0:
+        raise RuntimeError("Missing Content-Length for ranged download")
+
+    local_path.parent.mkdir(parents=True, exist_ok=True)
+    with local_path.open("wb") as out:
+        out.truncate(total)
+
+    total_chunks = math.ceil(total / chunk_size)
+    done_bytes = 0
+    lock = __import__("threading").Lock()
+
+    def _job(idx: int) -> int:
+        start = idx * chunk_size
+        end = min(start + chunk_size, total) - 1
+        sess = _clone_session(http)
+        r = sess.get(
+            url,
+            headers={"Range": f"bytes={start}-{end}"},
+            timeout=600,
+        )
+        if r.status_code not in (200, 206):
+            raise RuntimeError(f"Range GET failed ({r.status_code})")
+        with local_path.open("r+b") as f:
+            f.seek(start)
+            f.write(r.content)
+        return len(r.content)
+
+    with ThreadPoolExecutor(max_workers=max(1, workers)) as pool:
+        futures = [pool.submit(_job, i) for i in range(total_chunks)]
+        for fut in as_completed(futures):
+            n = fut.result()
+            with lock:
+                done_bytes += n
+                if on_progress:
+                    on_progress(min(done_bytes, total), total)

{aird-0.4.23.dev22 → aird-0.4.25.dev1}/aird/constants/__init__.py

@@ -44,6 +44,9 @@ FEATURE_FLAGS = {
     "abac_audit_decisions": True,
     "email_notifications": False,
     "webauthn": False,
+    "smb_server": False,
+    "webdav_server": False,
+    "transfer_sendfile": False,
 }
 
 # WebSocket connection configuration
@@ -60,15 +63,48 @@ WEBSOCKET_CONFIG = {
 UPLOAD_CONFIG = {
     "max_file_size_mb": 512,  # Default max upload file size in MB
     "allow_all_file_types": 0,  # 0 = use whitelist below, 1 = allow any extension
+    # 0 = stream via single POST up to max_file_size_mb; set lower (e.g. 90) behind reverse proxies
+    "single_request_max_mb": 0,
 }
 
-# File operation constants (derived from UPLOAD_CONFIG at startup)
+# File operation constants (derived from UPLOAD_CONFIG; call refresh_upload_derived_constants after changes)
 MAX_FILE_SIZE = UPLOAD_CONFIG["max_file_size_mb"] * 1024 * 1024
-# HTTP /upload body limit (browser small uploads + CLI)
 UPLOAD_REQUEST_MAX_BODY_SIZE = MAX_FILE_SIZE + (1024 * 1024)
-# Files below this use single POST /upload; at or above use Content-Range API
-LARGE_FILE_THRESHOLD_BYTES = 500 * 1024 * 1024
-RANGE_CHUNK_BYTES = 16 * 1024 * 1024
+LARGE_FILE_THRESHOLD_BYTES = MAX_FILE_SIZE
+RANGE_CHUNK_BYTES = 32 * 1024 * 1024
+RANGE_UPLOAD_CONCURRENCY = 4
+RANGE_DOWNLOAD_CONCURRENCY = 4
+
+COMPRESSION_CONFIG = {
+    "mode": "wan_only",
+    "level": 6,
+    "algorithms": ["zstd", "br", "gzip"],
+    "min_bytes": 1024,
+    "max_bytes": 50 * 1024 * 1024,
+}
+
+TRANSFER_CONFIG = {
+    "upload_mb_per_sec": 0,
+    "download_mb_per_sec": 0,
+    "burst_mb": 64,
+    "max_concurrent": 0,
+}
+
+
+def refresh_upload_derived_constants() -> None:
+    """Recompute upload size limits after UPLOAD_CONFIG is loaded or changed."""
+    global MAX_FILE_SIZE, UPLOAD_REQUEST_MAX_BODY_SIZE, LARGE_FILE_THRESHOLD_BYTES
+    MAX_FILE_SIZE = UPLOAD_CONFIG["max_file_size_mb"] * 1024 * 1024
+    UPLOAD_REQUEST_MAX_BODY_SIZE = MAX_FILE_SIZE + (1024 * 1024)
+    single_mb = int(UPLOAD_CONFIG.get("single_request_max_mb", 0) or 0)
+    if single_mb <= 0:
+        single_mb = UPLOAD_CONFIG["max_file_size_mb"]
+    else:
+        single_mb = min(single_mb, UPLOAD_CONFIG["max_file_size_mb"])
+    LARGE_FILE_THRESHOLD_BYTES = single_mb * 1024 * 1024
+
+
+refresh_upload_derived_constants()
 # Max JSON WebSocket control message size (search, stream commands, P2P signaling)
 WS_JSON_MESSAGE_MAX_BYTES = 64 * 1024
 MAX_READABLE_FILE_SIZE = 50 * 1024 * 1024  # 50 MB

{aird-0.4.23.dev22 → aird-0.4.25.dev1}/aird/constants/admin.py

@@ -16,6 +16,8 @@ URL_ADMIN_NETWORK_SHARES = "/admin/network-shares"
 ERR_DB_UNAVAILABLE = "Database+unavailable"
 ERR_ALL_FIELDS_REQUIRED = "All+fields+are+required"
 ERR_INVALID_PROTOCOL = "Invalid+protocol"
+ERR_SMB_UNAVAILABLE = "SMB+server+is+disabled+or+pysmbserver+is+not+installed"
+ERR_WEBDAV_UNAVAILABLE = "WebDAV+server+is+disabled+or+wsgidav+is+not+installed"
 ERR_FOLDER_NOT_EXIST = "Folder+does+not+exist"
 ERR_PORT_RANGE = "Port+must+be+1-65535"
 ERR_FAILED_CREATE_SHARE = "Failed+to+create+share"

aird-0.4.25.dev1/aird/core/compression.py

@@ -0,0 +1,171 @@
+"""HTTP response compression: zstd, brotli, gzip with streaming."""
+
+from __future__ import annotations
+
+import asyncio
+import gzip
+import io
+import logging
+import os
+from typing import AsyncIterator
+
+logger = logging.getLogger(__name__)
+
+_COMPRESSIBLE_MIME_PREFIXES = (
+    "text/",
+    "application/json",
+    "application/javascript",
+    "application/xml",
+    "application/yaml",
+    "application/x-yaml",
+)
+
+_INCOMPRESSIBLE_EXTENSIONS = frozenset(
+    {
+        ".gz",
+        ".zip",
+        ".bz2",
+        ".xz",
+        ".7z",
+        ".rar",
+        ".mp4",
+        ".webm",
+        ".mp3",
+        ".wav",
+        ".jpg",
+        ".jpeg",
+        ".png",
+        ".webp",
+        ".gif",
+        ".ico",
+        ".pdf",
+        ".br",
+        ".zst",
+        ".zstd",
+    }
+)
+
+_zstd_available = False
+_brotli_available = False
+
+try:
+    import zstandard as _zstd  # noqa: F401
+
+    _zstd_available = True
+except ImportError:
+    _zstd = None
+
+try:
+    import brotli as _brotli  # noqa: F401
+
+    _brotli_available = True
+except ImportError:
+    _brotli = None
+
+
+def codecs_available() -> dict[str, bool]:
+    return {"zstd": _zstd_available, "br": _brotli_available, "gzip": True}
+
+
+def negotiate_encoding(accept_header: str | None, enabled: list[str] | None = None) -> str | None:
+    """Pick best Content-Encoding from Accept-Encoding (zstd > br > gzip)."""
+    if not accept_header:
+        return None
+    allowed = enabled or ["zstd", "br", "gzip"]
+    tokens: dict[str, float] = {}
+    for part in accept_header.split(","):
+        piece = part.strip()
+        if not piece:
+            continue
+        if ";" in piece:
+            name, _, qpart = piece.partition(";")
+            qval = 1.0
+            if "q=" in qpart:
+                try:
+                    qval = float(qpart.split("q=", 1)[1].strip())
+                except ValueError:
+                    qval = 0.0
+        else:
+            name, qval = piece, 1.0
+        name = name.strip().lower()
+        if qval > 0:
+            tokens[name] = max(tokens.get(name, 0.0), qval)
+    for codec in ("zstd", "br", "gzip"):
+        if codec in allowed and codec in tokens:
+            if codec == "zstd" and not _zstd_available:
+                continue
+            if codec == "br" and not _brotli_available:
+                continue
+            return codec
+    return None
+
+
+def _ip_in_corporate(remote_ip: str, cidrs: list[str]) -> bool:
+    if not remote_ip or not cidrs:
+        return False
+    try:
+        import ipaddress
+
+        addr = ipaddress.ip_address(remote_ip)
+        for cidr in cidrs:
+            if addr in ipaddress.ip_network(cidr, strict=False):
+                return True
+    except ValueError:
+        pass
+    return False
+
+
+def should_compress(
+    *,
+    path: str,
+    mime_type: str,
+    file_size: int,
+    has_range: bool,
+    remote_ip: str,
+    compression_enabled: bool,
+    mode: str = "wan_only",
+    min_bytes: int = 1024,
+    max_bytes: int = 50 * 1024 * 1024,
+    corporate_cidrs: list[str] | None = None,
+) -> bool:
+    if not compression_enabled or has_range:
+        return False
+    if file_size < min_bytes or file_size > max_bytes:
+        return False
+    ext = os.path.splitext(path)[1].lower()
+    if ext in _INCOMPRESSIBLE_EXTENSIONS:
+        return False
+    if not any(mime_type.startswith(p) for p in _COMPRESSIBLE_MIME_PREFIXES):
+        return False
+    if mode == "never":
+        return False
+    if mode == "wan_only" and _ip_in_corporate(remote_ip, corporate_cidrs or []):
+        return False
+    return True
+
+
+def _compress_file_sync(path: str, encoding: str, level: int) -> bytes:
+    with open(path, "rb") as f_in:
+        raw = f_in.read()
+    if encoding == "zstd":
+        cctx = _zstd.ZstdCompressor(level=level)
+        return cctx.compress(raw)
+    if encoding == "br":
+        return _brotli.compress(raw, quality=min(level, 11))
+    buf = io.BytesIO()
+    with gzip.GzipFile(fileobj=buf, mode="wb", compresslevel=min(level, 9)) as gz:
+        gz.write(raw)
+    return buf.getvalue()
+
+
+async def compress_file(path: str, encoding: str, level: int = 6) -> bytes:
+    return await asyncio.to_thread(_compress_file_sync, path, encoding, level)
+
+
+async def stream_uncompressed(path: str, chunk_size: int = 65536) -> AsyncIterator[bytes]:
+    with open(path, "rb") as f:
+        while True:
+            chunk = await asyncio.to_thread(f.read, chunk_size)
+            if not chunk:
+                break
+            yield chunk

aird-0.4.25.dev1/aird/core/file_send.py

@@ -0,0 +1,58 @@
+"""Zero-copy file send via os.sendfile (Linux)."""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import os
+import sys
+
+logger = logging.getLogger(__name__)
+
+_SENDFILE_CHUNK = 8 * 1024 * 1024
+
+
+def sendfile_available() -> bool:
+    return sys.platform.startswith("linux") and hasattr(os, "sendfile")
+
+
+def _sendfile_sync(out_fd: int, in_fd: int, offset: int, count: int) -> int:
+    sent = 0
+    while sent < count:
+        n = os.sendfile(out_fd, in_fd, offset + sent, min(_SENDFILE_CHUNK, count - sent))
+        if n <= 0:
+            break
+        sent += n
+    return sent
+
+
+async def sendfile_to_socket(
+    sock,
+    file_path: str,
+    start: int = 0,
+    length: int | None = None,
+) -> bool:
+    """Send file bytes to socket via sendfile. Returns False if unsupported or failed."""
+    if not sendfile_available():
+        return False
+    try:
+        out_fd = sock.fileno()
+    except (AttributeError, OSError):
+        return False
+    try:
+        file_size = os.path.getsize(file_path)
+        end = file_size if length is None else start + length
+        count = min(end, file_size) - start
+        if count <= 0:
+            return True
+
+        def _run() -> int:
+            with open(file_path, "rb") as f:
+                in_fd = f.fileno()
+                return _sendfile_sync(out_fd, in_fd, start, count)
+
+        sent = await asyncio.to_thread(_run)
+        return sent >= count
+    except OSError:
+        logger.debug("sendfile failed for %s", file_path, exc_info=True)
+        return False