GitHub Actions deploy 7827e5068c351f4ea0e9b17f832620d2f52141a9

README.md

@@ -45,3 +45,16 @@ Nepieciešams:
 3. dataset repo artefaktu publicēšanai;
 4. model repo, kur publicēt treniņa rezultātu;
 5. ja paredzēts īsts train darbs, Space runtime ar pietiekamiem resursiem.
+
+## Automātisks treniņa starts
+
+Ja šo Space izmanto kā vienkāršu persistent training runneri, vari ieslēgt:
+
+- `MARIS_HUMAN_TRAINING_AUTO_TRAIN=true`
+- pēc vajadzības `MARIS_HUMAN_TRAINING_AUTO_TRAIN_MODEL_PRESET` vai `MARIS_HUMAN_TRAINING_AUTO_TRAIN_MODEL_NAME`
+- pēc vajadzības `MARIS_HUMAN_TRAINING_AUTO_TRAIN_OUTPUT_SUBDIR`
+
+Auto-starts palaiž `train-hf.sh` ar Space-safe `huggingface/training-config.json`
+konfigurāciju un pēc restarta nelaiž otru identisku skrējienu, ja output
+direktorijā jau ir pabeigta treniņa artefakti. Ja vajag apzināti pārrakstīt vai
+turpināt virs esoša output, iestati `MARIS_HUMAN_TRAINING_AUTO_TRAIN_FORCE=true`.

core-python/maris_core/training/space_ui.py

@@ -30,6 +30,13 @@ MARIS_PROGRESS_EVENT_KEY = "maris_training_event"
 # Keep a larger rolling event window than persisted run history because live status
 # parsing needs several recent progress/save/eval events from the current log tail.
 MAX_STRUCTURED_EVENTS = 64
+SPACE_TRAINING_CONFIG_PATH_DEFAULT = "huggingface/training-config.json"
+SPACE_TRAINING_COMPLETION_MARKERS = (
+    "training-metrics.json",
+    "trainer_state.json",
+    "training-provenance.json",
+    "branch-suite.json",
+)
 
 
 def _validate_repo_id(value: str) -> str:
@@ -158,7 +165,9 @@ def resolve_optional_persistent_path(persistent_dir: str, path_value: str) -> Pa
     root = Path(persistent_dir).expanduser().resolve()
     target = (root / normalized).resolve()
     if os.path.commonpath([str(root), str(target)]) != str(root):
-        raise ValueError("Continue modeļa direktorijai jāatrodas Maris persistent storage ietvaros.")
+        raise ValueError(
+            "Continue modeļa direktorijai jāatrodas Maris persistent storage ietvaros."
+        )
     return target
 
 
@@ -181,13 +190,26 @@ def build_space_training_env(
 ) -> dict[str, str]:
     """Sagatavo vidi Maris treniņa procesam."""
     output_dir = resolve_output_dir(persistent_dir, request.output_subdir)
-    continue_model_dir = resolve_optional_persistent_path(persistent_dir, request.continue_model_path)
+    continue_model_dir = resolve_optional_persistent_path(
+        persistent_dir, request.continue_model_path
+    )
+    config_path = (
+        str(
+            base_env.get("MARIS_SPACE_TRAIN_CONFIG_PATH")
+            or base_env.get("HF_SPACE_TRAINING_CONFIG_PATH")
+            or base_env.get("MARIS_TRAIN_CONFIG_PATH")
+            or base_env.get("HF_TRAINING_CONFIG_PATH")
+            or SPACE_TRAINING_CONFIG_PATH_DEFAULT
+        ).strip()
+        or SPACE_TRAINING_CONFIG_PATH_DEFAULT
+    )
     env = dict(base_env)
     env.update(
         {
             "MARIS_PERSISTENT_DIR": persistent_dir,
             "MARIS_MEMORY_REPO": request.dataset_repo,
             "MARIS_MODEL_REPO": request.hub_model_id,
+            "MARIS_TRAIN_CONFIG_PATH": config_path,
             "MARIS_TRAIN_NUM_EPOCHS": str(request.num_epochs),
             "MARIS_TRAIN_PUBLISH": "true" if request.push_to_hub else "false",
             "MARIS_TRAIN_OUTPUT_DIR": str(output_dir),
@@ -198,6 +220,7 @@ def build_space_training_env(
             "HF_PERSISTENT_DIR": persistent_dir,
             "HF_DATASET_REPO": request.dataset_repo,
             "HF_MODEL_REPO": request.hub_model_id,
+            "HF_TRAINING_CONFIG_PATH": config_path,
             "HF_TRAIN_NUM_EPOCHS": str(request.num_epochs),
             "HF_TRAIN_PUSH_TO_HUB": "true" if request.push_to_hub else "false",
             "HF_TRAIN_OUTPUT_DIR": str(output_dir),
@@ -231,6 +254,13 @@ def build_space_training_env(
     return env
 
 
+def has_completed_training_artifacts(output_dir: Path) -> bool:
+    """Nosaka, vai Space output direktorijā jau ir pabeigta treniņa artefakti."""
+    return any(
+        output_dir.joinpath(marker).is_file() for marker in SPACE_TRAINING_COMPLETION_MARKERS
+    )
+
+
 def tail_log(log_path: str | Path, *, max_chars: int = 16000) -> str:
     """Atgriež loga beigas UI vajadzībām."""
     path = Path(log_path)
@@ -321,9 +351,7 @@ def parse_training_progress(
 
     if learning_rate is None:
         learning_rate_matches = list(LEARNING_RATE_RE.finditer(log_text))
-        learning_rate = (
-            float(learning_rate_matches[-1].group(1)) if learning_rate_matches else None
-        )
+        learning_rate = float(learning_rate_matches[-1].group(1)) if learning_rate_matches else None
 
     percent = 0
     stage = structured_stage or "queued"
@@ -360,10 +388,7 @@ def parse_training_progress(
         stage = structured_stage or "training"
         progress_ratio = min(current_step / max(total_steps, 1), 1.0)
         percent = min(95, max(35, int(35 + progress_ratio * 55)))
-        label = (
-            structured_label
-            or f"Trenē modeli · solis {current_step}/{total_steps}"
-        )
+        label = structured_label or f"Trenē modeli · solis {current_step}/{total_steps}"
     elif current_epoch is not None:
         stage = structured_stage or "training"
         epoch_total = detected_total_epochs or total_epochs

core-python/tests/test_huggingface_human_training_space.py

@@ -50,10 +50,42 @@ def test_runtime_endpoint_exposes_roles_and_docs() -> None:
     assert set(body["roles"]) == {"owner", "secretary", "trainee", "user"}
     assert any(item["title"] == "Onboarding guide" for item in body["documentation"])
     assert body["training"]["defaults"]["hub_model_id"] == "MarisUK/maris-ai-lv"
+    assert isinstance(body["training"]["model_choices"], list)
+    assert body["training"]["model_choices"][0]["id"]
+    assert body["training"]["model_choices"][0]["label"]
     assert body["auth_required"] is False
     assert body["private_session"]["user"]["role"] == "owner"
 
 
+def test_maybe_start_automatic_training_starts_with_human_space_defaults(
+    monkeypatch, tmp_path: Path
+) -> None:
+    calls: list[dict[str, object]] = []
+
+    monkeypatch.setenv("MARIS_HUMAN_TRAINING_AUTO_TRAIN", "true")
+    monkeypatch.setattr(human_training_space_app, "PERSISTENT_DIR", tmp_path)
+    monkeypatch.setattr(
+        human_training_space_app,
+        "has_completed_training_artifacts",
+        lambda output_dir: False,
+    )
+    monkeypatch.setattr(
+        human_training_space_app,
+        "_start_training_process",
+        lambda request: (
+            calls.append(request.model_dump()) or {"pid": 77, "log_path": "/tmp/human-train.log"}
+        ),
+    )
+
+    human_training_space_app._maybe_start_automatic_training()
+
+    assert len(calls) == 1
+    assert calls[0]["dataset_repo"] == human_training_space_app.DEFAULT_DATASET_REPO
+    assert calls[0]["model_repo"] == human_training_space_app.DEFAULT_HUB_MODEL_ID
+    assert calls[0]["model_preset"] == "balanced"
+    assert calls[0]["continue_from_latest_artifact"] is True
+
+
 def test_register_and_login_flow(monkeypatch, tmp_path: Path) -> None:
     client = TestClient(human_training_space_app.app)
     monkeypatch.setattr(

core-python/tests/test_huggingface_space_app.py

@@ -54,6 +54,46 @@ def test_status_endpoint_includes_progress_metadata() -> None:
     assert "history" in body
 
 
+def test_maybe_start_automatic_training_starts_with_space_defaults(
+    monkeypatch, tmp_path: Path
+) -> None:
+    calls: list[dict[str, object]] = []
+
+    monkeypatch.setenv("MARIS_SPACE_AUTO_TRAIN", "true")
+    monkeypatch.setattr(space_app, "PERSISTENT_DIR", str(tmp_path))
+    monkeypatch.setattr(space_app, "has_completed_training_artifacts", lambda output_dir: False)
+    monkeypatch.setattr(
+        space_app,
+        "_start_training_process",
+        lambda request: (
+            calls.append(request.model_dump()) or {"pid": 99, "log_path": "/tmp/train.log"}
+        ),
+    )
+
+    space_app._maybe_start_automatic_training()
+
+    assert len(calls) == 1
+    assert calls[0]["dataset_repo"] == space_app.AGENT_RUNTIME.dataset_repo
+    assert calls[0]["model_repo"] == space_app.AGENT_RUNTIME.model_repo
+    assert calls[0]["model_preset"] == "balanced"
+    assert calls[0]["continue_from_latest_artifact"] is True
+
+
+def test_maybe_start_automatic_training_skips_when_completed_artifacts_exist(
+    monkeypatch, tmp_path: Path
+) -> None:
+    monkeypatch.setenv("MARIS_SPACE_AUTO_TRAIN", "true")
+    monkeypatch.setattr(space_app, "PERSISTENT_DIR", str(tmp_path))
+    monkeypatch.setattr(space_app, "has_completed_training_artifacts", lambda output_dir: True)
+    monkeypatch.setattr(
+        space_app,
+        "_start_training_process",
+        lambda request: (_ for _ in ()).throw(AssertionError("auto training should be skipped")),
+    )
+
+    space_app._maybe_start_automatic_training()
+
+
 def test_index_endpoint_defaults_to_balanced_preset() -> None:
     client = TestClient(space_app.app)
 
@@ -165,7 +205,9 @@ def test_websocket_sends_initial_snapshot(tmp_path: Path) -> None:
     assert "hello from log" in message["log_tail"]
 
 
-def test_status_endpoint_persists_training_history_and_artifacts(monkeypatch, tmp_path: Path) -> None:
+def test_status_endpoint_persists_training_history_and_artifacts(
+    monkeypatch, tmp_path: Path
+) -> None:
     client = TestClient(space_app.app)
     output_dir = tmp_path / "runs" / "demo"
     output_dir.mkdir(parents=True)
@@ -895,7 +937,7 @@ def test_workspace_command_runner_stops_when_task_is_cancelled(tmp_path: Path) -
     cancel_event.set()
 
     try:
-        runner({"command": "python -c \"import time; time.sleep(5)\""})
+        runner({"command": 'python -c "import time; time.sleep(5)"'})
     except space_app.SpaceAgentCancelledError as exc:
         assert "req-cancel" in str(exc)
         assert "task-cancel" in str(exc)

core-python/tests/test_space_ui.py

@@ -10,6 +10,7 @@ from maris_core.training.space_ui import (
     SpaceTrainingRequest,
     build_space_training_command,
     build_space_training_env,
+    has_completed_training_artifacts,
     list_space_model_choices,
     parse_training_progress,
     read_log_since,
@@ -78,6 +79,8 @@ def test_build_space_training_env_uses_preset_and_persistent_storage(tmp_path: P
     assert env["HF_LOCAL_MODEL_DIR"] == str(tmp_path / "runs" / "coder")
     assert env["HF_MODEL_REPO"] == "MarisUK/maris-ai-lv"
     assert env["HF_TRAIN_MODEL_PRESET"] == "coding"
+    assert env["HF_TRAINING_CONFIG_PATH"] == "huggingface/training-config.json"
+    assert env["MARIS_TRAIN_CONFIG_PATH"] == "huggingface/training-config.json"
     assert env["HF_TRAIN_PUSH_TO_HUB"] == "false"
     assert env["HF_TRAIN_CONTINUE_FROM_LATEST"] == "true"
     assert env["HF_TRAIN_CONTINUE_MODEL_PATH"] == str(tmp_path / "runs" / "checkpoints")
@@ -106,6 +109,30 @@ def test_build_space_training_env_clears_inherited_distributed_overrides(tmp_pat
     assert "MARIS_TRAIN_DISTRIBUTED_CONFIG_PATH" not in env
 
 
+def test_build_space_training_env_allows_explicit_space_config_override(tmp_path: Path) -> None:
+    request = SpaceTrainingRequest(model_preset="balanced")
+
+    env = build_space_training_env(
+        {"MARIS_SPACE_TRAIN_CONFIG_PATH": "huggingface/custom-space-config.json"},
+        request,
+        str(tmp_path),
+    )
+
+    assert env["HF_TRAINING_CONFIG_PATH"] == "huggingface/custom-space-config.json"
+    assert env["MARIS_TRAIN_CONFIG_PATH"] == "huggingface/custom-space-config.json"
+
+
+def test_has_completed_training_artifacts_detects_finished_space_run(tmp_path: Path) -> None:
+    output_dir = tmp_path / "runs" / "demo"
+    output_dir.mkdir(parents=True)
+
+    assert has_completed_training_artifacts(output_dir) is False
+
+    (output_dir / "training-metrics.json").write_text("{}", encoding="utf-8")
+
+    assert has_completed_training_artifacts(output_dir) is True
+
+
 def test_list_space_model_choices_exposes_presets() -> None:
     choices = list_space_model_choices()
 
@@ -192,7 +219,7 @@ def test_parse_training_progress_reports_completion() -> None:
 
 def test_parse_training_progress_prefers_structured_events() -> None:
     progress = parse_training_progress(
-        '\n'.join(
+        "\n".join(
             [
                 '{"maris_training_event": true, "event": "log", "stage": "training", "label": "Trenē modeli · solis 12/40", "epoch": 1.5, "total_epochs": 4, "step": 12, "total_steps": 40, "loss": 0.2451, "eval_loss": 0.1987, "learning_rate": 0.0002, "eta_seconds": 180}',
                 "Epoch 1/4",

huggingface_human_training_space/README.md

@@ -45,3 +45,16 @@ Nepieciešams:
 3. dataset repo artefaktu publicēšanai;
 4. model repo, kur publicēt treniņa rezultātu;
 5. ja paredzēts īsts train darbs, Space runtime ar pietiekamiem resursiem.
+
+## Automātisks treniņa starts
+
+Ja šo Space izmanto kā vienkāršu persistent training runneri, vari ieslēgt:
+
+- `MARIS_HUMAN_TRAINING_AUTO_TRAIN=true`
+- pēc vajadzības `MARIS_HUMAN_TRAINING_AUTO_TRAIN_MODEL_PRESET` vai `MARIS_HUMAN_TRAINING_AUTO_TRAIN_MODEL_NAME`
+- pēc vajadzības `MARIS_HUMAN_TRAINING_AUTO_TRAIN_OUTPUT_SUBDIR`
+
+Auto-starts palaiž `train-hf.sh` ar Space-safe `huggingface/training-config.json`
+konfigurāciju un pēc restarta nelaiž otru identisku skrējienu, ja output
+direktorijā jau ir pabeigta treniņa artefakti. Ja vajag apzināti pārrakstīt vai
+turpināt virs esoša output, iestati `MARIS_HUMAN_TRAINING_AUTO_TRAIN_FORCE=true`.

huggingface_human_training_space/app.py

@@ -34,10 +34,13 @@ from maris_core.training.human_training import (  # noqa: E402
     stage_human_training_artifacts,
 )
 from maris_core.training.space_ui import (  # noqa: E402
+    SpaceTrainingRequest,
     build_space_training_command,
     build_space_training_env,
+    has_completed_training_artifacts,
     list_space_model_choices,
     parse_training_progress,
+    resolve_output_dir,
     tail_log,
     terminate_process_tree,
 )
@@ -278,6 +281,27 @@ def _timestamp() -> str:
     return datetime.now(UTC).replace(microsecond=0).isoformat()
 
 
+def _env_flag(*names: str, default: bool = False) -> bool:
+    return get_env_any_or_default(
+        *names, default="true" if default else "false"
+    ).strip().lower() in {
+        "1",
+        "true",
+        "yes",
+        "on",
+    }
+
+
+def _env_int(*names: str, default: int) -> int:
+    value = get_env_any_or_default(*names, default=str(default)).strip()
+    try:
+        return int(value)
+    except ValueError as exc:
+        raise RuntimeError(
+            f"Nederīga vesela skaitļa vērtība env laukam {'/'.join(names)}: {value}"
+        ) from exc
+
+
 def _has_publish_token() -> bool:
     return bool(get_hf_token())
 
@@ -476,13 +500,133 @@ def _training_defaults() -> dict[str, Any]:
 
 
 def _training_runtime_payload() -> dict[str, Any]:
+    model_choices = [
+        {
+            "id": preset_id,
+            "label": f"{preset_id} — {config['model_name']}",
+            **config,
+        }
+        for preset_id, config in list_space_model_choices().items()
+    ]
     return {
-        "model_choices": list_space_model_choices(),
+        "model_choices": model_choices,
         "has_publish_token": _has_publish_token(),
         "defaults": _training_defaults(),
     }
 
 
+def _auto_training_request() -> SpaceTrainingRequest:
+    defaults = _training_defaults()
+    output_subdir = get_env_any_or_default(
+        "MARIS_HUMAN_TRAINING_AUTO_TRAIN_OUTPUT_SUBDIR",
+        "MARIS_SPACE_AUTO_TRAIN_OUTPUT_SUBDIR",
+        default=str(defaults["output_subdir"]),
+    ).strip()
+    continue_model_path = get_env_any_or_default(
+        "MARIS_HUMAN_TRAINING_AUTO_TRAIN_CONTINUE_MODEL_PATH",
+        "MARIS_SPACE_AUTO_TRAIN_CONTINUE_MODEL_PATH",
+        "MARIS_TRAIN_CONTINUE_MODEL_PATH",
+        "HF_TRAIN_CONTINUE_MODEL_PATH",
+        default=output_subdir,
+    ).strip()
+    model_name = get_env_any_or_default(
+        "MARIS_HUMAN_TRAINING_AUTO_TRAIN_MODEL_NAME",
+        "MARIS_SPACE_AUTO_TRAIN_MODEL_NAME",
+        "MARIS_TRAIN_BASE_MODEL",
+        "HF_TRAIN_BASE_MODEL",
+        default="",
+    ).strip()
+    model_preset = get_env_any_or_default(
+        "MARIS_HUMAN_TRAINING_AUTO_TRAIN_MODEL_PRESET",
+        "MARIS_SPACE_AUTO_TRAIN_MODEL_PRESET",
+        "MARIS_TRAIN_MODEL_PRESET",
+        "HF_TRAIN_MODEL_PRESET",
+        default=str(defaults["model_preset"]),
+    ).strip()
+    return SpaceTrainingRequest(
+        dataset_repo=get_env_any_or_default(
+            "MARIS_HUMAN_TRAINING_AUTO_TRAIN_DATASET_REPO",
+            "MARIS_MEMORY_REPO",
+            "MARIS_DATASET_REPO",
+            "HF_DATASET_REPO",
+            default=str(defaults["dataset_repo"]),
+        ),
+        model_repo=get_env_any_or_default(
+            "MARIS_HUMAN_TRAINING_AUTO_TRAIN_MODEL_REPO",
+            "MARIS_HUMAN_TRAINING_MODEL_REPO",
+            "MARIS_MODEL_REPO",
+            "HF_MODEL_REPO",
+            default=str(defaults["hub_model_id"]),
+        ),
+        model_preset="" if model_name else model_preset,
+        model_name=model_name,
+        num_epochs=_env_int(
+            "MARIS_HUMAN_TRAINING_AUTO_TRAIN_NUM_EPOCHS",
+            "MARIS_TRAIN_NUM_EPOCHS",
+            "HF_TRAIN_NUM_EPOCHS",
+            default=int(defaults["num_epochs"]),
+        ),
+        all_branches=_env_flag(
+            "MARIS_HUMAN_TRAINING_AUTO_TRAIN_ALL_BRANCHES",
+            "MARIS_SPACE_AUTO_TRAIN_ALL_BRANCHES",
+            default=bool(defaults["all_branches"]),
+        ),
+        push_to_hub=_env_flag(
+            "MARIS_HUMAN_TRAINING_AUTO_TRAIN_PUSH_TO_HUB",
+            "MARIS_SPACE_AUTO_TRAIN_PUSH_TO_HUB",
+            "MARIS_TRAIN_PUBLISH",
+            "HF_TRAIN_PUSH_TO_HUB",
+            default=bool(defaults["push_to_hub"]),
+        ),
+        output_subdir=output_subdir,
+        continue_from_latest_artifact=_env_flag(
+            "MARIS_HUMAN_TRAINING_AUTO_TRAIN_CONTINUE_FROM_LATEST",
+            "MARIS_SPACE_AUTO_TRAIN_CONTINUE_FROM_LATEST",
+            "MARIS_TRAIN_CONTINUE_FROM_LATEST",
+            "HF_TRAIN_CONTINUE_FROM_LATEST",
+            default=bool(defaults["continue_from_latest_artifact"]),
+        ),
+        continue_model_path=continue_model_path,
+    )
+
+
+def _maybe_start_automatic_training() -> None:
+    if not _env_flag(
+        "MARIS_HUMAN_TRAINING_AUTO_TRAIN",
+        "MARIS_SPACE_AUTO_TRAIN",
+        "HF_SPACE_AUTO_TRAIN",
+    ):
+        return
+    try:
+        request = _auto_training_request()
+        output_dir = resolve_output_dir(str(PERSISTENT_DIR), request.output_subdir)
+        force_start = _env_flag(
+            "MARIS_HUMAN_TRAINING_AUTO_TRAIN_FORCE",
+            "MARIS_SPACE_AUTO_TRAIN_FORCE",
+            "HF_SPACE_AUTO_TRAIN_FORCE",
+            default=False,
+        )
+        if not force_start and has_completed_training_artifacts(output_dir):
+            logger.info(
+                "Izlaižu human training Space auto-startu, jo output jau satur pabeigta skrējiena artefaktus: %s",
+                output_dir,
+            )
+            return
+        result = _start_training_process(request)
+        logger.info(
+            "Human training Space automātiskais treniņš palaists: pid=%s log=%s",
+            result["pid"],
+            result["log_path"],
+        )
+    except Exception:  # noqa: BLE001
+        logger.exception("Neizdevās automātiski palaist human training Space treniņu starta laikā.")
+
+
+@APP.on_event("startup")
+def _startup_auto_training() -> None:
+    _maybe_start_automatic_training()
+
+
 def _start_training_process(request: Any) -> dict[str, Any]:
     if bool(getattr(request, "push_to_hub", False)) and not _has_publish_token():
         raise HTTPException(