splent-cli 1.36.0__tar.gz → 1.38.0__tar.gz

{splent_cli-1.36.0/src/splent_cli.egg-info → splent_cli-1.38.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: splent_cli
-Version: 1.36.0
+Version: 1.38.0
 Summary: SPLENT-CLI is a CLI to be able to work on your development more easily.
 Author-email: DiversoLab <diversolab@us.es>
 License-Expression: LGPL-3.0-or-later

{splent_cli-1.36.0 → splent_cli-1.38.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "splent_cli"
-version = "1.36.0"
+version = "1.38.0"
 description = "SPLENT-CLI is a CLI to be able to work on your development more easily."
 readme = "README.md"
 requires-python = ">=3.13"

{splent_cli-1.36.0 → splent_cli-1.38.0}/src/splent_cli/commands/check/check_product.py

@@ -2,7 +2,8 @@
 check:product — Product-level health checks.
 
 Validates that the active product is correctly wired:
-  1. Required env vars from feature contracts are set
+  1. Required env vars from feature contracts are set, and the app.config
+     keys the contracts read (requires.config_keys) are listed, set or not
   2. Feature symlinks resolve to real directories
   3. Config overwrites are flagged
   4. Features that loaded but registered no blueprints are warned
@@ -176,6 +177,62 @@ def _check_env_vars(workspace, product_path, features, counters):
         counters["ok"] += 1
 
 
+def _check_config_keys(workspace, product_path, features):
+    """List the app.config keys the features read and no feature sets.
+
+    ``requires.config_keys`` of each contract. They are not environment
+    variables: a feature reads most of them with a default, and a list or a
+    table (theme's SITE_NAV) can only come from the product's config.py. So
+    a key the product leaves alone is shown, never counted as a failure,
+    which is what made check:product fail for every product once the
+    contracts of auth and theme listed them among the env_vars.
+    """
+    var_features: dict[str, list[str]] = {}
+    for entry in features:
+        ns_safe, name, version = parse_feature_entry(entry)
+        data = _resolve_feature_pyproject(
+            workspace, product_path, ns_safe, name, version, None
+        )
+        keys = (
+            (data or {})
+            .get("tool", {})
+            .get("splent", {})
+            .get("contract", {})
+            .get("requires", {})
+            .get("config_keys", [])
+        )
+        for key in keys if isinstance(keys, list) else []:
+            var_features.setdefault(str(key), []).append(_short(name))
+    if not var_features:
+        return
+
+    click.echo()
+    click.secho("  Config Keys", bold=True, fg="cyan")
+    click.echo()
+
+    config = None
+    try:
+        from splent_cli.utils.dynamic_imports import get_app
+
+        config = get_app().config
+    except Exception:
+        pass
+
+    col_var = 30
+    col_feat = 25
+    click.echo(f"  {'Key':<{col_var}}  {'Feature(s)':<{col_feat}}  Status")
+    click.echo(f"  {'-' * col_var}  {'-' * col_feat}  {'-' * 24}")
+    for key in sorted(var_features):
+        feats = ", ".join(sorted(var_features[key]))
+        if config is None:
+            status = click.style("? app not built", fg="bright_black")
+        elif key in config:
+            status = click.style("✔ set", fg="green")
+        else:
+            status = click.style("· the feature's default", fg="bright_black")
+        click.echo(f"  {key:<{col_var}}  {feats:<{col_feat}}  {status}")
+
+
 # ── Symlinks ─────────────────────────────────────────────────────────────────
 
 
@@ -434,6 +491,7 @@ def check_product():
     check_and_refresh_contracts(workspace, features, interactive=False)
 
     _check_env_vars(workspace, product_path, features, counters)
+    _check_config_keys(workspace, product_path, features)
     _check_symlinks(product_path, features, counters)
     _check_config_overwrites(counters)
     _check_blueprints(counters)

splent_cli-1.38.0/src/splent_cli/commands/check/check_vendor.py

@@ -0,0 +1,271 @@
+"""
+check:vendor — Find Keenthemes (Metronic) code in a product and its features.
+
+Metronic is Keenthemes' commercial theme, and its licence does not allow
+redistributing it, so neither a product of the line nor a feature any
+product can pin may carry it. A feature written against it also breaks as
+soon as the product that ships its files drops them: its icons go blank and
+its scripts call globals nobody defines.
+
+It is found by content, not by where it sits: the globals its JavaScript
+defines, its icon classes, its data attributes and its name, in the
+product's own tree and in the src/ of every feature the product declares,
+at the copy the product runs. Only Duotune's icons, SVG with no mark of
+their own, are found by the name in their path. tests/ is left out
+everywhere, since a test may name the patterns it guards against.
+"""
+
+import os
+import re
+
+import click
+
+from splent_cli.services import context
+
+# (name, regular expression). The globals and classes are matched as the
+# start of a word, the name in any case.
+PATTERNS = (
+    ("KTUtil", r"\bKTUtil"),
+    ("KTComponents", r"\bKTComponents"),
+    ("KTApp", r"\bKTApp"),
+    ("KTMenu", r"\bKTMenu"),
+    ("KTStepper", r"\bKTStepper"),
+    ("keenthemes", r"(?i:keenthemes)"),
+    ("Metronic", r"(?i:\bmetronic\b)"),
+    ("ki-duotone", r"\bki-duotone\b"),
+    ("ki-outline", r"\bki-outline\b"),
+    ("ki-solid", r"\bki-solid\b"),
+    ("data-kt-", r"\bdata-kt-"),
+)
+
+_PATTERN = re.compile(
+    "|".join(f"(?P<p{i}>{regex})" for i, (_, regex) in enumerate(PATTERNS))
+)
+
+# Keenthemes' names in a file or folder name, for Duotune, its icon set.
+_PATH_PATTERN = re.compile(r"(?i)duotune|keenicons|keenthemes|metronic")
+
+# Never searched: tests, installed packages, caches, and hidden folders
+# (.git, virtual environments).
+SKIPPED_DIRS = {"tests", "node_modules", "__pycache__"}
+
+# Also left out of the product's tree: what the app writes while it runs.
+# Its features/ folder, the links product:resolve makes, is skipped at the
+# top, and each feature is searched on its own.
+SKIPPED_PRODUCT_DIRS = SKIPPED_DIRS | {"instance", "uploads"}
+
+# Read as bytes first: a file with a NUL byte is binary and has no text to
+# search. These are not even opened.
+BINARY_SUFFIXES = (
+    ".png",
+    ".jpg",
+    ".jpeg",
+    ".gif",
+    ".webp",
+    ".ico",
+    ".bmp",
+    ".woff",
+    ".woff2",
+    ".ttf",
+    ".otf",
+    ".eot",
+    ".pdf",
+    ".zip",
+    ".gz",
+    ".tgz",
+    ".mp4",
+    ".webm",
+    ".mp3",
+    ".pyc",
+)
+
+# Files listed per place before the rest is counted, unless --all.
+SHOWN_PER_PLACE = 10
+
+
+def scan_file(path: str) -> dict | None:
+    """{"line": first line, "patterns": [...], "count": matches} for a file
+    with Keenthemes code, or None."""
+    try:
+        with open(path, "rb") as f:
+            raw = f.read()
+    except OSError:
+        return None
+    if b"\0" in raw[:8192]:
+        return None
+    first = None
+    names: set[str] = set()
+    count = 0
+    for number, line in enumerate(raw.decode("utf-8", "replace").splitlines(), 1):
+        for match in _PATTERN.finditer(line):
+            names.add(PATTERNS[int(match.lastgroup[1:])][0])
+            count += 1
+            if first is None:
+                first = number
+    if not count:
+        return None
+    order = [name for name, _ in PATTERNS]
+    return {"line": first, "patterns": sorted(names, key=order.index), "count": count}
+
+
+def scan_tree(root: str, *, skip=SKIPPED_DIRS, skip_at_root=()) -> dict[str, dict]:
+    """{path relative to root: hit} for every file of the tree with
+    Keenthemes code, or a Keenthemes name in its path under root. A hit is
+    scan_file()'s, and a file found by its path alone has no line and a
+    count of 0. Symbolic links to folders are not followed."""
+    found: dict[str, dict] = {}
+    for current, dirs, files in os.walk(root):
+        dirs[:] = sorted(
+            d
+            for d in dirs
+            if not d.startswith(".")
+            and d not in skip
+            and not (current == root and d in skip_at_root)
+        )
+        for name in sorted(files):
+            path = os.path.join(current, name)
+            relative = os.path.relpath(path, root)
+            named = _PATH_PATTERN.search(relative)
+            hit = None
+            if not name.lower().endswith(BINARY_SUFFIXES):
+                hit = scan_file(path)
+            if named:
+                hit = hit or {"line": None, "patterns": [], "count": 0}
+                hit["patterns"].insert(0, f"{named.group().lower()} in its path")
+            if hit:
+                found[relative] = hit
+    return found
+
+
+def _feature_places(workspace: str, product_dir: str, data: dict):
+    """(label, src folder or None) for every feature the product declares,
+    in every environment, at the copy the product runs."""
+    from splent_cli.utils.feature_utils import read_all_feature_entries
+    from splent_cli.utils.refinement_facts import product_source
+
+    for entry in read_all_feature_entries(data):
+        source = product_source(workspace, product_dir, entry)
+        label = f"{source.name}@{source.version}" if source.version else source.name
+        src = source.root / "src" if source.root is not None else None
+        yield label, (str(src) if src is not None and src.is_dir() else None)
+
+
+def _report_place(label: str, where: str, found: dict, show_all: bool, tone):
+    click.echo(
+        click.style(f"  {label}", bold=True) + click.style(f"  ({where})", dim=True)
+    )
+    paths = sorted(found)
+    shown = paths if show_all else paths[:SHOWN_PER_PLACE]
+    for path in shown:
+        hit = found[path]
+        location = f"{path}:{hit['line']}" if hit["line"] else path
+        what = ", ".join(hit["patterns"])
+        if hit["count"]:
+            what += " (1 match)" if hit["count"] == 1 else f" ({hit['count']} matches)"
+        click.secho(f"    {tone[0]} {location}  {what}", fg=tone[1])
+    if len(paths) > len(shown):
+        click.secho(
+            f"    … and {len(paths) - len(shown)} more files (--all lists them)",
+            fg=tone[1],
+        )
+
+
+@click.command(
+    "check:vendor",
+    short_help="Find Keenthemes (Metronic) code in the product and its features.",
+)
+@click.option(
+    "--warn",
+    is_flag=True,
+    help="Report what is found without failing, while a product moves off it.",
+)
+@click.option("--all", "show_all", is_flag=True, help="List every file found.")
+def check_vendor(warn, show_all):
+    """
+    Search the active product and the features it declares for Keenthemes
+    code: Metronic's globals (KTUtil, KTApp, KTMenu, KTStepper,
+    KTComponents), its icon classes (ki-duotone, ki-outline, ki-solid), its
+    data-kt- attributes and the names Keenthemes and Metronic, and files
+    with Duotune or Keenthemes in their path.
+
+    \b
+    It reads the product's tree and the src/ of each feature, at the
+    release the product pins (or the working copy of an editable one),
+    and leaves out tests/, node_modules/ and hidden folders. A feature with
+    no local copy is said and not searched.
+
+    \b
+    Exits 1 when anything is found. --warn reports it and exits 0.
+
+    \b
+    Examples:
+      splent check:vendor
+      splent check:vendor --warn
+      splent check:vendor --all
+    """
+    from splent_cli.commands.uvl.uvl_utils import load_pyproject
+
+    workspace = str(context.workspace())
+    product = context.require_app()
+    product_dir = os.path.join(workspace, product)
+    data = load_pyproject(os.path.join(product_dir, "pyproject.toml"))
+    tone = ("⚠️ ", "yellow") if warn else ("✗", "red")
+
+    click.echo()
+    click.echo(click.style(f"  check:vendor  {product}", bold=True))
+    click.echo(click.style(f"  {'-' * 60}", fg="bright_black"))
+
+    places: list[tuple[str, int]] = []
+    found = scan_tree(
+        product_dir, skip=SKIPPED_PRODUCT_DIRS, skip_at_root=("features",)
+    )
+    if found:
+        _report_place(product, "the product's tree", found, show_all, tone)
+        places.append((product, len(found)))
+
+    clean = 0
+    unchecked: list[str] = []
+    for label, src in _feature_places(workspace, product_dir, data):
+        if src is None:
+            unchecked.append(label)
+            continue
+        found = scan_tree(src)
+        if found:
+            _report_place(label, "src/", found, show_all, tone)
+            places.append((label, len(found)))
+        else:
+            clean += 1
+
+    click.echo()
+    if unchecked:
+        click.secho(
+            f"  ℹ️  Not searched, no local copy: {', '.join(unchecked)}",
+            fg="bright_black",
+        )
+    if not places:
+        click.secho(
+            f"  ✅ No Keenthemes code in {product} or its "
+            f"{clean} feature{'s' if clean != 1 else ''}",
+            fg="green",
+        )
+        click.echo()
+        return
+
+    files = sum(n for _, n in places)
+    features = [label for label, _ in places if label != product]
+    summary = f"{files} file{'s' if files != 1 else ''} with Keenthemes code"
+    if features:
+        summary += f", in {len(features)} feature{'s' if len(features) != 1 else ''}"
+        if places[0][0] == product:
+            summary += " and the product"
+    click.secho(f"  {tone[0]} {summary}", fg=tone[1], bold=True)
+    click.echo(
+        "    Replace it with Bootstrap, feather icons or code of your own. In a "
+        "feature, that takes a release the product then pins."
+    )
+    click.echo()
+    if not warn:
+        raise SystemExit(1)
+
+
+cli_command = check_vendor

splent_cli-1.38.0/src/splent_cli/commands/clear/clear_uploads.py

@@ -0,0 +1,298 @@
+import importlib.util
+import os
+import shutil
+
+import click
+
+from splent_cli.utils.path_utils import PathUtils
+from splent_cli.services import context
+
+
+class UploadsDirError(Exception):
+    """The uploads directory of the active product cannot be resolved safely."""
+
+
+# Top-level directories of a system or a container. No product keeps its
+# uploads in one of them, and emptying one would take the machine with it.
+_SYSTEM_DIRS = {
+    "/bin",
+    "/boot",
+    "/dev",
+    "/etc",
+    "/home",
+    "/lib",
+    "/lib64",
+    "/opt",
+    "/proc",
+    "/root",
+    "/run",
+    "/sbin",
+    "/srv",
+    "/sys",
+    "/tmp",
+    "/usr",
+    "/var",
+}
+
+# What a directory of code has at its top and a directory of uploads never
+# has. A PROTECTED_UPLOADS_DIR pointing at a checkout is refused on sight.
+_CODE_MARKERS = ("pyproject.toml", "setup.py", ".git", "__init__.py")
+
+
+def _instance_path(product: str, product_dir: str) -> str:
+    """Flask's instance folder for the product's app.
+
+    A product running from its source tree, as in development, gets
+    ``<product>/src/instance``. One installed outside it, as the production
+    image installs it, gets the folder Flask picks for an installed package.
+    """
+    try:
+        spec = importlib.util.find_spec(product)
+    except (ImportError, ValueError):
+        spec = None
+    # A namespace match (the product directory itself on sys.path) has no
+    # origin and says nothing about where the app runs from.
+    origin = os.path.realpath(spec.origin) if spec and spec.origin else ""
+    if origin and not origin.startswith(product_dir + os.sep):
+        try:
+            from flask.sansio.scaffold import find_package
+        except ImportError:
+            find_package = None
+        if find_package is not None:
+            prefix, package_path = find_package(product)
+            if prefix is not None:
+                return os.path.join(prefix, "var", f"{product}-instance")
+            return os.path.join(package_path, "instance")
+    return os.path.join(product_dir, "src", "instance")
+
+
+def _configured_dir(app) -> str:
+    """PROTECTED_UPLOADS_DIR as the app reads it: its config, then the
+    environment. Every command starts with the product's env files loaded
+    (utils/dynamic_imports), so the environment here is the app's."""
+    if app is not None:
+        configured = app.config.get("PROTECTED_UPLOADS_DIR")
+        if configured:
+            return str(configured)
+    return os.getenv("PROTECTED_UPLOADS_DIR", "").strip()
+
+
+def _refuse(path: str, real: str, why: str):
+    shown = path if path == real else f"{path} (resolves to {real})"
+    raise UploadsDirError(f"{shown} {why}. Nothing was deleted.")
+
+
+def resolve_uploads_dir(app=None) -> str:
+    """Return the directory where the product's app keeps protected uploads.
+
+    That is where the files of the hub live (hubfile and dataset write under
+    it, media keeps its restricted files there): PROTECTED_UPLOADS_DIR, which
+    the production compose mounts as a named volume, or, when it is empty,
+    ``<instance_path>/protected_uploads``, the framework's fallback
+    (splent_framework.utils.path_utils.protected_uploads_dir). With ``app``
+    the path comes from the app itself; without it, from the environment and
+    the product on disk, so the product does not need to be importable.
+
+    Raises UploadsDirError when no product is selected, the product directory
+    does not exist, or the path is one no uploads directory can be: relative,
+    the root, a system directory, the home directory, the workspace, the
+    product or its package, anything holding one of them, or a directory with
+    code at its top.
+    """
+    product = os.getenv("SPLENT_APP", "")
+    if not product or product in (".", "..") or os.sep in product or "/" in product:
+        raise UploadsDirError(f"'{product}' is not a valid product name.")
+
+    product_dir = os.path.realpath(PathUtils.get_app_base_dir())
+    if not os.path.isdir(product_dir):
+        raise UploadsDirError(f"Product directory not found: {product_dir}")
+
+    configured = _configured_dir(app)
+    if configured:
+        uploads_dir = configured
+    elif app is not None:
+        uploads_dir = os.path.join(app.instance_path, "protected_uploads")
+    else:
+        uploads_dir = os.path.join(
+            _instance_path(product, product_dir), "protected_uploads"
+        )
+
+    if not os.path.isabs(uploads_dir):
+        raise UploadsDirError(
+            f"PROTECTED_UPLOADS_DIR={uploads_dir} is not an absolute path, so it "
+            "depends on where the app was started. Nothing was deleted."
+        )
+
+    real = os.path.realpath(uploads_dir)
+    if real == os.sep or real in _SYSTEM_DIRS:
+        _refuse(uploads_dir, real, "is a system directory")
+    if real == os.path.realpath(os.path.expanduser("~")):
+        _refuse(uploads_dir, real, "is the home directory")
+
+    package_dir = os.path.join(product_dir, "src", product)
+    guarded = [product_dir, package_dir]
+    workspace = PathUtils.get_working_dir()
+    if workspace:
+        guarded.append(os.path.realpath(workspace))
+    for kept in guarded:
+        if real == kept or kept.startswith(real + os.sep):
+            _refuse(uploads_dir, real, f"holds {kept}")
+    if real.startswith(package_dir + os.sep):
+        _refuse(uploads_dir, real, f"is inside the product's package {package_dir}")
+    for marker in _CODE_MARKERS:
+        if os.path.lexists(os.path.join(real, marker)):
+            _refuse(uploads_dir, real, f"has a {marker}, so it holds code, not uploads")
+    return real
+
+
+def clear_product_uploads(app=None) -> list[str]:
+    """Delete the contents of the active product's protected uploads.
+
+    Prints the outcome and returns the errors (empty when everything was
+    cleared or there was nothing to clear). It never raises SystemExit, so
+    db:reset can call it after dropping the schema and still re-apply the
+    migrations. It does not ask: its callers do.
+    """
+    try:
+        uploads_dir = resolve_uploads_dir(app)
+    except UploadsDirError as e:
+        click.echo(click.style(f"Cannot clear the uploads directory. {e}", fg="red"))
+        return [str(e)]
+
+    if not os.path.isdir(uploads_dir):
+        click.echo(
+            click.style(
+                f"The uploads directory {uploads_dir} does not exist.", fg="yellow"
+            )
+        )
+        return []
+
+    errors = []
+    try:
+        entries = sorted(os.listdir(uploads_dir))
+    except OSError as e:
+        entries = []
+        errors.append(f"{uploads_dir}: {e}")
+
+    for filename in entries:
+        file_path = os.path.join(uploads_dir, filename)
+        try:
+            # A symlink is removed itself, never the directory it points to
+            if os.path.islink(file_path) or not os.path.isdir(file_path):
+                os.remove(file_path)
+            else:
+                shutil.rmtree(file_path)
+        except OSError as e:
+            errors.append(f"{filename}: {e}")
+
+    if errors:
+        click.echo(
+            click.style(
+                f"Error clearing the uploads directory {uploads_dir}. "
+                f"Could not delete {len(errors)} "
+                f"{'entry' if len(errors) == 1 else 'entries'}.",
+                fg="red",
+            )
+        )
+        for err in errors:
+            click.echo(click.style(f"  {err}", fg="red"))
+    else:
+        click.echo(
+            click.style(
+                f"The contents of the uploads directory {uploads_dir} have been "
+                "successfully cleared.",
+                fg="green",
+            )
+        )
+    return errors
+
+
+def _run_where_the_uploads_are(product: str, env: str, yes: bool) -> None:
+    """Run this command in the product's web container when it is up there.
+
+    PROTECTED_UPLOADS_DIR is a path inside that container, and in production
+    a named volume only that container mounts: emptying the same path from
+    the CLI container would empty a directory the app never reads, and say
+    it worked. That container is ``<product>_web`` in development and
+    ``<product>_web_deploy`` in production; only the first was looked for,
+    so a production deployment was never reached.
+
+    Returns when this already is that container, or when it is down in
+    development, where the CLI container sees the same files. In production
+    with it down, nothing here is the app's: it says so and exits.
+    """
+    from splent_cli.services import web_container
+
+    if web_container.is_product_container():
+        return
+    container = web_container.name(product, env)
+    if web_container.running(container):
+        # No --prod: the container runs as what it is, and the CLI of an
+        # older image would not know the flag.
+        argv = ["clear:uploads", *(["--yes"] if yes else [])]
+        raise SystemExit(web_container.delegate(product, argv, container=container))
+
+    if env == "prod":
+        # product:clean --prod gets here after 'down -v', which deleted the
+        # volume with everything in it.
+        click.echo(
+            click.style(
+                f"{container} is not running, and its uploads are in a volume "
+                "only it mounts. Nothing was deleted from here.",
+                fg="yellow",
+            )
+        )
+        raise SystemExit(0)
+    deployed = web_container.name(product, "prod")
+    if web_container.running(deployed):
+        click.echo(
+            click.style(
+                f"These are the development uploads. {deployed} is running: "
+                "'splent clear:uploads --prod' empties its own.",
+                fg="yellow",
+            )
+        )
+
+
+@click.command(
+    "clear:uploads",
+    short_help="Empty the product's protected uploads (PROTECTED_UPLOADS_DIR).",
+)
+@click.option("--dev", "env_dev", is_flag=True, help="Use development environment.")
+@click.option("--prod", "env_prod", is_flag=True, help="Use production environment.")
+@click.option("-y", "--yes", is_flag=True, help="Confirm without prompting.")
+@context.requires_product
+def clear_uploads(env_dev, env_prod, yes):
+    """
+    Delete every file in the directory where the product's app keeps the
+    uploads it serves behind an access check: PROTECTED_UPLOADS_DIR, or the
+    app's instance/protected_uploads when it is empty. The directory itself
+    stays. Public files under static/ are not touched.
+
+    When the product's web container is up, the command runs there, where
+    the directory is mounted: <product>_web in development, and
+    <product>_web_deploy with --prod or SPLENT_ENV=prod. In production
+    nothing is deleted while that container is down, since its uploads are
+    a volume only it mounts.
+    """
+    if env_dev and env_prod:
+        click.echo(click.style("Cannot specify both --dev and --prod.", fg="red"))
+        raise SystemExit(1)
+    env = context.resolve_env(env_dev, env_prod)
+    _run_where_the_uploads_are(os.getenv("SPLENT_APP", ""), env, yes)
+
+    try:
+        uploads_dir = resolve_uploads_dir()
+    except UploadsDirError as e:
+        click.echo(click.style(f"Cannot clear the uploads directory. {e}", fg="red"))
+        raise SystemExit(1)
+
+    if not yes:
+        click.confirm(
+            f"Delete every file in {uploads_dir}? The datasets and documents "
+            "the app serves from it cannot be recovered.",
+            abort=True,
+        )
+
+    if clear_product_uploads():
+        raise SystemExit(1)

{splent_cli-1.36.0 → splent_cli-1.38.0}/src/splent_cli/commands/database/db_reset.py

@@ -305,7 +305,7 @@ def _reset_one_feature(app, feature_name, yes, product_path, product_name):
 
 def _reset_everything(app, yes, product_path, product_name):
     if not yes and not click.confirm(
-        "⚠️  WARNING: This will DROP all tables and clear uploads. Are you sure?",
+        "⚠️  WARNING: This will DROP all tables and empty the protected uploads. Are you sure?",
         abort=True,
     ):
         return
@@ -367,7 +367,9 @@ def _reset_everything(app, yes, product_path, product_name):
         raise SystemExit(1)
 
     # The schema is already gone: a failure here must not stop the migrations.
-    if clear_product_uploads():
+    # The app says where its protected uploads are, the rows of which were
+    # just dropped.
+    if clear_product_uploads(app):
         click.echo(
             click.style(
                 "⚠️  Uploads were not cleared. The reset continues.", fg="yellow"