calkit-python 0.24.6__tar.gz → 0.24.8__tar.gz

{calkit_python-0.24.6 → calkit_python-0.24.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: calkit-python
-Version: 0.24.6
+Version: 0.24.8
 Summary: Reproducibility simplified.
 Project-URL: Homepage, https://calkit.org
 Project-URL: Issues, https://github.com/calkit/calkit/issues
@@ -54,47 +54,23 @@ Description-Content-Type: text/markdown
   </a>
 </p>
 
-Calkit is a language-agnostic project framework and toolkit
-to make your research or analytics project
-reproducible to the highest standard,
-which means:
-
-> Inputs and process definitions are provided and sufficiently described
-> such that anyone can easily verify that they produced the outputs
-> used to support the conclusions.
-
-"Easily" means that after obtaining your project files,
-it should only require executing a single command
-(like "pressing a single button" in
-[Claerbout and Karrenbach (1992)](https://doi.org/10.1190/1.1822162)),
-which should finish in less than 15 minutes
-(suggested by
-[Vandewalle et al. (2009)](https://doi.org/10.1109/MSP.2009.932122)).
-
-If the processes are too expensive to rerun in under 15 minutes,
-it should be possible to confirm that none of the input data
-or process definitions (e.g., environment specifications, scripts)
-have changed since saving the current versions of each output artifact
-(figure, table, dataset, publication, etc.)
-
-When your project is reproducible,
-you'll be able to iterate more quickly and more often,
-easily onboard collaborators,
-make fewer mistakes,
-and feel confident sharing all of your project materials
-with your research articles,
-because you'll know the code will actually run!
-This will allow others to reuse parts of your project in their own research,
-accelerating the pace of discovery.
-
-Working at this level of automation, discipline, and rigor may sound like
-a lot of effort,
-but Calkit makes it easy!
+Calkit's mission is to make every scientific study reproducible.
+That is,
+it should be possible to go from raw data to research article
+by "pressing a single button"
+([Claerbout and Karrenbach (1992)](https://doi.org/10.1190/1.1822162)).
+
+Calkit makes this level of automation possible without extensive software
+engineering expertise by providing a project framework and toolset that unifies
+and simplifies the use of enabling technologies like Git,
+DVC, Conda, Docker, and more,
+while guiding users away from common reproducibility pitfalls.
 
 ## Features
 
 - A declarative pipeline that forces users to define an environment
-  for every stage, so "but it works on my machine" is a thing of the past.
+  for every stage, so long lists of instructions in a README and
+  "but it works on my machine" are things of the past.
 - A CLI to run the project's pipeline to verify it's reproducible,
   regenerating outputs as needed and
   ensuring all
@@ -106,7 +82,7 @@ but Calkit makes it easy!
 - A command line interface (CLI) to simplify keeping code, text, and larger
   data files backed up in the same project repo using both
   [Git](https://git-scm.com/) and [DVC](https://dvc.org/).
-- A complementary
+- A complementary self-hostable and GitHub-integrated
   [cloud system](https://github.com/calkit/calkit-cloud)
   to facilitate backup, collaboration,
   and sharing throughout the entire research lifecycle.

{calkit_python-0.24.6 → calkit_python-0.24.8}/README.md

@@ -17,47 +17,23 @@
   </a>
 </p>
 
-Calkit is a language-agnostic project framework and toolkit
-to make your research or analytics project
-reproducible to the highest standard,
-which means:
-
-> Inputs and process definitions are provided and sufficiently described
-> such that anyone can easily verify that they produced the outputs
-> used to support the conclusions.
-
-"Easily" means that after obtaining your project files,
-it should only require executing a single command
-(like "pressing a single button" in
-[Claerbout and Karrenbach (1992)](https://doi.org/10.1190/1.1822162)),
-which should finish in less than 15 minutes
-(suggested by
-[Vandewalle et al. (2009)](https://doi.org/10.1109/MSP.2009.932122)).
-
-If the processes are too expensive to rerun in under 15 minutes,
-it should be possible to confirm that none of the input data
-or process definitions (e.g., environment specifications, scripts)
-have changed since saving the current versions of each output artifact
-(figure, table, dataset, publication, etc.)
-
-When your project is reproducible,
-you'll be able to iterate more quickly and more often,
-easily onboard collaborators,
-make fewer mistakes,
-and feel confident sharing all of your project materials
-with your research articles,
-because you'll know the code will actually run!
-This will allow others to reuse parts of your project in their own research,
-accelerating the pace of discovery.
-
-Working at this level of automation, discipline, and rigor may sound like
-a lot of effort,
-but Calkit makes it easy!
+Calkit's mission is to make every scientific study reproducible.
+That is,
+it should be possible to go from raw data to research article
+by "pressing a single button"
+([Claerbout and Karrenbach (1992)](https://doi.org/10.1190/1.1822162)).
+
+Calkit makes this level of automation possible without extensive software
+engineering expertise by providing a project framework and toolset that unifies
+and simplifies the use of enabling technologies like Git,
+DVC, Conda, Docker, and more,
+while guiding users away from common reproducibility pitfalls.
 
 ## Features
 
 - A declarative pipeline that forces users to define an environment
-  for every stage, so "but it works on my machine" is a thing of the past.
+  for every stage, so long lists of instructions in a README and
+  "but it works on my machine" are things of the past.
 - A CLI to run the project's pipeline to verify it's reproducible,
   regenerating outputs as needed and
   ensuring all
@@ -69,7 +45,7 @@ but Calkit makes it easy!
 - A command line interface (CLI) to simplify keeping code, text, and larger
   data files backed up in the same project repo using both
   [Git](https://git-scm.com/) and [DVC](https://dvc.org/).
-- A complementary
+- A complementary self-hostable and GitHub-integrated
   [cloud system](https://github.com/calkit/calkit-cloud)
   to facilitate backup, collaboration,
   and sharing throughout the entire research lifecycle.

{calkit_python-0.24.6 → calkit_python-0.24.8}/calkit/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.24.6"
+__version__ = "0.24.8"
 
 from .core import *  # noqa: F403, I001
 from . import git  # noqa: F401

{calkit_python-0.24.6 → calkit_python-0.24.8}/calkit/cli/check.py

@@ -55,7 +55,7 @@ def check_environment(
     verbose: Annotated[
         bool, typer.Option("--verbose", help="Print verbose output.")
     ] = False,
-):
+) -> str | None:
     """Check that an environment is up-to-date."""
     dotenv.load_dotenv(dotenv_path=".env", verbose=verbose)
     ck_info = calkit.load_calkit_info(process_includes="environments")
@@ -136,6 +136,7 @@ def check_environment(
         )
     else:
         raise_error(f"Environment kind '{env['kind']}' not supported")
+    return get_env_lock_fpath(env=env, env_name=env_name, as_posix=False)
 
 
 @check_app.command(name="docker-env")
@@ -192,11 +193,11 @@ def check_docker_env(
         # content in the image
         keys = [
             "RepoTags",
+            "RepoDigests",
             "Architecture",
             "Os",
             "Size",
             "RootFS",
-            "Descriptor",
         ]
         resp = {}
         for key in keys:

{calkit_python-0.24.6 → calkit_python-0.24.8}/calkit/cli/new.py

@@ -21,6 +21,7 @@ from typing_extensions import Annotated
 
 import calkit
 from calkit.cli import raise_error, warn
+from calkit.cli.check import check_environment
 from calkit.cli.update import update_devcontainer
 from calkit.core import ryaml
 from calkit.docker import LAYERS
@@ -593,6 +594,13 @@ def new_docker_env(
     no_commit: Annotated[
         bool, typer.Option("--no-commit", help="Do not commit changes.")
     ] = False,
+    no_check: Annotated[
+        bool,
+        typer.Option(
+            "--no-check",
+            help="Do not check environment is up-to-date after creation.",
+        ),
+    ] = False,
 ):
     """Create a new Docker environment."""
     if base is not None and path is None:
@@ -648,6 +656,10 @@ def new_docker_env(
     with open("calkit.yaml", "w") as f:
         ryaml.dump(ck_info, f)
     repo.git.add("calkit.yaml")
+    if not no_check:
+        env_lock_fpath = check_environment(env_name=name)
+        if env_lock_fpath is not None:
+            repo.git.add(env_lock_fpath)
     if not no_commit and repo.git.diff("--staged"):
         repo.git.commit(["-m", f"Add Docker environment {name}"])
 
@@ -1033,6 +1045,13 @@ def new_conda_env(
     no_commit: Annotated[
         bool, typer.Option("--no-commit", help="Do not commit changes.")
     ] = False,
+    no_check: Annotated[
+        bool,
+        typer.Option(
+            "--no-check",
+            help="Do not check environment is up-to-date after creation.",
+        ),
+    ] = False,
 ):
     """Create a new Conda environment."""
     if os.path.isfile(path) and not overwrite:
@@ -1081,6 +1100,10 @@ def new_conda_env(
     with open("calkit.yaml", "w") as f:
         ryaml.dump(ck_info, f)
     repo.git.add("calkit.yaml")
+    if not no_check:
+        env_lock_fpath = check_environment(env_name=name)
+        if env_lock_fpath is not None:
+            repo.git.add(env_lock_fpath)
     if not no_commit and repo.git.diff("--staged"):
         repo.git.commit(["-m", f"Add Conda environment {name}"])
 
@@ -1117,6 +1140,13 @@ def new_uv_venv(
     no_commit: Annotated[
         bool, typer.Option("--no-commit", help="Do not commit changes.")
     ] = False,
+    no_check: Annotated[
+        bool,
+        typer.Option(
+            "--no-check",
+            help="Do not check environment is up-to-date after creation.",
+        ),
+    ] = False,
 ):
     """Create a new uv virtual environment."""
     if os.path.isfile(path) and not overwrite:
@@ -1158,6 +1188,10 @@ def new_uv_venv(
     with open("calkit.yaml", "w") as f:
         ryaml.dump(ck_info, f)
     repo.git.add("calkit.yaml")
+    if not no_check:
+        env_lock_fpath = check_environment(env_name=name)
+        if env_lock_fpath is not None:
+            repo.git.add(env_lock_fpath)
     if not no_commit and repo.git.diff("--staged"):
         repo.git.commit(["-m", f"Add uv venv {name}"])
 
@@ -1191,6 +1225,13 @@ def new_venv(
     no_commit: Annotated[
         bool, typer.Option("--no-commit", help="Do not commit changes.")
     ] = False,
+    no_check: Annotated[
+        bool,
+        typer.Option(
+            "--no-check",
+            help="Do not check environment is up-to-date after creation.",
+        ),
+    ] = False,
 ):
     """Create a new Python virtual environment with venv."""
     if os.path.isfile(path) and not overwrite:
@@ -1230,6 +1271,10 @@ def new_venv(
     with open("calkit.yaml", "w") as f:
         ryaml.dump(ck_info, f)
     repo.git.add("calkit.yaml")
+    if not no_check:
+        env_lock_fpath = check_environment(env_name=name)
+        if env_lock_fpath is not None:
+            repo.git.add(env_lock_fpath)
     if not no_commit and repo.git.diff("--staged"):
         repo.git.commit(["-m", f"Add venv {name}"])
 
@@ -1263,6 +1308,13 @@ def new_pixi_env(
     no_commit: Annotated[
         bool, typer.Option("--no-commit", help="Do not commit changes.")
     ] = False,
+    no_check: Annotated[
+        bool,
+        typer.Option(
+            "--no-check",
+            help="Do not check environment is up-to-date after creation.",
+        ),
+    ] = False,
 ):
     """Create a new pixi virtual environment."""
     repo = git.Repo()
@@ -1321,6 +1373,10 @@ def new_pixi_env(
         ryaml.dump(ck_info, f)
     repo.git.add("pixi.toml")
     repo.git.add("calkit.yaml")
+    if not no_check:
+        env_lock_fpath = check_environment(env_name=name)
+        if env_lock_fpath is not None:
+            repo.git.add(env_lock_fpath)
     if not no_commit and repo.git.diff("--staged"):
         repo.git.commit(["-m", f"Add pixi env {name}"])
 

{calkit_python-0.24.6 → calkit_python-0.24.8}/calkit/tests/cli/test_new.py

@@ -272,6 +272,7 @@ def test_new_stage(tmp_dir):
             "tex",
             "--image",
             "texlive/texlive:latest-full",
+            "--no-check",
         ]
     )
     subprocess.check_call(
@@ -450,6 +451,7 @@ def test_new_python_script_stage(tmp_dir):
             "--python",
             "3.13",
             "requests",
+            "--no-check",
         ]
     )
     subprocess.check_call(
@@ -524,6 +526,7 @@ def test_new_latex_stage(tmp_dir):
             "tex",
             "--image",
             "texlive/texlive:latest-full",
+            "--no-check",
         ]
     )
     subprocess.check_call(
@@ -567,6 +570,7 @@ def test_new_matlab_script_stage(tmp_dir):
             "matlab1",
             "--image",
             "mathworks/matlab:latest",
+            "--no-check",
         ]
     )
     subprocess.check_call(

{calkit_python-0.24.6 → calkit_python-0.24.8}/calkit/tests/test_conda.py

@@ -50,6 +50,7 @@ def test_check_env(tmp_dir, conda_env_name):
             "conda-env",
             "-n",
             ENV_NAME,
+            "--no-check",
             "python",
             "pip",
             "--pip",
@@ -71,6 +72,7 @@ def test_check_env(tmp_dir, conda_env_name):
             "--overwrite",
             "-n",
             ENV_NAME,
+            "--no-check",
             "python=3.11.0",
             "pip",
             "--pip",
@@ -94,6 +96,7 @@ def test_check_env(tmp_dir, conda_env_name):
             "--overwrite",
             "-n",
             ENV_NAME,
+            "--no-check",
             "python=3.11.0",
             "pip",
             "sqlalchemy",
@@ -121,6 +124,7 @@ def test_check_env(tmp_dir, conda_env_name):
             "--overwrite",
             "-n",
             ENV_NAME,
+            "--no-check",
             "python=3.11.0",
             "pip",
             "sqlalchemy",
@@ -136,6 +140,7 @@ def test_check_env(tmp_dir, conda_env_name):
             "--overwrite",
             "-n",
             ENV_NAME,
+            "--no-check",
             "python=3.11.0",
             "pip",
             "--pip",
@@ -153,6 +158,7 @@ def test_check_env(tmp_dir, conda_env_name):
             "--overwrite",
             "-n",
             ENV_NAME,
+            "--no-check",
             "python=3.12",
             "--pip",
             "numpy>=1",
@@ -185,6 +191,7 @@ def test_check_prefix_env(tmp_dir, conda_env_prefix):
             "python=3.12",
             "--prefix",
             conda_env_prefix,
+            "--no-check",
         ]
     )
     res = check_env()

{calkit_python-0.24.6 → calkit_python-0.24.8}/docs/index.md

@@ -1,27 +1,16 @@
 # Home
 
-Calkit is a language-agnostic project framework and toolkit
-to make your research or analytics project
-reproducible to the highest standard,
-which means:
-
-> Inputs and process definitions are provided and sufficiently described
-> such that anyone can easily verify that they produced the outputs
-> used to support the conclusions.
-
-"Easily" means that after obtaining your project files,
-it should only require executing a single command
-(like "pressing a single button" in
-[Claerbout and Karrenbach (1992)](https://doi.org/10.1190/1.1822162)),
-which should finish in less than 15 minutes
-(suggested by
-[Vandewalle et al. (2009)](https://doi.org/10.1109/MSP.2009.932122)).
-
-If the processes are too expensive to rerun in under 15 minutes,
-it should be possible to confirm that none of the input data
-or process definitions (e.g., environment specifications, scripts)
-have changed since saving the current versions of each output artifact
-(figure, table, dataset, publication, etc.)
+Calkit's mission is to make every scientific study reproducible.
+That is,
+it should be possible to go from raw data to research article
+by "pressing a single button"
+([Claerbout and Karrenbach (1992)](https://doi.org/10.1190/1.1822162)).
+
+Calkit makes this level of automation possible without extensive software
+engineering expertise by providing a project framework and toolset that unifies
+and simplifies the use of enabling technologies like Git,
+DVC, Conda, Docker, and more,
+while guiding users away from common reproducibility pitfalls.
 
 When your project is reproducible,
 you'll be able to iterate more quickly and more often,
@@ -33,14 +22,11 @@ because you'll know the code will actually run!
 This will allow others to reuse parts of your project in their own research,
 accelerating the pace of discovery.
 
-Working at this level of automation, discipline, and rigor may sound like
-a lot of effort,
-but Calkit makes it easy!
-
 ## Features
 
 - A declarative pipeline that forces users to define an environment
-  for every stage, so "but it works on my machine" is a thing of the past.
+  for every stage, so long lists of instructions in a README and
+  "but it works on my machine" are things of the past.
 - A CLI to run the project's pipeline to verify it's reproducible,
   regenerating outputs as needed and
   ensuring all
@@ -52,7 +38,7 @@ but Calkit makes it easy!
 - A command line interface (CLI) to simplify keeping code, text, and larger
   data files backed up in the same project repo using both
   [Git](https://git-scm.com/) and [DVC](https://dvc.org/).
-- A complementary
+- A complementary self-hostable and GitHub-integrated
   [cloud system](https://github.com/calkit/calkit-cloud)
   to facilitate backup, collaboration,
   and sharing throughout the entire research lifecycle.