streamtex 0.7.74__tar.gz → 0.7.76__tar.gz

{streamtex-0.7.74/streamtex.egg-info → streamtex-0.7.76}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: streamtex
-Version: 0.7.74
+Version: 0.7.76
 Summary: AI-powered content framework for Streamlit — create presentations, courses, and web-books with Claude or Cursor, no coding required.
 Author-email: Nicolas Guelfi <nicolas.guelfi@laposte.net>
 License-Expression: BUSL-1.1

{streamtex-0.7.74 → streamtex-0.7.76}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "streamtex"
-version = "0.7.74"
+version = "0.7.76"
 description = "AI-powered content framework for Streamlit — create presentations, courses, and web-books with Claude or Cursor, no coding required."
 readme = "README.md"
 requires-python = ">=3.11"

{streamtex-0.7.74 → streamtex-0.7.76}/streamtex/book.py

@@ -58,7 +58,7 @@ from .marker import (
 )
 from .marker_runtime import inject_marker_runtime
 from .pdf_export import PdfConfig
-from .presentation import get_presentation_config, st_presentation_footer
+from .presentation import get_presentation_config, presentation_page_scrolls, st_presentation_footer
 from .presentation_profile import (
     _ACTIVE_PROFILE_KEY,
     PresentationProfile,
@@ -482,6 +482,10 @@ def _offer_export_downloads(html: str, base_name: str,
 
             submitted = st.form_submit_button("Generate")
 
+        # A Generate that had to rebuild the full document first is carried over its rerun (#151):
+        # a form counts as submitted on one run only, so the reader had to click a second time.
+        _pending_key = f"_stx_export_pending_{_pk}"
+        submitted = submitted or st.session_state.pop(_pending_key, False)
         if submitted:
             results = {}
             # Resolve which HTML to use based on scope
@@ -494,6 +498,7 @@ def _offer_export_downloads(html: str, base_name: str,
                     if rebuild_fn:
                         with st.spinner("Generating full document..."):
                             rebuild_fn()
+                        st.session_state[_pending_key] = True
                         st.rerun()
                 if full_book_html:
                     # Built once per session with the view of that moment:
@@ -2308,6 +2313,11 @@ def _render_page(module, page: dict, pages: list[dict], block_args, block_kwargs
     st_include(module, *block_args, _inspector_config=inspector, **block_kwargs)
 
 
+def _stops_on_page(markers: list[dict], page: int) -> int:
+    """How many slides (navigation stops) *page* holds."""
+    return sum(1 for m in markers if is_stop(m) and m.get("page_idx", 0) == page)
+
+
 def _footer_first_slide(markers: list[dict], page: int, initial_marker: int | None) -> int:
     """The slide number the footer shows on its first paint (#117).
 
@@ -3652,6 +3662,8 @@ def _paginated_book(module_list, toc_config, marker_config, separator,
 
     # --- Presentation footer (auto-rendered when PresentationConfig is active) ---
     _pres_cfg = get_presentation_config()
+    if _pres_cfg is not None and _stops_on_page(cache.get("markers", []), current_page) > 1:
+        presentation_page_scrolls(_pres_cfg)         # several slides on this page (#153)
     if _pres_cfg is not None and _pres_cfg.footer:
         _n = stop_count() if _pres_cfg.counter_mode == "slide" else 0
         if _n:

{streamtex-0.7.74 → streamtex-0.7.76}/streamtex/cli/release_cmd.py

@@ -259,6 +259,82 @@ def wake_cmd(site, target):
     click.echo(f"{site}: live face running again")
 
 
+@release.command("remove")
+@click.argument("site")
+@_target
+@click.option("--yes", is_flag=True, help="Do not ask for confirmation.")
+@click.option("--force", is_flag=True, help="Remove a site still declared in stx.toml.")
+def remove_cmd(site, target, yes, force):
+    """Take SITE off the server (#143): its program, its port, its folders, its state entry.
+
+    Refused while SITE is still declared in stx.toml, unless --force. No other site is touched and the
+    project's media stay. The domains are not changed here: `stx release setup --domains --dry-run`
+    shows them, then `--domains --deploy` writes them (it redeploys both applications)."""
+    cfg, state, t = _ctx(target)
+    if site in cfg.by_name and not force:
+        raise ReleaseError(f"{site} is still declared in stx.toml — remove it there first, or pass --force")
+    plan = ops.remove_plan(t, state, site)
+    if not plan:
+        raise ReleaseError(f"{site}: nothing on {t.name}")
+    click.echo(f"On {t.name}, this removes:")
+    for line in plan:
+        click.echo(f"  - {line}")
+    if not yes and not click.confirm("Remove?", default=False):
+        raise ReleaseError("nothing removed")
+    ops.remove_site(t, cfg, state, site, click.echo)
+    if site not in cfg.by_name:
+        click.echo("Domains: `stx release setup --domains --dry-run` shows the one to drop; "
+                   "`--domains --deploy` writes them (redeploys both applications, out of class).")
+
+
+@release.command("media-report")
+@click.argument("site")
+@click.option("--list", "show", type=click.Choice(["kept", "dropped"]), default=None,
+              help="Also list the files kept, or those no longer served.")
+@click.option("--html-env", "html_env", multiple=True, help="KEY=VALUE for the HTML export, as for publish.")
+def media_report_cmd(site, show, html_env):
+    """What SITE's live face would serve with `[release] media_per_site = true` (#142), on this machine.
+
+    Exports SITE's HTML from the commit, as publish does, then sorts its static folder: the files the
+    export shows and those media_keep names are kept, the others would no longer be served. Nothing is
+    sent: the server is not read nor changed."""
+    import tempfile
+    from pathlib import Path
+
+    from ..release import media as md
+
+    cfg = load_config()
+    s = cfg.site(site)
+    if "html" not in s.faces:
+        raise ReleaseError(f"{site} has no HTML face: its live face serves its whole static folder")
+    with tempfile.TemporaryDirectory(prefix="stx-media-") as w:
+        work = Path(w)
+        code = build.snapshot(cfg, s, work)
+        html, _ = build.export(cfg, s, code, work, "media-report", _html_env(html_env))
+        mp = md.plan(cfg, s, code, html)
+    if mp.static is None:
+        raise ReleaseError(f"{site}: {s.doc_dir}/static is not a folder — the live face serves no media")
+    kept, dropped = sorted(mp.kept), mp.dropped
+    by_export = sum(1 for why in mp.kept.values() if why == "export")
+    click.echo(f"{site} — static folder {mp.static} ({len(mp.files)} files, {md.human(mp.size(mp.files))})")
+    click.echo(f"  kept: {len(kept)} file(s), {md.human(mp.size(kept))} — {by_export} shown by the HTML "
+               f"export, {len(kept) - by_export} named by media_keep")
+    click.echo(f"  no longer served: {len(dropped)} file(s), {md.human(mp.size(dropped))}")
+    if mp.unmatched:
+        click.echo(f"  {mp.unmatched} export file(s) match no static file (inlined or generated: nothing to keep)")
+    if mp.named:
+        click.echo(f"  ! named in the site's files but not kept — add them to media_keep if the live face "
+                   f"needs them ({len(mp.named)}):")
+        for p in mp.named:
+            click.echo(f"      {p}")
+    if show:
+        click.echo(f"{'Kept' if show == 'kept' else 'No longer served'}:")
+        for p in (kept if show == "kept" else dropped):
+            click.echo(f"  {p}" + (f"   ({mp.kept[p]})" if show == "kept" else ""))
+    click.echo(f"[release] media_per_site = {'true: applied' if cfg.media_per_site else 'false: nothing changes'}"
+               " at the next publication")
+
+
 @release.command("lock")
 def lock_cmd():
     """Write the live image's requirements.txt and stx-version from uv.lock (then rebuild the live app).

{streamtex-0.7.74 → streamtex-0.7.76}/streamtex/deploy/stx_auth.py

@@ -107,7 +107,7 @@ from pathlib import Path
 from urllib.parse import parse_qs, urlsplit
 
 #: The library release this file ships with, and its interface number (#135).
-STX_VERSION = "0.7.74"
+STX_VERSION = "0.7.76"
 AUTH_INTERFACE = 3
 
 DEFAULT_ROOT = "/var/lib/stx-auth"

{streamtex-0.7.74 → streamtex-0.7.76}/streamtex/presentation.py

@@ -47,7 +47,9 @@ class PresentationConfig:
     """CSS aspect-ratio value ("16/9", "4/3", "16/10")."""
 
     enforce_ratio: bool = True
-    """When True, apply aspect-ratio + overflow:hidden to the slide container."""
+    """When True, the page is clipped at the screen's height (overflow hidden).
+    A page holding several slides is not clipped: it scrolls, so the
+    navigation reaches each of its slides (#153)."""
 
     # Footer
     footer: bool = True
@@ -287,6 +289,22 @@ def _inject_presentation_css(config: PresentationConfig) -> None:
         st.html(css)
 
 
+def presentation_page_scrolls(config: PresentationConfig) -> None:
+    """Let the current page scroll when it holds several slides (#153).
+
+    With ``enforce_ratio`` the page is clipped at the screen's height and,
+    with ``center_content``, centred in it: a page of two slides (two
+    screens high) had its first slide above the screen and the second below
+    it, out of the navigation's reach. Such a page now grows and scrolls as
+    without presentation mode, so the navigation reaches each slide. A page
+    of one slide keeps the clipping.
+    """
+    if not config.enforce_ratio:
+        return
+    st.html("<style>.stMain .block-container { max-height: none !important; overflow: visible !important; "
+            "justify-content: flex-start !important; flex: 0 0 auto !important; }</style>")
+
+
 # ---------------------------------------------------------------------------
 # Footer rendering
 # ---------------------------------------------------------------------------

{streamtex-0.7.74 → streamtex-0.7.76}/streamtex/release/config.py

@@ -9,6 +9,9 @@
     snapshot = ["content", "shared", "trainings_pack"]   # in every code snapshot, besides the site's paths
     media = "assets"               # copied once per project, linked into every snapshot (optional)
     media_exclude = [".DS_Store", "*-original.*"]
+    media_per_site = true          # the live face serves only the site's own media (#142; default false):
+                                   # those its HTML export shows, plus media_keep — see release/media.py
+    media_keep = ["media/videos/*"]   # globs under the site's static folder, served by every site
     pythonpath = ["trainings_pack"]  # PYTHONPATH of the live process, relative to the snapshot
     lock_exclude = ["trainings-pack"]  # local packages kept out of the live image's requirements
     lock_no_sources = false        # true: requirements resolved without [tool.uv.sources] (git packs)
@@ -26,6 +29,7 @@
     exclude = ["trainings/CHAT1D/pack"]   # removed from the snapshot
     explicit = false               # true: published only when named (a home page)
     zoom = 80                      # the HTML face opens as at this browser zoom, in percent (optional)
+    media_keep = ["downloads/chat1d/*"]   # served by this site besides [release] media_keep (#142)
 """
 
 from __future__ import annotations
@@ -41,10 +45,10 @@ from . import ReleaseError
 
 FACES = ("live", "html")
 SITE_RE = re.compile(r"^[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?$")
-_SITE_KEYS = {"site", "book", "group", "faces", "paths", "exclude", "explicit", "legacy", "zoom"}
+_SITE_KEYS = {"site", "book", "group", "faces", "paths", "exclude", "explicit", "legacy", "zoom", "media_keep"}
 _RELEASE_KEYS = {"project", "langs", "snapshot", "media", "media_exclude", "pythonpath", "lock_exclude",
                  "lock_no_sources", "apt", "min_words", "port_base", "dir", "sites", "sites_from", "checks",
-                 "verify"}
+                 "verify", "media_per_site", "media_keep"}
 _APT_RE = re.compile(r"^[a-z0-9][a-z0-9.+-]+$")
 
 
@@ -61,6 +65,7 @@ class Site:
     explicit: bool = False
     legacy: tuple[str, ...] = ()          # the prototype's (training, kind), for convert-passwords
     zoom: float | None = None             # the HTML face's zoom in percent (stx export html --zoom)
+    media_keep: tuple[str, ...] = ()      # globs served by this site's live face besides its export's (#142)
 
     @property
     def doc_dir(self) -> str:
@@ -91,6 +96,8 @@ class ReleaseConfig:
     dir: str = ".stx-release"
     checks: str | None = None
     verify: str | None = None             # the project's check of each HTML export (#144)
+    media_per_site: bool = False          # the live face serves only the site's own media (#142)
+    media_keep: tuple[str, ...] = ()      # globs served by every site's live face besides its export's
     by_name: dict[str, Site] = field(default_factory=dict)
 
     def __post_init__(self):
@@ -139,6 +146,13 @@ def _call(spec: str, root: Path, what: str):
         sys.path.remove(str(root))
 
 
+def _globs(raw: object, where: str) -> tuple[str, ...]:
+    if not isinstance(raw, list) or not all(isinstance(x, str) and x and not x.startswith("/") for x in raw):
+        raise ReleaseError(f"{where}: media_keep — a list of globs under the static folder, "
+                           "such as [\"media/videos/*\"]")
+    return tuple(raw)
+
+
 def _site(raw: object, where: str) -> Site:
     if not isinstance(raw, dict):
         raise ReleaseError(f"{where}: a site is a table")
@@ -162,7 +176,8 @@ def _site(raw: object, where: str) -> Site:
         raise ReleaseError(f"{where} ({name}): zoom {zoom!r} — a positive percentage, such as 80")
     return Site(site=name, book=book, group=str(raw.get("group") or name), faces=faces, paths=paths,
                 exclude=tuple(raw.get("exclude", ())), explicit=bool(raw.get("explicit", False)), legacy=legacy,
-                zoom=float(zoom) if zoom is not None else None)
+                zoom=float(zoom) if zoom is not None else None,
+                media_keep=_globs(raw.get("media_keep", []), f"{where} ({name})"))
 
 
 def load_config(root: Path | None = None) -> ReleaseConfig:
@@ -201,6 +216,9 @@ def load_config(root: Path | None = None) -> ReleaseConfig:
     verify = data.get("verify")
     if verify is not None and not (isinstance(verify, str) and re.fullmatch(r"[\w.]+:\w+", verify)):
         raise ReleaseError(f"[release] verify = {verify!r} — expected 'module:function'")
+    per_site = data.get("media_per_site", False)
+    if not isinstance(per_site, bool):
+        raise ReleaseError(f"[release] media_per_site = {per_site!r} — true or false")
     return ReleaseConfig(
         root=root, project=project, sites=sites, langs=langs,
         snapshot=tuple(data.get("snapshot", ())), media=data.get("media"),
@@ -208,7 +226,8 @@ def load_config(root: Path | None = None) -> ReleaseConfig:
         pythonpath=tuple(data.get("pythonpath", ())), lock_exclude=tuple(data.get("lock_exclude", ())),
         lock_no_sources=bool(data.get("lock_no_sources", False)), apt=apt,
         min_words=int(data.get("min_words", 100)), port_base=int(data.get("port_base", 9000)),
-        dir=str(data.get("dir", ".stx-release")), checks=data.get("checks"), verify=verify)
+        dir=str(data.get("dir", ".stx-release")), checks=data.get("checks"), verify=verify,
+        media_per_site=per_site, media_keep=_globs(data.get("media_keep", []), "[release]"))
 
 
 def run_checks(cfg: ReleaseConfig, sites: list[Site]) -> None:

streamtex-0.7.76/streamtex/release/media.py

@@ -0,0 +1,153 @@
+"""Media per site (#142): the live face serves only the files its site shows.
+
+The router serves ``/app/static/`` from ``live/sites/<site>/static``, a link to the site's
+``<doc>/static`` folder — in a project whose documents share one media folder, every file of every
+document. With ``[release] media_per_site = true``, each release of the code holds a folder
+``.stx-served`` of links to the files the site uses, and the router serves that folder instead:
+
+* the files its HTML export shows: each file of the export's ``data/`` folders, found again in the
+  static folder by its content (size, then SHA-256) — the export copies a served file unchanged;
+* the files ``media_keep`` names (``[release]`` and the site's table): glob patterns relative to the
+  static folder, as in ``/app/static/<path>``; ``*`` also crosses ``/``.
+
+The code itself is unchanged: a block that reads a file of the static folder still finds it. A site
+without an HTML face keeps serving its whole static folder. ``stx release media-report SITE`` shows
+the plan without changing anything.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import os
+import re
+from collections import defaultdict
+from dataclasses import dataclass, field
+from fnmatch import fnmatchcase
+from pathlib import Path
+
+from .config import ReleaseConfig, Site
+
+SERVED = ".stx-served"
+
+#: A path under the static folder named in a site's own files: ``static/…`` or ``app/static/…``.
+_NAMED_RE = re.compile(r"""(?:app/)?static/([\w.~/-]+)""")
+_TEXT = {".py", ".md", ".html", ".css", ".js", ".toml", ".json", ".txt", ".yaml", ".yml"}
+
+
+@dataclass
+class MediaPlan:
+    """What the live face of one site serves."""
+
+    static: Path | None                       # the site's static folder, resolved (None: it has none)
+    files: dict[str, int] = field(default_factory=dict)       # every file of it → its size
+    kept: dict[str, str] = field(default_factory=dict)        # served → why: "export" or the pattern
+    unmatched: int = 0                        # export files found in no static file (inlined, generated)
+    named: list[str] = field(default_factory=list)            # named in the site's files, not kept
+
+    @property
+    def dropped(self) -> list[str]:
+        return sorted(set(self.files) - set(self.kept))
+
+    def size(self, paths) -> int:
+        return sum(self.files[p] for p in paths)
+
+
+def _walk(root: Path) -> dict[str, int]:
+    out: dict[str, int] = {}
+    for d, dirs, names in os.walk(root, followlinks=True):
+        dirs[:] = [x for x in dirs if x != SERVED]
+        for n in names:
+            p = Path(d) / n
+            try:
+                out[p.relative_to(root).as_posix()] = p.stat().st_size
+            except OSError:                    # a broken link: nothing to serve
+                pass
+    return out
+
+
+def _digest(p: Path) -> str:
+    h = hashlib.sha256()
+    with open(p, "rb") as f:
+        for chunk in iter(lambda: f.read(1 << 20), b""):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def keep_patterns(cfg: ReleaseConfig, site: Site) -> tuple[str, ...]:
+    return (*cfg.media_keep, *site.media_keep)
+
+
+def plan(cfg: ReleaseConfig, site: Site, code: Path, html: Path) -> MediaPlan:
+    """The files the live face of *site* serves, from its snapshot *code* and its HTML export *html*,
+    both on this machine; the snapshot's media folder is linked to the project's while it is read."""
+    linked = None
+    if cfg.media and not (code / cfg.media).exists() and (cfg.root / cfg.media).is_dir():
+        linked = code / cfg.media
+        if linked.is_symlink():               # a link left dangling
+            linked.unlink()
+        linked.parent.mkdir(parents=True, exist_ok=True)
+        linked.symlink_to(cfg.root / cfg.media)
+    try:
+        return _plan(cfg, site, code, html)
+    finally:
+        if linked is not None:
+            linked.unlink()
+
+
+def _plan(cfg: ReleaseConfig, site: Site, code: Path, html: Path) -> MediaPlan:
+    folder = code / site.doc_dir / "static"
+    if not folder.is_dir():
+        return MediaPlan(static=None)
+    mp = MediaPlan(static=folder.resolve(), files=_walk(folder))
+    by_size: dict[int, list[str]] = defaultdict(list)
+    for rel, size in mp.files.items():
+        by_size[size].append(rel)
+    digests: dict[str, str] = {}
+    for f in sorted(html.rglob("*")):
+        if not f.is_file() or "data" not in f.relative_to(html).parts[:-1]:
+            continue
+        same = by_size.get(f.stat().st_size, [])
+        found = False
+        if same:
+            want = _digest(f)
+            for rel in same:
+                if rel not in digests:
+                    digests[rel] = _digest(folder / rel)
+                if digests[rel] == want:
+                    mp.kept.setdefault(rel, "export")
+                    found = True
+        mp.unmatched += not found
+    for pat in keep_patterns(cfg, site):
+        for rel in mp.files:
+            if fnmatchcase(rel, pat):
+                mp.kept.setdefault(rel, pat)
+    named = set()
+    for d, dirs, names in os.walk(code / site.doc_dir):
+        dirs[:] = [x for x in dirs if x not in ("static", SERVED, "__pycache__")]
+        for n in names:
+            if Path(n).suffix in _TEXT:
+                text = (Path(d) / n).read_text(encoding="utf-8", errors="replace")
+                named.update(m.rstrip("/.") for m in _NAMED_RE.findall(text))
+    mp.named = sorted(p for p in named if p in mp.files and p not in mp.kept)
+    return mp
+
+
+def build_served(code: Path, site: Site, kept) -> Path:
+    """The folder ``.stx-served`` of the snapshot: one relative link per kept file, to the same file
+    under ``<doc>/static`` — the links resolve on the server as they do here."""
+    served = code / SERVED
+    static = code / site.doc_dir / "static"
+    for rel in sorted(kept):
+        link = served / rel
+        link.parent.mkdir(parents=True, exist_ok=True)
+        link.symlink_to(os.path.relpath(static / rel, link.parent))
+    served.mkdir(exist_ok=True)               # no file kept: the folder exists, empty — nothing served
+    return served
+
+
+def human(n: int) -> str:
+    for unit in ("B", "KB", "MB", "GB"):
+        if n < 1024 or unit == "GB":
+            return f"{n:.0f} {unit}" if unit == "B" else f"{n:.1f} {unit}"
+        n /= 1024
+    return f"{n} B"

{streamtex-0.7.74 → streamtex-0.7.76}/streamtex/release/ops.py

@@ -11,6 +11,7 @@ On the target (``<root>`` of the target, ``/srv/<face>`` in the containers)::
     live/sites/<site>/current -> releases/<release>
     live/sites/<site>/pass                    the live face's records
     live/sites/<site>/static -> current/<doc>/static   the site's media, served by the router
+                             -> current/.stx-served    with media_per_site: its own media alone (#142)
     live/media/<project>/<media>/             the project's media, shared by every snapshot
     live/conf/programs/<site>.conf            the site's supervisord program
     live/conf/ports.map                       site → port, read by the router
@@ -38,9 +39,10 @@ from pathlib import Path
 
 from . import ReleaseError, build
 from . import levels as lv
+from . import media as md
 from . import passwords as pw
-from .config import ReleaseConfig, Site
-from .state import save_state, sites_of
+from .config import SITE_RE, ReleaseConfig, Site
+from .state import STATE_FILE, save_state, sites_of
 from .target import LIVE_ROOT, Target
 
 TEMPLATES = Path(__file__).parent / "templates"
@@ -78,9 +80,21 @@ def html_of(v: dict) -> str | None:
 
 
 def switch(t: Target, site: Site, release: str, faces: list[str] | None = None) -> None:
-    """Each face's ``current`` link on *release*."""
-    for face in faces or _faces_dirs(site):
+    """Each face's ``current`` link on *release*; the live face's media follow it."""
+    dirs = faces or _faces_dirs(site)
+    for face in dirs:
         t.sh(t.switch_cmd(t.path(face, "sites", site.site), release))
+    if "live" in dirs:
+        link_static(t, site)
+
+
+def link_static(t: Target, site: Site) -> None:
+    """The media the router serves for *site*: the release's ``.stx-served`` when it has one (#142),
+    else its whole ``<doc>/static`` — a rollback to a release of before brings its media back."""
+    cur = f"{LIVE_ROOT}/sites/{site.site}/current"
+    t.sh(f"cd {shlex.quote(t.path('live', 'sites', site.site))} && "
+         f"if [ -d current/{md.SERVED} ]; then ln -sfn {shlex.quote(f'{cur}/{md.SERVED}')} static; "
+         f"else ln -sfn {shlex.quote(f'{cur}/{site.doc_dir}/static')} static; fi")
 
 
 def server_records(t: Target) -> str:
@@ -288,6 +302,18 @@ def publish_site(t: Target, cfg: ReleaseConfig, state: dict, site: Site, release
             build.verify_export(cfg, site, html)
             if cfg.verify:
                 echo(f"  ✓ export accepted by {cfg.verify}")
+        if cfg.media_per_site and "live" in site.faces:
+            if html is None:
+                echo(f"  ! media per site: {site.site} has no HTML face — its live face serves its whole "
+                     "static folder")
+            elif (mp := md.plan(cfg, site, code, html)).static is not None:
+                md.build_served(code, site, mp.kept)
+                echo(f"  ✓ media per site: {len(mp.kept)} of {len(mp.files)} file(s) served "
+                     f"({md.human(mp.size(mp.kept))})")
+                if mp.named:
+                    echo(f"  ! named in the site's files, not served: {', '.join(mp.named[:5])}"
+                         + (f" (+{len(mp.named) - 5})" if len(mp.named) > 5 else "")
+                         + " — add them to media_keep")
         if "live" in site.faces:
             dirs = [t.path("live", "sites", site.site, "releases")]
             if cfg.media:
@@ -315,9 +341,6 @@ def publish_site(t: Target, cfg: ReleaseConfig, state: dict, site: Site, release
                 media.symlink_to(f"{LIVE_ROOT}/media/{cfg.project}/{cfg.media}")
             t.rsync(str(code) + "/", t.path("live", "sites", site.site, "releases", release) + "/", "--delete")
             t.sh(f"chmod -R a+rX {shlex.quote(t.path('live', 'sites', site.site, 'releases', release))}")
-    if "live" in site.faces:
-        t.sh(f"ln -sfn {LIVE_ROOT}/sites/{site.site}/current/{site.doc_dir}/static "
-             f"{shlex.quote(t.path('live', 'sites', site.site, 'static'))}")
     apply_passwords(t, cfg, state, site, faces, pool)
     write_maps(t, state)
     if "html" in site.faces:
@@ -452,6 +475,49 @@ def sleep_wake(t: Target, cfg: ReleaseConfig, state: dict, site: Site, asleep: b
     save_state(cfg.root, state)
 
 
+def remove_plan(t: Target, state: dict, name: str) -> list[str]:
+    """What ``stx release remove`` takes off the target for site *name* (#143): ``[]`` when nothing."""
+    if not SITE_RE.match(name):
+        raise ReleaseError(f"{name!r} is not a site name")
+    out = []
+    for face in ("static", "live"):
+        d = t.path(face, "sites", name)
+        if t.sh(f"test -d {shlex.quote(d)}", check=False).returncode == 0:
+            out.append(f"folder {d}")
+    conf = t.path("live", "conf", "programs", f"{name}.conf")
+    if t.sh(f"test -f {shlex.quote(conf)}", check=False).returncode == 0:
+        out.append(f"program {conf} (stopped first)")
+    v = sites_of(state, t.name).get(name)
+    if v is not None:
+        if v.get("port"):
+            out.append(f"line '{name} {v['port']};' of {t.path('live', 'conf', 'ports.map')}")
+        out.append(f"entry {name} of {STATE_FILE} (target {t.name})")
+    return out
+
+
+def remove_site(t: Target, cfg: ReleaseConfig, state: dict, name: str, echo: Echo) -> None:
+    """Take site *name* off the target: its program, its port, its folders and its state entry. No
+    other site is touched; the project's media stay (shared by every site)."""
+    if not SITE_RE.match(name):
+        raise ReleaseError(f"{name!r} is not a site name")
+    conf = t.path("live", "conf", "programs", f"{name}.conf")
+    t.dexec("live", f"supervisorctl stop {name}", check=False)
+    t.sh(f"rm -f {shlex.quote(conf)}")
+    sites_of(state, t.name).pop(name, None)
+    write_maps(t, state)
+    t.dexec("live", "supervisorctl reread", check=False)
+    t.dexec("live", "supervisorctl update", check=False)
+    t.dexec("static", "nginx -s reload", check=False)
+    t.dexec("live", "nginx -s reload", check=False)
+    for face in ("static", "live"):
+        d = t.path(face, "sites", name)
+        if not (SITE_RE.match(name) and d.rstrip("/").endswith(f"sites/{name}")):
+            raise ReleaseError(f"refused to remove {d!r}")
+        t.sh(f"rm -rf {shlex.quote(d)}")
+    save_state(cfg.root, state)
+    echo(f"  ✓ {name} removed from {t.name}")
+
+
 def image_version(t: Target) -> str:
     """The streamtex version the live application actually runs, or ``""`` when it cannot be read."""
     r = t.dexec("live", "/app/.venv/bin/python -c 'import streamtex; print(streamtex.__version__)'", check=False)

{streamtex-0.7.74 → streamtex-0.7.76/streamtex.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: streamtex
-Version: 0.7.74
+Version: 0.7.76
 Summary: AI-powered content framework for Streamlit — create presentations, courses, and web-books with Claude or Cursor, no coding required.
 Author-email: Nicolas Guelfi <nicolas.guelfi@laposte.net>
 License-Expression: BUSL-1.1

{streamtex-0.7.74 → streamtex-0.7.76}/streamtex.egg-info/SOURCES.txt

@@ -155,6 +155,7 @@ streamtex/release/build.py
 streamtex/release/config.py
 streamtex/release/coolify.py
 streamtex/release/levels.py
+streamtex/release/media.py
 streamtex/release/ops.py
 streamtex/release/passwords.py
 streamtex/release/state.py