composable-data-stack 0.5.1__tar.gz → 0.5.2__tar.gz

{composable_data_stack-0.5.1 → composable_data_stack-0.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: composable-data-stack
-Version: 0.5.1
+Version: 0.5.2
 Summary: CLI for validating and composing composable data stack profiles
 Author: Ronald Hensbergen
 License-Expression: Apache-2.0

{composable_data_stack-0.5.1 → composable_data_stack-0.5.2}/cli/getter.py

@@ -5,6 +5,7 @@ import os
 import re
 import shlex
 import shutil
+import sys
 import tarfile
 import tempfile
 from collections.abc import Iterator
@@ -667,15 +668,49 @@ def _write_tracking_manifest(
 def _read_tracking_manifest(path: Path) -> dict[str, Any]:
     if not path.exists():
         return {"version": 1, "profiles": {}}
+
     try:
-        data = json.loads(path.read_text(encoding="utf-8"))
-    except (OSError, json.JSONDecodeError):
-        return {"version": 1, "profiles": {}}
-    if not isinstance(data, dict):
+        raw_text = path.read_text(encoding="utf-8")
+    except OSError as exc:
+        # The file could not be read at all, so it cannot be backed up either;
+        # skip the doomed copy attempt and report the read failure directly.
+        print(
+            f"WARNING {path} could not be read ({exc}); resetting tracking manifest.",
+            file=sys.stderr,
+        )
         return {"version": 1, "profiles": {}}
-    data.setdefault("version", 1)
-    data.setdefault("profiles", {})
-    return data
+
+    malformed_reason: str = ""
+    try:
+        data = json.loads(raw_text)
+    except json.JSONDecodeError as exc:
+        malformed_reason = f"invalid JSON: {exc}"
+    else:
+        if not isinstance(data, dict):
+            malformed_reason = "manifest root must be a JSON object"
+        else:
+            data.setdefault("version", 1)
+            data.setdefault("profiles", {})
+            return data
+
+    _backup_malformed_manifest(path, malformed_reason)
+    return {"version": 1, "profiles": {}}
+
+
+def _backup_malformed_manifest(path: Path, reason: str) -> None:
+    timestamp = datetime.now(UTC).strftime("%Y%m%dT%H%M%S%fZ")
+    backup_path = path.with_name(f"{path.name}.corrupt-{timestamp}")
+    try:
+        shutil.copy2(path, backup_path)
+        backup_message = f"backed up to {backup_path}"
+    except OSError as exc:
+        backup_message = f"backup failed: {exc}"
+
+    print(
+        f"WARNING {path} is malformed ({reason}); resetting tracking manifest "
+        f"({backup_message}).",
+        file=sys.stderr,
+    )
 
 
 def _asset_root_relative_path(asset_root: Path, source_repo: Path) -> str:

{composable_data_stack-0.5.1 → composable_data_stack-0.5.2}/cli/main.py

@@ -114,12 +114,19 @@ def get_modules_root() -> Path:
 def find_project_root(start: Path | None = None) -> Path:
     """
     Walk up from `start` (default: current working directory) looking for a
-    project root marker (pyproject.toml or .git). Falls back to `start` itself
-    if no marker is found.
+    project root marker: `.cds` (CDS's own state directory, created by
+    `cds get`/`cds use`), `pyproject.toml`, or `.git`. `.cds` is checked first
+    at each level so a CDS working directory takes priority over an unrelated
+    ancestor repository (e.g. a dotfiles repo at $HOME) that happens to sit
+    further up the tree. Falls back to `start` itself if no marker is found.
     """
     current = (start or Path.cwd()).resolve()
     for directory in [current, *current.parents]:
-        if (directory / "pyproject.toml").exists() or (directory / ".git").exists():
+        if (
+            (directory / ".cds").exists()
+            or (directory / "pyproject.toml").exists()
+            or (directory / ".git").exists()
+        ):
             return directory
     return current
 
@@ -335,13 +342,19 @@ def resolve_project_root(profile_path: str) -> Path:
     """
     Resolve a project root for output artifacts.
 
-    The resolver walks up from the selected profile location and picks the first
-    directory containing either pyproject.toml or .git. If no marker is found,
-    it falls back to the current working directory.
+    The resolver walks up from the selected profile location and picks the
+    first directory containing `.cds` (CDS's own state directory, checked
+    first so it takes priority over an unrelated ancestor repository),
+    `pyproject.toml`, or `.git`. If no marker is found, it falls back to the
+    current working directory.
     """
     start = Path(profile_path).resolve().parent
     for directory in [start, *start.parents]:
-        if (directory / "pyproject.toml").exists() or (directory / ".git").exists():
+        if (
+            (directory / ".cds").exists()
+            or (directory / "pyproject.toml").exists()
+            or (directory / ".git").exists()
+        ):
             return directory
     return Path.cwd().resolve()
 

{composable_data_stack-0.5.1 → composable_data_stack-0.5.2}/composable_data_stack.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: composable-data-stack
-Version: 0.5.1
+Version: 0.5.2
 Summary: CLI for validating and composing composable data stack profiles
 Author: Ronald Hensbergen
 License-Expression: Apache-2.0

{composable_data_stack-0.5.1 → composable_data_stack-0.5.2}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "composable-data-stack"
-version = "0.5.1"
+version = "0.5.2"
 description = "CLI for validating and composing composable data stack profiles"
 readme = "README.md"
 license = "Apache-2.0"

{composable_data_stack-0.5.1 → composable_data_stack-0.5.2}/tests/test_getter.py

@@ -1,3 +1,4 @@
+import contextlib
 import io
 import json
 import os
@@ -119,6 +120,139 @@ class GetterTest(unittest.TestCase):
             )
             self.assertIn("kind: Profile", profile_file.read_text(encoding="utf-8"))
 
+    def test_fetch_profile_backs_up_and_warns_on_malformed_manifest(self) -> None:
+        with tempfile.TemporaryDirectory() as source_dir, tempfile.TemporaryDirectory() as dest_dir:
+            source_root = Path(source_dir)
+            destination_root = Path(dest_dir)
+            _make_source_repo(source_root)
+
+            manifest_path = destination_root / ".cds" / "get-manifest.json"
+            _write(manifest_path, "{not valid json")
+
+            stderr = io.StringIO()
+            with contextlib.redirect_stderr(stderr):
+                _, returned_manifest_path = fetch_profile(
+                    "demo",
+                    local=str(source_root),
+                    destination_root=destination_root,
+                )
+
+            self.assertEqual(returned_manifest_path.resolve(), manifest_path.resolve())
+            manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+            self.assertEqual(manifest["profiles"]["demo"]["requestedProfile"], "demo")
+
+            warning_output = stderr.getvalue()
+            self.assertIn("WARNING", warning_output)
+            self.assertIn("is malformed", warning_output)
+            self.assertIn("invalid JSON", warning_output)
+
+            backups = list(manifest_path.parent.glob("get-manifest.json.corrupt-*"))
+            self.assertEqual(len(backups), 1)
+            self.assertEqual(backups[0].read_text(encoding="utf-8"), "{not valid json")
+            self.assertIn(backups[0].name, warning_output)
+
+    def test_fetch_profile_backs_up_and_warns_on_non_dict_manifest(self) -> None:
+        with tempfile.TemporaryDirectory() as source_dir, tempfile.TemporaryDirectory() as dest_dir:
+            source_root = Path(source_dir)
+            destination_root = Path(dest_dir)
+            _make_source_repo(source_root)
+
+            manifest_path = destination_root / ".cds" / "get-manifest.json"
+            _write(manifest_path, "[1, 2, 3]")
+
+            stderr = io.StringIO()
+            with contextlib.redirect_stderr(stderr):
+                fetch_profile(
+                    "demo",
+                    local=str(source_root),
+                    destination_root=destination_root,
+                )
+
+            manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+            self.assertEqual(manifest["profiles"]["demo"]["requestedProfile"], "demo")
+
+            warning_output = stderr.getvalue()
+            self.assertIn("WARNING", warning_output)
+            self.assertIn("is malformed", warning_output)
+            self.assertIn("manifest root must be a JSON object", warning_output)
+
+            backups = list(manifest_path.parent.glob("get-manifest.json.corrupt-*"))
+            self.assertEqual(len(backups), 1)
+            self.assertIn(backups[0].name, warning_output)
+
+    def test_fetch_profile_warns_without_backup_when_manifest_unreadable(self) -> None:
+        with tempfile.TemporaryDirectory() as source_dir, tempfile.TemporaryDirectory() as dest_dir:
+            source_root = Path(source_dir)
+            destination_root = Path(dest_dir)
+            _make_source_repo(source_root)
+
+            manifest_path = destination_root / ".cds" / "get-manifest.json"
+            _write(manifest_path, "{}")
+
+            original_read_text = Path.read_text
+
+            def _raising_read_text(self: Path, *args: object, **kwargs: object) -> str:
+                if self.resolve() == manifest_path.resolve():
+                    raise OSError("permission denied")
+                return original_read_text(self, *args, **kwargs)
+
+            stderr = io.StringIO()
+            with patch.object(Path, "read_text", _raising_read_text):
+                with contextlib.redirect_stderr(stderr):
+                    fetch_profile(
+                        "demo",
+                        local=str(source_root),
+                        destination_root=destination_root,
+                    )
+
+            manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+            self.assertEqual(manifest["profiles"]["demo"]["requestedProfile"], "demo")
+
+            warning_output = stderr.getvalue()
+            self.assertIn("WARNING", warning_output)
+            self.assertIn("could not be read", warning_output)
+            self.assertIn("permission denied", warning_output)
+            self.assertNotIn("is malformed", warning_output)
+
+            backups = list(manifest_path.parent.glob("get-manifest.json.corrupt-*"))
+            self.assertEqual(len(backups), 0)
+
+    def test_fetch_profile_loads_valid_manifest_unchanged(self) -> None:
+        with tempfile.TemporaryDirectory() as source_dir, tempfile.TemporaryDirectory() as dest_dir:
+            source_root = Path(source_dir)
+            destination_root = Path(dest_dir)
+            _make_source_repo(source_root)
+
+            manifest_path = destination_root / ".cds" / "get-manifest.json"
+            _write(
+                manifest_path,
+                json.dumps(
+                    {
+                        "version": 1,
+                        "profiles": {
+                            "other": {"requestedProfile": "other", "files": []},
+                        },
+                    }
+                ),
+            )
+
+            stderr = io.StringIO()
+            with contextlib.redirect_stderr(stderr):
+                fetch_profile(
+                    "demo",
+                    local=str(source_root),
+                    destination_root=destination_root,
+                )
+
+            self.assertEqual(stderr.getvalue(), "")
+
+            manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+            self.assertIn("other", manifest["profiles"])
+            self.assertEqual(manifest["profiles"]["demo"]["requestedProfile"], "demo")
+
+            backups = list(manifest_path.parent.glob("get-manifest.json.corrupt-*"))
+            self.assertEqual(len(backups), 0)
+
     def test_fetch_profile_dry_run_ignores_conflicting_files(self) -> None:
         with tempfile.TemporaryDirectory() as source_dir, tempfile.TemporaryDirectory() as dest_dir:
             source_root = Path(source_dir)

{composable_data_stack-0.5.1 → composable_data_stack-0.5.2}/tests/test_main.py

@@ -395,6 +395,60 @@ class MainCLITest(unittest.TestCase):
                 
                 self.assertEqual(resolved, Path("/mock/cwd").resolve())
 
+    def test_find_project_root_prefers_nearby_cds_over_ancestor_git(self):
+        """Regression test: a `cds get`/`cds use` working directory that has
+        its own `.cds` marker must not be shadowed by an unrelated `.git`
+        repository further up the tree (e.g. a dotfiles repo at $HOME)."""
+        import tempfile
+        from cli.main import find_project_root
+
+        with tempfile.TemporaryDirectory() as td:
+            home_like_root = Path(td)
+            (home_like_root / ".git").mkdir()
+            work_dir = home_like_root / "tmp"
+            work_dir.mkdir()
+            (work_dir / ".cds").mkdir()
+
+            resolved = find_project_root(work_dir)
+
+            self.assertEqual(resolved, work_dir.resolve())
+
+    def test_find_project_root_falls_back_to_git_when_no_cds_marker(self):
+        """A fresh checkout of the CDS repo itself (no `.cds` yet) should
+        still resolve to the repo root via `.git`/`pyproject.toml`."""
+        import tempfile
+        from cli.main import find_project_root
+
+        with tempfile.TemporaryDirectory() as td:
+            repo_root = Path(td)
+            (repo_root / ".git").mkdir()
+            sub_dir = repo_root / "profiles" / "some-profile"
+            sub_dir.mkdir(parents=True)
+
+            resolved = find_project_root(sub_dir)
+
+            self.assertEqual(resolved, repo_root.resolve())
+
+    def test_resolve_project_root_prefers_nearby_cds_over_ancestor_git(self):
+        """Same regression as find_project_root, but for the resolver used
+        to place rendered docker-compose.yml output for `cds up`/`render`."""
+        import tempfile
+        from cli.main import resolve_project_root
+
+        with tempfile.TemporaryDirectory() as td:
+            home_like_root = Path(td)
+            (home_like_root / ".git").mkdir()
+            work_dir = home_like_root / "tmp"
+            work_dir.mkdir()
+            (work_dir / ".cds").mkdir()
+            profile_path = work_dir / "profiles" / "some-profile" / "profile.yaml"
+            profile_path.parent.mkdir(parents=True)
+            profile_path.touch()
+
+            resolved = resolve_project_root(str(profile_path))
+
+            self.assertEqual(resolved, work_dir.resolve())
+
     def test_init_generates_env_file_from_profile_secrets(self):
         import tempfile