katalyst-taxonomy-cli 2.0.1a4__tar.gz → 2.0.1a6__tar.gz

{katalyst_taxonomy_cli-2.0.1a4 → katalyst_taxonomy_cli-2.0.1a6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: katalyst-taxonomy-cli
-Version: 2.0.1a4
+Version: 2.0.1a6
 Summary: CLI for katalyst-taxonomy — the kata command
 Author: eSimplicity
 License: Proprietary

{katalyst_taxonomy_cli-2.0.1a4 → katalyst_taxonomy_cli-2.0.1a6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "katalyst-taxonomy-cli"
-version = "2.0.1a4"
+version = "2.0.1a6"
 description = "CLI for katalyst-taxonomy — the kata command"
 license = { text = "Proprietary" }
 requires-python = ">=3.12"

{katalyst_taxonomy_cli-2.0.1a4 → katalyst_taxonomy_cli-2.0.1a6}/src/katalyst_taxonomy_cli/app.py

@@ -311,14 +311,15 @@ def cli(ctx: click.Context, profile: str | None) -> None:
         ctx.meta[ROOT_PROFILE_META_KEY] = profile
     _configure_logging()
     # A KATALYST_HOME that names no home fails every command here, before any of them
-    # reads or writes anything (`--home` was checked as it was parsed).
-    from katalyst_taxonomy.adapters.filesystem.homes import resolve_existing_home
+    # reads or writes anything (`--home` was checked as it was parsed) — unless
+    # KATALYST_HOME_SOURCE says what to create it from.
+    from katalyst_taxonomy.adapters.config_sources.homes import resolve_home_on_demand
     from katalyst_taxonomy.domain.homes import HomeError
 
     from .install import refuse_default_home_for_development
 
     try:
-        home = resolve_existing_home()
+        home = resolve_home_on_demand(announce=lambda m: click.echo(m, err=True))
     except HomeError as exc:
         raise click.ClickException(str(exc)) from exc
     # `kata config` decides for itself: `kata config home …` manages homes, not uses one.

{katalyst_taxonomy_cli-2.0.1a4 → katalyst_taxonomy_cli-2.0.1a6}/src/katalyst_taxonomy_cli/commands/config_home.py

@@ -4,7 +4,7 @@ A home is the config, state and cache a process uses (:mod:`katalyst_taxonomy.do
 ``kata --home NAME`` or ``KATALYST_HOME=NAME`` selects one; a named home must exist first::
 
     kata config home list
-    kata config home create NAME [--from HOME]
+    kata config home create NAME [--from HOME | --source URI [--source-profile P]]
     kata config home rm NAME [--yes]
 
 Path homes (an absolute ``KATALYST_HOME``, for tests and CI) are never listed: they are
@@ -14,7 +14,6 @@ wherever their caller put them.
 from __future__ import annotations
 
 import json
-import os
 import shutil
 from typing import Any
 
@@ -32,6 +31,7 @@ from katalyst_taxonomy.domain.homes import (
     resolve_home,
 )
 from katalyst_taxonomy.domain.paths import CONFIG_FILE_NAME
+from katalyst_taxonomy.processes import is_process_running
 
 from ..output import ConsoleOutput
 
@@ -52,9 +52,7 @@ def _running_api(home: Home) -> dict[str, Any] | None:
         pid, host, port = int(record["pid"]), str(record["host"]), int(record["port"])
     except (OSError, ValueError, KeyError, TypeError):
         return None
-    try:
-        os.kill(pid, 0)
-    except OSError:
+    if not is_process_running(pid):
         return None
     return {"pid": pid, "url": f"http://{host}:{port}"}
 
@@ -121,15 +119,56 @@ def home_list(fmt: str) -> None:
 @click.argument("name")
 @click.option(
     "--from",
-    "source",
+    "copy_from",
     default=None,
     metavar="HOME",
     help="Copy config.yaml (only) from this home: 'default', a name, or an absolute path.",
 )
-def home_create(name: str, source: str | None) -> None:
-    """Create the named home NAME, empty or with another home's config.yaml."""
+@click.option(
+    "--source",
+    "profile_source",
+    default=None,
+    metavar="URI",
+    help=(
+        "Give the home one read-only profile sourced from URI, such as home:default "
+        "(another home: the same repositories), then sync it."
+    ),
+)
+@click.option(
+    "--source-profile",
+    default=None,
+    metavar="PROFILE",
+    help="The profile in the source's configuration (default: @active, whichever is active there).",
+)
+def home_create(
+    name: str, copy_from: str | None, profile_source: str | None, source_profile: str | None
+) -> None:
+    """Create the named home NAME: empty, with another home's config.yaml, or sourced.
+
+    With --source, NAME's config.yaml holds one profile sourced from URI, and nothing
+    else. By default it follows the source's active profile (@active), at every sync. A
+    home: source's profile reads the other home's repositories; its state (the API's
+    record and token) and cache are never read.
+    """
+    if copy_from is not None and profile_source is not None:
+        raise click.ClickException("give --from or --source, not both")
+    if source_profile is not None and profile_source is None:
+        raise click.ClickException("--source-profile needs --source")
+    out = ConsoleOutput()
+    if profile_source is not None:
+        from katalyst_taxonomy.adapters.config_sources.homes import create_sourced_home
+        from katalyst_taxonomy.config.profile_sources import ACTIVE_PROFILE
+
+        wanted = source_profile or ACTIVE_PROFILE
+        try:
+            created, pin = create_sourced_home(name, profile_source, source_profile=wanted)
+        except HomeError as exc:
+            raise click.ClickException(str(exc)) from exc
+        out.success(f"Created home {created.label}, with profile {wanted!r} of {profile_source}")
+        out.info(f"Synced it: pinned {pin}")
+        return
     try:
-        origin = home_for(source) if source is not None else None
+        origin = home_for(copy_from) if copy_from is not None else None
         created = create_home(name)
     except HomeError as exc:
         raise click.ClickException(str(exc)) from exc
@@ -139,7 +178,7 @@ def home_create(name: str, source: str | None) -> None:
         if config_file.is_file():
             shutil.copy2(config_file, created.config_dir / CONFIG_FILE_NAME)
             copied = f", with config.yaml from {origin.name}"
-    ConsoleOutput().success(f"Created home {created.label}{copied}")
+    out.success(f"Created home {created.label}{copied}")
 
 
 @home.command("rm")

{katalyst_taxonomy_cli-2.0.1a4 → katalyst_taxonomy_cli-2.0.1a6}/src/katalyst_taxonomy_cli/commands/config_profile.py

@@ -318,7 +318,8 @@ def profile_show(name: str, fmt: str) -> None:
     metavar="URI",
     help=(
         "Read the profile from elsewhere: git:<url>[@<ref>][#path=<file>], "
-        "github:<owner>/<repo>[@<ref>][#path=<file>], or a kata API's https:// URL."
+        "github:<owner>/<repo>[@<ref>][#path=<file>], a kata API's https:// URL, or "
+        "home:<home> (another home on this machine)."
     ),
 )
 @click.option(

{katalyst_taxonomy_cli-2.0.1a4 → katalyst_taxonomy_cli-2.0.1a6}/src/katalyst_taxonomy_cli/commands/config_sources.py

@@ -109,9 +109,7 @@ def config_status(offline: bool, fmt: str) -> None:
         ["profile", "source", "pin", "fetched", "upstream"],
         [
             [
-                row.profile
-                if row.source_profile == row.profile
-                else f"{row.profile} ({row.source_profile})",
+                _profile_label(row),
                 row.source,
                 _short(row.pin) if row.pin else "never fetched",
                 row.fetched_at or "-",
@@ -125,6 +123,14 @@ def config_status(offline: bool, fmt: str) -> None:
             out.warning(f"{row.profile}: {row.error}")
 
 
+def _profile_label(row: Any) -> str:
+    if row.source_profile == row.profile:
+        return str(row.profile)
+    if row.pinned_profile and row.pinned_profile != row.source_profile:
+        return f"{row.profile} ({row.source_profile}: {row.pinned_profile})"
+    return f"{row.profile} ({row.source_profile})"
+
+
 def _upstream(row: Any, offline: bool) -> str:
     if offline:
         return "not checked"

{katalyst_taxonomy_cli-2.0.1a4 → katalyst_taxonomy_cli-2.0.1a6}/src/katalyst_taxonomy_cli/commands/lifecycle.py

@@ -101,24 +101,38 @@ def restore(ctx: CliContext, address: str, backend_target: str | None) -> None:
 def import_(ctx: CliContext, file: Path, backend_target: str) -> None:
     """Create every node document of FILE (a YAML stream) in the backend, or none of them.
 
-    The whole change set passes the local shapes first, with the nodes it refers to;
-    then the nodes are created parents first, each as ``kata tax create`` creates it.
-    If one fails, the ones already created are removed again.
+    The stream is one change set: a reference resolves against every node in it as well
+    as the backend, and the whole set passes the reference checks and the local shapes
+    first. Then the nodes are created, each as ``kata tax create`` creates it, after the
+    nodes it needs (its parent, the nodes it refers to). If one fails, the ones already
+    created are removed again; so are those of an import that was killed part-way, by
+    the next one.
     """
     import yaml
-    from katalyst_taxonomy.adapters.orchestration import create_node
-    from katalyst_taxonomy.services.change_import import ImportError_, import_documents
+    from katalyst_taxonomy.adapters.orchestration import create_node, import_journal
+    from katalyst_taxonomy.services.change_import import (
+        ImportError_,
+        import_documents,
+        recover_import,
+    )
 
     from .._wiring import resolve_backend
 
     resolved = resolve_backend(ctx, backend_target)
     documents = [d for d in yaml.safe_load_all(file.read_text(encoding="utf-8")) if d]
+    journal = import_journal(resolved.backend)
     try:
+        rolled_back = recover_import(resolved.backend, journal)
+        if rolled_back:
+            ctx.output.echo(
+                "Rolled back an import that stopped part-way; removed: " + ", ".join(rolled_back)
+            )
         created = import_documents(
             resolved.backend,
             [cast("dict[str, Any]", d) for d in documents],
             create=lambda request: create_node(resolved.backend, request),
             source=file,
+            journal=journal,
         )
     except ImportError_ as exc:
         ctx.output.echo(f"Error: {exc}")