qase-python-commons 5.1.2__tar.gz → 5.1.4__tar.gz

{qase_python_commons-5.1.2 → qase_python_commons-5.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qase-python-commons
-Version: 5.1.2
+Version: 5.1.4
 Summary: A library for Qase TestOps and Qase Report
 Author-email: Qase Team <support@qase.io>
 Project-URL: Homepage, https://github.com/qase-tms/qase-python/tree/main/qase-python-commons
@@ -65,6 +65,7 @@ Core library for all Qase Python reporters. Contains the complete configuration
   - [Status Filtering](#status-filtering)
   - [External Links](#external-links)
   - [Test Run Configurations](#test-run-configurations)
+  - [Upload Reliability](#upload-reliability)
 
 ---
 
@@ -137,6 +138,9 @@ The reporter mode is set via the `mode` option:
 |-------------|-------------|---------------------|---------|----------|
 | API token | `testops.api.token` | `QASE_TESTOPS_API_TOKEN` | — | Yes* |
 | API host | `testops.api.host` | `QASE_TESTOPS_API_HOST` | `qase.io` | No |
+| Request timeout, seconds | `testops.api.timeout` | `QASE_TESTOPS_API_TIMEOUT` | `30` | No |
+| Upload attempts | `testops.api.retries` | `QASE_TESTOPS_API_RETRIES` | `3` | No |
+| Retry backoff base, seconds | `testops.api.retryBackoff` | `QASE_TESTOPS_API_RETRY_BACKOFF` | `2` | No |
 | Project code | `testops.project` | `QASE_TESTOPS_PROJECT` | — | Yes* |
 | Test run ID | `testops.run.id` | `QASE_TESTOPS_RUN_ID` | — | No |
 | Test run title | `testops.run.title` | `QASE_TESTOPS_RUN_TITLE` | `Automated run <date>` | No |
@@ -296,6 +300,9 @@ export QASE_TESTOPS_API_TOKEN="<token>"
 export QASE_TESTOPS_PROJECT="DEMO"
 export QASE_TESTOPS_RUN_TITLE="Automated Run"
 export QASE_TESTOPS_RUN_COMPLETE="true"
+export QASE_TESTOPS_API_TIMEOUT="30"
+export QASE_TESTOPS_API_RETRIES="3"
+export QASE_TESTOPS_API_RETRY_BACKOFF="2"
 
 # Pytest
 export QASE_PYTEST_CAPTURE_LOGS="true"
@@ -409,6 +416,44 @@ Creates or finds configurations in Qase TestOps:
 }
 ```
 
+### Upload Reliability
+
+Results are uploaded in batches from background threads. A batch that fails on
+a transient error is retried rather than dropped.
+
+| Setting | Meaning |
+|---------|---------|
+| `testops.api.timeout` | Per-request timeout in seconds. Without it a stalled connection blocks the session at teardown. |
+| `testops.api.retries` | Total attempts per batch, not retries on top of the first. `3` means three tries; `0` sends once and never retries. |
+| `testops.api.retryBackoff` | Base of the exponential delay: attempt *n* waits `retryBackoff ** n` seconds. |
+
+Retried: connection resets, timeouts and other transport failures, plus HTTP
+408, 429 and 5xx. Not retried: 400, 401, 403, 404, 413, 422 and 507 — a second
+attempt fails identically and only adds load.
+
+When a 429 carries a `Retry-After` header, that value replaces the computed
+backoff. Qase sends roughly 60 seconds, so a run that hits the rate limit takes
+longer to finish rather than losing the batch.
+
+**If a batch cannot be delivered after all attempts**, the reporter logs an
+error naming how many results were lost and **does not mark the run complete**.
+An open run is the signal that its data is incomplete; a completed run over
+partial results would look trustworthy and not be. In `testops_multi` mode this
+is per project — one project's failure does not stop the others completing.
+
+```json
+{
+  "testops": {
+    "api": {
+      "token": "<token>",
+      "timeout": 30,
+      "retries": 3,
+      "retryBackoff": 2
+    }
+  }
+}
+```
+
 ---
 
 ## Requirements

{qase_python_commons-5.1.2 → qase_python_commons-5.1.4}/README.md

@@ -30,6 +30,7 @@ Core library for all Qase Python reporters. Contains the complete configuration
   - [Status Filtering](#status-filtering)
   - [External Links](#external-links)
   - [Test Run Configurations](#test-run-configurations)
+  - [Upload Reliability](#upload-reliability)
 
 ---
 
@@ -102,6 +103,9 @@ The reporter mode is set via the `mode` option:
 |-------------|-------------|---------------------|---------|----------|
 | API token | `testops.api.token` | `QASE_TESTOPS_API_TOKEN` | — | Yes* |
 | API host | `testops.api.host` | `QASE_TESTOPS_API_HOST` | `qase.io` | No |
+| Request timeout, seconds | `testops.api.timeout` | `QASE_TESTOPS_API_TIMEOUT` | `30` | No |
+| Upload attempts | `testops.api.retries` | `QASE_TESTOPS_API_RETRIES` | `3` | No |
+| Retry backoff base, seconds | `testops.api.retryBackoff` | `QASE_TESTOPS_API_RETRY_BACKOFF` | `2` | No |
 | Project code | `testops.project` | `QASE_TESTOPS_PROJECT` | — | Yes* |
 | Test run ID | `testops.run.id` | `QASE_TESTOPS_RUN_ID` | — | No |
 | Test run title | `testops.run.title` | `QASE_TESTOPS_RUN_TITLE` | `Automated run <date>` | No |
@@ -261,6 +265,9 @@ export QASE_TESTOPS_API_TOKEN="<token>"
 export QASE_TESTOPS_PROJECT="DEMO"
 export QASE_TESTOPS_RUN_TITLE="Automated Run"
 export QASE_TESTOPS_RUN_COMPLETE="true"
+export QASE_TESTOPS_API_TIMEOUT="30"
+export QASE_TESTOPS_API_RETRIES="3"
+export QASE_TESTOPS_API_RETRY_BACKOFF="2"
 
 # Pytest
 export QASE_PYTEST_CAPTURE_LOGS="true"
@@ -374,6 +381,44 @@ Creates or finds configurations in Qase TestOps:
 }
 ```
 
+### Upload Reliability
+
+Results are uploaded in batches from background threads. A batch that fails on
+a transient error is retried rather than dropped.
+
+| Setting | Meaning |
+|---------|---------|
+| `testops.api.timeout` | Per-request timeout in seconds. Without it a stalled connection blocks the session at teardown. |
+| `testops.api.retries` | Total attempts per batch, not retries on top of the first. `3` means three tries; `0` sends once and never retries. |
+| `testops.api.retryBackoff` | Base of the exponential delay: attempt *n* waits `retryBackoff ** n` seconds. |
+
+Retried: connection resets, timeouts and other transport failures, plus HTTP
+408, 429 and 5xx. Not retried: 400, 401, 403, 404, 413, 422 and 507 — a second
+attempt fails identically and only adds load.
+
+When a 429 carries a `Retry-After` header, that value replaces the computed
+backoff. Qase sends roughly 60 seconds, so a run that hits the rate limit takes
+longer to finish rather than losing the batch.
+
+**If a batch cannot be delivered after all attempts**, the reporter logs an
+error naming how many results were lost and **does not mark the run complete**.
+An open run is the signal that its data is incomplete; a completed run over
+partial results would look trustworthy and not be. In `testops_multi` mode this
+is per project — one project's failure does not stop the others completing.
+
+```json
+{
+  "testops": {
+    "api": {
+      "token": "<token>",
+      "timeout": 30,
+      "retries": 3,
+      "retryBackoff": 2
+    }
+  }
+}
+```
+
 ---
 
 ## Requirements

{qase_python_commons-5.1.2 → qase_python_commons-5.1.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "qase-python-commons"
-version = "5.1.2"
+version = "5.1.4"
 description = "A library for Qase TestOps and Qase Report"
 readme = "README.md"
 authors = [{name = "Qase Team", email = "support@qase.io"}]

{qase_python_commons-5.1.2 → qase_python_commons-5.1.4}/src/qase/commons/client/api_v1_client.py

@@ -26,6 +26,9 @@ class ApiV1Client(BaseApiClient):
             configuration = Configuration()
             configuration.api_key['TokenAuth'] = self.config.testops.api.token
             configuration.ssl_ca_cert = certifi.where()
+            # See the note in ApiV2Client: urllib3's default retry policy is
+            # pinned off so it cannot multiply with the application-level one.
+            configuration.retries = 0
             host = self.config.testops.api.host
             if host == 'qase.io':
                 configuration.host = f'https://api.{host}/v1'

{qase_python_commons-5.1.2 → qase_python_commons-5.1.4}/src/qase/commons/client/api_v2_client.py

@@ -36,6 +36,11 @@ class ApiV2Client(ApiV1Client):
             configuration = Configuration()
             configuration.api_key['TokenAuth'] = self.config.testops.api.token
             configuration.ssl_ca_cert = certifi.where()
+            # Pin urllib3's own retry policy off: the reporter retries at the
+            # application level, and leaving this at None lets urllib3's
+            # defaults multiply with ours -- a 3-attempt policy would issue
+            # 9 requests, the opposite of what is wanted on a 429.
+            configuration.retries = 0
             host = self.config.testops.api.host
             if host == 'qase.io':
                 configuration.host = f'https://api.{host}/v2'
@@ -131,7 +136,8 @@ class ApiV2Client(ApiV1Client):
         run_id_int = int(run_id) if isinstance(run_id, str) else run_id
         self.logger.log_debug(f"Sending results for run {run_id_int}: {results_to_send}")
         api_results.create_results_v2(project_code, run_id_int,
-                                      create_results_request_v2=CreateResultsRequestV2(results=results_to_send))
+                                      create_results_request_v2=CreateResultsRequestV2(results=results_to_send),
+                                      _request_timeout=self.config.testops.api.timeout)
         self.logger.log_debug(f"Results for run {run_id_int} sent successfully")
 
     def _prepare_result(self, project_code: str, result: Result) -> ResultCreate:
@@ -158,6 +164,7 @@ class ApiV2Client(ApiV1Client):
                 result.params[key] = "empty"
 
         result_model_v2 = ResultCreate(
+            id=result.id,
             title=result.get_title(),
             signature=result.signature,
             testops_ids=result.get_testops_ids(),

{qase_python_commons-5.1.2 → qase_python_commons-5.1.4}/src/qase/commons/config.py

@@ -109,6 +109,20 @@ class ConfigManager:
                                 self.config.testops.api.set_token(
                                     api.get("token"))
 
+                            if api.get("timeout"):
+                                self.config.testops.api.set_timeout(
+                                    api.get("timeout"))
+
+                            # `is not None`, not truthiness: 0 is a valid value
+                            # for both, meaning "no retries" / "no backoff".
+                            if api.get("retries") is not None:
+                                self.config.testops.api.set_retries(
+                                    api.get("retries"))
+
+                            if api.get("retryBackoff") is not None:
+                                self.config.testops.api.set_retry_backoff(
+                                    api.get("retryBackoff"))
+
                         if testops.get("project"):
                             self.config.testops.set_project(
                                 testops.get("project"))
@@ -288,6 +302,15 @@ class ConfigManager:
                 if key == 'QASE_TESTOPS_API_TOKEN':
                     self.config.testops.api.set_token(value)
 
+                if key == 'QASE_TESTOPS_API_TIMEOUT':
+                    self.config.testops.api.set_timeout(value)
+
+                if key == 'QASE_TESTOPS_API_RETRIES':
+                    self.config.testops.api.set_retries(value)
+
+                if key == 'QASE_TESTOPS_API_RETRY_BACKOFF':
+                    self.config.testops.api.set_retry_backoff(value)
+
                 if key == 'QASE_TESTOPS_PROJECT':
                     self.config.testops.set_project(value)
 

qase_python_commons-5.1.4/src/qase/commons/models/config/api.py

@@ -0,0 +1,39 @@
+from ..basemodel import BaseModel
+
+
+class ApiConfig(BaseModel):
+    token: str = None
+    host: str = None
+    timeout: int = None
+    retries: int = None
+    retry_backoff: int = None
+
+    def __init__(self):
+        self.host = "qase.io"
+        self.timeout = 30
+        self.retries = 3
+        self.retry_backoff = 2
+
+    def set_token(self, token: str):
+        self.token = token
+
+    def set_host(self, host: str):
+        self.host = host
+
+    def set_timeout(self, timeout: int):
+        timeout = int(timeout)
+        if timeout <= 0:
+            raise ValueError("API timeout should be greater than 0")
+        self.timeout = timeout
+
+    def set_retries(self, retries: int):
+        retries = int(retries)
+        if retries < 0:
+            raise ValueError("API retries should be 0 or greater")
+        self.retries = retries
+
+    def set_retry_backoff(self, retry_backoff: int):
+        retry_backoff = int(retry_backoff)
+        if retry_backoff < 0:
+            raise ValueError("API retry backoff should be 0 or greater")
+        self.retry_backoff = retry_backoff

{qase_python_commons-5.1.2 → qase_python_commons-5.1.4}/src/qase/commons/models/config/batch.py

@@ -8,6 +8,6 @@ class BatchConfig(BaseModel):
         self.size = 200
 
     def set_size(self, size: int):
-        if size > 2000 or size == 0:
-            raise ValueError("Batch size should be greater than 0 and less than 2000")
+        if size > 200 or size == 0:
+            raise ValueError("Batch size should be greater than 0 and no greater than 200")
         self.size = size

{qase_python_commons-5.1.2 → qase_python_commons-5.1.4}/src/qase/commons/reporters/testops.py

@@ -8,6 +8,7 @@ from .. import Logger, ReporterException
 from ..client.base_api_client import BaseApiClient
 from ..models import Result
 from ..models.config.qaseconfig import QaseConfig
+from ..retry import send_with_retry
 
 DEFAULT_BATCH_SIZE = 200
 DEFAULT_THREAD_COUNT = 4
@@ -32,10 +33,12 @@ class QaseTestOps:
         self.complete_after_run = self.config.testops.run.complete
         self.environment = None
 
-        self.batch_size = min(2000, max(1, int(self.config.testops.batch.size or DEFAULT_BATCH_SIZE)))
+        self.batch_size = min(200, max(1, int(self.config.testops.batch.size or DEFAULT_BATCH_SIZE)))
         self.send_semaphore = threading.Semaphore(DEFAULT_THREAD_COUNT)  # Semaphore to limit concurrent sends
         self.lock = threading.Lock()
         self.count_running_threads = 0
+        # Results in batches that could not be delivered after all retries.
+        self.lost_results = 0
 
         environment = self.config.environment
         if environment:
@@ -70,15 +73,28 @@ class QaseTestOps:
 
     def _send_results_threaded(self, results):
         try:
-            self.client.send_results(self.project_code, self.run_id, results)
+            send_with_retry(
+                lambda: self.client.send_results(self.project_code, self.run_id, results),
+                attempts=self.config.testops.api.retries,
+                backoff=self.config.testops.api.retry_backoff,
+                logger=self.logger,
+            )
             with self.lock:
                 self.processed.extend(results)
         except Exception as e:
+            # Account for the batch here rather than re-raising. The raise only
+            # ever surfaced as a PytestUnhandledThreadExceptionWarning that
+            # nothing acted on, which is how the loss stayed invisible.
             with self.lock:
-                self.logger.log(f"Error at sending results for run {self.run_id}: {e}", "error")
-            raise  # Re-raise the exception to be caught by the thread handler
+                self.lost_results += len(results)
+                self.logger.log(
+                    f"Failed to send {len(results)} results for run {self.run_id} "
+                    f"after {self.config.testops.api.retries} attempt(s): {e}",
+                    "error",
+                )
         finally:
-            self.count_running_threads -= 1
+            with self.lock:
+                self.count_running_threads -= 1
             self.send_semaphore.release()  # Release semaphore whether success or exception
 
     def _send_results(self) -> None:
@@ -101,7 +117,8 @@ class QaseTestOps:
             if results_to_send:
                 # Acquire semaphore before starting the send operation
                 self.send_semaphore.acquire()
-                self.count_running_threads += 1
+                with self.lock:
+                    self.count_running_threads += 1
 
                 # Start a new thread for sending results
                 send_thread = threading.Thread(target=self._send_results_threaded, args=(results_to_send,))
@@ -136,7 +153,17 @@ class QaseTestOps:
 
         while self.count_running_threads > 0:
             time.sleep(DEFAULT_THREAD_POLL_INTERVAL)
-        
+
+        if self.lost_results > 0:
+            # Leaving the run open is the signal. A run marked complete over
+            # partial data looks trustworthy and is not.
+            self.logger.log(
+                f"{self.lost_results} result(s) were not delivered to Qase. "
+                f"The run will not be marked complete so the gap stays visible.",
+                "error",
+            )
+            return
+
         if self.complete_after_run:
             self.logger.log_debug("Completing run")
             self.client.complete_run(self.project_code, self.run_id)
@@ -158,7 +185,7 @@ class QaseTestOps:
         if len(self.results) > 0:
             self._send_results()
         while self.count_running_threads > 0:
-            pass
+            time.sleep(DEFAULT_THREAD_POLL_INTERVAL)
         self.logger.log_debug("Worker completed")
 
     def add_result(self, result: Result) -> None:

{qase_python_commons-5.1.2 → qase_python_commons-5.1.4}/src/qase/commons/reporters/testops_multi.py

@@ -1,4 +1,5 @@
 import threading
+import time
 import urllib.parse
 import copy
 
@@ -8,9 +9,11 @@ from .. import Logger, ReporterException
 from ..client.base_api_client import BaseApiClient
 from ..models import Result
 from ..models.config.qaseconfig import QaseConfig
+from ..retry import send_with_retry
 
 DEFAULT_BATCH_SIZE = 200
 DEFAULT_THREAD_COUNT = 4
+DEFAULT_THREAD_POLL_INTERVAL = 0.05
 
 
 class QaseTestOpsMulti:
@@ -22,7 +25,7 @@ class QaseTestOpsMulti:
         self.client = client
 
         self.multi_config = config.testops_multi
-        self.batch_size = min(2000, max(1, int(self.config.testops.batch.size or DEFAULT_BATCH_SIZE)))
+        self.batch_size = min(200, max(1, int(self.config.testops.batch.size or DEFAULT_BATCH_SIZE)))
         self.send_semaphore = threading.Semaphore(DEFAULT_THREAD_COUNT)
         self.lock = threading.Lock()
         self.count_running_threads = 0
@@ -44,6 +47,9 @@ class QaseTestOpsMulti:
         self.project_results: Dict[str, List[Result]] = {project.code: [] for project in self.multi_config.projects}
         self.project_runs: Dict[str, int] = {}  # Store run_id as int
         self.processed: Dict[str, List[Result]] = {project.code: [] for project in self.multi_config.projects}
+        # Results in batches that could not be delivered after all retries,
+        # counted per project so one project's loss does not hide another's.
+        self.lost_results: Dict[str, int] = {project.code: 0 for project in self.multi_config.projects}
 
         # Initialize environment for each project
         for project_code, project_data in self.project_configs.items():
@@ -101,15 +107,28 @@ class QaseTestOpsMulti:
         try:
             # Convert run_id to str for send_results (it will convert to int internally for API)
             run_id_str = str(run_id) if isinstance(run_id, int) else run_id
-            self.client.send_results(project_code, run_id_str, results)
+            send_with_retry(
+                lambda: self.client.send_results(project_code, run_id_str, results),
+                attempts=self.config.testops.api.retries,
+                backoff=self.config.testops.api.retry_backoff,
+                logger=self.logger,
+            )
             with self.lock:
                 self.processed[project_code].extend(results)
         except Exception as e:
+            # Account for the batch here rather than re-raising. The raise only
+            # ever surfaced as a PytestUnhandledThreadExceptionWarning that
+            # nothing acted on, which is how the loss stayed invisible.
             with self.lock:
-                self.logger.log(f"Error at sending results for project {project_code}, run {run_id}: {e}", "error")
-            raise
+                self.lost_results[project_code] = self.lost_results.get(project_code, 0) + len(results)
+                self.logger.log(
+                    f"Failed to send {len(results)} results for project {project_code}, "
+                    f"run {run_id} after {self.config.testops.api.retries} attempt(s): {e}",
+                    "error",
+                )
         finally:
-            self.count_running_threads -= 1
+            with self.lock:
+                self.count_running_threads -= 1
             self.send_semaphore.release()
 
     def _send_results_for_project(self, project_code: str) -> None:
@@ -141,7 +160,8 @@ class QaseTestOpsMulti:
         if results_to_send:
             # Acquire semaphore before starting the send operation
             self.send_semaphore.acquire()
-            self.count_running_threads += 1
+            with self.lock:
+                self.count_running_threads += 1
 
             # Start a new thread for sending results
             # run_id is stored as int, convert to str for thread (will be converted back to int in send_results)
@@ -230,10 +250,21 @@ class QaseTestOpsMulti:
 
         # Wait for all send operations to complete
         while self.count_running_threads > 0:
-            pass
+            time.sleep(DEFAULT_THREAD_POLL_INTERVAL)
 
         # Complete all test runs
         for project_code, project_data in self.project_configs.items():
+            if self.lost_results.get(project_code, 0) > 0:
+                # `continue`, not `return`: one project's loss must not stop
+                # the others completing. Leaving this run open is the signal.
+                self.logger.log(
+                    f"{self.lost_results[project_code]} result(s) were not delivered for "
+                    f"project {project_code}. Its run will not be marked complete so the "
+                    f"gap stays visible.",
+                    "error",
+                )
+                continue
+
             if project_data.get('complete_after_run'):
                 run_id = self.project_runs.get(project_code)
                 if run_id:
@@ -258,7 +289,7 @@ class QaseTestOpsMulti:
         if any(len(results) > 0 for results in self.project_results.values()):
             self._send_results()
         while self.count_running_threads > 0:
-            pass
+            time.sleep(DEFAULT_THREAD_POLL_INTERVAL)
         self.logger.log_debug("Worker completed")
 
     def add_result(self, result: Result) -> None:

qase_python_commons-5.1.4/src/qase/commons/retry.py

@@ -0,0 +1,94 @@
+"""Bounded retry for result uploads.
+
+Retries transport failures and the HTTP statuses that can succeed on a second
+attempt. Never retries a status that would be rejected identically -- an
+oversized batch, an invalid payload, an expired token -- where retrying only
+delays the error and adds load.
+
+Safe only because ResultCreate.id is populated: a request that was accepted
+but whose response was lost is indistinguishable from one that never arrived,
+and the idempotency key is what stops the retry creating duplicates.
+"""
+
+import time
+from typing import Callable, Optional
+
+RETRYABLE_STATUSES = frozenset({408, 429, 500, 502, 503, 504})
+
+_TRANSPORT_ERRORS = (ConnectionError, OSError, TimeoutError)
+
+
+def _urllib3_errors():
+    try:
+        from urllib3.exceptions import HTTPError
+
+        return (HTTPError,)
+    except ImportError:  # pragma: no cover - urllib3 is a hard dependency
+        return ()
+
+
+def is_retryable(exc: BaseException) -> bool:
+    """True when another attempt could plausibly succeed."""
+    status = getattr(exc, "status", None)
+    if status is not None:
+        try:
+            return int(status) in RETRYABLE_STATUSES
+        except (TypeError, ValueError):
+            return False
+    return isinstance(exc, _TRANSPORT_ERRORS + _urllib3_errors())
+
+
+def retry_after_seconds(exc: BaseException) -> Optional[float]:
+    """Seconds requested by a Retry-After header, when there is one.
+
+    Qase answers 429 with roughly 60 seconds, which no short backoff ladder
+    survives, so honouring the header matters more than the ladder itself.
+    """
+    headers = getattr(exc, "headers", None)
+    if not headers:
+        return None
+    try:
+        value = headers.get("Retry-After")
+    except AttributeError:
+        return None
+    if value is None:
+        return None
+    try:
+        return float(value)
+    except (TypeError, ValueError):
+        # The RFC also allows an HTTP-date. We do not parse it: falling back to
+        # the computed backoff is safer than guessing at a clock skew.
+        return None
+
+
+def send_with_retry(
+    send: Callable[[], None],
+    attempts: int,
+    backoff: int,
+    sleep: Callable[[float], None] = time.sleep,
+    logger=None,
+) -> None:
+    """Call send(), retrying retryable failures. Re-raises the last exception.
+
+    `attempts` is the total number of tries, not the number of retries on top
+    of the first: a configured `retries: 3` means three attempts in all, and
+    `retries: 0` still sends once but never retries.
+    """
+    attempts = max(1, attempts)
+    for attempt in range(1, attempts + 1):
+        try:
+            send()
+            return
+        except Exception as exc:
+            if attempt == attempts or not is_retryable(exc):
+                raise
+            delay = retry_after_seconds(exc)
+            if delay is None:
+                delay = backoff ** attempt
+            if logger:
+                logger.log(
+                    f"Upload attempt {attempt}/{attempts} failed ({exc}); "
+                    f"retrying in {delay}s",
+                    "warning",
+                )
+            sleep(delay)

{qase_python_commons-5.1.2 → qase_python_commons-5.1.4}/src/qase_python_commons.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qase-python-commons
-Version: 5.1.2
+Version: 5.1.4
 Summary: A library for Qase TestOps and Qase Report
 Author-email: Qase Team <support@qase.io>
 Project-URL: Homepage, https://github.com/qase-tms/qase-python/tree/main/qase-python-commons
@@ -65,6 +65,7 @@ Core library for all Qase Python reporters. Contains the complete configuration
   - [Status Filtering](#status-filtering)
   - [External Links](#external-links)
   - [Test Run Configurations](#test-run-configurations)
+  - [Upload Reliability](#upload-reliability)
 
 ---
 
@@ -137,6 +138,9 @@ The reporter mode is set via the `mode` option:
 |-------------|-------------|---------------------|---------|----------|
 | API token | `testops.api.token` | `QASE_TESTOPS_API_TOKEN` | — | Yes* |
 | API host | `testops.api.host` | `QASE_TESTOPS_API_HOST` | `qase.io` | No |
+| Request timeout, seconds | `testops.api.timeout` | `QASE_TESTOPS_API_TIMEOUT` | `30` | No |
+| Upload attempts | `testops.api.retries` | `QASE_TESTOPS_API_RETRIES` | `3` | No |
+| Retry backoff base, seconds | `testops.api.retryBackoff` | `QASE_TESTOPS_API_RETRY_BACKOFF` | `2` | No |
 | Project code | `testops.project` | `QASE_TESTOPS_PROJECT` | — | Yes* |
 | Test run ID | `testops.run.id` | `QASE_TESTOPS_RUN_ID` | — | No |
 | Test run title | `testops.run.title` | `QASE_TESTOPS_RUN_TITLE` | `Automated run <date>` | No |
@@ -296,6 +300,9 @@ export QASE_TESTOPS_API_TOKEN="<token>"
 export QASE_TESTOPS_PROJECT="DEMO"
 export QASE_TESTOPS_RUN_TITLE="Automated Run"
 export QASE_TESTOPS_RUN_COMPLETE="true"
+export QASE_TESTOPS_API_TIMEOUT="30"
+export QASE_TESTOPS_API_RETRIES="3"
+export QASE_TESTOPS_API_RETRY_BACKOFF="2"
 
 # Pytest
 export QASE_PYTEST_CAPTURE_LOGS="true"
@@ -409,6 +416,44 @@ Creates or finds configurations in Qase TestOps:
 }
 ```
 
+### Upload Reliability
+
+Results are uploaded in batches from background threads. A batch that fails on
+a transient error is retried rather than dropped.
+
+| Setting | Meaning |
+|---------|---------|
+| `testops.api.timeout` | Per-request timeout in seconds. Without it a stalled connection blocks the session at teardown. |
+| `testops.api.retries` | Total attempts per batch, not retries on top of the first. `3` means three tries; `0` sends once and never retries. |
+| `testops.api.retryBackoff` | Base of the exponential delay: attempt *n* waits `retryBackoff ** n` seconds. |
+
+Retried: connection resets, timeouts and other transport failures, plus HTTP
+408, 429 and 5xx. Not retried: 400, 401, 403, 404, 413, 422 and 507 — a second
+attempt fails identically and only adds load.
+
+When a 429 carries a `Retry-After` header, that value replaces the computed
+backoff. Qase sends roughly 60 seconds, so a run that hits the rate limit takes
+longer to finish rather than losing the batch.
+
+**If a batch cannot be delivered after all attempts**, the reporter logs an
+error naming how many results were lost and **does not mark the run complete**.
+An open run is the signal that its data is incomplete; a completed run over
+partial results would look trustworthy and not be. In `testops_multi` mode this
+is per project — one project's failure does not stop the others completing.
+
+```json
+{
+  "testops": {
+    "api": {
+      "token": "<token>",
+      "timeout": 30,
+      "retries": 3,
+      "retryBackoff": 2
+    }
+  }
+}
+```
+
 ---
 
 ## Requirements

{qase_python_commons-5.1.2 → qase_python_commons-5.1.4}/src/qase_python_commons.egg-info/SOURCES.txt

@@ -5,6 +5,7 @@ src/qase/commons/__init__.py
 src/qase/commons/config.py
 src/qase/commons/loader.py
 src/qase/commons/logger.py
+src/qase/commons/retry.py
 src/qase/commons/utils.py
 src/qase/commons/client/api_v1_client.py
 src/qase/commons/client/api_v2_client.py

qase_python_commons-5.1.2/src/qase/commons/models/config/api.py

@@ -1,15 +0,0 @@
-from ..basemodel import BaseModel
-
-
-class ApiConfig(BaseModel):
-    token: str = None
-    host: str = None
-
-    def __init__(self):
-        self.host = "qase.io"
-
-    def set_token(self, token: str):
-        self.token = token
-
-    def set_host(self, host: str):
-        self.host = host