calkit-python 0.42.1__tar.gz → 0.44.0__tar.gz

{calkit_python-0.42.1 → calkit_python-0.44.0}/.gitmodules

@@ -1,3 +1,6 @@
 [submodule "examples/basic"]
 	path = examples/basic
 	url = https://github.com/calkit/example-basic.git
+[submodule "examples/ssh"]
+	path = examples/ssh
+	url = git@github.com:calkit/example-ssh.git

{calkit_python-0.42.1 → calkit_python-0.44.0}/AGENTS.md

@@ -6,6 +6,10 @@
 - The JupyterLab extension lives in `src`
 - The VS Code extension lives in `vscode-ext`
 - The Chrome extension lives in `browser-ext`
+- GitHub Actions live in `actions`, e.g., `calkit/calkit/actions/run`
+- Config Calkit installs into projects, e.g., the dev container, VS Code, and
+  GitHub Actions configs, lives in `calkit/resources`; see the README there
+  before editing, since some of those files are generated
 
 ## Working
 

{calkit_python-0.42.1 → calkit_python-0.44.0}/Makefile

@@ -17,7 +17,7 @@ frontend-client: ## Regenerate the hub frontend's API client.
 	@$(MAKE) -C hub/frontend client
 
 .PHONY: format
-format: sync-docs ## Automatically format files.
+format: sync-docs sync-resources ## Automatically format files.
 	@echo "🚀 Linting code with pre-commit"
 	@uv run pre-commit run -a
 
@@ -44,13 +44,36 @@ test-cov: ## Test the code coverage with pytest.
 test-docs: sync-docs ## Test if documentation can be built without warnings or errors.
 	@uv run mkdocs build -s
 
+.PHONY: schema
+schema: ## Generate the published JSON schema for calkit.yaml.
+	@echo "🚀 Generating calkit.yaml JSON schema"
+	@uv run calkit describe schema -o docs/schemas/calkit.json
+	@cp docs/schemas/calkit.json vscode-ext/schemas/calkit.json
+
 .PHONY: sync-docs
-sync-docs: ## Sync documentation content from docs/*.md into README.md.
+sync-docs: schema ## Sync documentation content from docs/*.md into README.md.
 	@echo "🚀 Generating docs references"
 	@uv run python scripts/generate-docs-references.py
 	@echo "🚀 Syncing documentation"
 	@uv run python scripts/sync-docs.py
 
+.PHONY: changes
+changes: ## List each product's commits since its last release.
+	@uv run python scripts/list-changes.py
+
+.PHONY: sync-resources
+sync-resources: ## Regenerate the dev container spec from the VS Code config.
+	@echo "🚀 Syncing project resources"
+	@uv run python scripts/sync-resources.py
+
+.PHONY: devcontainer-image
+devcontainer-image: ## Build the dev container image and smoke test it.
+	@echo "🚀 Building the dev container image"
+	@docker build -t calkit/devcontainer:dev calkit/resources/devcontainer
+	@echo "🚀 Smoke testing the dev container image"
+	@docker run --rm calkit/devcontainer:dev bash -c \
+		"calkit --version && uv --version && pixi --version && conda --version"
+
 .PHONY: docs
 docs: sync-docs ## Build and serve the documentation.
 	@uv run mkdocs serve --livereload

{calkit_python-0.42.1 → calkit_python-0.44.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: calkit-python
-Version: 0.42.1
+Version: 0.44.0
 Summary: Reproducibility simplified.
 Project-URL: Homepage, https://calkit.org
 Project-URL: Issues, https://github.com/calkit/calkit/issues
@@ -96,7 +96,7 @@ without the cognitive overhead.
 
 <!-- https://docs.google.com/drawings/d/1XMGnbgYYNFAVUBDyUaCyLfRB7efvJdrnrKmFlNmT19o/edit -->
 
-![pipeline](docs/img/pipeline.png)
+![pipeline](https://docs.calkit.org/img/pipeline.png)
 
 ## Features
 
@@ -261,7 +261,7 @@ This re-execs the CLI via `uvx --from calkit-python@<version> calkit`,
 so it requires [uv](https://docs.astral.sh/uv/) on `PATH`.
 You can also declare a minimum version in `calkit.yaml`;
 see
-[Pinning the Calkit CLI version](https://docs.calkit.org/dependencies.md#pinning-the-calkit-cli-version).
+[Pinning the Calkit CLI version](https://docs.calkit.org/requirements.md#pinning-the-calkit-cli-version).
 
 ### Calkit Assistant
 

{calkit_python-0.42.1 → calkit_python-0.44.0}/README.md

@@ -37,7 +37,7 @@ without the cognitive overhead.
 
 <!-- https://docs.google.com/drawings/d/1XMGnbgYYNFAVUBDyUaCyLfRB7efvJdrnrKmFlNmT19o/edit -->
 
-![pipeline](docs/img/pipeline.png)
+![pipeline](https://docs.calkit.org/img/pipeline.png)
 
 ## Features
 
@@ -202,7 +202,7 @@ This re-execs the CLI via `uvx --from calkit-python@<version> calkit`,
 so it requires [uv](https://docs.astral.sh/uv/) on `PATH`.
 You can also declare a minimum version in `calkit.yaml`;
 see
-[Pinning the Calkit CLI version](https://docs.calkit.org/dependencies.md#pinning-the-calkit-cli-version).
+[Pinning the Calkit CLI version](https://docs.calkit.org/requirements.md#pinning-the-calkit-cli-version).
 
 ### Calkit Assistant
 

calkit_python-0.44.0/actions/run/README.md

@@ -0,0 +1,115 @@
+# Calkit run GitHub Action
+
+A GitHub Action to run a Calkit project's pipeline and optionally save results
+(commit and push) to Git and DVC.
+
+The action lives in the Calkit repo because it's a thin wrapper around a
+sequence of CLI commands, and it reads `calkit list environments` output to
+decide what tooling to install.
+Keeping it here means a change to either is tested against the other before
+release.
+
+## Usage
+
+Reference the action by a Calkit release tag:
+
+```yaml
+- uses: calkit/calkit/actions/run@v0.43.0
+```
+
+The easiest way to add it to a project is:
+
+```sh
+calkit update github-actions
+```
+
+which writes the workflow below to `.github/workflows/run-calkit.yml`,
+pinned to the version of Calkit that wrote it.
+Rerun it after upgrading Calkit to move the pin.
+
+<!-- Do not edit the snippet below since it is automatically populated -->
+<!-- snippet:example.yml:start -->
+
+```yaml
+name: Run pipeline
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+  workflow_dispatch:
+
+permissions:
+  contents: write
+  id-token: write
+
+# Make sure we only ever run one per branch so we don't have issues pushing
+# after running the pipeline
+concurrency:
+  group: calkit-run-${{ github.ref }}
+  cancel-in-progress: false
+
+jobs:
+  main:
+    name: Run
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          # For PRs, checkout the head ref to avoid detached HEAD
+          ref: ${{ github.head_ref || github.ref_name }}
+          token: ${{ secrets.GITHUB_TOKEN }}
+      - name: Configure Git credentials
+        run: |
+          git config user.name github-actions[bot]
+          git config user.email 41898282+github-actions[bot]@users.noreply.github.com
+      # This action automatically runs necessary setup steps based on environments
+      - name: Run Calkit
+        uses: calkit/calkit/actions/run@main
+```
+
+<!-- snippet:example.yml:end -->
+
+Note the permissions, concurrency, and checkout options.
+The action detects required environment kinds from `calkit.yaml` and sets up
+needed tooling (for example Calkit via `uv`, Julia, Pixi, Conda, R, MATLAB,
+and Docker Buildx) before running.
+
+## Configuration
+
+If simply running the pipeline is desired, the `save` option can be set to
+`false`.
+Additionally, caching DVC data can be disabled with `cache_dvc: false`.
+When caching is enabled, the action saves DVC cache entries using the current
+branch name plus the current commit SHA.
+The restore step first looks for the
+most recent cache for the current branch and then falls back to the default
+branch cache if the current branch cache doesn't exist yet.
+
+## System dependencies
+
+System dependencies like `uv`, `pixi`, `conda`, `juliaup` will be installed
+automatically if missing, and if the project has an environment with the
+corresponding kind.
+If you'd like control over which versions are used, you can add setup steps
+before the Calkit Action, and Calkit will detect and skip installation.
+
+## Development
+
+`example.yml` is the source for both the snippet above and the copy bundled
+into the Python package at `calkit/resources/github-actions`.
+After editing it, run `make sync-resources`.
+
+CI runs the action against real example projects on every pull request that
+touches this directory, with Calkit installed from the working tree first, so
+the action exercises the CLI being changed rather than the last release.
+
+## Previous home
+
+This action was previously published from
+[`calkit/run-action`](https://github.com/calkit/run-action), which is no
+longer maintained.
+Workflows referencing `calkit/run-action@v2` still work, but should be
+updated to `calkit/calkit/actions/run@<version>`, which
+`calkit update github-actions` will do in place.

calkit_python-0.44.0/actions/run/action.yml

@@ -0,0 +1,349 @@
+name: Run Calkit
+description: >
+  Run a Calkit project pipeline and optionally commit and push results to Git
+  and DVC remotes.
+branding:
+  icon: arrow-right
+  color: green
+inputs:
+  save:
+    description: Whether or not to save (commit and push) results to Git and DVC remotes.
+    default: "true"
+  dvc_token:
+    description:
+      DVC token for pushing results. If not provided, will be obtained
+      via GitHub OIDC.
+    required: false
+  pull_dvc:
+    description: Whether or not to pull DVC data before running.
+    required: false
+    default: "true"
+  cache_dvc:
+    description: Whether or not to cache DVC data.
+    required: false
+    default: "true"
+  run_args:
+    description: Arguments passed to calkit run command.
+    required: false
+    default: ""
+outputs: {}
+runs:
+  using: composite
+  steps:
+    - name: Check for uv and Calkit
+      id: tools
+      shell: bash
+      run: |
+        set -euo pipefail
+        if command -v uv >/dev/null 2>&1; then
+          echo "uv_missing=false" >> "$GITHUB_OUTPUT"
+        else
+          echo "uv_missing=true" >> "$GITHUB_OUTPUT"
+        fi
+        if command -v calkit >/dev/null 2>&1; then
+          echo "calkit_missing=false" >> "$GITHUB_OUTPUT"
+        else
+          echo "calkit_missing=true" >> "$GITHUB_OUTPUT"
+        fi
+
+    # uv is only needed up front to install Calkit; uv-venv projects that
+    # need uv but already have Calkit are handled by the uv step after
+    # detection.
+    - name: Setup uv
+      if: ${{ steps.tools.outputs.uv_missing == 'true' && steps.tools.outputs.calkit_missing == 'true' }}
+      uses: astral-sh/setup-uv@v5
+
+    - name: Install Calkit
+      if: ${{ steps.tools.outputs.calkit_missing == 'true' }}
+      shell: bash
+      run: |
+        uv tool install calkit-python
+        echo "$HOME/.local/bin" >> "$GITHUB_PATH"
+
+    - name: Detect setup requirements
+      id: detect
+      shell: bash
+      run: |
+        set -euo pipefail
+
+        # Let Calkit parse its own config so we only look at the
+        # `environments` section (a real YAML parse that also resolves
+        # includes), rather than grepping every `kind:` in the file --
+        # pipeline stages, dependencies, datasets, etc. all use `kind:` too.
+        kinds=$(calkit list environments 2>/dev/null \
+          | grep -E '^[[:space:]]+kind:' \
+          | sed -E 's/^[[:space:]]+kind:[[:space:]]*//; s/[[:space:]]+#.*$//' \
+          | tr -d "\"'" | sort -u || true)
+        echo "Detected environment kinds: $(echo "$kinds" | paste -sd, -)"
+
+        has_kind() {
+          printf '%s\n' "$kinds" | grep -qx "$1"
+        }
+
+        if command -v python >/dev/null 2>&1 || command -v python3 >/dev/null 2>&1; then
+          python_missing=false
+        else
+          python_missing=true
+        fi
+
+        if command -v uv >/dev/null 2>&1; then
+          uv_missing=false
+        else
+          uv_missing=true
+        fi
+
+        if command -v conda >/dev/null 2>&1; then
+          conda_missing=false
+        else
+          conda_missing=true
+        fi
+
+        if command -v pixi >/dev/null 2>&1; then
+          pixi_missing=false
+        else
+          pixi_missing=true
+        fi
+
+        # Calkit manages Julia versions via juliaup (e.g. `juliaup add
+        # 1.11.7` for a `julia: "1.11.7"` environment), so juliaup -- not a
+        # fixed Julia -- is what must be present. We deliberately gate only on
+        # juliaup and ignore any plain `julia` on the runner: hosted runner
+        # images ship a pinned Julia that usually won't match the project's
+        # required version, and without juliaup Calkit can't install the right
+        # one. Users who manage Julia themselves should install juliaup, which
+        # this then detects and leaves alone.
+        if command -v juliaup >/dev/null 2>&1; then
+          juliaup_missing=false
+        else
+          juliaup_missing=true
+        fi
+
+        if command -v Rscript >/dev/null 2>&1 || command -v R >/dev/null 2>&1; then
+          r_missing=false
+        else
+          r_missing=true
+        fi
+
+        if command -v matlab >/dev/null 2>&1; then
+          matlab_missing=false
+        else
+          matlab_missing=true
+        fi
+
+        if command -v docker >/dev/null 2>&1 && docker buildx version >/dev/null 2>&1; then
+          docker_buildx_missing=false
+        else
+          docker_buildx_missing=true
+        fi
+
+        needs_python=false
+        needs_uv=false
+        needs_conda=false
+        needs_pixi=false
+        needs_julia=false
+        needs_r=false
+        needs_matlab=false
+        needs_docker=false
+        docker_cli_missing=false
+        unsupported_kinds=""
+
+        if has_kind "uv-venv" || has_kind "venv" || has_kind "uv"; then
+          if [ "$python_missing" = true ]; then
+            needs_python=true
+          fi
+        fi
+        # uv is installed up front to install Calkit, so it is normally
+        # already present here; this covers the case where Calkit was
+        # pre-installed (so we skipped the initial uv setup) but uv is not.
+        if has_kind "uv-venv" || has_kind "uv"; then
+          if [ "$uv_missing" = true ]; then
+            needs_uv=true
+          fi
+        fi
+        if has_kind "conda"; then
+          if [ "$conda_missing" = true ]; then
+            needs_conda=true
+          fi
+          if [ "$python_missing" = true ]; then
+            needs_python=true
+          fi
+        fi
+        if has_kind "pixi"; then
+          if [ "$pixi_missing" = true ]; then
+            needs_pixi=true
+          fi
+        fi
+        if has_kind "julia"; then
+          if [ "$juliaup_missing" = true ]; then
+            needs_julia=true
+          fi
+        fi
+        if has_kind "renv"; then
+          if [ "$r_missing" = true ]; then
+            needs_r=true
+          fi
+        fi
+        if has_kind "matlab"; then
+          if [ "$matlab_missing" = true ]; then
+            needs_matlab=true
+          fi
+        fi
+        if has_kind "docker"; then
+          if command -v docker >/dev/null 2>&1; then
+            if [ "$docker_buildx_missing" = true ]; then
+              needs_docker=true
+            fi
+          else
+            docker_cli_missing=true
+          fi
+        fi
+
+        # These kinds do not have a direct setup action in this composite action.
+        if has_kind "ssh"; then unsupported_kinds="${unsupported_kinds}ssh,"; fi
+        if has_kind "slurm"; then unsupported_kinds="${unsupported_kinds}slurm,"; fi
+        if has_kind "pbs"; then unsupported_kinds="${unsupported_kinds}pbs,"; fi
+        if has_kind "nix"; then unsupported_kinds="${unsupported_kinds}nix,"; fi
+        unsupported_kinds="${unsupported_kinds%,}"
+
+        echo "needs_python=${needs_python}" >> "$GITHUB_OUTPUT"
+        echo "needs_uv=${needs_uv}" >> "$GITHUB_OUTPUT"
+        echo "needs_conda=${needs_conda}" >> "$GITHUB_OUTPUT"
+        echo "needs_pixi=${needs_pixi}" >> "$GITHUB_OUTPUT"
+        echo "needs_julia=${needs_julia}" >> "$GITHUB_OUTPUT"
+        echo "needs_r=${needs_r}" >> "$GITHUB_OUTPUT"
+        echo "needs_matlab=${needs_matlab}" >> "$GITHUB_OUTPUT"
+        echo "needs_docker=${needs_docker}" >> "$GITHUB_OUTPUT"
+        echo "docker_cli_missing=${docker_cli_missing}" >> "$GITHUB_OUTPUT"
+        echo "unsupported_kinds=${unsupported_kinds}" >> "$GITHUB_OUTPUT"
+
+    - name: Setup uv for uv and uv-venv environments
+      if: ${{ steps.detect.outputs.needs_uv == 'true' }}
+      uses: astral-sh/setup-uv@v5
+
+    - name: Setup Python
+      if: ${{ steps.detect.outputs.needs_python == 'true' }}
+      uses: actions/setup-python@v5
+      with:
+        python-version: "3.x"
+
+    - name: Setup Miniconda
+      if: ${{ steps.detect.outputs.needs_conda == 'true' }}
+      uses: conda-incubator/setup-miniconda@v3
+      with:
+        auto-activate-base: true
+        conda-remove-defaults: true
+
+    - name: Setup Pixi
+      if: ${{ steps.detect.outputs.needs_pixi == 'true' }}
+      uses: prefix-dev/setup-pixi@v0.9.6
+      with:
+        run-install: false
+
+    # Install juliaup (not a fixed Julia) so Calkit can install and select
+    # the exact Julia version(s) declared in each environment via
+    # `juliaup add`. The channel here is just a default bootstrap install.
+    - name: Setup juliaup
+      if: ${{ steps.detect.outputs.needs_julia == 'true' }}
+      uses: julia-actions/install-juliaup@v2
+      with:
+        channel: "1"
+
+    - name: Setup R
+      if: ${{ steps.detect.outputs.needs_r == 'true' }}
+      uses: r-lib/actions/setup-r@v2
+
+    - name: Setup MATLAB
+      if: ${{ steps.detect.outputs.needs_matlab == 'true' }}
+      uses: matlab-actions/setup-matlab@v2
+
+    - name: Setup Docker Buildx
+      if: ${{ steps.detect.outputs.needs_docker == 'true' }}
+      uses: docker/setup-buildx-action@v3
+
+    - name: Report unsupported environment kinds
+      if: ${{ steps.detect.outputs.unsupported_kinds != '' }}
+      shell: bash
+      run: |
+        echo "::notice::Detected environment kinds without explicit setup action: ${{ steps.detect.outputs.unsupported_kinds }}"
+
+    - name: Report missing Docker CLI for docker environments
+      if: ${{ steps.detect.outputs.docker_cli_missing == 'true' }}
+      shell: bash
+      run: |
+        echo "::notice::Detected kind 'docker' in calkit.yaml, but Docker CLI is not available on this runner. Install Docker on the runner to use docker environments."
+
+    - name: Restore DVC cache for current branch
+      if: ${{ inputs.cache_dvc == 'true' }}
+      id: cache-dvc-restore
+      uses: actions/cache/restore@v5
+      with:
+        path: .dvc/cache
+        key: >-
+          ${{ runner.os }}-dvc-cache-${{ github.head_ref || github.ref_name }}-${{ github.sha }}
+        restore-keys: |
+          ${{ runner.os }}-dvc-cache-${{ github.head_ref || github.ref_name }}-
+          ${{ runner.os }}-dvc-cache-${{ github.event.repository.default_branch }}-
+
+    - name: Get GitHub OIDC token
+      if: ${{ !inputs.dvc_token && (inputs.save == 'true' || inputs.pull_dvc ==
+        'true') }}
+      id: get-oidc-token
+      shell: bash
+      run: |
+        OIDC_TOKEN=$(curl -H "Authorization: Bearer $ACTIONS_ID_TOKEN_REQUEST_TOKEN" "$ACTIONS_ID_TOKEN_REQUEST_URL&audience=calkit.io" -s | jq -r '.value')
+        if [ -z "$OIDC_TOKEN" ] || [ "$OIDC_TOKEN" == "null" ]; then
+          echo "Failed to obtain OIDC token"
+          exit 1
+        fi
+        echo "::add-mask::$OIDC_TOKEN"
+        echo "oidc-token=$OIDC_TOKEN" >> $GITHUB_OUTPUT
+
+    - name: Exchange OIDC token for Calkit token
+      if: ${{ !inputs.dvc_token && (inputs.save == 'true' || inputs.pull_dvc ==
+        'true') }}
+      id: get-calkit-token
+      shell: bash
+      run: |
+        CALKIT_TOKEN=$(curl -X POST https://api.calkit.io/login/github-oidc \
+          -H "Authorization: Bearer ${{ steps.get-oidc-token.outputs.oidc-token }}" \
+          -s | jq -r '.access_token')
+        if [ -z "$CALKIT_TOKEN" ] || [ "$CALKIT_TOKEN" == "null" ]; then
+          echo "Failed to obtain Calkit token"
+          exit 1
+        fi
+        echo "::add-mask::$CALKIT_TOKEN"
+        echo "calkit-token=$CALKIT_TOKEN" >> $GITHUB_OUTPUT
+
+    - run: calkit config remote-auth
+      if: ${{ inputs.save == 'true' || inputs.pull_dvc == 'true' }}
+      shell: bash
+      env:
+        CALKIT_TOKEN: ${{ inputs.dvc_token || steps.get-calkit-token.outputs.calkit-token }}
+        CALKIT_DVC_TOKEN: ${{ inputs.dvc_token || steps.get-calkit-token.outputs.calkit-token }}
+
+    - run: calkit dvc pull
+      if: ${{ inputs.pull_dvc == 'true' }}
+      shell: bash
+      continue-on-error: true
+      env:
+        CALKIT_TOKEN: ${{ inputs.dvc_token || steps.get-calkit-token.outputs.calkit-token }}
+        CALKIT_DVC_TOKEN: ${{ inputs.dvc_token || steps.get-calkit-token.outputs.calkit-token }}
+
+    - run: calkit run ${{ inputs.run_args }}
+      shell: bash
+
+    - run: calkit save -am "Run pipeline"
+      if: ${{ inputs.save == 'true' }}
+      shell: bash
+      env:
+        CALKIT_TOKEN: ${{ inputs.dvc_token || steps.get-calkit-token.outputs.calkit-token }}
+        CALKIT_DVC_TOKEN: ${{ inputs.dvc_token || steps.get-calkit-token.outputs.calkit-token }}
+
+    - name: Save DVC cache
+      if: ${{ inputs.cache_dvc == 'true' }}
+      id: cache-dvc-save
+      uses: actions/cache/save@v5
+      with:
+        path: .dvc/cache
+        key: >-
+          ${{ runner.os }}-dvc-cache-${{ github.head_ref || github.ref_name }}-${{ github.sha }}

calkit_python-0.44.0/actions/run/example.yml

@@ -0,0 +1,36 @@
+name: Run pipeline
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+  workflow_dispatch:
+
+permissions:
+  contents: write
+  id-token: write
+
+# Make sure we only ever run one per branch so we don't have issues pushing
+# after running the pipeline
+concurrency:
+  group: calkit-run-${{ github.ref }}
+  cancel-in-progress: false
+
+jobs:
+  main:
+    name: Run
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          # For PRs, checkout the head ref to avoid detached HEAD
+          ref: ${{ github.head_ref || github.ref_name }}
+          token: ${{ secrets.GITHUB_TOKEN }}
+      - name: Configure Git credentials
+        run: |
+          git config user.name github-actions[bot]
+          git config user.email 41898282+github-actions[bot]@users.noreply.github.com
+      # This action automatically runs necessary setup steps based on environments
+      - name: Run Calkit
+        uses: calkit/calkit/actions/run@main

{calkit_python-0.42.1 → calkit_python-0.44.0}/agent-plugin/skills/conventions/SKILL.md

@@ -18,6 +18,10 @@ is `calkit.yaml`, the project's metadata database.
 
 `calkit.yaml` lives at the repo root and contains:
 
+- `requirements`—what must be true of the machine before anything runs
+  (apps on `PATH`, environmental variables, setup steps, machine
+  properties like CPU count); formerly called `dependencies`, which
+  still works
 - `environments`—computational environments (Python venvs, Conda, Docker,
   R, Julia, MATLAB, etc.)
 - `pipeline.stages`—the reproducible pipeline

{calkit_python-0.42.1 → calkit_python-0.44.0}/calkit/__init__.py

@@ -38,6 +38,8 @@ if TYPE_CHECKING:
         overleaf,
         pipeline,
         releases,
+        resources,
+        schema,
         server,
         templates,
     )
@@ -61,6 +63,7 @@ _SUBMODULES = {
     "github",
     "invenio",
     "releases",
+    "resources",
     "licenses",
     "overleaf",
     "julia",
@@ -76,6 +79,7 @@ _SUBMODULES = {
     "install",
     "magics",
     "ops",
+    "schema",
     "server",
 }