cloudfall 0.2.1__tar.gz → 0.3.0__tar.gz

{cloudfall-0.2.1 → cloudfall-0.3.0}/CHANGELOG.md

@@ -6,6 +6,25 @@ Notable changes to Cloudfall. The format follows
 
 ## [Unreleased]
 
+## [0.3.0] — 2026-09-20
+
+### Removed
+
+- `cloudfall init --rev` and `--source`, and the machinery behind them:
+  `GitRevision`, `GitSourceUrl`, `GitPin`, `IndexPin`, `CheckoutState`, the
+  checkout inspection, and the `project_revision_unresolved`,
+  `project_revision_uncommitted` and `project_revision_unpublished` errors.
+  Cloudfall is on PyPI, so a project pins a release and resolves it like any
+  other dependency; `resolve_installed_version` replaces
+  `resolve_installed_pin`, and the `init` envelope reports `version` rather
+  than a `pin` object. To run an unreleased Cloudfall in a project, point the
+  dependency at a checkout with uv's own `[tool.uv.sources]`
+
+### Changed
+
+- The quickstart and the Render migration guide install Cloudfall from the
+  index rather than from git
+
 ## [0.2.1] — 2026-09-20
 
 ### Fixed

{cloudfall-0.2.1 → cloudfall-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: cloudfall
-Version: 0.2.1
+Version: 0.3.0
 Summary: AI-native control plane for dedicated Debian application fleets
 Project-URL: Homepage, https://cloudfall.dev
 Project-URL: Repository, https://github.com/romamo/cloudfall
@@ -198,10 +198,8 @@ Your servers, applications, evidence, and any playbooks of your own belong in
 a project: a directory of its own, kept private. Cloudfall's wheel bundles the
 schema catalog and the Ansible engine, so the project needs no checkout of
 this repository. `cloudfall init` is the first command, and it pins the
-project to the Cloudfall that ran it: the released version when that came
-from PyPI, the exact commit when it came from git or a clone. Without a
-directory argument it initializes the current directory, which must be
-empty:
+project to the released Cloudfall that ran it. Without a directory argument
+it initializes the current directory, which must be empty:
 
 ```console
 uvx cloudfall init my-project
@@ -230,10 +228,11 @@ dependencies = ["cloudfall==<version>"]
 package = false
 ```
 
-Bump that pin and run `uv sync` to move the project to a newer Cloudfall. A
-project initialized from a git or source install pins a commit instead, with
-a `[tool.uv.sources]` table naming the repository and revision; `--rev` asks
-for that explicitly.
+Bump that version and run `uv sync` to move the project to a newer
+Cloudfall. To run an unreleased Cloudfall in a project, point the dependency
+at a checkout or a commit with uv's own
+[`[tool.uv.sources]`](https://docs.astral.sh/uv/concepts/projects/dependencies/#dependency-sources);
+Cloudfall itself only ever pins a release.
 
 Only the kind directories are read as resources, so playbooks, roles, docs,
 and tooling files may live anywhere else in the project. Commands find the

{cloudfall-0.2.1 → cloudfall-0.3.0}/README.md

@@ -172,10 +172,8 @@ Your servers, applications, evidence, and any playbooks of your own belong in
 a project: a directory of its own, kept private. Cloudfall's wheel bundles the
 schema catalog and the Ansible engine, so the project needs no checkout of
 this repository. `cloudfall init` is the first command, and it pins the
-project to the Cloudfall that ran it: the released version when that came
-from PyPI, the exact commit when it came from git or a clone. Without a
-directory argument it initializes the current directory, which must be
-empty:
+project to the released Cloudfall that ran it. Without a directory argument
+it initializes the current directory, which must be empty:
 
 ```console
 uvx cloudfall init my-project
@@ -204,10 +202,11 @@ dependencies = ["cloudfall==<version>"]
 package = false
 ```
 
-Bump that pin and run `uv sync` to move the project to a newer Cloudfall. A
-project initialized from a git or source install pins a commit instead, with
-a `[tool.uv.sources]` table naming the repository and revision; `--rev` asks
-for that explicitly.
+Bump that version and run `uv sync` to move the project to a newer
+Cloudfall. To run an unreleased Cloudfall in a project, point the dependency
+at a checkout or a commit with uv's own
+[`[tool.uv.sources]`](https://docs.astral.sh/uv/concepts/projects/dependencies/#dependency-sources);
+Cloudfall itself only ever pins a release.
 
 Only the kind directories are read as resources, so playbooks, roles, docs,
 and tooling files may live anywhere else in the project. Commands find the

{cloudfall-0.2.1 → cloudfall-0.3.0}/docs/render-migration-guide.md

@@ -55,7 +55,7 @@ Not imported today; each lands in the gap report instead of being guessed at:
 - Your `render.yaml` blueprint and access to your application repositories
 - Python 3.14 and [`uv`](https://docs.astral.sh/uv/) on the machine you run
   Cloudfall from (your workstation works; no management server is required)
-- A project: `uvx --from git+https://github.com/romamo/cloudfall.git cloudfall init my-project`,
+- A project: `uvx cloudfall init my-project`,
   then `cd my-project && uv sync`. Every command below runs from inside it
 
 ## Step 1: import the blueprint

{cloudfall-0.2.1 → cloudfall-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cloudfall"
-version = "0.2.1"
+version = "0.3.0"
 description = "AI-native control plane for dedicated Debian application fleets"
 readme = "README.md"
 license = "AGPL-3.0-or-later"

{cloudfall-0.2.1 → cloudfall-0.3.0}/sdk/src/cloudfall/cli.py

@@ -96,18 +96,14 @@ from cloudfall.operator import (
     run_once as operator_run_once,
 )
 from cloudfall.project import (
-    DEFAULT_SOURCE_URL,
     PROJECT_DIRECTORY_VARIABLE,
-    GitPin,
-    GitRevision,
-    GitSourceUrl,
     InitOptions,
     ProjectDescription,
     ProjectError,
     ProjectName,
     init_project,
     project_context,
-    resolve_installed_pin,
+    resolve_installed_version,
 )
 from cloudfall.render_api import (
     HttpRenderApiClient,
@@ -200,14 +196,6 @@ def _add_init_parser(
         "--name",
         help="package name written to pyproject.toml (default: the directory name)",
     )
-    init_parser.add_argument(
-        "--rev",
-        help=(
-            "Cloudfall commit to pin, installed from --source (default: the "
-            "released version of the running cloudfall, or the commit it was "
-            "installed from when that was a git or source install)"
-        ),
-    )
     init_parser.add_argument(
         "--description",
         help=(
@@ -215,14 +203,6 @@ def _add_init_parser(
             "and pyproject.toml"
         ),
     )
-    init_parser.add_argument(
-        "--source",
-        default=DEFAULT_SOURCE_URL,
-        help=(
-            "git location of Cloudfall to install from, with --rev "
-            f"(default: {DEFAULT_SOURCE_URL})"
-        ),
-    )
 
 
 def _add_add_parsers(
@@ -1033,18 +1013,10 @@ def _run_init(arguments: Namespace) -> int:
             if arguments.name is not None
             else ProjectName.from_directory(directory)
         )
-        pin = (
-            GitPin(
-                GitRevision.from_boundary(arguments.rev),
-                GitSourceUrl.from_boundary(arguments.source),
-            )
-            if arguments.rev is not None
-            else resolve_installed_pin()
-        )
         options = InitOptions(
             directory=directory,
             name=name,
-            pin=pin,
+            version=resolve_installed_version(),
             description=(
                 ProjectDescription.from_boundary(arguments.description)
                 if arguments.description is not None

{cloudfall-0.2.1 → cloudfall-0.3.0}/sdk/src/cloudfall/project.py

@@ -4,8 +4,7 @@ A project is one directory holding everything Cloudfall needs to run one
 user's stack: the fleet (servers, server types, SSH public keys), the
 applications (applications, components, services, domains), the operating
 declarations (alert rules, operator policies, logging stacks), and the
-``pyproject.toml`` that pins the Cloudfall the project runs with: a
-released version from the package index, or a commit in the repository.
+``pyproject.toml`` that pins the released Cloudfall the project runs with.
 Every ``cloudfall`` command runs inside a project: the current directory
 when it is one, else ``--project``, else ``CLOUDFALL_PROJECT``.
 Evidence, receipts, and rendered files land under ``tmp/`` inside the
@@ -14,7 +13,6 @@ project and are never committed.
 
 from __future__ import annotations
 
-import json
 import os
 import re
 import shutil
@@ -26,7 +24,6 @@ from enum import Enum
 from importlib import metadata
 from pathlib import Path
 from typing import TYPE_CHECKING
-from urllib.parse import urlparse
 
 from cloudfall.commands import CommandEffect, commands_with_effect
 from cloudfall.domain import ResourceKind
@@ -34,20 +31,17 @@ from cloudfall.domain import ResourceKind
 if TYPE_CHECKING:
     from collections.abc import Callable, Iterator, Mapping
 
-_GIT_REVISION_PATTERN = re.compile(r"^[0-9a-f]{40}$")
 _PROJECT_NAME_PATTERN = re.compile(r"^[a-z0-9](?:[a-z0-9._-]*[a-z0-9])?$")
 _RELEASE_VERSION_PATTERN = re.compile(
     r"^\d+(?:\.\d+)*(?:(?:a|b|rc)\d+)?(?:\.post\d+)?(?:\.dev\d+)?$"
 )
-_SCP_LIKE_SOURCE_PATTERN = re.compile(
-    r"^(?P<user>[\w.-]+)@(?P<host>[\w.-]+):(?P<path>[\w./-]+)$"
-)
 _PROJECT_NAME_MAX_LENGTH = 64
 _PROJECT_DESCRIPTION_MAX_LENGTH = 512
 _GIT_TIMEOUT_SECONDS = 30
 _GIT_NOT_A_REPOSITORY_EXIT_CODE = 128
 
-DEFAULT_SOURCE_URL = "https://github.com/romamo/cloudfall.git"
+REPOSITORY_URL = "https://github.com/romamo/cloudfall"
+"""Location of the Cloudfall repository, for links to its files."""
 
 SECRETS_DIRECTORY = "secrets"
 """Project directory holding sops-encrypted secret fragments."""
@@ -70,9 +64,6 @@ CLAUDE_POINTER_FILE = "CLAUDE.md"
 _ERROR_NAME_UNDERIVED = "project_name_underived"
 _ERROR_DIRECTORY_MISSING = "project_directory_missing"
 _ERROR_DIRECTORY_UNRESOLVED = "project_directory_unresolved"
-_ERROR_REVISION_UNRESOLVED = "project_revision_unresolved"
-_ERROR_REVISION_UNCOMMITTED = "project_revision_uncommitted"
-_ERROR_REVISION_UNPUBLISHED = "project_revision_unpublished"
 _ERROR_VERSION_UNRESOLVED = "project_version_unresolved"
 _ERROR_NOT_A_DIRECTORY = "project_directory_not_a_directory"
 _ERROR_NOT_EMPTY = "project_directory_not_empty"
@@ -104,76 +95,6 @@ class ProjectError(RuntimeError):
         }
 
 
-@dataclass(frozen=True, slots=True)
-class GitRevision:
-    """Full 40-character commit hash a project pins Cloudfall to."""
-
-    value: str
-
-    def __post_init__(self) -> None:
-        """Enforce the full-hash invariant at construction time."""
-        if not _GIT_REVISION_PATTERN.fullmatch(self.value):
-            message = f"git revision must be a full 40-hex commit hash: {self.value!r}"
-            raise ValueError(message)
-
-    @classmethod
-    def from_boundary(cls, value: object) -> GitRevision:
-        """Coerce a boundary value while keeping internal APIs strictly typed."""
-        if not isinstance(value, str):
-            message = f"git revision must be a string, got {type(value).__name__}"
-            raise TypeError(message)
-        return cls(value.strip().lower())
-
-    def __str__(self) -> str:
-        """Return the serialized hash."""
-        return self.value
-
-
-@dataclass(frozen=True, slots=True)
-class GitSourceUrl:
-    """Location of the Cloudfall repository a project installs from."""
-
-    value: str
-
-    def __post_init__(self) -> None:
-        """Accept https and ssh git locations only."""
-        parsed = urlparse(self.value)
-        https = parsed.scheme == "https" and bool(parsed.netloc)
-        ssh = parsed.scheme == "ssh" and bool(parsed.netloc)
-        scp_like = _SCP_LIKE_SOURCE_PATTERN.fullmatch(self.value) is not None
-        if not (https or ssh or scp_like):
-            message = f"git source must be an https or ssh location: {self.value!r}"
-            raise ValueError(message)
-
-    @classmethod
-    def from_boundary(cls, value: object) -> GitSourceUrl:
-        """Coerce a boundary value while keeping internal APIs strictly typed."""
-        if not isinstance(value, str):
-            message = f"git source must be a string, got {type(value).__name__}"
-            raise TypeError(message)
-        return cls(value.strip())
-
-    @property
-    def browse_url(self) -> str:
-        """Return the https location of the repository for links to its files.
-
-        ``https://host/owner/repo.git``, ``ssh://git@host/owner/repo.git``, and
-        ``git@host:owner/repo.git`` all browse at ``https://host/owner/repo``.
-        """
-        scp_like = _SCP_LIKE_SOURCE_PATTERN.fullmatch(self.value)
-        if scp_like is not None:
-            host, path = scp_like.group("host"), scp_like.group("path")
-        else:
-            parsed = urlparse(self.value)
-            host, path = parsed.hostname or "", parsed.path
-        path = path.strip("/").removesuffix(".git")
-        return f"https://{host}/{path}"
-
-    def __str__(self) -> str:
-        """Return the serialized location."""
-        return self.value
-
-
 @dataclass(frozen=True, slots=True)
 class ReleaseVersion:
     """Released Cloudfall version a project pins from the package index."""
@@ -199,84 +120,6 @@ class ReleaseVersion:
         return self.value
 
 
-@dataclass(frozen=True, slots=True)
-class GitPin:
-    """A project that installs Cloudfall from a commit in the repository."""
-
-    revision: GitRevision
-    source: GitSourceUrl = GitSourceUrl(DEFAULT_SOURCE_URL)
-
-    @property
-    def requirement(self) -> str:
-        """Return the dependency specifier for the project's ``pyproject``."""
-        return "cloudfall"
-
-    @property
-    def sources_table(self) -> str:
-        """Return the ``[tool.uv.sources]`` table that resolves the commit."""
-        return f"""
-# Cloudfall is an installed package: the schema catalog and the Ansible engine
-# ship inside the wheel. Bump `rev` to move this project to a newer Cloudfall
-# commit, then run `uv sync`. Add the `mcp` extra (`cloudfall[mcp]`) to run
-# the `cloudfall-mcp` agent server.
-[tool.uv.sources]
-cloudfall = {{ git = "{self.source}", rev = "{self.revision}" }}
-"""
-
-    @property
-    def browse_url(self) -> str:
-        """Return the https location of the repository the pin reads from."""
-        return self.source.browse_url
-
-    @property
-    def browse_ref(self) -> str:
-        """Return the git ref whose files match the pinned Cloudfall."""
-        return str(self.revision)
-
-    def as_dict(self) -> dict[str, object]:
-        """Serialize the pin for system boundaries."""
-        return {
-            "kind": "git",
-            "revision": str(self.revision),
-            "source": str(self.source),
-        }
-
-
-@dataclass(frozen=True, slots=True)
-class IndexPin:
-    """A project that installs a released Cloudfall from the package index."""
-
-    version: ReleaseVersion
-
-    @property
-    def requirement(self) -> str:
-        """Return the dependency specifier for the project's ``pyproject``."""
-        return f"cloudfall=={self.version}"
-
-    @property
-    def sources_table(self) -> str:
-        """Return nothing: a released version needs no source override."""
-        return ""
-
-    @property
-    def browse_url(self) -> str:
-        """Return the https location of the repository the release came from."""
-        return GitSourceUrl(DEFAULT_SOURCE_URL).browse_url
-
-    @property
-    def browse_ref(self) -> str:
-        """Return the release tag whose files match the pinned Cloudfall."""
-        return f"v{self.version}"
-
-    def as_dict(self) -> dict[str, object]:
-        """Serialize the pin for system boundaries."""
-        return {"kind": "index", "version": str(self.version)}
-
-
-type ProjectPin = GitPin | IndexPin
-"""What a project pins Cloudfall to: a released version, or a commit."""
-
-
 @dataclass(frozen=True, slots=True)
 class ProjectName:
     """Package name of a project, as written into its ``pyproject.toml``."""
@@ -363,7 +206,7 @@ class InitOptions:
 
     directory: Path
     name: ProjectName
-    pin: ProjectPin
+    version: ReleaseVersion
     description: ProjectDescription | None = None
 
 
@@ -383,7 +226,7 @@ class ProjectScaffold:
 
     directory: Path
     name: ProjectName
-    pin: ProjectPin
+    version: ReleaseVersion
     files: tuple[str, ...]
     git: GitSetup
 
@@ -394,7 +237,7 @@ class ProjectScaffold:
             "project": {
                 "directory": str(self.directory),
                 "name": str(self.name),
-                "pin": self.pin.as_dict(),
+                "version": str(self.version),
                 "git": self.git.value,
             },
             "files": list(self.files),
@@ -407,17 +250,6 @@ class ProjectScaffold:
         }
 
 
-@dataclass(frozen=True, slots=True)
-class CheckoutState:
-    """What a source checkout says about the commit it is running."""
-
-    head: str
-    clean: bool
-    """No tracked file differs from ``HEAD``, so ``HEAD`` is the running code."""
-    published: bool
-    """``HEAD`` is reachable from a remote-tracking branch, so it can be fetched."""
-
-
 def is_project(directory: Path) -> bool:
     """Return whether a directory holds at least one resource kind directory."""
     return directory.is_dir() and any(
@@ -493,77 +325,24 @@ def project_path(value: str) -> Path:
     return path
 
 
-def resolve_installed_pin(
-    read_direct_url: Callable[[], str | None] | None = None,
-    inspect_checkout: Callable[[Path], CheckoutState] | None = None,
-    read_version: Callable[[], str] | None = None,
-) -> ProjectPin:
-    """Return what the running Cloudfall pins a new project to.
-
-    An install from the package index records no origin, and its version is
-    the pin: the project depends on ``cloudfall==<version>`` and resolves it
-    the ordinary way. A wheel installed from git records its commit in
-    ``direct_url.json``; an editable source checkout records the checkout
-    location, whose ``HEAD`` is the commit, provided the checkout is clean
-    (else ``HEAD`` is not the code that is running) and ``HEAD`` is on a
-    remote branch (else ``uv sync`` cannot fetch it). Anything else cannot be
-    pinned and must be given explicitly.
-    """
-    direct_url = (read_direct_url or _installed_direct_url)()
-    if direct_url is None:
-        return IndexPin(_installed_release_version(read_version))
-    record = json.loads(direct_url)
-    if not isinstance(record, dict):
-        message = f"direct_url.json is not an object: {direct_url!r}"
-        raise ProjectError(_ERROR_REVISION_UNRESOLVED, message)
-    vcs_info = record.get("vcs_info")
-    if isinstance(vcs_info, dict) and "commit_id" in vcs_info:
-        return GitPin(GitRevision.from_boundary(vcs_info["commit_id"]))
-    dir_info = record.get("dir_info")
-    url = record.get("url")
-    if (
-        isinstance(dir_info, dict)
-        and isinstance(url, str)
-        and url.startswith("file://")
-    ):
-        checkout = Path(urlparse(url).path)
-        inspect = inspect_checkout or _inspect_checkout
-        return GitPin(_pinnable_head(checkout, inspect(checkout)))
-    message = (
-        "the installed cloudfall distribution is neither a git install nor a "
-        f"source checkout ({url!r}); pass --rev with the commit to pin"
-    )
-    raise ProjectError(_ERROR_REVISION_UNRESOLVED, message)
-
-
-def _pinnable_head(checkout: Path, state: CheckoutState) -> GitRevision:
-    head = GitRevision.from_boundary(state.head)
-    if not state.clean:
-        message = (
-            f"the source checkout {checkout} has uncommitted changes, so HEAD "
-            f"{head} is not the code that is running; commit them or pass --rev"
-        )
-        raise ProjectError(_ERROR_REVISION_UNCOMMITTED, message)
-    if not state.published:
-        message = (
-            f"HEAD {head} of the source checkout {checkout} is on no remote "
-            "branch, so `uv sync` could not fetch it; push it or pass --rev"
-        )
-        raise ProjectError(_ERROR_REVISION_UNPUBLISHED, message)
-    return head
-
-
-def _installed_release_version(
+def resolve_installed_version(
     read_version: Callable[[], str] | None = None,
 ) -> ReleaseVersion:
+    """Return the released version of the running Cloudfall.
+
+    A project depends on ``cloudfall==<version>`` and resolves it from the
+    package index like any other dependency. An install whose version is not
+    a release cannot be pinned that way, which is a checkout of this
+    repository between releases.
+    """
     raw = (read_version or _installed_version)()
     try:
         return ReleaseVersion.from_boundary(raw)
     except ValueError as error:
         message = (
-            "the installed cloudfall distribution records no origin and its "
-            f"version {raw!r} is not a release, so there is nothing to pin; "
-            "pass --rev with the commit to pin"
+            f"the installed cloudfall version {raw!r} is not a release, so a "
+            "project cannot pin it; install a released cloudfall, or set the "
+            "dependency in the project's pyproject.toml by hand"
         )
         raise ProjectError(_ERROR_VERSION_UNRESOLVED, message) from error
 
@@ -572,10 +351,6 @@ def _installed_version() -> str:
     return metadata.version("cloudfall")
 
 
-def _installed_direct_url() -> str | None:
-    return metadata.distribution("cloudfall").read_text("direct_url.json")
-
-
 def _git_binary() -> str:
     git = shutil.which("git")
     if git is None:
@@ -609,15 +384,6 @@ def _git_or_fail(directory: Path, *arguments: str) -> str:
     return completed.stdout
 
 
-def _inspect_checkout(checkout: Path) -> CheckoutState:
-    head = _git_or_fail(checkout, "rev-parse", "HEAD").strip()
-    changes = _git_or_fail(checkout, "status", "--porcelain", "--untracked-files=no")
-    remote_branches = _git_or_fail(checkout, "branch", "--remotes", "--contains", head)
-    return CheckoutState(
-        head=head, clean=not changes.strip(), published=bool(remote_branches.strip())
-    )
-
-
 def _initialize_git(directory: Path) -> GitSetup:
     """Create a repository in the directory unless one already encloses it."""
     enclosing = _run_git(directory, "rev-parse", "--is-inside-work-tree")
@@ -666,7 +432,7 @@ def init_project(
     return ProjectScaffold(
         directory=directory,
         name=options.name,
-        pin=options.pin,
+        version=options.version,
         files=tuple(files),
         git=git,
     )
@@ -684,14 +450,14 @@ version = "0"
 description = "{description}"
 requires-python = ">=3.14"
 # Cloudfall is an installed package: the schema catalog and the Ansible engine
-# ship inside the wheel. Bump this pin to move the project to a newer
+# ship inside the wheel. Bump this version to move the project to a newer
 # Cloudfall, then run `uv sync`. Add the `mcp` extra (`cloudfall[mcp]`) to run
 # the `cloudfall-mcp` agent server.
-dependencies = ["{options.pin.requirement}"]
+dependencies = ["cloudfall=={options.version}"]
 
 [tool.uv]
 package = false
-{options.pin.sources_table}"""
+"""
 
 
 _GITIGNORE = f"""# Runtime state: evidence, receipts, rendered inventory, built
@@ -722,8 +488,8 @@ creation_rules:
 def _readme(options: InitOptions, git: GitSetup) -> str:
     tmp = RUNTIME_DIRECTORY
     secrets = SECRETS_DIRECTORY
-    browse = options.pin.browse_url
-    ref = options.pin.browse_ref
+    browse = REPOSITORY_URL
+    ref = f"v{options.version}"
     secrets_guide = f"{browse}/blob/{ref}/{SECRETS_GUIDE_PATH}"
     examples = f"{browse}/tree/{ref}/{EXAMPLES_PATH}"
     about = (
@@ -808,9 +574,9 @@ uv run cloudfall migrate --build <component>=main
 uv run cloudfall migrate --build <component>=main --yes
 ```
 
-Cloudfall is pinned to one commit in `pyproject.toml`; bump `rev` and run
-`uv sync` to move the project to a newer release. The links below point at
-the pinned commit.
+Cloudfall is pinned to one released version in `pyproject.toml`; bump it
+and run `uv sync` to move the project to a newer release. The links below
+point at the pinned release.
 
 [cloudfall]: {browse}
 [secrets-guide]: {secrets_guide}

{cloudfall-0.2.1 → cloudfall-0.3.0}/sdk/tests/test_agent_tools.py

@@ -9,10 +9,9 @@ import pytest
 import yaml
 from cloudfall.agent_tools import AgentConfig, AgentToolset
 from cloudfall.project import (
-    GitPin,
-    GitRevision,
     InitOptions,
     ProjectName,
+    ReleaseVersion,
     init_project,
 )
 
@@ -32,7 +31,7 @@ services:
 """
 
 
-REVISION = "5dea76ae7fdf4f99f5e8eb84b939dfa68b12ef3b"
+VERSION = "0.3.0"
 
 
 def _config(
@@ -147,7 +146,7 @@ def _fresh_project(tmp_path: Path) -> AgentToolset:
         InitOptions(
             directory=directory,
             name=ProjectName("project"),
-            pin=GitPin(GitRevision(REVISION)),
+            version=ReleaseVersion(VERSION),
         )
     )
     return AgentToolset(_config(tmp_path, project_directory=directory))

{cloudfall-0.2.1 → cloudfall-0.3.0}/sdk/tests/test_authoring.py

@@ -18,10 +18,9 @@ from cloudfall.authoring import (
 from cloudfall.cli import main
 from cloudfall.domain import ConnectionAddress, LinuxUser, ResourceId, TcpPort
 from cloudfall.project import (
-    GitPin,
-    GitRevision,
     InitOptions,
     ProjectName,
+    ReleaseVersion,
     init_project,
 )
 from cloudfall.validation import ConfigValidationError, validate_config
@@ -29,7 +28,7 @@ from cloudfall.validation import ConfigValidationError, validate_config
 ROOT = Path(__file__).parents[2]
 SCHEMAS = ROOT / "config" / "schemas" / "v1"
 EXAMPLES = ROOT / "config" / "examples"
-REVISION = "5dea76ae7fdf4f99f5e8eb84b939dfa68b12ef3b"
+VERSION = "0.3.0"
 
 
 def _example_key() -> str:
@@ -52,7 +51,7 @@ def _project(tmp_path: Path) -> Path:
         InitOptions(
             directory=directory,
             name=ProjectName("project"),
-            pin=GitPin(GitRevision(REVISION)),
+            version=ReleaseVersion(VERSION),
         )
     )
     return directory