savetest-cli 0.3.0rc2__tar.gz → 0.3.0rc4__tar.gz

{savetest_cli-0.3.0rc2 → savetest_cli-0.3.0rc4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: savetest-cli
-Version: 0.3.0rc2
+Version: 0.3.0rc4
 Summary: CLI for SaveTest: upload Allure results as a ZIP, as raw files, or by watching a directory
 License-Expression: MIT
 Requires-Python: >=3.8
@@ -196,6 +196,8 @@ savetest upload_files ./allure-results/*-result.json ./allure-results/executor.j
 
 Первая пачка создаёт тест-ран, если не передан `--test-run-id`. Следующие файлы пишутся в тот же ран: пока ран не создан, вторая пачка ждёт. Код возврата `1`, если хотя бы один импорт не завершился как `completed`.
 
+Пачка уходит одним запросом, статусы задач в очереди тоже читаются одним запросом. Если сервер ещё старый и отвечает 404 или 405, до конца этого запуска watch сам возвращается к прежней схеме: три запроса на пачку и опрос задач по одной, с головы очереди до первой незавершённой. Уже выпущенные версии утилиты с новым сервером работают как раньше.
+
 Вложение уезжает вместе с `*-result.json`, который на него ссылается. Результат подождёт вложение до `--attachment-wait` секунд. Пачка без файла результата не отправляется.
 
 Привязки к фреймворку нет. После `--` watch запускает любую команду как есть и не разбирает её аргументы: pytest, JUnit, Maven, Gradle, npm или свой скрипт. Ему всё равно, кто пишет файлы. Нужны только `*-result.json` в каталоге, который указан первым аргументом. `pytest` в примерах ниже — один из вариантов, не требование.
@@ -220,7 +222,7 @@ savetest watch ./allure-results \
 - Если тесты и загрузка — разные джобы, отдайте каталог `allure-results` артефактом тоже с `when: always`.
 - `--wait` оставляйте включённым: джоба должна завершиться только когда импорт дошёл до конца.
 - Вложения включайте только если они реально нужны. По умолчанию CLI их не шлёт.
-- `0.3.0rc2` — предварительная версия для SaveTest 1.5.0: `pip install savetest-cli==0.3.0rc2`. Обычный `pip install savetest-cli` остаётся на последней стабильной версии.
+- `0.3.0rc4` — предварительная версия для SaveTest 1.5.0: `pip install savetest-cli==0.3.0rc4`. Обычный `pip install savetest-cli` остаётся на последней стабильной версии.
 
 ### Результаты по мере прогона
 

savetest_cli-0.3.0rc2/savetest_cli.egg-info/PKG-INFO → savetest_cli-0.3.0rc4/README.md

@@ -1,13 +1,3 @@
-Metadata-Version: 2.4
-Name: savetest-cli
-Version: 0.3.0rc2
-Summary: CLI for SaveTest: upload Allure results as a ZIP, as raw files, or by watching a directory
-License-Expression: MIT
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-Requires-Dist: click>=8.0
-Requires-Dist: requests>=2.28
-
 <p align="center">
   <img src="savetest_cli/pwa-512x512.png" alt="SaveTest" width="128">
 </p>
@@ -196,6 +186,8 @@ savetest upload_files ./allure-results/*-result.json ./allure-results/executor.j
 
 Первая пачка создаёт тест-ран, если не передан `--test-run-id`. Следующие файлы пишутся в тот же ран: пока ран не создан, вторая пачка ждёт. Код возврата `1`, если хотя бы один импорт не завершился как `completed`.
 
+Пачка уходит одним запросом, статусы задач в очереди тоже читаются одним запросом. Если сервер ещё старый и отвечает 404 или 405, до конца этого запуска watch сам возвращается к прежней схеме: три запроса на пачку и опрос задач по одной, с головы очереди до первой незавершённой. Уже выпущенные версии утилиты с новым сервером работают как раньше.
+
 Вложение уезжает вместе с `*-result.json`, который на него ссылается. Результат подождёт вложение до `--attachment-wait` секунд. Пачка без файла результата не отправляется.
 
 Привязки к фреймворку нет. После `--` watch запускает любую команду как есть и не разбирает её аргументы: pytest, JUnit, Maven, Gradle, npm или свой скрипт. Ему всё равно, кто пишет файлы. Нужны только `*-result.json` в каталоге, который указан первым аргументом. `pytest` в примерах ниже — один из вариантов, не требование.
@@ -220,7 +212,7 @@ savetest watch ./allure-results \
 - Если тесты и загрузка — разные джобы, отдайте каталог `allure-results` артефактом тоже с `when: always`.
 - `--wait` оставляйте включённым: джоба должна завершиться только когда импорт дошёл до конца.
 - Вложения включайте только если они реально нужны. По умолчанию CLI их не шлёт.
-- `0.3.0rc2` — предварительная версия для SaveTest 1.5.0: `pip install savetest-cli==0.3.0rc2`. Обычный `pip install savetest-cli` остаётся на последней стабильной версии.
+- `0.3.0rc4` — предварительная версия для SaveTest 1.5.0: `pip install savetest-cli==0.3.0rc4`. Обычный `pip install savetest-cli` остаётся на последней стабильной версии.
 
 ### Результаты по мере прогона
 

{savetest_cli-0.3.0rc2 → savetest_cli-0.3.0rc4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "savetest-cli"
-version = "0.3.0rc2"
+version = "0.3.0rc4"
 description = "CLI for SaveTest: upload Allure results as a ZIP, as raw files, or by watching a directory"
 readme = "README.md"
 requires-python = ">=3.8"

savetest_cli-0.3.0rc4/savetest_cli/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.3.0rc4"

{savetest_cli-0.3.0rc2 → savetest_cli-0.3.0rc4}/savetest_cli/cli.py

@@ -28,6 +28,7 @@ DEFAULT_SETTLE_SEC = 1.0
 DEFAULT_ATTACHMENT_WAIT_SEC = 5.0
 DEFAULT_WATCH_BATCH_WINDOW_SEC = 1.0
 DEFAULT_WATCH_BATCH_MAX_WAIT_SEC = 5.0
+DEFAULT_WATCH_HEARTBEAT_SEC = 15
 TERMINAL_STATUSES = frozenset({"completed", "partial", "failed", "cancelled"})
 _JUNK_NAMES = {".ds_store", "thumbs.db", ".project_id", ".gitkeep"}
 
@@ -536,17 +537,24 @@ def _is_result_file(path: Path) -> bool:
     return name.endswith("-result.json") or (name.startswith("test-result-") and name.endswith(".json"))
 
 
+def _raw_file_name_reason(name: str, *, include_attachments: bool) -> Optional[str]:
+    """Причина пропустить файл по одному имени, без stat."""
+    if name.startswith(".") or name.lower() in _JUNK_NAMES or name == "__MACOSX":
+        return "служебный файл"
+    if name.lower().endswith(".zip"):
+        return "ZIP загружается командой upload"
+    if not include_attachments and _is_attachment(name):
+        return "вложение"
+    return None
+
+
 def _skip_raw_file(path: Path, *, include_attachments: bool) -> Optional[str]:
     """None — файл берём. Иначе короткая причина пропуска."""
     if not path.is_file():
         return "не файл"
-    if "__MACOSX" in path.parts or path.name.startswith(".") or path.name.lower() in _JUNK_NAMES:
+    if "__MACOSX" in path.parts:
         return "служебный файл"
-    if path.suffix.lower() == ".zip":
-        return "ZIP загружается командой upload"
-    if not include_attachments and _is_attachment(path.name):
-        return "вложение"
-    return None
+    return _raw_file_name_reason(path.name, include_attachments=include_attachments)
 
 
 def _collect_directory(root: Path, include_attachments: bool) -> list:
@@ -826,26 +834,6 @@ def upload_files(
 # watch — каталог в реальном времени
 # ---------------------------------------------------------------------------
 
-def _attachment_sources(data: Any) -> List[str]:
-    names: List[str] = []
-
-    def walk(node: Any) -> None:
-        if isinstance(node, dict):
-            source = node.get("source")
-            if isinstance(source, str) and source:
-                names.append(Path(source).name)
-            for value in node.values():
-                walk(value)
-        elif isinstance(node, list):
-            for value in node:
-                walk(value)
-
-    if isinstance(data, dict):
-        walk(data.get("attachments"))
-        walk(data.get("steps"))
-    return names
-
-
 def _load_json_if_complete(path: Path) -> Optional[Any]:
     try:
         with open(path, "r", encoding="utf-8") as handle:
@@ -854,49 +842,51 @@ def _load_json_if_complete(path: Path) -> Optional[Any]:
         return None
 
 
-def _snapshot_raw_files(root: Path, include_attachments: bool) -> Dict[str, Tuple[Path, int, int]]:
+def _snapshot_raw_files(
+    root: Path,
+    include_attachments: bool,
+    uploaded: Optional[set] = None,
+) -> Dict[str, Tuple[Path, int, int]]:
+    """Файлы каталога, которые ещё не отправлены.
+
+    Уже отправленные (rel in uploaded) не stat'ятся и в снимок не попадают.
+    Имя отсекается до stat. Ключ — относительный posix-путь.
+    """
     found: Dict[str, Tuple[Path, int, int]] = {}
-    if not root.is_dir():
-        return found
-    for file_path in root.rglob("*"):
-        if _skip_raw_file(file_path, include_attachments=include_attachments):
-            continue
+    done = uploaded or ()
+
+    def walk(directory: str, prefix: str) -> None:
         try:
-            stat = file_path.stat()
+            iterator = os.scandir(directory)
         except OSError:
-            continue
-        found[file_path.relative_to(root).as_posix()] = (file_path, stat.st_size, stat.st_mtime_ns)
-    return found
-
-
-def _index_snapshot_names(
-    snapshot: Dict[str, Tuple[Path, int, int]],
-) -> Dict[str, List[str]]:
-    """Имя файла → пути. Сопоставление вложений не должно перебирать весь каталог."""
-    index: Dict[str, List[str]] = {}
-    for rel in snapshot:
-        index.setdefault(Path(rel).name, []).append(rel)
-    return index
-
+            return
+        with iterator:
+            for entry in iterator:
+                name = entry.name
+                rel = f"{prefix}/{name}" if prefix else name
+                if rel in done:
+                    continue
+                try:
+                    if entry.is_dir(follow_symlinks=False):
+                        if name != "__MACOSX":
+                            walk(entry.path, rel)
+                        continue
+                except OSError:
+                    continue
+                if _raw_file_name_reason(name, include_attachments=include_attachments):
+                    continue
+                if "__MACOSX" in rel.split("/"):
+                    continue
+                try:
+                    if not entry.is_file(follow_symlinks=False):
+                        continue
+                    file_stat = entry.stat(follow_symlinks=False)
+                except OSError:
+                    continue
+                found[rel] = (Path(entry.path), file_stat.st_size, file_stat.st_mtime_ns)
 
-def _resolve_named_file(
-    snapshot: Dict[str, Tuple[Path, int, int]],
-    result_rel: str,
-    source_name: str,
-    name_index: Optional[Dict[str, List[str]]] = None,
-) -> Optional[str]:
-    name = Path(source_name).name
-    result_dir = str(Path(result_rel).parent)
-    if name_index is None:
-        matches = [rel for rel in snapshot if Path(rel).name == name]
-    else:
-        matches = name_index.get(name) or []
-    if not matches:
-        return None
-    for rel in matches:
-        if str(Path(rel).parent) == result_dir:
-            return rel
-    return matches[0]
+    walk(os.fspath(root), "")
+    return found
 
 
 def _pick_watch_batch(
@@ -910,11 +900,8 @@ def _pick_watch_batch(
     *,
     flushing: bool,
 ) -> List[Tuple[str, Path]]:
-    """Файлы, которые уже дописаны и их можно отправить одной пачкой.
-
-    Результат ждёт свои вложения не дольше attachment_wait_sec, чтобы не уехать
-    раньше скриншота. Пачка без *-result.json не отправляется: сервер её не примет.
-    """
+    """Файлы, которые уже дописаны. Результат и вложение уходят по отдельности."""
+    del include_attachments, attachment_wait_sec
     ready: Dict[str, Path] = {}
     for rel in list(stable_since):
         if rel not in snapshot:
@@ -936,50 +923,7 @@ def _pick_watch_batch(
             continue
         ready[rel] = path
 
-    name_index = _index_snapshot_names(snapshot)
-    held = set()
-    if include_attachments:
-        for rel, path in list(ready.items()):
-            if not _is_result_file(path):
-                continue
-            document = _load_json_if_complete(path) or {}
-            missing = False
-            for source in _attachment_sources(document):
-                attachment_rel = _resolve_named_file(snapshot, rel, source, name_index)
-                if attachment_rel is None or attachment_rel not in ready:
-                    missing = True
-                    break
-            if not missing:
-                continue
-            ready_since = stable_since.get(rel, (0, 0, now))[2]
-            if not flushing and (now - ready_since) < settle_sec + attachment_wait_sec:
-                held.add(rel)
-            else:
-                click.echo(f"Результат {rel} отправляю без части вложений: они так и не появились.")
-
-    send_results = [
-        (rel, path) for rel, path in ready.items()
-        if _is_result_file(path) and rel not in held
-    ]
-    if not send_results:
-        return []
-
-    needed = set()
-    for rel, path in send_results:
-        document = _load_json_if_complete(path) or {}
-        for source in _attachment_sources(document):
-            attachment_rel = _resolve_named_file(snapshot, rel, source, name_index)
-            if attachment_rel and attachment_rel in ready:
-                needed.add(attachment_rel)
-
-    selected = list(send_results)
-    for rel, path in ready.items():
-        if _is_result_file(path):
-            continue
-        if include_attachments and _is_attachment(path.name) and rel not in needed:
-            continue
-        selected.append((rel, path))
-    return selected
+    return [(rel, path) for rel, path in ready.items()]
 
 
 def _watch_batch_due(
@@ -1018,28 +962,7 @@ def _chunk_watch_selection(
     max_count: int = DEFAULT_FILE_BATCH_COUNT,
     max_bytes: int = DEFAULT_FILE_BATCH_BYTES,
 ) -> List[List[Tuple[str, Path]]]:
-    """Режет готовые файлы на пачки. Результат не отрывается от своих вложений."""
-    results = [(rel, path) for rel, path in selected if _is_result_file(path)]
-    extras = {rel: (rel, path) for rel, path in selected if not _is_result_file(path)}
-    extras_by_name: Dict[str, List[str]] = {}
-    for extra_rel in extras:
-        extras_by_name.setdefault(Path(extra_rel).name, []).append(extra_rel)
-    used = set()
-    groups: List[List[Tuple[str, Path]]] = []
-    for rel, path in results:
-        group = [(rel, path)]
-        document = _load_json_if_complete(path) or {}
-        for source in _attachment_sources(document):
-            name = Path(source).name
-            for extra_rel in extras_by_name.get(name) or []:
-                if extra_rel in used:
-                    continue
-                group.append(extras[extra_rel])
-                used.add(extra_rel)
-                break
-        groups.append(group)
-
-    loose = [extra for rel, extra in extras.items() if rel not in used]
+    """Режет готовые файлы на пачки по числу и размеру, без разбора содержимого."""
     chunks: List[List[Tuple[str, Path]]] = []
     current: List[Tuple[str, Path]] = []
     current_bytes = 0
@@ -1051,31 +974,39 @@ def _chunk_watch_selection(
             current = []
             current_bytes = 0
 
-    for group in groups:
-        group_bytes = _selection_bytes(group)
-        if current and (
-            len(current) + len(group) > max_count
-            or current_bytes + group_bytes > max_bytes
-        ):
+    for item in selected:
+        _rel, path = item
+        try:
+            size = path.stat().st_size
+        except OSError:
+            size = 0
+        if current and (len(current) >= max_count or current_bytes + size > max_bytes):
             flush()
-        if loose and not current:
-            current.extend(loose)
-            current_bytes += _selection_bytes(loose)
-            loose = []
-        current.extend(group)
-        current_bytes += group_bytes
+        current.append(item)
+        current_bytes += size
         if len(current) >= max_count or current_bytes >= max_bytes:
             flush()
     flush()
     return chunks
 
 
-def _enqueue_watch_batch(
-    selected: List[Tuple[str, Path]],
+class _WatchApi:
+    """Какие быстрые ручки ещё пробуем в этом запуске watch.
+
+    404/405 значит, что сервер старый: до конца запуска остаётся прежний путь.
+    """
+
+    def __init__(self) -> None:
+        self.files_batch = True
+        self.tasks_batch = True
+
+
+_TASK_STATUS_BATCH_LIMIT = 500
+_MISSING_ROUTE = frozenset({404, 405})
+
+
+def _watch_form_data(
     *,
-    host: str,
-    token: str,
-    project_id: str,
     test_run_id: Optional[str],
     test_run_name: Optional[str],
     description: Optional[str],
@@ -1088,18 +1019,17 @@ def _enqueue_watch_batch(
     configuration_name: Optional[str],
     branch: Optional[str],
     include_attachments: bool,
-) -> str:
-    headers = {"Authorization": f"Bearer {token}"}
-    init_data: Dict[str, str] = {
+) -> Dict[str, str]:
+    data: Dict[str, str] = {
         "include_attachments": "true" if include_attachments else "false",
     }
     if branch:
-        init_data["git_branch"] = branch
+        data["git_branch"] = branch
     if test_run_id:
-        init_data["test_run_id"] = str(test_run_id)
+        data["test_run_id"] = str(test_run_id)
     else:
         _append_new_test_run_fields(
-            init_data,
+            data,
             test_run_name=test_run_name,
             description=description,
             version=version,
@@ -1110,7 +1040,58 @@ def _enqueue_watch_batch(
             configuration_id=configuration_id,
             configuration_name=configuration_name,
         )
+    return data
+
+
+def _require_task_id(payload: Dict[str, Any]) -> str:
+    task_id = payload.get("task_id")
+    if not task_id:
+        click.echo("Файлы приняты, но task_id не получен.", err=True)
+        sys.exit(1)
+    return str(task_id)
+
+
+def _try_watch_files_batch(
+    selected: List[Tuple[str, Path]],
+    *,
+    host: str,
+    project_id: str,
+    headers: Dict[str, str],
+    init_data: Dict[str, str],
+    api: _WatchApi,
+) -> Optional[str]:
+    """task_id новой ручки. None — сервер её не знает, флаг уже снят."""
+    if not api.files_batch:
+        return None
+    url = f"{host}/api/v1/projects/{project_id}/allure-results/files/batch"
+    handles = []
+    multipart = []
+    try:
+        for rel, path in selected:
+            handle = open(path, "rb")
+            handles.append(handle)
+            multipart.append(("files", (path.name, handle, "application/octet-stream")))
+            multipart.append(("relative_paths", (None, rel)))
+        resp = requests.post(url, headers=headers, data=init_data, files=multipart, timeout=180)
+    finally:
+        for handle in handles:
+            handle.close()
+    if resp.status_code in _MISSING_ROUTE:
+        api.files_batch = False
+        click.echo("Сервер без пакетной загрузки, отправляю пачку прежним способом.")
+        return None
+    _check_response(resp, "watch batch")
+    return _require_task_id(resp.json())
+
 
+def _enqueue_watch_batch_steps(
+    selected: List[Tuple[str, Path]],
+    *,
+    host: str,
+    project_id: str,
+    headers: Dict[str, str],
+    init_data: Dict[str, str],
+) -> str:
     resp = requests.post(
         f"{host}/api/v1/projects/{project_id}/allure-results/files/init",
         headers=headers,
@@ -1137,11 +1118,64 @@ def _enqueue_watch_batch(
 
     resp = requests.post(f"{url}/complete", headers=headers, timeout=60)
     _check_response(resp, "watch complete")
-    task_id = resp.json().get("task_id")
-    if not task_id:
-        click.echo("Файлы приняты, но task_id не получен.", err=True)
-        sys.exit(1)
-    return str(task_id)
+    return _require_task_id(resp.json())
+
+
+def _enqueue_watch_batch(
+    selected: List[Tuple[str, Path]],
+    *,
+    host: str,
+    token: str,
+    project_id: str,
+    test_run_id: Optional[str],
+    test_run_name: Optional[str],
+    description: Optional[str],
+    version: Optional[str],
+    revision: Optional[str],
+    test_object: Optional[str],
+    epic_id: Optional[str],
+    epic_name: Optional[str],
+    configuration_id: Optional[str],
+    configuration_name: Optional[str],
+    branch: Optional[str],
+    include_attachments: bool,
+    api: Optional[_WatchApi] = None,
+) -> str:
+    if api is None:
+        api = _WatchApi()
+    headers = {"Authorization": f"Bearer {token}"}
+    init_data = _watch_form_data(
+        test_run_id=test_run_id,
+        test_run_name=test_run_name,
+        description=description,
+        version=version,
+        revision=revision,
+        test_object=test_object,
+        epic_id=epic_id,
+        epic_name=epic_name,
+        configuration_id=configuration_id,
+        configuration_name=configuration_name,
+        branch=branch,
+        include_attachments=include_attachments,
+    )
+    if api.files_batch:
+        task_id = _try_watch_files_batch(
+            selected,
+            host=host,
+            project_id=project_id,
+            headers=headers,
+            init_data=init_data,
+            api=api,
+        )
+        if task_id:
+            return task_id
+    return _enqueue_watch_batch_steps(
+        selected,
+        host=host,
+        project_id=project_id,
+        headers=headers,
+        init_data=init_data,
+    )
 
 
 def _fetch_task(host: str, project_id: str, task_id: str, token: str) -> Dict[str, Any]:
@@ -1154,6 +1188,141 @@ def _fetch_task(host: str, project_id: str, task_id: str, token: str) -> Dict[st
     return resp.json()
 
 
+def _task_status_items(body: Any) -> List[Dict[str, Any]]:
+    if isinstance(body, list):
+        items = body
+    elif isinstance(body, dict) and isinstance(body.get("tasks"), list):
+        items = body["tasks"]
+    else:
+        items = []
+    return [item for item in items if isinstance(item, dict)]
+
+
+def _fetch_task_status_map(
+    task_ids: List[str],
+    *,
+    host: str,
+    project_id: str,
+    token: str,
+    api: _WatchApi,
+) -> Optional[Dict[str, Dict[str, Any]]]:
+    """Карта task_id -> статус. None — сервер без пакетной ручки."""
+    if not api.tasks_batch or not task_ids:
+        return None
+    found: Dict[str, Dict[str, Any]] = {}
+    headers = {"Authorization": f"Bearer {token}"}
+    url = f"{host}/api/v1/projects/{project_id}/allure-results/tasks/status"
+    for offset in range(0, len(task_ids), _TASK_STATUS_BATCH_LIMIT):
+        chunk = task_ids[offset:offset + _TASK_STATUS_BATCH_LIMIT]
+        resp = requests.post(url, headers=headers, json={"task_ids": chunk}, timeout=60)
+        if resp.status_code in _MISSING_ROUTE:
+            api.tasks_batch = False
+            click.echo("Сервер без пакетного статуса задач, опрашиваю по одной.")
+            return None
+        _check_response(resp, "watch tasks")
+        for item in _task_status_items(resp.json()):
+            task_id = item.get("task_id")
+            if task_id:
+                found[str(task_id)] = item
+    return found
+
+
+def _poll_watch_tasks(
+    inflight: List[str],
+    *,
+    host: str,
+    project_id: str,
+    token: str,
+    api: _WatchApi,
+) -> List[Tuple[str, Dict[str, Any]]]:
+    """Статусы inflight.
+
+    Новая ручка читает все сразу. Старый сервер — с головы до первой незавершённой.
+    """
+    if not inflight:
+        return []
+    batched = _fetch_task_status_map(
+        inflight,
+        host=host,
+        project_id=project_id,
+        token=token,
+        api=api,
+    )
+    if batched is not None:
+        pairs: List[Tuple[str, Dict[str, Any]]] = []
+        for task_id in inflight:
+            status = batched.get(task_id)
+            if status is None:
+                status = _fetch_task(host, project_id, task_id, token)
+            pairs.append((task_id, status))
+        return pairs
+    pairs = []
+    for task_id in inflight:
+        status = _fetch_task(host, project_id, task_id, token)
+        pairs.append((task_id, status))
+        if status.get("status", "") not in TERMINAL_STATUSES:
+            break
+    return pairs
+
+
+def _watch_session_url(host: str, project_id: str, session_id: Optional[str] = None, action: str = "") -> str:
+    url = f"{host}/api/v1/projects/{project_id}/allure-results/watch/sessions"
+    if session_id:
+        url = f"{url}/{session_id}"
+    if action:
+        url = f"{url}/{action}"
+    return url
+
+
+def _post_watch_session(
+    host: str,
+    project_id: str,
+    token: str,
+    payload: Dict[str, Any],
+    session_id: Optional[str] = None,
+    action: str = "",
+) -> Optional[Dict[str, Any]]:
+    """Сигнал платформе. Ошибка здесь не останавливает тесты."""
+    try:
+        resp = requests.post(
+            _watch_session_url(host, project_id, session_id, action),
+            headers={"Authorization": f"Bearer {token}"},
+            json=payload,
+            timeout=20,
+        )
+    except requests.RequestException:
+        return None
+    if resp.status_code >= 400:
+        return None
+    try:
+        body = resp.json()
+    except ValueError:
+        return None
+    return body if isinstance(body, dict) else None
+
+
+def _watch_session_payload(
+    *,
+    test_run_id: Optional[str],
+    test_run_name: Optional[str],
+    stats: Dict[str, int],
+    status: Optional[str] = None,
+) -> Dict[str, Any]:
+    payload: Dict[str, Any] = {
+        "results_processed": stats["processed"],
+        "results_created": stats["created"],
+        "test_cases_matched": stats["matched"],
+        "skipped": stats["skipped"],
+    }
+    if test_run_name:
+        payload["test_run_name"] = test_run_name
+    if test_run_id and str(test_run_id).isdigit():
+        payload["test_run_id"] = int(test_run_id)
+    if status:
+        payload["status"] = status
+    return payload
+
+
 @cli.command(
     "watch",
     context_settings={"ignore_unknown_options": True, "allow_extra_args": True},
@@ -1166,7 +1335,7 @@ def _fetch_task(host: str, project_id: str, task_id: str, token: str) -> Dict[st
 )
 @click.option("--interval", default=DEFAULT_WATCH_INTERVAL_SEC, show_default=True, type=float, help="Как часто смотреть каталог (сек).")
 @click.option("--settle", default=DEFAULT_SETTLE_SEC, show_default=True, type=float, help="Сколько секунд размер файла не должен меняться, прежде чем его забрать.")
-@click.option("--attachment-wait", default=DEFAULT_ATTACHMENT_WAIT_SEC, show_default=True, type=float, help="Сколько ждать вложение, на которое ссылается свежий *-result.json.")
+@click.option("--attachment-wait", default=DEFAULT_ATTACHMENT_WAIT_SEC, show_default=True, type=float, help="Не используется: файл уходит, как только перестал меняться.")
 @click.option("--batch-window", default=DEFAULT_WATCH_BATCH_WINDOW_SEC, show_default=True, type=float, help="Сколько секунд копить готовые файлы после последнего нового, прежде чем отправить пачку.")
 @click.option("--batch-max-wait", default=DEFAULT_WATCH_BATCH_MAX_WAIT_SEC, show_default=True, type=float, help="Дольше этого готовые файлы не держатся, даже если новые всё ещё появляются. 0 — ждать только тишины.")
 @click.option("--idle-timeout", default=0, show_default=True, type=int, help="Выйти, если столько секунд нет новых файлов и загрузок. 0 — не выходить по тишине.")
@@ -1213,7 +1382,9 @@ def watch(
     Готовые файлы не уходят по одному. Если они появляются подряд, watch держит их
     --batch-window секунд после последнего нового и отправляет вместе. Дольше
     --batch-max-wait секунд пачка не копится. Предел одной отправки — 200 файлов
-    или 32 МБ.
+    или 32 МБ. Если сервер умеет, пачка и статусы задач уходят одним запросом.
+    Ответ 404 или 405 — до конца этого запуска прежний путь: три запроса на пачку
+    и опрос задач с головы очереди до первой незавершённой.
     """
     command = [arg for arg in ctx.args if arg != "--"]
     host = host.rstrip("/")
@@ -1227,6 +1398,7 @@ def watch(
     had_failure = False
     run_create_failed = False
     sent_batches = 0
+    watch_api = _WatchApi()
     drain_until = 0.0
     announced_flush = False
     hold_opened = 0.0
@@ -1270,6 +1442,21 @@ def watch(
         click.echo(f"Также выйду после {idle_timeout} с тишины.")
 
     watch_code = 0
+    session_id = None
+    session_stats = {"processed": 0, "created": 0, "matched": 0, "skipped": 0}
+    last_heartbeat = 0.0
+    session_dirty = False
+    open_payload: Dict[str, Any] = {}
+    if test_run_name:
+        open_payload["test_run_name"] = test_run_name
+    if test_run_id and str(test_run_id).isdigit():
+        open_payload["test_run_id"] = int(test_run_id)
+    opened = _post_watch_session(host, project_id, token, open_payload)
+    if opened and opened.get("task_id"):
+        session_id = str(opened["task_id"])
+        click.echo(f"Платформа показывает загрузку: {session_id}")
+    else:
+        click.echo("Карточка загрузки на платформе не открылась. Файлы всё равно будут отправлены.", err=True)
     try:
         if command:
             child["proc"] = subprocess.Popen(
@@ -1286,7 +1473,7 @@ def watch(
             timed_out = bool(timeout) and (now - started) >= timeout
             flushing = stop["requested"] or timed_out
 
-            snapshot = _snapshot_raw_files(root, include_attachments) if root.is_dir() else {}
+            snapshot = _snapshot_raw_files(root, include_attachments, uploaded)
             if flushing and not announced_flush:
                 pending = sum(1 for rel in snapshot if rel not in uploaded)
                 click.echo(f"После остановки осталось файлов: {pending}.")
@@ -1365,6 +1552,7 @@ def watch(
                         configuration_name=configuration_name,
                         branch=branch,
                         include_attachments=include_attachments,
+                        api=watch_api,
                     )
                     for rel, _path in chunk:
                         uploaded.add(rel)
@@ -1375,9 +1563,15 @@ def watch(
                 hold_opened = 0.0
                 hold_key = None
 
+            pairs = _poll_watch_tasks(
+                inflight,
+                host=host,
+                project_id=project_id,
+                token=token,
+                api=watch_api,
+            )
             still_running: List[str] = []
-            for task_id in inflight:
-                status = _fetch_task(host, project_id, task_id, token)
+            for task_id, status in pairs:
                 state = status.get("status", "")
                 if state not in TERMINAL_STATUSES:
                     still_running.append(task_id)
@@ -1393,6 +1587,11 @@ def watch(
                     f"создано {status.get('results_created', 0)}, "
                     f"обработано {status.get('results_processed', 0)}"
                 )
+                session_stats["processed"] += int(status.get("results_processed") or 0)
+                session_stats["created"] += int(status.get("results_created") or 0)
+                session_stats["matched"] += int(status.get("test_cases_matched") or 0)
+                session_stats["skipped"] += int(status.get("skipped") or 0)
+                session_dirty = True
                 if state != "completed":
                     had_failure = True
                     for err in (status.get("errors") or [])[:3]:
@@ -1400,8 +1599,30 @@ def watch(
                     if not known_run_id:
                         run_create_failed = True
                         click.echo("Тест-ран не создан, новые пачки не отправляю.", err=True)
+            if len(pairs) < len(inflight):
+                still_running.extend(inflight[len(pairs):])
             inflight = still_running
 
+            if session_id and (
+                now - last_heartbeat >= DEFAULT_WATCH_HEARTBEAT_SEC
+                or (session_dirty and now - last_heartbeat >= 2)
+            ):
+                sent = _post_watch_session(
+                    host,
+                    project_id,
+                    token,
+                    _watch_session_payload(
+                        test_run_id=known_run_id,
+                        test_run_name=test_run_name,
+                        stats=session_stats,
+                    ),
+                    session_id=session_id,
+                    action="heartbeat",
+                )
+                last_heartbeat = now
+                if sent is not None:
+                    session_dirty = False
+
             if run_create_failed and not inflight:
                 click.echo("watch остановлен: первая загрузка не создала тест-ран.", err=True)
                 watch_code = 1
@@ -1426,6 +1647,25 @@ def watch(
             time.sleep(interval)
     finally:
         _stop_child()
+        if session_id:
+            finish_status = "failed" if had_failure or run_create_failed else "completed"
+            closed = _post_watch_session(
+                host,
+                project_id,
+                token,
+                _watch_session_payload(
+                    test_run_id=known_run_id,
+                    test_run_name=test_run_name,
+                    stats=session_stats,
+                    status=finish_status,
+                ),
+                session_id=session_id,
+                action="complete",
+            )
+            if closed is not None:
+                click.echo("Платформа закрыла карточку загрузки.")
+            else:
+                click.echo("Не удалось закрыть карточку загрузки на платформе.", err=True)
 
     test_status = 0
     if child["proc"] is not None:
@@ -1436,3 +1676,7 @@ def watch(
             test_status = child["proc"].wait()
     if test_status or watch_code:
         sys.exit(test_status or watch_code)
+
+
+if __name__ == "__main__":
+    cli()

savetest_cli-0.3.0rc2/README.md → savetest_cli-0.3.0rc4/savetest_cli.egg-info/PKG-INFO

@@ -1,3 +1,13 @@
+Metadata-Version: 2.4
+Name: savetest-cli
+Version: 0.3.0rc4
+Summary: CLI for SaveTest: upload Allure results as a ZIP, as raw files, or by watching a directory
+License-Expression: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: click>=8.0
+Requires-Dist: requests>=2.28
+
 <p align="center">
   <img src="savetest_cli/pwa-512x512.png" alt="SaveTest" width="128">
 </p>
@@ -186,6 +196,8 @@ savetest upload_files ./allure-results/*-result.json ./allure-results/executor.j
 
 Первая пачка создаёт тест-ран, если не передан `--test-run-id`. Следующие файлы пишутся в тот же ран: пока ран не создан, вторая пачка ждёт. Код возврата `1`, если хотя бы один импорт не завершился как `completed`.
 
+Пачка уходит одним запросом, статусы задач в очереди тоже читаются одним запросом. Если сервер ещё старый и отвечает 404 или 405, до конца этого запуска watch сам возвращается к прежней схеме: три запроса на пачку и опрос задач по одной, с головы очереди до первой незавершённой. Уже выпущенные версии утилиты с новым сервером работают как раньше.
+
 Вложение уезжает вместе с `*-result.json`, который на него ссылается. Результат подождёт вложение до `--attachment-wait` секунд. Пачка без файла результата не отправляется.
 
 Привязки к фреймворку нет. После `--` watch запускает любую команду как есть и не разбирает её аргументы: pytest, JUnit, Maven, Gradle, npm или свой скрипт. Ему всё равно, кто пишет файлы. Нужны только `*-result.json` в каталоге, который указан первым аргументом. `pytest` в примерах ниже — один из вариантов, не требование.
@@ -210,7 +222,7 @@ savetest watch ./allure-results \
 - Если тесты и загрузка — разные джобы, отдайте каталог `allure-results` артефактом тоже с `when: always`.
 - `--wait` оставляйте включённым: джоба должна завершиться только когда импорт дошёл до конца.
 - Вложения включайте только если они реально нужны. По умолчанию CLI их не шлёт.
-- `0.3.0rc2` — предварительная версия для SaveTest 1.5.0: `pip install savetest-cli==0.3.0rc2`. Обычный `pip install savetest-cli` остаётся на последней стабильной версии.
+- `0.3.0rc4` — предварительная версия для SaveTest 1.5.0: `pip install savetest-cli==0.3.0rc4`. Обычный `pip install savetest-cli` остаётся на последней стабильной версии.
 
 ### Результаты по мере прогона
 

{savetest_cli-0.3.0rc2 → savetest_cli-0.3.0rc4}/savetest_cli.egg-info/SOURCES.txt

@@ -9,4 +9,5 @@ savetest_cli.egg-info/SOURCES.txt
 savetest_cli.egg-info/dependency_links.txt
 savetest_cli.egg-info/entry_points.txt
 savetest_cli.egg-info/requires.txt
-savetest_cli.egg-info/top_level.txt
+savetest_cli.egg-info/top_level.txt
+tests/test_watch_fastpath.py

savetest_cli-0.3.0rc4/tests/test_watch_fastpath.py

@@ -0,0 +1,219 @@
+"""Снимок watch и фолбэк на старые ручки."""
+
+import os
+from pathlib import Path
+from unittest.mock import patch
+
+import pytest
+
+from savetest_cli.cli import (
+    _WatchApi,
+    _enqueue_watch_batch,
+    _poll_watch_tasks,
+    _snapshot_raw_files,
+)
+
+
+class _Resp:
+    def __init__(self, status_code, payload):
+        self.status_code = status_code
+        self._payload = payload
+        self.ok = 200 <= status_code < 300
+        self.text = payload if isinstance(payload, str) else ""
+
+    def json(self):
+        if isinstance(self._payload, str):
+            raise ValueError("not json")
+        return self._payload
+
+
+def _send(selected, api):
+    return _enqueue_watch_batch(
+        selected,
+        host="https://example.test",
+        token="tok",
+        project_id="7",
+        test_run_id=None,
+        test_run_name="Прогон",
+        description=None,
+        version=None,
+        revision=None,
+        test_object=None,
+        epic_id=None,
+        epic_name=None,
+        configuration_id=None,
+        configuration_name=None,
+        branch="main",
+        include_attachments=False,
+        api=api,
+    )
+
+
+def _kind(url: str) -> str:
+    if url.endswith("/files/batch"):
+        return "batch"
+    if url.endswith("/files/init"):
+        return "init"
+    if url.endswith("/complete"):
+        return "complete"
+    if "/allure-results/files/" in url:
+        return "upload"
+    return url
+
+
+def test_snapshot_does_not_stat_uploaded_files(tmp_path: Path):
+    (tmp_path / "sent-result.json").write_text("{}", encoding="utf-8")
+    (tmp_path / "new-result.json").write_text('{"status": "passed"}', encoding="utf-8")
+    nested = tmp_path / "sub" / "deep"
+    nested.mkdir(parents=True)
+    (nested / "nested-result.json").write_text("{}", encoding="utf-8")
+    (tmp_path / "sub" / "old-result.json").write_text("{}", encoding="utf-8")
+    (tmp_path / ".DS_Store").write_text("x", encoding="utf-8")
+    (tmp_path / "shot.png").write_text("x", encoding="utf-8")
+    (tmp_path / "pack.zip").write_text("x", encoding="utf-8")
+    macos = tmp_path / "__MACOSX"
+    macos.mkdir()
+    (macos / "junk-result.json").write_text("{}", encoding="utf-8")
+
+    uploaded = {"sent-result.json", "sub/old-result.json"}
+    uploaded_names = {"sent-result.json", "old-result.json"}
+    skipped_names = uploaded_names | {".DS_Store", "shot.png", "pack.zip", "junk-result.json"}
+    stat_names = []
+    real_dir_stat = os.DirEntry.stat
+    real_os_stat = os.stat
+
+    def dir_stat(self, *args, **kwargs):
+        stat_names.append(self.name)
+        if self.name in uploaded_names:
+            raise AssertionError(f"DirEntry.stat для уже отправленного {self.name}")
+        return real_dir_stat(self, *args, **kwargs)
+
+    def os_stat(path, *args, **kwargs):
+        base = os.path.basename(os.fspath(path))
+        if base in uploaded_names:
+            raise AssertionError(f"os.stat для уже отправленного {base}")
+        return real_os_stat(path, *args, **kwargs)
+
+    with patch.object(os.DirEntry, "stat", dir_stat), patch("os.stat", os_stat):
+        found = _snapshot_raw_files(tmp_path, False, uploaded)
+
+    assert set(found) == {"new-result.json", "sub/deep/nested-result.json"}
+    assert "new-result.json" in stat_names
+    assert "nested-result.json" in stat_names
+    assert not (set(stat_names) & skipped_names)
+    path, size, mtime = found["sub/deep/nested-result.json"]
+    assert path.name == "nested-result.json"
+    assert size > 0
+    assert mtime > 0
+    assert _snapshot_raw_files(tmp_path / "missing", False, set()) == {}
+
+
+def test_files_batch_404_falls_back_once(tmp_path: Path):
+    result = tmp_path / "a-result.json"
+    result.write_text("{}", encoding="utf-8")
+    selected = [("a-result.json", result)]
+    api = _WatchApi()
+    calls = []
+
+    def fake_post(url, **kwargs):
+        calls.append(_kind(url))
+        if url.endswith("/files/batch"):
+            assert kwargs["data"]["include_attachments"] == "false"
+            assert kwargs["data"]["git_branch"] == "main"
+            assert kwargs["data"]["test_run_name"] == "Прогон"
+            return _Resp(404, "missing")
+        if url.endswith("/files/init"):
+            return _Resp(200, {"upload_id": "up1"})
+        if url.endswith("/complete"):
+            return _Resp(200, {"task_id": "task-1", "status": "pending"})
+        if "/allure-results/files/" in url:
+            return _Resp(200, {"ok": True})
+        raise AssertionError(url)
+
+    with patch("savetest_cli.cli.requests.post", side_effect=fake_post):
+        assert _send(selected, api) == "task-1"
+        assert _send(selected, api) == "task-1"
+
+    assert calls == [
+        "batch", "init", "upload", "complete",
+        "init", "upload", "complete",
+    ]
+    assert api.files_batch is False
+
+
+def test_task_status_404_polls_until_first_open():
+    api = _WatchApi()
+    calls = []
+    states = {"a": "completed", "b": "processing", "c": "completed"}
+
+    def fake_post(url, **kwargs):
+        calls.append(("POST", url))
+        assert kwargs["json"] == {"task_ids": ["a", "b", "c"]}
+        return _Resp(404, "missing")
+
+    def fake_get(url, **kwargs):
+        task_id = url.rstrip("/").split("/")[-1]
+        calls.append(("GET", task_id))
+        return _Resp(200, {"task_id": task_id, "status": states[task_id]})
+
+    with patch("savetest_cli.cli.requests.post", side_effect=fake_post), patch(
+        "savetest_cli.cli.requests.get", side_effect=fake_get
+    ):
+        first = _poll_watch_tasks(
+            ["a", "b", "c"],
+            host="https://example.test",
+            project_id="7",
+            token="tok",
+            api=api,
+        )
+        second = _poll_watch_tasks(
+            ["a", "b", "c"],
+            host="https://example.test",
+            project_id="7",
+            token="tok",
+            api=api,
+        )
+
+    assert [task_id for task_id, _status in first] == ["a", "b"]
+    assert first[-1][1]["status"] == "processing"
+    assert [task_id for task_id, _status in second] == ["a", "b"]
+    assert calls == [
+        ("POST", "https://example.test/api/v1/projects/7/allure-results/tasks/status"),
+        ("GET", "a"),
+        ("GET", "b"),
+        ("GET", "a"),
+        ("GET", "b"),
+    ]
+    assert api.tasks_batch is False
+
+
+def test_task_status_batch_reads_all_without_get(monkeypatch: pytest.MonkeyPatch):
+    api = _WatchApi()
+    posts = []
+    monkeypatch.setattr("savetest_cli.cli._TASK_STATUS_BATCH_LIMIT", 2)
+
+    def fake_post(url, **kwargs):
+        posts.append(kwargs["json"]["task_ids"])
+        payload = [
+            {"task_id": task_id, "status": "completed"}
+            for task_id in kwargs["json"]["task_ids"]
+        ]
+        return _Resp(200, payload)
+
+    def fake_get(url, **kwargs):
+        raise AssertionError(url)
+
+    with patch("savetest_cli.cli.requests.post", side_effect=fake_post), patch(
+        "savetest_cli.cli.requests.get", side_effect=fake_get
+    ):
+        pairs = _poll_watch_tasks(
+            ["a", "b", "c"],
+            host="https://example.test",
+            project_id="7",
+            token="tok",
+            api=api,
+        )
+
+    assert posts == [["a", "b"], ["c"]]
+    assert [task_id for task_id, _status in pairs] == ["a", "b", "c"]
+    assert api.tasks_batch is True

savetest_cli-0.3.0rc2/savetest_cli/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.3.0rc2"