framework-py 0.1.0.dev2__py3-none-any.whl → 0.1.0.dev3__py3-none-any.whl

framework/_pages.py

@@ -0,0 +1,228 @@
+"""Publishing to GitHub Pages: ``publish(..., to="github")``.
+
+Framework Cloud's "Publish with GitHub Pages" commits a workflow that deploys
+the repository's ``published/`` folder from the default branch. This side
+copies a document into ``published/<slug>/``, commits only that folder, and
+pushes. Documents never pass through the cloud. R and fw behave the same way.
+"""
+
+from __future__ import annotations
+
+import re
+import shutil
+import subprocess
+import sys
+import tempfile
+import warnings
+from dataclasses import dataclass
+from pathlib import Path
+
+from framework._log import inform
+from framework.errors import FrameworkError, FrameworkWarning
+
+PUBLIC_NOTICE = "GitHub Pages sites are public, even when the repository is private."
+_SLUG = re.compile(r"^[a-z0-9][a-z0-9._-]*$")
+_REMOTE = re.compile(r"github\.com[:/]+([^/]+)/([^/]+?)(?:\.git)?/?$")
+
+
+@dataclass(frozen=True)
+class _Remote:
+    name: str
+    owner: str
+    repo: str
+    has_upstream: bool
+
+
+def _git(top: Path, *args: str) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        ["git", "-C", str(top), *args], capture_output=True, text=True, check=False
+    )
+
+
+def github_remote(url: str) -> tuple[str, str] | None:
+    """The owner and repository of a GitHub remote URL (https, ssh, or scp-style)."""
+    match = _REMOTE.search(url.strip())
+    return (match[1], match[2]) if match else None
+
+
+def pages_base(owner: str, repo: str) -> str:
+    """The URL GitHub gives a repository's Pages site."""
+    host = f"{owner.lower()}.github.io"
+    if repo.lower() == host:
+        return f"https://{host}/"
+    return f"https://{host}/{repo}/"
+
+
+def pages_slug(source: Path) -> str:
+    """The file name lowercased, with each run of other characters as "-".
+
+    GitHub Pages URLs are case-sensitive. "Final Report (v2).html" becomes
+    "final-report-v2".
+    """
+    name = source.name if source.is_dir() else source.stem
+    return re.sub(r"[^a-z0-9]+", "-", name.lower()).strip("-")
+
+
+def _remote(top: Path) -> _Remote | None:
+    """The branch's upstream remote, then origin, then any GitHub remote."""
+    upstream = _git(top, "rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}")
+    upstream_name = upstream.stdout.strip().split("/")[0] if upstream.returncode == 0 else None
+    listed = _git(top, "remote")
+    names = listed.stdout.split() if listed.returncode == 0 else []
+    candidates = [n for n in (upstream_name, "origin", *names) if n is not None]
+    for name in dict.fromkeys(candidates):
+        if name not in names:
+            continue
+        url = _git(top, "remote", "get-url", name)
+        found = github_remote(url.stdout) if url.returncode == 0 else None
+        if found is not None:
+            return _Remote(name, found[0], found[1], name == upstream_name)
+    return None
+
+
+def _stage(source: Path, stage: Path, self_contained: bool) -> None:
+    """Copy ``source`` into ``stage`` as a folder whose front page is index.html."""
+    suffix = source.suffix.lower()
+    if source.is_dir():
+        if not (source / "index.html").is_file():
+            raise FrameworkError(
+                f"A folder published to GitHub Pages needs an index.html at its top: {source}"
+            )
+        shutil.copytree(source, stage, dirs_exist_ok=True)
+        return
+    if suffix in (".html", ".htm"):
+        shutil.copy2(source, stage / source.name)
+        assets = source.with_name(f"{source.stem}_files")
+        if assets.is_dir():
+            # The supporting folder keeps its name, so relative links still resolve
+            shutil.copytree(assets, stage / assets.name)
+    elif suffix in (".qmd", ".ipynb"):
+        quarto = shutil.which("quarto")
+        if quarto is None:
+            raise FrameworkError("Rendering requires the quarto command on your PATH.")
+        command = [quarto, "render", str(source.resolve()), "--output-dir", str(stage)]
+        command += ["--to", "html", *(["--embed-resources"] if self_contained else [])]
+        inform(f"Rendering {source.name}...")
+        result = subprocess.run(command, capture_output=True, text=True, check=False)
+        if result.returncode != 0:
+            raise FrameworkError(f"Quarto render failed:\n{result.stdout}{result.stderr}")
+    else:
+        raise FrameworkError(
+            "GitHub Pages publishing takes rendered HTML, a render folder, or a .qmd or "
+            f".ipynb to render. Got: {suffix or source.name}"
+        )
+    if not (stage / "index.html").is_file():
+        main = stage / f"{source.stem}.html"
+        if not main.is_file():
+            pages = sorted(stage.glob("*.htm*"))
+            if len(pages) != 1:
+                raise FrameworkError(f"No single HTML page found to publish from {source}")
+            main = pages[0]
+        main.rename(stage / "index.html")
+
+
+def _cloud_pages_url(root: Path) -> tuple[bool, str | None, str | None]:
+    """Whether the cloud answered, its Pages URL (None when Pages is off), and the server.
+
+    One call to ``/api/v1/me`` with the project token. Not known when there is
+    no project token or the call fails.
+    """
+    from framework.cloud import CloudError, api, cloud_server, project_token
+
+    token = project_token(root)
+    if token is None:
+        return False, None, None
+    try:
+        server = cloud_server(scope="project", project_dir=root).url
+        me = api("/api/v1/me", token, server)
+    except CloudError:
+        return False, None, None
+    if not isinstance(me, dict) or me.get("kind") != "project":
+        return False, None, None
+    pages = me.get("pages_url")
+    return True, pages if isinstance(pages, str) and pages else None, server
+
+
+def _confirm() -> None:
+    # Shown on every run, even when Framework's messages are off
+    print(PUBLIC_NOTICE, file=sys.stderr)
+    if sys.stdin.isatty():
+        answer = input("Publish it? [y/N] ").strip().lower()
+        if answer not in ("y", "yes"):
+            raise FrameworkError("Cancelled: nothing was published.")
+
+
+def github_publish(source: Path, slug: str | None = None, self_contained: bool = True) -> str:
+    """Copy ``source`` to ``published/<slug>/``, commit only that folder, and push."""
+    from framework.project import find_settings_file
+
+    if slug is None:
+        slug = pages_slug(source)
+    if not _SLUG.match(slug):
+        raise FrameworkError(
+            "slug must start with a lowercase letter or digit and use only lowercase letters, "
+            "digits, '.', '_', and '-' (GitHub Pages URLs are case-sensitive)."
+        )
+    settings_file = find_settings_file()
+    root = settings_file.parent if settings_file is not None else Path.cwd()
+    shown = _git(root, "rev-parse", "--show-toplevel")
+    if shown.returncode != 0:
+        raise FrameworkError(
+            "This project isn't a git repository. Create the project on GitHub first."
+        )
+    top = Path(shown.stdout.strip())
+    remote = _remote(top)
+    if remote is None:
+        raise FrameworkError(
+            "This project has no GitHub remote. Create the project on GitHub first, then "
+            "publish again."
+        )
+    _confirm()
+
+    # published/ sits at the top of the repository, where the workflow deploys from
+    rel = f"published/{slug}"
+    with tempfile.TemporaryDirectory(prefix="fw_pages_") as temp:
+        _stage(source, Path(temp), self_contained)
+        target = top / rel
+        if target.exists():
+            shutil.rmtree(target)
+        shutil.copytree(temp, target)
+
+    # Commit only this folder; anything else the user staged stays staged
+    _git(top, "add", "-A", "--", rel)
+    if _git(top, "diff", "--cached", "--quiet", "--", rel).returncode == 0:
+        inform(f"No change in {rel}; nothing committed or pushed.")
+    else:
+        commit = _git(top, "commit", "-m", f"Publish {slug}", "--", rel)
+        if commit.returncode != 0:
+            raise FrameworkError(f"git commit failed:\n{commit.stdout}{commit.stderr}")
+        branch = _git(top, "rev-parse", "--abbrev-ref", "HEAD").stdout.strip()
+        default = _git(top, "symbolic-ref", "--short", f"refs/remotes/{remote.name}/HEAD")
+        if default.returncode == 0:
+            default_branch = default.stdout.strip().split("/", 1)[-1]
+            if branch != default_branch:
+                warnings.warn(
+                    f"You're on '{branch}'. GitHub Pages deploys only from the default branch "
+                    f"('{default_branch}'), so this won't appear until it's merged there.",
+                    FrameworkWarning,
+                    stacklevel=3,
+                )
+        push = (
+            _git(top, "push")
+            if remote.has_upstream
+            else _git(top, "push", "-u", remote.name, "HEAD")
+        )
+        if push.returncode != 0:
+            raise FrameworkError(f"Committed, but git push failed:\n{push.stdout}{push.stderr}")
+
+    known, pages_url, server = _cloud_pages_url(root)
+    if known and pages_url is None:
+        warnings.warn(
+            f"GitHub Pages is off for this project. Turn it on under Projects at {server}.",
+            FrameworkWarning,
+            stacklevel=3,
+        )
+    base = pages_url or pages_base(remote.owner, remote.repo)
+    url = f"{base.rstrip('/')}/{slug}/"
+    inform(f"Published to {url}")
+    return url

framework/_private.py

@@ -0,0 +1,69 @@
+"""The check before an upload: a path with "private" in it needs confirmation.
+
+Uploads are always the user's explicit choice, so the check never refuses
+outright. Any source whose full path contains "private", in any letter case,
+is listed with a warning. An interactive session asks before uploading. A
+session with no terminal (scripts, CI, notebooks run by agents) raises an
+error unless ``include_private=True`` is passed.
+"""
+
+from __future__ import annotations
+
+import sys
+import warnings
+from collections.abc import Iterable
+from pathlib import Path
+
+from framework.errors import FrameworkError
+
+# macOS resolves /tmp, /var, and /etc to /private/..., which the user did not name
+_SYSTEM_PREFIX = "/private/"
+
+
+def is_private_path(path: Path) -> bool:
+    """Whether the full absolute path contains "private", ignoring the system prefix."""
+    full = path.expanduser().resolve().as_posix()
+    if full.startswith(_SYSTEM_PREFIX):
+        full = full[len(_SYSTEM_PREFIX) - 1 :]
+    return "private" in full.lower()
+
+
+def include_private_arg(include_private: bool, allow_private: bool | None) -> bool:
+    """``include_private``, honoring the deprecated ``allow_private`` name."""
+    if allow_private is None:
+        return include_private
+    warnings.warn(
+        "allow_private is deprecated; use include_private instead.",
+        DeprecationWarning,
+        stacklevel=3,
+    )
+    return include_private or allow_private
+
+
+def confirm_private_upload(paths: Iterable[Path], include_private: bool) -> None:
+    """Warn about private paths among ``paths`` and ask before uploading them.
+
+    Raises:
+        FrameworkError: When there is no terminal to ask on and ``include_private`` is
+            False, or when the user declines.
+    """
+    if include_private:
+        return
+    flagged = [p for p in paths if is_private_path(p)]
+    if not flagged:
+        return
+    shown = "".join(f"\n  {p}" for p in flagged[:5])
+    if len(flagged) > 5:
+        shown += f"\n  ... and {len(flagged) - 5} more"
+    print(
+        f"Warning: {len(flagged)} file(s) to upload have 'private' in their path:{shown}",
+        file=sys.stderr,
+    )
+    if not sys.stdin.isatty():
+        raise FrameworkError(
+            "Not uploading files with 'private' in their path without confirmation. "
+            "Review them, then pass include_private=True to upload them."
+        )
+    answer = input("Upload them anyway? [y/N] ").strip().lower()
+    if answer not in ("y", "yes"):
+        raise FrameworkError("Cancelled. Nothing was uploaded.")

framework/cloud.py

@@ -41,6 +41,7 @@ import pandas as pd
 
 from framework import _secretservice, _wincred, _yaml, db, dotenv
 from framework._log import inform, show_messages
+from framework._private import confirm_private_upload
 from framework.config_home import config_dir, ensure_config_dir, r_config_dir
 from framework.errors import FrameworkError, FrameworkWarning
 from framework.integrity import file_hash
@@ -803,14 +804,23 @@ def cloud_publish(
     self_contained: bool = True,
     slug: str | bool | None = None,
     title: str | None = None,
+    include_private: bool = False,
 ) -> str:
     """Publish rendered HTML (or a .qmd or .ipynb to render) to the project's cloud server.
 
     Accepts a self-contained ``.html``, an ``.html`` with a sibling
     ``<name>_files/`` folder, a render output folder, or a ``.qmd`` or ``.ipynb``. Each
     publish adds a version. ``slug`` names the document and turns on its
-    readable URL (``True`` uses the derived name, ``False`` turns it off).
+    readable URL (``True`` uses the derived name, ``False`` turns it off). A source with
+    "private" in its path needs confirmation, or ``include_private=True``.
     """
+    sources = [source]
+    if source.is_dir():
+        sources = sorted(p for p in source.rglob("*") if p.is_file())
+    elif source.with_name(f"{source.stem}_files").is_dir():
+        assets = source.with_name(f"{source.stem}_files")
+        sources += sorted(p for p in assets.rglob("*") if p.is_file())
+    confirm_private_upload(sources, include_private)
     token = _require_project_token()
     with tempfile.TemporaryDirectory(prefix="fw_publish_") as temp:
         stage = Path(temp)

framework/storage.py

@@ -12,8 +12,9 @@ Credentials come from the environment (``S3_ACCESS_KEY`` and
 environment variables take precedence over values in the settings.
 
 Publishing uploads files with a public-read ACL and returns their URLs.
-Sources inside a ``private`` folder of the project are refused unless
-``allow_private=True`` is passed, as in R.
+A source with "private" anywhere in its full path is listed with a warning
+and needs confirmation: an interactive session asks, and a session with no
+terminal raises an error unless ``include_private=True`` is passed.
 """
 
 from __future__ import annotations
@@ -33,6 +34,7 @@ from typing import Any
 import pandas as pd
 
 from framework._log import inform
+from framework._private import confirm_private_upload, include_private_arg
 from framework.errors import FrameworkError
 from framework.settings import settings_read
 
@@ -208,29 +210,6 @@ def resolve_bucket(connection: str | None = None) -> Bucket:
 # Uploading --------------------------------------------------------------------------
 
 
-def _refuse_private(path: Path, allow_private: bool) -> None:
-    """Refuse a source inside a folder named ``private`` within the project.
-
-    Folders above the project root do not count (macOS keeps temporary files
-    under ``/private``), and nothing is refused outside a project.
-    """
-    from framework.project import find_settings_file
-
-    settings_file = find_settings_file()
-    if allow_private or settings_file is None:
-        return
-    root = settings_file.parent.resolve()
-    resolved = path.resolve()
-    if not resolved.is_relative_to(root):
-        return
-    relative = resolved.relative_to(root)
-    if "private" in relative.parts:
-        raise FrameworkError(
-            f"Refusing to publish '{relative.as_posix()}': it is inside a private folder, which "
-            "holds restricted data. Pass allow_private=True if you really mean to publish it."
-        )
-
-
 def _content_type(path: Path) -> str:
     return (
         _CONTENT_TYPES.get(path.suffix.lower())
@@ -295,6 +274,37 @@ def _target(connection: str | None) -> str:
     )
 
 
+def _publish_github(
+    to: str,
+    source: Path,
+    dest: str | None,
+    connection: str | None,
+    slug: str | bool | None,
+    self_contained: bool,
+) -> str:
+    """``to="github"``, after rejecting arguments that mean something only elsewhere."""
+    from framework._pages import github_publish
+
+    if to != "github":
+        raise FrameworkError(f'to must be "github" or None (got "{to}").')
+    given = [
+        name
+        for name, used in (
+            ("dest", dest is not None),
+            ("connection", connection is not None),
+            ("slug=True/False", isinstance(slug, bool)),
+        )
+        if used
+    ]
+    if given:
+        raise FrameworkError(
+            f'Not used with to="github": {", ".join(given)}. Name the published folder with '
+            'slug="...".'
+        )
+    assert not isinstance(slug, bool)
+    return github_publish(source, slug=slug, self_contained=self_contained)
+
+
 def _slug_ignored(slug: str | bool | None) -> None:
     if slug is not None:
         import warnings
@@ -315,7 +325,10 @@ def publish(
     overwrite: bool = True,
     self_contained: bool = True,
     slug: str | bool | None = None,
-    allow_private: bool = False,
+    include_private: bool = False,
+    *,
+    to: str | None = None,
+    allow_private: bool | None = None,
 ) -> str | list[str]:
     """Upload a file or folder to the project's storage bucket.
 
@@ -326,8 +339,13 @@ def publish(
         overwrite: Accepted for parity with R; uploads always replace.
         self_contained: For Framework Cloud publishing.
         slug: For Framework Cloud publishing.
-        allow_private: Publish even though the source is inside a ``private``
-            folder. Only a person who has reviewed the file should set this.
+        include_private: Upload files with "private" in their path without asking. Only a
+            person who has reviewed the files should set this.
+        to: "github" publishes to the project's GitHub Pages site: the page is copied to
+            ``published/<slug>/`` at the top of the repository, only that folder is
+            committed, and the commit is pushed. Pages sites are public, even from a private
+            repository. Default: a storage bucket or Framework Cloud.
+        allow_private: Deprecated name for ``include_private``.
 
     Returns:
         The public URL, or a list of URLs for a folder.
@@ -335,11 +353,16 @@ def publish(
     path = Path(source)
     if not path.exists():
         raise FrameworkError(f"Source not found: {path}")
-    _refuse_private(path, allow_private)
+    include = include_private_arg(include_private, allow_private)
+    confirm_private_upload(_files(path, True, None) if path.is_dir() else [path], include)
+    if to is not None:
+        return _publish_github(to, path, dest, connection, slug, self_contained)
     if _target(connection) == "cloud":
         from framework.cloud import cloud_publish
 
-        return cloud_publish(path, dest=dest, self_contained=self_contained, slug=slug)
+        return cloud_publish(
+            path, dest=dest, self_contained=self_contained, slug=slug, include_private=True
+        )
     _slug_ignored(slug)
     bucket = resolve_bucket(connection)
     dest = dest or path.name
@@ -359,7 +382,10 @@ def publish_notebook(
     self_contained: bool = True,
     format: str = "html",
     slug: str | bool | None = None,
-    allow_private: bool = False,
+    include_private: bool = False,
+    *,
+    to: str | None = None,
+    allow_private: bool | None = None,
 ) -> str:
     """Render a Quarto notebook with the ``quarto`` command and upload the result.
 
@@ -385,20 +411,30 @@ def publish_notebook(
         slug: For Framework Cloud: a string names the document and turns on its readable URL,
             True uses the derived name, and False turns the readable URL off. A storage bucket
             ignores it with a warning.
-        allow_private: Publish even though the source is inside a ``private`` folder in the
-            project. Only a person who has reviewed the file should set this.
+        include_private: Upload files with "private" in their path without asking. Only a
+            person who has reviewed the files should set this.
+        to: "github" publishes to the project's GitHub Pages site: the page is copied to
+            ``published/<slug>/`` at the top of the repository, only that folder is
+            committed, and the commit is pushed. Pages sites are public, even from a private
+            repository. Default: a storage bucket or Framework Cloud.
+        allow_private: Deprecated name for ``include_private``.
 
     Returns:
         The public URL.
 
     Raises:
-        FrameworkError: When the file is missing or not a notebook, is inside a ``private``
-            folder, Quarto is not installed, rendering fails, or there is nowhere to publish.
+        FrameworkError: When the file is missing or not a notebook, has "private" in its path
+            and is not confirmed, Quarto is not installed, rendering fails, or there is nowhere
+            to publish.
     """
     source = Path(file)
     if not source.is_file() or source.suffix.lower() not in (".qmd", ".ipynb"):
         raise FrameworkError(f"publish_notebook() needs an existing .qmd or .ipynb file: {source}")
-    _refuse_private(source, allow_private)
+    confirm_private_upload([source], include_private_arg(include_private, allow_private))
+    if to is not None:
+        if format != "html":
+            raise FrameworkError(f'GitHub Pages publishes HTML only (got format="{format}").')
+        return _publish_github(to, source, dest, connection, slug, self_contained)
     quarto = shutil.which("quarto")
     if quarto is None:
         raise FrameworkError(
@@ -409,7 +445,9 @@ def publish_notebook(
             raise FrameworkError(f'Framework Cloud publishes HTML only (got format="{format}").')
         from framework.cloud import cloud_publish
 
-        return cloud_publish(source, dest=dest, self_contained=self_contained, slug=slug)
+        return cloud_publish(
+            source, dest=dest, self_contained=self_contained, slug=slug, include_private=True
+        )
     _slug_ignored(slug)
     bucket = resolve_bucket(connection)
     self_contained = self_contained or not bucket.static_hosting
@@ -449,7 +487,9 @@ def publish_data(
     format: str = "csv",
     connection: str | None = None,
     compress: bool = False,
-    allow_private: bool = False,
+    include_private: bool = False,
+    *,
+    allow_private: bool | None = None,
 ) -> str:
     """Upload a DataFrame (as CSV, Parquet, or JSON) or a data file.
 
@@ -463,18 +503,20 @@ def publish_data(
         connection: A storage bucket name from the settings. Default: the project's default
             bucket, then one marked ``default: true``, then the first.
         compress: Gzip the file before uploading.
-        allow_private: Publish a file even though it is inside a ``private`` folder in the
-            project. Only a person who has reviewed the file should set this.
+        include_private: Upload files with "private" in their path without asking. Only a
+            person who has reviewed the files should set this.
+        allow_private: Deprecated name for ``include_private``.
 
     Returns:
         The public URL.
 
     Raises:
-        FrameworkError: When ``format`` is not allowed, the file is missing or inside a
-            ``private`` folder, no bucket is configured, or the upload fails.
+        FrameworkError: When ``format`` is not allowed, the file is missing or has "private"
+            in its path and is not confirmed, no bucket is configured, or the upload fails.
     """
     if format not in ("csv", "parquet", "json"):
         raise FrameworkError("format must be csv, parquet, or json (rds is R-only)")
+    include = include_private_arg(include_private, allow_private)
     bucket = resolve_bucket(connection)
     with tempfile.TemporaryDirectory(prefix="publish_data_") as temp:
         if isinstance(data, pd.DataFrame):
@@ -489,7 +531,7 @@ def publish_data(
             source = Path(data)
             if not source.is_file():
                 raise FrameworkError(f"File not found: {source}")
-            _refuse_private(source, allow_private)
+            confirm_private_upload([source], include)
         if compress:
             compressed = Path(temp) / f"{source.name}.gz"
             with source.open("rb") as raw, gzip.open(compressed, "wb") as packed:
@@ -507,7 +549,9 @@ def publish_dir(
     connection: str | None = None,
     pattern: str | None = None,
     recursive: bool = True,
-    allow_private: bool = False,
+    include_private: bool = False,
+    *,
+    allow_private: bool | None = None,
 ) -> list[str]:
     """Upload the files in a folder. ``pattern`` is a regular expression on the paths.
 
@@ -520,25 +564,27 @@ def publish_dir(
         pattern: Only upload files whose path matches this regular expression (searched
             anywhere in the path). Default: every file.
         recursive: Include files in subfolders.
-        allow_private: Publish even though the source is inside a ``private`` folder in the
-            project. Only a person who has reviewed the file should set this.
+        include_private: Upload files with "private" in their path without asking. Only a
+            person who has reviewed the files should set this.
+        allow_private: Deprecated name for ``include_private``.
 
     Returns:
         The public URL of each file uploaded. The list is empty when no file matched.
 
     Raises:
-        FrameworkError: When the folder is missing or inside a ``private`` folder, no bucket is
-            configured, or an upload fails.
+        FrameworkError: When the folder is missing, a file has "private" in its path and is
+            not confirmed, no bucket is configured, or an upload fails.
     """
     folder = Path(dir)
     if not folder.is_dir():
         raise FrameworkError(f"Directory not found: {folder}")
-    _refuse_private(folder, allow_private)
-    bucket = resolve_bucket(connection)
+    include = include_private_arg(include_private, allow_private)
     files = _files(folder, recursive, pattern)
     if not files:
         inform("No files found to upload")
         return []
+    confirm_private_upload(files, include)
+    bucket = resolve_bucket(connection)
     dest = dest or folder.resolve().name
     inform(f"Uploading {len(files)} files...")
     urls = _upload_folder(folder, dest, bucket, files)

framework/templates/skills/framework-outputs/SKILL.md

@@ -61,8 +61,8 @@ fw.publish("outputs/report.html")
 fw.publish_notebook("notebooks/analysis.qmd")
 ```
 
-The publish functions refuse files inside a `private` folder, because those
-folders hold restricted data. They take `allow_private=True` to override
-this. Never pass `allow_private=True` on your own: only the person who has
-reviewed the file can decide that it is safe to publish. See the
-`framework-sensitive-data` skill if this project has one.
+The publish functions warn about any file with "private" in its path and ask
+the user to confirm. In a script they stop with an error. Never pass
+`include_private=True` or answer the prompt on the user's behalf: only the
+person who has reviewed the file can decide that it is safe to publish. See
+the `framework-sensitive-data` skill if this project has one.

framework/templates/skills/framework-sensitive-data/SKILL.md

@@ -15,8 +15,9 @@ whether something is safe, treat it as private.
 2. Raw data with identifiers goes in a `private/` folder.
 3. Only de-identified, aggregated data goes in a `public/` folder.
 4. Review every output before saving it to a public folder.
-5. Never publish anything from a private folder, and never pass
-   `allow_private=True` to a publish function on your own.
+5. Never publish anything from a private folder. Never pass
+   `include_private=True` to a publish function or answer its prompt on the
+   user's behalf.
 6. Do not read or print restricted files. Values you print are sent to the
    model provider. Work from the data dictionary and simulated data instead.
 

{framework_py-0.1.0.dev2.dist-info → framework_py-0.1.0.dev3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: framework-py
-Version: 0.1.0.dev2
+Version: 0.1.0.dev3
 Summary: Structured data science projects: a data catalog, integrity tracking, caching, outputs, and AI guardrails
 Project-URL: Homepage, https://framework.pub
 Project-URL: Source, https://github.com/frameworktools/framework-py

{framework_py-0.1.0.dev2.dist-info → framework_py-0.1.0.dev3.dist-info}/RECORD

@@ -1,7 +1,9 @@
 framework/__init__.py,sha256=Mq-Oq0FPzKPL7RbTGbwDaKV3do5DYLsBHkUSREabvoU,5652
 framework/__main__.py,sha256=2YFKuWdA_X9z8nE0STKaTkzrvdc_cEdMxW_XM0h3GBo,3579
 framework/_log.py,sha256=MhVL7izCJUvdg7F9430j8gPFiFyx3VcJ0qyJmrn2uUk,885
+framework/_pages.py,sha256=Bm5b2NWr7H0I4t_kLtwFpaPaoPO2zGfsAuX8Z-95YTY,9250
 framework/_paths.py,sha256=iAnUfmnnLDOUSbf7CGLXdW9SYWxchJxfVvJPbQkxyJk,2200
+framework/_private.py,sha256=pZpvs1CSaUiSPCaBvqF13r2uwbXD8f5UFsCVu-9TzQY,2545
 framework/_secretservice.py,sha256=zv5UvEekQic466qRmVpLG_hfEkisikHfab8e6kyzS2k,2450
 framework/_time.py,sha256=mv-BS3NjOo0hr6bwYRhUBY-3sG6SJmzaboaMD62QcJw,306
 framework/_wincred.py,sha256=oJGS37Dcw_PZVmiAGRu4H_lhcOC5-FqGGYfxVUGPPmU,3891
@@ -10,7 +12,7 @@ framework/ai.py,sha256=oKJOjHMUByqom8Ngk5dVlJj5ZbWJtFD7Mddvbqsh5qc,8114
 framework/bootstrap.py,sha256=giXT20hQ-InqUlbtvOluqVMD4cpk5DcCrD5LqOFTARA,7913
 framework/cache.py,sha256=I7LIPcxiT6j9N7ogJlNb0Nw99SNiMDcmed2xMzBFRBQ,12342
 framework/catalog.py,sha256=7icsQYhdAqi56pN74Lc650L4FhqyB_jOd6d88NhpDV4,8632
-framework/cloud.py,sha256=v4FTscF7m6dIjZ5VumkveidtCJGINC15zOIiIQFYGgg,34938
+framework/cloud.py,sha256=1_VW0jbvBOSzHrQktI2hko_YQ8lUqjXRanHWmHeC5_c,35475
 framework/config_home.py,sha256=MHvKZ0vV0m2R1uPQmtMlfoim2XMhcLveJyBAyCpTKn8,7218
 framework/connections.py,sha256=Y-pOaoKbd9CCNb31po9xtdutvq00s6jCP5miWhidqoI,17057
 framework/console.py,sha256=zQ0LuFDcxe1W1kuc5E1bJ03h8d3cvwFoqDT8dAJQyN0,1267
@@ -32,7 +34,7 @@ framework/scaffold.py,sha256=MvyKbNStU-DJkIfNgXAVHoNmn-oAtYeC5gfYxe07ryk,10072
 framework/scratch.py,sha256=idxthUR5BIMX7FIGS7KzIuhOrO3-HKLbBsV8It3EEE4,3890
 framework/security.py,sha256=lPhAU_f3Yiq_yRAOroN_cMqeYvjKUanK9uls1BKDavg,24770
 framework/settings.py,sha256=c0FNmOKZf7_E_HhEWSS0hus2ZC7stOAzDVDHqgZWkzc,18290
-framework/storage.py,sha256=flGhHB53JaHL1HRsq_KRjfHuxb38Rp2V0LFRAdj2BPE,23293
+framework/storage.py,sha256=7iE1Hx34Vs4oXheCQoeTFhJZPtv_B8YgWr9DlBxPkzA,25424
 framework/_assets/init.sql,sha256=-aIiuIcCmBniGKq-CHdRtUiV9e_CLXoqxxd05snmgOE,1156
 framework/_assets/hooks/pre-commit,sha256=wXkNetsub3sTi2LYewB-b5DRN8yoAd-M8pG9OEa0TPs,2280
 framework/_assets/schema/docs-reference.v1.json,sha256=4RWr0daKXxXUbFeU8F-IBiPpKGGX_9pqTB_o3Lkwn18,5922
@@ -49,16 +51,16 @@ framework/templates/gitignore/presentation,sha256=CAl2vPcA1Lgv1CXsVmuKf7DtIVs-g6
 framework/templates/gitignore/project,sha256=D8jFTFhIyJyTIh1xrPE5wFkvuJlSkqaqeJYafnmRPts,2622
 framework/templates/gitignore/sensitive,sha256=mz0KwMHq1UJhOGJTFzTbzJug6C6p2wbec9ADl2veqhE,3550
 framework/templates/skills/framework-data/SKILL.md,sha256=jdy9b0OgEWEvySgBTEVwEr6haSHYqRgCRRaT9Xd9zso,1802
-framework/templates/skills/framework-outputs/SKILL.md,sha256=TPxr8mr8Xmf3cdsA8gsd2E6qnADraDz8TMlz2JaMyVw,2407
+framework/templates/skills/framework-outputs/SKILL.md,sha256=5ipWm8GBTmc0SL79I9HQ8ezaibpk1zwuHJbdp9Za5Tc,2419
 framework/templates/skills/framework-packages/SKILL.md,sha256=hReYddtMTK9dzqLiGOrSxbE8YA6OFia_E8tqbkSgNxI,1170
-framework/templates/skills/framework-sensitive-data/SKILL.md,sha256=o3TY43t5Ln6wCUacZ7rvOwVuRgDl2yVUgScsufnwFzk,1536
+framework/templates/skills/framework-sensitive-data/SKILL.md,sha256=1Qid4542CV0sctzUaEXCtNxkl5l8JMuZs6hUwkmGTPc,1567
 framework/templates/skills/framework-workflow/SKILL.md,sha256=-UIc81zJrO-0FfKlt2QK5Zfh0YzqbqNzBPskBpXe_1Q,2139
 framework/templates/stubs/notebook-default.ipynb,sha256=2p3Zj6bQEHlUL1eEVAbPfTTxqGBs84C67tA3MkCzVQs,685
 framework/templates/stubs/notebook-default.qmd,sha256=8Js1S2BcHYeQWmJS-kt31gBvIjKzQeGEy2M2lQCVA1Y,472
 framework/templates/stubs/notebook-minimal.qmd,sha256=2U2k8judffhrh_6m6r6OAbQBCYEtViAjeKRBqBYCJTM,178
 framework/templates/stubs/notebook-revealjs.qmd,sha256=_ztT_gHoudpB5DIjlbvtB5zQ8163DeV8xbWcT-HgJrI,409
 framework/templates/stubs/script-default.py,sha256=vbWqgW0_rHot17mQC3tYb92g_9L-cbTOeL3y99BRrSk,216
-framework_py-0.1.0.dev2.dist-info/METADATA,sha256=sQoSQQFfOxJ55-gMEO0nRlEJmR-8qm8j1x9R3vPv1Lk,3730
-framework_py-0.1.0.dev2.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
-framework_py-0.1.0.dev2.dist-info/licenses/LICENSE,sha256=giOOgSwALkZimC7uhLZQK8Untez641bLW1-2-Cjvmq0,1072
-framework_py-0.1.0.dev2.dist-info/RECORD,,
+framework_py-0.1.0.dev3.dist-info/METADATA,sha256=x16APIzNkCGAurfJ06wWvrOT_OaL3YFaET2H9mvoZBM,3730
+framework_py-0.1.0.dev3.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+framework_py-0.1.0.dev3.dist-info/licenses/LICENSE,sha256=giOOgSwALkZimC7uhLZQK8Untez641bLW1-2-Cjvmq0,1072
+framework_py-0.1.0.dev3.dist-info/RECORD,,