Skip to content

Qwen3.8-Flash-Next on any consumer hardware: one-click install for Windows / Linux. Strata inference engine, OpenAI/Anthropic API on localhost, optional image input.

C++
5.8 KB
Raw Blame
"""Windows path length (MAX_PATH).

A Windows PC with "long paths" off (the default on a fresh install) refuses any ordinary file path of 260 characters or more.
The AMD engine packages hold paths up to 149 characters (hipBLASLt tensile libraries), so under a long user name the unpacked
engine can go past the limit. Two defences, neither of which needs a setting from the user:

* every file Strata itself touches inside a component folder goes through `long_path`, which turns the path into the
  extended-length form (``\\\\?\\C:\\...``) that Windows accepts at any length (up to 32,767 characters);
* when a folder is still too deep for the engine's *own* file loading (the GPU math libraries open their files with ordinary
  paths), `warning_for` gives one plain sentence with the fix; the install continues (recommend, never refuse).

Nothing here reads or writes the registry. `plain_long_paths_work` finds out by trying.
"""
from __future__ import annotations

import os
import shutil
import uuid
from pathlib import Path

#: the longest ordinary path Windows accepts with long paths off (MAX_PATH is 260 including the terminating null)
PLAIN_LIMIT = 259
_PREFIX = "\\\\?\\"
_UNC_PREFIX = "\\\\?\\UNC\\"

#: longest path inside an engine package, by backend, as shipped in 0.2.1 (hip: rocm/bin/hipblaslt/library/gfx1200/TensileLibrary_...).
#: The warning before a download can only estimate; after unpacking the real manifest is measured.
LONGEST_IN_PACKAGE = {"hip": 150}
LONGEST_IN_PACKAGE_DEFAULT = 60


def long_path(path) -> Path:
    """`path` in the form that works at any length: absolute, normalised, with the ``\\\\?\\`` prefix on Windows. Elsewhere unchanged."""
    p = Path(path)
    if os.name != "nt":
        return p
    text = str(p)
    if text.startswith(_PREFIX):
        return p
    text = os.path.normpath(os.path.abspath(text))
    if text.startswith("\\\\"):
        return Path(_UNC_PREFIX + text[2:])
    return Path(_PREFIX + text)


def plain(path) -> str:
    """The path as a person would read it, without the extended-length prefix."""
    text = str(path)
    if text.startswith(_UNC_PREFIX):
        return "\\\\" + text[len(_UNC_PREFIX):]
    return text[len(_PREFIX):] if text.startswith(_PREFIX) else text


def same_tree(path: Path, root: Path) -> bool:
    """Whether the (already resolved) `path` is `root` or below it; the prefix on either side does not matter."""
    a, b = os.path.normcase(plain(path)), os.path.normcase(plain(root))
    return a == b or a.startswith(b.rstrip("\\/") + os.sep)


def too_long(path, *, extra: int = 0) -> bool:
    """Would an ordinary (not extended) path be refused? Only ever true on Windows."""
    if os.name != "nt":
        return False
    return len(os.path.abspath(plain(path))) + extra > PLAIN_LIMIT


def plain_long_paths_work(directory: Path) -> bool:
    """Whether this process can open a path longer than 259 characters without the extended prefix (so Windows long paths are on).
    Tried, not read from the registry: a few folders are made through the extended form and reached through the ordinary one."""
    if os.name != "nt":
        return True
    base = long_path(Path(directory) / f".lp-{uuid.uuid4().hex[:6]}")
    try:
        deep = base / ("a" * 90) / ("b" * 90) / ("c" * 90)
        os.makedirs(deep)
        try:
            return os.path.isdir(plain(deep)) and len(plain(deep)) > PLAIN_LIMIT
        except OSError:
            return False
    except OSError:
        return True                                    # could not even test: say nothing rather than warn wrongly
    finally:
        shutil.rmtree(base, ignore_errors=True)


def warning_for(folder: Path, longest_inside: int) -> str | None:
    """One plain sentence when the files of a package placed in `folder` would pass the ordinary path limit, else None."""
    if os.name != "nt" or not too_long(Path(folder) / ("x" * (longest_inside + 1))):
        return None
    reach = len(plain(folder)) + 1 + longest_inside
    return (f"Strata's folder is deep: some engine files will have paths of about {reach} characters, and Windows stops at 259 unless "
            f"long paths are turned on. The install carries on, but the engine's graphics libraries may fail to load those files. "
            f"To fix it, turn on Windows long paths (Group Policy: Enable Win32 long paths) or put Strata in a shorter folder "
            f"(for example set STRATA_COMPONENTS_DIR to C:\\Strata) and update again.")


def describe_oserror(exc: BaseException) -> str:
    """Plain words for a failed file operation: which file, and when the cause is a path that is too long, that."""
    name = getattr(exc, "filename", None) or getattr(exc, "filename2", None)
    kind = type(exc).__name__
    if name is not None:
        shown = plain(os.fsdecode(name))
        if too_long(shown):
            return (f"a file path is longer than Windows allows ({len(os.path.abspath(shown))} characters, the limit is {PLAIN_LIMIT}): "
                    f"{shown}. Windows long paths are off on this PC. Put Strata in a shorter folder (set STRATA_COMPONENTS_DIR "
                    f"to something short like C:\\Strata) or turn on Windows long paths, then try again ({kind})")
        if isinstance(exc, FileNotFoundError):
            return f"Strata could not find or create {shown} ({kind})"
        if isinstance(exc, PermissionError):
            return f"Windows or another program would not let Strata use {shown} ({kind})"
        reason = getattr(exc, "strerror", None)
        return f"Strata could not use {shown}" + (f": {reason}" if reason else "") + f" ({kind})"
    return f"a file operation failed ({kind})"


def file_words(exc: BaseException) -> str:
    """The one-line message the command line prints for a failed local file operation."""
    return "local file operation failed: " + describe_oserror(exc)