calkit-python 0.47.2__tar.gz → 0.47.3__tar.gz

{calkit_python-0.47.2 → calkit_python-0.47.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: calkit-python
-Version: 0.47.2
+Version: 0.47.3
 Summary: Reproducibility simplified.
 Project-URL: Homepage, https://calkit.org
 Project-URL: Issues, https://github.com/calkit/calkit/issues

{calkit_python-0.47.2 → calkit_python-0.47.3}/calkit/cli/latex.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import hashlib
 import json
 import os
+import re
 import shutil
 import string
 import subprocess
@@ -539,8 +540,44 @@ def _build_diff(
     try:
         # --flatten pulls \input and \include files into one document on
         # each side, so a multi-file paper compares as a whole
+        latexdiff_cmd = ["latexdiff", "--flatten", "--encoding=utf8"]
+        # latexdiff dies trying to open a verbatim input that's a macro
+        # parameter, e.g., \verbatiminput{#1.wcsum} in a \newcommand, so a
+        # filter breaks the line after the command, which TeX reads the same
+        # but latexdiff's pattern doesn't match
+        verbatim_param = re.compile(
+            r"\\(?:verbatiminput\*?|lstinputlisting)"
+            r"\s*(?:\[[^\]\n]*\])?\s*\{[^}\n]*#[0-9]"
+        )
+        sources = [base_tex, head_tex] + [
+            path
+            for side in (base_tex, head_tex)
+            for path in calkit.latex.detect_inputs(side)
+            if Path(path).suffix in calkit.latex._SOURCE_EXTS
+        ]
+        if any(
+            os.path.isfile(path)
+            and verbatim_param.search(
+                Path(path).read_text(encoding="utf-8", errors="replace")
+            )
+            for path in sources
+        ):
+            filter_path = Path(DIFF_TMP_DIR, "verbatim-param-filter.pl")
+            os.makedirs(filter_path.parent, exist_ok=True)
+            # latexdiff appends a newline to what it sends, so drop it
+            filter_path.write_text(
+                "local $/;\n"
+                "my $text = <STDIN>;\n"
+                "$text =~ s/\\n\\z//;\n"
+                "$text =~ s/(\\\\(?:verbatiminput\\*?|lstinputlisting))"
+                "(?=\\s*(?:\\[[^\\]\\n]*\\])?\\s*\\{[^}\\n]*#[0-9])/$1%\\n/g;\n"
+                "print $text;\n"
+            )
+            latexdiff_cmd.append(
+                f"--filter-script=perl {filter_path.as_posix()}"
+            )
         cmd = _tex_cmd(
-            ["latexdiff", "--flatten", "--encoding=utf8", base_tex, head_tex],
+            latexdiff_cmd + [base_tex, head_tex],
             environment=environment,
             no_check=no_check,
             verbose=verbose,

{calkit_python-0.47.2 → calkit_python-0.47.3}/calkit/cli/main/core.py

@@ -1672,6 +1672,14 @@ def push(
             git_cmd = ["git", "push"]
             if not no_recursive and "--recurse-submodules" not in git_args:
                 git_cmd.append("--recurse-submodules=on-demand")
+            # A plain `git push` leaves tags behind, so annotated tags end
+            # up only on the machine that made them
+            if not {
+                "--follow-tags",
+                "--no-follow-tags",
+                "--tags",
+            }.intersection(git_args):
+                git_cmd.append("--follow-tags")
             subprocess.check_call(git_cmd + git_args)
         except subprocess.CalledProcessError:
             raise_error("Git push failed")

{calkit_python-0.47.2 → calkit_python-0.47.3}/calkit/conda.py

@@ -207,6 +207,42 @@ def _normalize_git_dep_url(dep: str) -> str:
     return url.rstrip("/")
 
 
+def _unparseable_version_satisfies(
+    req_spec: str, actual_vers: str
+) -> bool | None:
+    """Check a requirement spec against a version string PEP 440 rejects.
+
+    Returns ``True`` or ``False`` when every clause in ``req_spec`` is a plain
+    equality or inequality (``==``, ``===`` or ``!=``), since those can be
+    decided by comparing the version strings directly. Returns ``None`` when
+    the spec needs version ordering (``<``, ``<=``, ``>``, ``>=``, ``~=``) or
+    contains a wildcard, both of which need a parsed version.
+
+    An empty spec means any version satisfies the requirement.
+
+    The comparison is an exact string match: without a parsed version there is
+    no zero-padding, so ``==1.0`` will not match an installed ``1.0.0``.
+    """
+    if not req_spec:
+        return True
+    clauses = [clause for clause in req_spec.split(",") if clause]
+    for clause in clauses:
+        for op in ("===", "==", "!="):
+            if not clause.startswith(op):
+                continue
+            value = clause[len(op) :]
+            if "*" in value:
+                # Wildcards need normalised versions to expand.
+                return None
+            if (actual_vers == value) == (op == "!="):
+                return False
+            break
+        else:
+            # An ordering operator, or something unrecognized.
+            return None
+    return True
+
+
 def _check_single(
     req: str, actual: str, env_spec_dir: str, conda: bool = False
 ) -> bool:
@@ -248,7 +284,10 @@ def _check_single(
         return _pkg_name_from_dep(req) == _pkg_name_from_dep(actual)
     if req_is_git:
         req = _GIT_RE.split(req)[0].strip()
-    req_name = re.split("[=<>]", req)[0].strip()
+    # Split on the first version operator. "!" and "~" are in the class so
+    # that "!=" and "~=" requirements yield the bare package name instead of a
+    # name with the operator's leading character stuck to it.
+    req_name = re.split("[=<>!~]", req)[0].strip()
     req_spec = req.removeprefix(req_name).strip().replace(" ", "")
     if "[" in req_name:
         warnings.warn(f"Cannot check optional dependencies for {req_name}")
@@ -266,7 +305,7 @@ def _check_single(
     if actual_is_git:
         # Spec has no git URL but installed dep does; name match is sufficient
         actual = _GIT_RE.split(actual)[0].strip()
-    actual_parts = re.split("[=<>]+", actual, maxsplit=1)
+    actual_parts = re.split("[=<>!~]+", actual, maxsplit=1)
     actual_name = actual_parts[0]
     actual_vers = actual_parts[1] if len(actual_parts) > 1 else ""
     if actual_name.strip().lower() != req_name.lower():
@@ -279,11 +318,33 @@ def _check_single(
     try:
         version = Version(actual_vers)
     except InvalidVersion:
-        warnings.warn(
-            f"Cannot properly check {actual_name} version {actual_vers}"
-        )
-        # TODO: Check exact version only
-        return True
+        # An unparseable actual version (e.g. conda's "9e") can't go through
+        # SpecifierSet, which needs a parsed version to order by. Equality
+        # comparisons don't need ordering, so decide those from the version
+        # strings directly.
+        exact = _unparseable_version_satisfies(req_spec, actual_vers)
+        if exact is None:
+            # Ordering constraints and wildcards are genuinely undecidable
+            # here. A bare package name accepts any version; a pinned
+            # constraint we can't confirm counts as not satisfied rather than
+            # silently passing.
+            if not req_spec:
+                warnings.warn(
+                    f"Cannot properly check {actual_name} version "
+                    f"{actual_vers}"
+                )
+                return True
+            warnings.warn(
+                f"Cannot properly check {actual_name} version {actual_vers} "
+                f"against constraint '{req_spec}'"
+            )
+            return False
+        if not exact:
+            warnings.warn(
+                f"Installed {actual_name} version {actual_vers} does not "
+                f"satisfy '{req_spec}'"
+            )
+        return exact
     spec = SpecifierSet(req_spec)
     return spec.contains(version, prereleases=editable)
 

{calkit_python-0.47.2 → calkit_python-0.47.3}/calkit/tests/cli/main/test_core.py

@@ -2784,3 +2784,43 @@ def test_push_reports_what_was_pushed(monkeypatch, tmp_dir):
     assert sent[-1]["targets"] == ["dvc"]
     cli_core._tell_hub_we_pushed(["dvc", "docker", "git"], [])
     assert sent[-1]["targets"] == ["dvc", "docker", "git"]
+
+
+def test_push_carries_annotated_tags(tmp_dir):
+    """Annotated tags should reach the remote along with their commits.
+
+    A plain ``git push`` leaves tags behind, so a project that tags its
+    results ends up with labels that exist only on the machine that made
+    them.
+    """
+    remote = os.path.join(tmp_dir, "remote.git")
+    subprocess.check_call(["git", "init", "--bare", "-q", remote])
+    work = os.path.join(tmp_dir, "work")
+    os.makedirs(work)
+    os.chdir(work)
+    subprocess.check_call(["git", "init", "-q"])
+    subprocess.check_call(["git", "remote", "add", "origin", remote])
+    # ``calkit init`` commits what it creates, so there is a commit to tag
+    subprocess.check_call(["calkit", "init"])
+    subprocess.check_call(["git", "tag", "-a", "v0.1.0", "-m", "First"])
+    # An unannotated tag must stay local: --follow-tags is deliberately the
+    # conservative form, so scratch tags do not get published by accident
+    subprocess.check_call(["git", "tag", "scratch"])
+    subprocess.check_call(
+        [
+            "calkit",
+            "push",
+            "git",
+            "--git-arg",
+            "-u",
+            "--git-arg",
+            "origin",
+            "--git-arg",
+            "HEAD",
+        ]
+    )
+    tags = subprocess.check_output(
+        ["git", "ls-remote", "--tags", remote], text=True
+    )
+    assert "v0.1.0" in tags
+    assert "scratch" not in tags

{calkit_python-0.47.2 → calkit_python-0.47.3}/calkit/tests/cli/test_latex.py

@@ -358,6 +358,7 @@ def test_marked_up_digest_ignores_the_header():
     assert _marked_up_digest(changed) != _marked_up_digest(first)
 
 
+@skipif_windows_docker
 def test_latex_diff_of_one_revision_against_itself(tmp_dir):
     # Two revisions that resolve to the same commit is what a pull request
     # diff looks like from the default branch. The pipeline resolves both
@@ -387,3 +388,17 @@ def test_latex_diff_of_one_revision_against_itself(tmp_dir):
         text=True,
     )
     assert "Nothing to compare" not in result.stderr
+    # A verbatim input that's a macro parameter used to make latexdiff try
+    # to open, e.g., '#1.wcsum' and fail
+    with open("paper/main.tex", "w") as f:
+        f.write("\\documentclass{article}\n\\usepackage{verbatim}\n")
+        f.write("\\newcommand{\\wc}[1]{\\verbatiminput{#1.wcsum}}\n")
+        f.write("\\begin{document}\nHi\n\\end{document}\n")
+    _commit("macro")
+    result = subprocess.run(
+        ["calkit", "latex", "diff", "paper/main.tex", "--from", sha],
+        capture_output=True,
+        text=True,
+    )
+    assert "Couldn't open" not in result.stderr
+    assert result.returncode == 0, result.stderr

{calkit_python-0.47.2 → calkit_python-0.47.3}/calkit/tests/test_conda.py

@@ -14,6 +14,7 @@ from calkit.conda import (
     _enrich_pip_deps_from_freeze,
     _get_pip_dependency_list,
     _split_env_dependencies,
+    _unparseable_version_satisfies,
     check_env,
     find_conda_exe,
 )
@@ -77,6 +78,64 @@ def test_check_single():
         env_spec_dir=".",
         conda=False,
     )
+    # Unparseable actual version (e.g. conda's "9e"): equality and inequality
+    # are still decidable by comparing version strings, a bare name accepts any
+    # version, and an ordering constraint can't be confirmed so it counts as
+    # unsatisfied.
+    assert _check_single("jpeg", "jpeg=9e", env_spec_dir=".", conda=True)
+    assert _check_single("jpeg=9e", "jpeg=9e", env_spec_dir=".", conda=True)
+    assert _check_single("jpeg!=1", "jpeg=9e", env_spec_dir=".", conda=True)
+    assert not _check_single(
+        "jpeg!=9e", "jpeg=9e", env_spec_dir=".", conda=True
+    )
+    assert not _check_single("jpeg=1", "jpeg=9e", env_spec_dir=".", conda=True)
+    # conda's "=1.2" expands to "==1.2.*", and a wildcard needs a parsed
+    # version, so it stays unverifiable.
+    assert not _check_single(
+        "jpeg=1.2", "jpeg=9e", env_spec_dir=".", conda=True
+    )
+    assert not _check_single(
+        "jpeg>=1", "jpeg=9e", env_spec_dir=".", conda=True
+    )
+    # Pip-style specifiers behave the same way
+    assert _check_single("jpeg==9e", "jpeg==9e", env_spec_dir=".", conda=False)
+    # "!=" and "~=" must parse the package name correctly, which they didn't
+    # when the name was split on "=<>" alone
+    assert _check_single(
+        "jpeg!=1.0", "jpeg==9.0", env_spec_dir=".", conda=False
+    )
+    assert not _check_single(
+        "jpeg!=9.0", "jpeg==9.0", env_spec_dir=".", conda=False
+    )
+    assert _check_single(
+        "jpeg~=1.0", "jpeg==1.9", env_spec_dir=".", conda=False
+    )
+    assert not _check_single(
+        "jpeg~=1.0", "jpeg==2.0", env_spec_dir=".", conda=False
+    )
+
+
+def test_unparseable_version_satisfies():
+    check = _unparseable_version_satisfies
+    # No constraint accepts anything
+    assert check("", "9e") is True
+    # Plain equality and inequality compare as strings
+    assert check("==9e", "9e") is True
+    assert check("==9e", "9f") is False
+    assert check("!=9e", "9e") is False
+    assert check("!=9f", "9e") is True
+    # PEP 440 arbitrary equality is also a string comparison
+    assert check("===9e", "9e") is True
+    # Conjunctions hold only if every clause holds
+    assert check("==9e,!=9f", "9e") is True
+    assert check("==9e,==9f", "9e") is False
+    # Wildcards and ordering operators need a parsed version
+    assert check("==1.*", "9e") is None
+    assert check("!=1.*", "9e") is None
+    assert check(">=1", "9e") is None
+    assert check("~=1.2", "9e") is None
+    # Matching is exact, with no zero-padding
+    assert check("==1.0", "1.0.0") is False
 
 
 def test_enrich_pip_deps_from_freeze():

{calkit_python-0.47.2 → calkit_python-0.47.3}/pyproject.toml

@@ -1,7 +1,9 @@
 [build-system]
 requires = [
   "hatchling>=1.5.0",
-  "jupyterlab>=4.0.0,<5",
+  # 4.6 builds with jupyter-builder, which needs @jupyter/builder or else
+  # fetches core-meta from GitHub's rate-limited API
+  "jupyterlab>=4.0.0,<4.6",
   "hatch-nodejs-version>=0.3.2",
   "hatch-vcs>=0.3.0",
 ]