dds-cli 2.14.3__tar.gz → 2.15.0__tar.gz

dds_cli-2.15.0/MANIFEST.in

@@ -0,0 +1 @@
+include requirements.txt

{dds_cli-2.14.3 → dds_cli-2.15.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dds_cli
-Version: 2.14.3
+Version: 2.15.0
 Summary: A command line tool to manage data and projects in the SciLifeLab Data Delivery System.
 Home-page: https://github.com/ScilifelabDataCentre/dds_cli
 Author: SciLifeLab Data Centre
@@ -16,20 +16,20 @@ License-File: LICENSE
 Requires-Dist: boto3==1.24.73
 Requires-Dist: botocore==1.27.73
 Requires-Dist: click==8.1.3
-Requires-Dist: cryptography==48.0.0
+Requires-Dist: cryptography==50.0.0
 Requires-Dist: immutabledict==2.2.1
-Requires-Dist: jwcrypto==1.5.7
+Requires-Dist: jwcrypto==1.5.8
 Requires-Dist: prettytable==3.7.0
 Requires-Dist: prompt-toolkit==3.0.40
 Requires-Dist: PyNaCl==1.6.2
-Requires-Dist: pytz==2026.2
+Requires-Dist: pytz==2026.3.post1
 Requires-Dist: PyYAML==6.0.2
 Requires-Dist: questionary==2.1.1
 Requires-Dist: requests==2.33.0
 Requires-Dist: rich==15.0.0
 Requires-Dist: rich-click==1.5.2
 Requires-Dist: simplejson==4.1.1
-Requires-Dist: tzlocal==4.2
+Requires-Dist: tzlocal==4.3.1
 Requires-Dist: zstandard==0.23.0
 Requires-Dist: legacy-cgi==2.6.1; python_version >= "3.13"
 Dynamic: author

{dds_cli-2.14.3 → dds_cli-2.15.0}/dds_cli/__init__.py

@@ -100,6 +100,7 @@ class DDSEndpoint:
     FILE_ADD_FAILED = BASE_ENDPOINT + "/file/failed/add"
 
     # Project specific urls
+    PROJ_UPLOAD_COMPLETE = BASE_ENDPOINT + "/proj/upload/complete"
     PROJ_ACCESS = BASE_ENDPOINT + "/proj/access"
     PROJ_BUSY_ANY = BASE_ENDPOINT + "/proj/busy/any"
     PROJ_INFO = BASE_ENDPOINT + "/proj/info"

{dds_cli-2.14.3 → dds_cli-2.15.0}/dds_cli/base.py

@@ -108,7 +108,9 @@ class DDSBaseClass:
 
         # Exception is not handled
         if exception_type is not None:
-            LOG.debug("Exception: %s with value %s", exception_type, exception_value)
+            # %r calls repr(), so exception_value is not interpreted as rich markup
+            # and cannot trigger a MarkupError during logging.
+            LOG.debug("Exception: %r with value %r", exception_type, exception_value)
             return False
 
         return True

{dds_cli-2.14.3 → dds_cli-2.15.0}/dds_cli/data_getter.py

@@ -148,29 +148,20 @@ class DataGetter(base.DDSBaseClass):
 
         LOG.debug("File '%s' downloaded: %s", file_name_in_db, file_downloaded)
 
-        file_size_verified = False
-
+        # `get()` now verifies the on-disk byte count against `size_stored`
+        # internally and only returns True if the file matches. If we reach
+        # this branch, the encrypted-size check has already passed.
+        # Defensive guard: make the contract explicit so a future refactor of
+        # get() that breaks the size guarantee fails loudly here rather than
+        # silently proceeding to decryption and surfacing as failed_op="crypto".
         if file_downloaded:
-            ## File size verification
-            expected_size = file_info["size_stored"]
             actual_size = file_info["path_downloaded"].stat().st_size
-
-            if actual_size == expected_size:
-                file_size_verified = True
-                LOG.debug(
-                    "Downloaded file '%s' size matches expected size: %s bytes.",
-                    file_name_in_db,
-                    expected_size,
-                )
-            else:
-                LOG.debug(
-                    "Downloaded file '%s' size mismatch: expected %s bytes, got %s bytes. Not decrypting.",
-                    file_name_in_db,
-                    expected_size,
-                    actual_size,
+            expected_size = file_info["size_stored"]
+            if actual_size != expected_size:
+                raise RuntimeError(
+                    f"get() returned True but size mismatch for '{file_name_in_db}': "
+                    f"expected {expected_size} bytes, got {actual_size} bytes"
                 )
-
-        if file_size_verified:
             db_updated, message = self.update_db(file=file)
             LOG.debug(
                 "API call: database updated for file '%s': %s",
@@ -239,18 +230,27 @@ class DataGetter(base.DDSBaseClass):
 
     @update_status
     def get(self, file, progress, task):
-        """Download files from the cloud."""
+        """Download files from the cloud and verify the byte count."""
         downloaded = False
         error = ""
-        file_local = self.filehandler.data[file]["path_downloaded"]
-        file_remote = self.filehandler.data[file]["url"]
-        file_name_in_db = escape(str(self.filehandler.data[file]["name_in_db"]))
+        file_info = self.filehandler.data[file]
+        file_local = file_info["path_downloaded"]
+        file_remote = file_info["url"]
+        # The encrypted size on the bucket — what we expect on disk after the GET.
+        # `size_original` is the plaintext size and is checked later, after decryption.
+        expected_size = file_info["size_stored"]
+        file_name_in_db = escape(str(file_info["name_in_db"]))
 
+        # ChunkedEncodingError is included so that silent stream truncation
+        # (raised manually below) hits the same backoff/retry path as a real
+        # network error. Without it, a truncated body looked like a successful
+        # download to requests/urllib3 and the retry loop never fired.
         retryable_exceptions = (
             requests.exceptions.ConnectTimeout,
             requests.exceptions.ReadTimeout,
             requests.exceptions.Timeout,
             requests.exceptions.ConnectionError,
+            requests.exceptions.ChunkedEncodingError,
         )
 
         max_retries = constants.DOWNLOAD_MAX_RETRIES
@@ -262,7 +262,13 @@ class DataGetter(base.DDSBaseClass):
             error = ""
             if attempt > 1:
                 progress.reset(task, completed=0)
+                # Drop the partial file from the previous attempt before retrying.
+                # We don't (yet) support Range-based resume, so a fresh GET starts
+                # at byte zero; leaving the old bytes around would just confuse
+                # the size check below.
+                self._remove_partial(file_local, file_name_in_db)
 
+            bytes_written = 0
             try:
                 with requests.get(
                     file_remote,
@@ -270,10 +276,42 @@ class DataGetter(base.DDSBaseClass):
                     timeout=(constants.CONNECT_TIMEOUT, constants.READ_TIMEOUT),
                 ) as req:
                     req.raise_for_status()
+                    # Server-advertised body size. AWS S3 sets this on every GET,
+                    # but S3-compatible backends behind a proxy may use chunked
+                    # transfer encoding (no Content-Length) or send a malformed
+                    # value. Treat both as "unknown" and rely on the size_stored
+                    # check below to catch truncation in that case.
+                    try:
+                        content_length = int(req.headers.get("Content-Length", 0))
+                    except (TypeError, ValueError):
+                        content_length = 0
                     with file_local.open(mode="wb") as new_file:
                         for chunk in req.iter_content(chunk_size=FileSegment.SEGMENT_SIZE_CIPHER):
                             progress.update(task, advance=len(chunk))
                             new_file.write(chunk)
+                            bytes_written += len(chunk)
+
+                # Guard against silent truncation: requests/urllib3 do not
+                # validate that bytes received == Content-Length. A clean TCP
+                # FIN mid-stream otherwise looks like an EOF and the loop exits
+                # successfully. Raise so the retry path catches us.
+                if content_length and bytes_written != content_length:
+                    raise requests.exceptions.ChunkedEncodingError(
+                        f"Truncated download for '{file_name_in_db}': "
+                        f"got {bytes_written} of {content_length} bytes"
+                    )
+
+                # Cross-check against the size DDS recorded for the encrypted
+                # blob. This used to live in download_and_verify() (outside the
+                # retry loop), which made truncation unrecoverable in a single
+                # run. Doing it here means a mismatch retries like any other
+                # transport error.
+                actual_size = file_local.stat().st_size
+                if actual_size != expected_size:
+                    raise requests.exceptions.ChunkedEncodingError(
+                        f"Size mismatch for '{file_name_in_db}': "
+                        f"expected {expected_size} bytes, got {actual_size} bytes"
+                    )
             except (requests.exceptions.HTTPError, *retryable_exceptions) as err:
                 if (
                     isinstance(err, requests.exceptions.HTTPError)
@@ -295,6 +333,11 @@ class DataGetter(base.DDSBaseClass):
                     wait *= backoff_factor
             else:
                 downloaded = True
+                LOG.debug(
+                    "Downloaded file '%s' size matches expected size: %s bytes.",
+                    file_name_in_db,
+                    expected_size,
+                )
                 break
 
         if not downloaded and error:
@@ -306,9 +349,34 @@ class DataGetter(base.DDSBaseClass):
                 max_retries,
                 error,
             )
+            LOG.warning(
+                "Download of '%s' could not be completed after %d attempts. "
+                "Please ensure your internet connection is stable and that your "
+                "computer does not enter sleep mode during large file transfers.",
+                file_name_in_db,
+                max_retries,
+            )
+            # Don't leave a partial blob on disk after we've given up — it just
+            # consumes space and risks being mistaken for a complete file.
+            self._remove_partial(file_local, file_name_in_db)
 
         return downloaded, error
 
+    @staticmethod
+    def _remove_partial(file_local, file_name_in_db):
+        """Delete a partial download. Best-effort — never raises."""
+        try:
+            file_local.unlink(missing_ok=True)
+        except OSError as unlink_err:
+            # File-locking on Windows occasionally blocks unlink while the
+            # progress bar still holds the path; we don't want this to mask
+            # the real download error, so just log and move on.
+            LOG.debug(
+                "Could not remove partial download for '%s': %s",
+                file_name_in_db,
+                unlink_err,
+            )
+
     @update_status
     def update_db(self, file):
         """Update file info in db."""

{dds_cli-2.14.3 → dds_cli-2.15.0}/dds_cli/data_putter.py

@@ -10,6 +10,7 @@ import itertools
 import json
 import logging
 import pathlib
+import threading
 
 # Installed
 import boto3
@@ -187,6 +188,9 @@ def put(
             else:
                 LOG.debug("Database retry finished.")
 
+        # Single project metadata refresh after batch (date_updated / last_updated_by)
+        putter.touch_project_after_upload()
+
 
 ###############################################################################
 # CLASSES ########################################################### CLASSES #
@@ -225,6 +229,9 @@ class DataPutter(base.DDSBaseClass):
         self.overwrite = overwrite
         self.silent = silent
         self.filehandler = None
+        self._db_add_lock = threading.Lock()
+        self.any_successful_db_add = False
+        self.retry_added_any_file = False
 
         # Only method "put" can use the DataPutter class
         if self.method != "put":
@@ -456,6 +463,8 @@ class DataPutter(base.DDSBaseClass):
             )
             added_to_db, message = (True, response_json)
             LOG.debug("API call for file '%s: Adding to database'", fileinfo["path_raw"])
+            with self._db_add_lock:
+                self.any_successful_db_add = True
         except (
             dds_cli.exceptions.ApiRequestError,
             dds_cli.exceptions.ApiResponseError,
@@ -505,6 +514,8 @@ class DataPutter(base.DDSBaseClass):
         files_added = response.get("files_added")
 
         # Get successfully added files
+        if files_added:
+            self.retry_added_any_file = True
         if len(files_added) == len(failed):
             LOG.info(
                 "All successfully uploaded files were successfully added to the database during the retry."
@@ -523,3 +534,35 @@ class DataPutter(base.DDSBaseClass):
                     "message": "Added with 'retry_add_file_db'",
                 }
             )
+
+    def touch_project_after_upload(self):
+        """Ask API to refresh project ``date_updated`` / ``last_updated_by`` once per batch."""
+        if not (self.any_successful_db_add or self.retry_added_any_file):
+            return
+        try:
+            dds_cli.utils.perform_request(
+                DDSEndpoint.PROJ_UPLOAD_COMPLETE,
+                method="post",
+                params={"project": self.project},
+                headers=self.token,
+                error_message="Failed to update project timestamp after upload",
+            )
+        except (
+            dds_cli.exceptions.ApiRequestError,
+            dds_cli.exceptions.ApiResponseError,
+            dds_cli.exceptions.DDSCLIException,
+        ) as err:
+            err_text = str(err)
+            if "Response code: 404" in err_text:
+                LOG.warning(
+                    "Upload succeeded, but the project 'Last updated' timestamp could not "
+                    "be refreshed because the backend does not expose the upload-complete "
+                    "endpoint (HTTP 404). Uploaded files are unaffected. Update the backend "
+                    "to match this CLI version if you need the timestamp to update."
+                )
+            else:
+                LOG.warning(
+                    "Upload succeeded, but the project 'Last updated' timestamp could not "
+                    "be refreshed. Uploaded files are unaffected. Details: %s",
+                    err,
+                )

{dds_cli-2.14.3 → dds_cli-2.15.0}/dds_cli/version.py

@@ -2,4 +2,4 @@
 
 # Do not change bump the major version unless absolutely necessary - makes incompatible with API
 # If mid or minor version reaches 9, continue to 10, 11 etc.
-__version__ = "2.14.3"
+__version__ = "2.15.0"

{dds_cli-2.14.3 → dds_cli-2.15.0}/dds_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dds_cli
-Version: 2.14.3
+Version: 2.15.0
 Summary: A command line tool to manage data and projects in the SciLifeLab Data Delivery System.
 Home-page: https://github.com/ScilifelabDataCentre/dds_cli
 Author: SciLifeLab Data Centre
@@ -16,20 +16,20 @@ License-File: LICENSE
 Requires-Dist: boto3==1.24.73
 Requires-Dist: botocore==1.27.73
 Requires-Dist: click==8.1.3
-Requires-Dist: cryptography==48.0.0
+Requires-Dist: cryptography==50.0.0
 Requires-Dist: immutabledict==2.2.1
-Requires-Dist: jwcrypto==1.5.7
+Requires-Dist: jwcrypto==1.5.8
 Requires-Dist: prettytable==3.7.0
 Requires-Dist: prompt-toolkit==3.0.40
 Requires-Dist: PyNaCl==1.6.2
-Requires-Dist: pytz==2026.2
+Requires-Dist: pytz==2026.3.post1
 Requires-Dist: PyYAML==6.0.2
 Requires-Dist: questionary==2.1.1
 Requires-Dist: requests==2.33.0
 Requires-Dist: rich==15.0.0
 Requires-Dist: rich-click==1.5.2
 Requires-Dist: simplejson==4.1.1
-Requires-Dist: tzlocal==4.2
+Requires-Dist: tzlocal==4.3.1
 Requires-Dist: zstandard==0.23.0
 Requires-Dist: legacy-cgi==2.6.1; python_version >= "3.13"
 Dynamic: author

{dds_cli-2.14.3 → dds_cli-2.15.0}/dds_cli.egg-info/SOURCES.txt

@@ -1,6 +1,8 @@
 LICENSE
+MANIFEST.in
 README.md
 pyproject.toml
+requirements.txt
 setup.py
 dds_cli/__init__.py
 dds_cli/__main__.py

{dds_cli-2.14.3 → dds_cli-2.15.0}/dds_cli.egg-info/requires.txt

@@ -1,20 +1,20 @@
 boto3==1.24.73
 botocore==1.27.73
 click==8.1.3
-cryptography==48.0.0
+cryptography==50.0.0
 immutabledict==2.2.1
-jwcrypto==1.5.7
+jwcrypto==1.5.8
 prettytable==3.7.0
 prompt-toolkit==3.0.40
 PyNaCl==1.6.2
-pytz==2026.2
+pytz==2026.3.post1
 PyYAML==6.0.2
 questionary==2.1.1
 requests==2.33.0
 rich==15.0.0
 rich-click==1.5.2
 simplejson==4.1.1
-tzlocal==4.2
+tzlocal==4.3.1
 zstandard==0.23.0
 
 [:python_version >= "3.13"]

dds_cli-2.15.0/requirements.txt

@@ -0,0 +1,19 @@
+boto3==1.24.73
+botocore==1.27.73
+click==8.1.3
+cryptography==50.0.0
+immutabledict==2.2.1
+jwcrypto==1.5.8
+prettytable==3.7.0
+prompt-toolkit==3.0.40
+PyNaCl==1.6.2
+pytz==2026.3.post1
+PyYAML==6.0.2
+questionary==2.1.1
+requests==2.33.0
+rich==15.0.0
+rich-click==1.5.2
+simplejson==4.1.1
+tzlocal==4.3.1
+zstandard==0.23.0
+legacy-cgi==2.6.1 ; python_version >= '3.13'

{dds_cli-2.14.3 → dds_cli-2.15.0}/tests/test_data_getter.py

@@ -2,7 +2,9 @@
 
 # IMPORTS ######################################################################
 
+import logging
 import pathlib
+import pytest
 import requests
 from types import SimpleNamespace
 from unittest.mock import MagicMock
@@ -14,8 +16,13 @@ from dds_cli import constants
 # HELPERS ######################################################################
 
 
-def _prepare_data_getter(file_name, download_path=None):
-    """Mock a DataGetter instance with a filehandler containing a single file entry."""
+def _prepare_data_getter(file_name, download_path=None, size_stored=4):
+    """Mock a DataGetter instance with a filehandler containing a single file entry.
+
+    `size_stored` defaults to 4 to match the canonical ``b"data"`` body used by most
+    tests below; the byte-count check inside ``get()`` only passes when the on-disk
+    size equals this value.
+    """
     # Create DataGetter instance without running __init__
     dg = DataGetter.__new__(DataGetter)
 
@@ -31,12 +38,29 @@ def _prepare_data_getter(file_name, download_path=None):
                 "path_downloaded": pathlib.Path(download_path or file_name),
                 "url": "https://example.com/file",
                 "name_in_db": file_name,
+                "size_stored": size_stored,
             }
         }
     )
     return dg
 
 
+def _ok_response(body=b"data"):
+    """Build a mock requests.Response that streams ``body`` as a single chunk.
+
+    Sets a Content-Length header matching the body length so the truncation
+    check inside ``get()`` is satisfied. Tests that want to simulate a
+    truncated response should override ``headers.get`` themselves.
+    """
+    mock_response = MagicMock()
+    mock_response.__enter__.return_value = mock_response
+    mock_response.__exit__.return_value = False
+    mock_response.iter_content.return_value = [body]
+    mock_response.raise_for_status.return_value = None
+    mock_response.headers.get.return_value = len(body)
+    return mock_response
+
+
 # TESTS ########################################################################
 
 
@@ -54,13 +78,7 @@ def test_get_uses_timeout(monkeypatch, tmp_path):
 
     # Create mock objects
     progress = MagicMock()  # needed for get method but doesn't invoke real progress
-    mock_response = MagicMock()
-
-    # Define the mock return values
-    mock_response.__enter__.return_value = mock_response
-    mock_response.__exit__.return_value = False
-    mock_response.iter_content.return_value = [b"data"]  # Simulate content chunks
-    mock_response.raise_for_status.return_value = None  # Used in download to check for HTTP errors
+    mock_response = _ok_response()
 
     # Mock the requests.get method to return the mock_response
     mock_get = MagicMock(return_value=mock_response)
@@ -147,11 +165,7 @@ def test_get_retries_on_connection_error(monkeypatch, tmp_path):
     monkeypatch.setattr(constants, "DOWNLOAD_MAX_RETRIES", 3)
     monkeypatch.setattr(constants, "DOWNLOAD_INITIAL_WAIT", 0)
 
-    mock_response = MagicMock()
-    mock_response.__enter__.return_value = mock_response
-    mock_response.__exit__.return_value = False
-    mock_response.iter_content.return_value = [b"data"]
-    mock_response.raise_for_status.return_value = None
+    mock_response = _ok_response()
 
     call_count = 0
 
@@ -235,11 +249,7 @@ def test_get_retries_on_http_500(monkeypatch, tmp_path):
     mock_500_response = MagicMock()
     mock_500_response.status_code = 500
 
-    mock_ok_response = MagicMock()
-    mock_ok_response.__enter__.return_value = mock_ok_response
-    mock_ok_response.__exit__.return_value = False
-    mock_ok_response.iter_content.return_value = [b"data"]
-    mock_ok_response.raise_for_status.return_value = None
+    mock_ok_response = _ok_response()
 
     call_count = 0
 
@@ -289,11 +299,7 @@ def test_get_progress_reset_only_on_retry(monkeypatch, tmp_path):
     monkeypatch.setattr(constants, "DOWNLOAD_MAX_RETRIES", 3)
     monkeypatch.setattr(constants, "DOWNLOAD_INITIAL_WAIT", 0)
 
-    mock_response = MagicMock()
-    mock_response.__enter__.return_value = mock_response
-    mock_response.__exit__.return_value = False
-    mock_response.iter_content.return_value = [b"data"]
-    mock_response.raise_for_status.return_value = None
+    mock_response = _ok_response()
 
     call_count = 0
 
@@ -312,3 +318,206 @@ def test_get_progress_reset_only_on_retry(monkeypatch, tmp_path):
     DataGetter.get.__wrapped__(getter, file=file_name, progress=progress, task=task)
 
     assert progress.reset.call_count == 2
+
+
+def test_get_detects_truncated_stream_via_content_length(monkeypatch, tmp_path):
+    """A clean TCP close with fewer bytes than Content-Length must trigger a retry.
+
+    Reproduces the failure mode from the May 2026 ngisthlm02415 incident:
+    requests/urllib3 happily report a "successful" download even when the body
+    is short, so ``get()`` has to validate the byte count itself.
+    """
+    file_name = "file.bin"
+    file_path = tmp_path / file_name
+    # Server says 100 bytes, body delivers 4 — mimics a connection drop
+    # mid-stream where the FIN arrives before the full payload.
+    getter = _prepare_data_getter(file_name=file_name, download_path=file_path, size_stored=100)
+
+    monkeypatch.setattr(constants, "DOWNLOAD_MAX_RETRIES", 3)
+    monkeypatch.setattr(constants, "DOWNLOAD_INITIAL_WAIT", 0)
+
+    truncated_response = _ok_response(body=b"data")
+    truncated_response.headers.get.return_value = 100  # advertised, not delivered
+
+    monkeypatch.setattr("dds_cli.data_getter.requests.get", lambda *_, **__: truncated_response)
+
+    downloaded, message = DataGetter.get.__wrapped__(
+        getter, file=file_name, progress=MagicMock(), task=1
+    )
+
+    # The retry path engaged on every attempt and ultimately gave up.
+    assert downloaded is False
+    assert "Truncated download" in message
+    assert "attempt 1/3" in message
+
+
+def test_get_detects_size_mismatch_against_size_stored(monkeypatch, tmp_path):
+    """If the body size matches Content-Length but not size_stored, still fail.
+
+    This catches the case where a misbehaving S3-compatible backend serves a
+    Content-Length that disagrees with what DDS recorded — we trust the DDS
+    metadata as the source of truth.
+    """
+    file_name = "file.bin"
+    file_path = tmp_path / file_name
+    # DDS expects 100 bytes; the proxy reports and delivers 4 — they agree
+    # with each other but disagree with the catalogue.
+    getter = _prepare_data_getter(file_name=file_name, download_path=file_path, size_stored=100)
+
+    monkeypatch.setattr(constants, "DOWNLOAD_MAX_RETRIES", 2)
+    monkeypatch.setattr(constants, "DOWNLOAD_INITIAL_WAIT", 0)
+
+    # Content-Length matches the 4-byte body, so the truncation guard passes;
+    # the size_stored comparison is the one that has to catch this.
+    consistent_short_response = _ok_response(body=b"data")  # headers.get returns 4
+
+    monkeypatch.setattr(
+        "dds_cli.data_getter.requests.get", lambda *_, **__: consistent_short_response
+    )
+
+    downloaded, message = DataGetter.get.__wrapped__(
+        getter, file=file_name, progress=MagicMock(), task=1
+    )
+
+    assert downloaded is False
+    assert "Size mismatch" in message
+
+
+def test_get_cleans_up_partial_file_on_failure(monkeypatch, tmp_path):
+    """After exhausting retries, the truncated blob must not be left on disk."""
+    file_name = "file.bin"
+    file_path = tmp_path / file_name
+    getter = _prepare_data_getter(file_name=file_name, download_path=file_path, size_stored=100)
+
+    monkeypatch.setattr(constants, "DOWNLOAD_MAX_RETRIES", 2)
+    monkeypatch.setattr(constants, "DOWNLOAD_INITIAL_WAIT", 0)
+
+    truncated_response = _ok_response(body=b"data")
+    truncated_response.headers.get.return_value = 100
+
+    monkeypatch.setattr("dds_cli.data_getter.requests.get", lambda *_, **__: truncated_response)
+
+    DataGetter.get.__wrapped__(getter, file=file_name, progress=MagicMock(), task=1)
+
+    # The point: don't leave a useless 4-byte file masquerading as a download.
+    assert not file_path.exists()
+
+
+def test_get_retries_on_truncation_and_eventually_succeeds(monkeypatch, tmp_path):
+    """A retry after a truncated attempt should produce a complete file."""
+    file_name = "file.bin"
+    file_path = tmp_path / file_name
+    getter = _prepare_data_getter(file_name=file_name, download_path=file_path, size_stored=4)
+
+    monkeypatch.setattr(constants, "DOWNLOAD_MAX_RETRIES", 3)
+    monkeypatch.setattr(constants, "DOWNLOAD_INITIAL_WAIT", 0)
+
+    # First attempt: server claims 4 bytes but only delivers 2 — truncation.
+    truncated = MagicMock()
+    truncated.__enter__.return_value = truncated
+    truncated.__exit__.return_value = False
+    truncated.iter_content.return_value = [b"da"]
+    truncated.raise_for_status.return_value = None
+    truncated.headers.get.return_value = 4
+
+    # Second attempt: clean 4-byte response.
+    full = _ok_response(body=b"data")
+
+    responses = iter([truncated, full])
+    monkeypatch.setattr("dds_cli.data_getter.requests.get", lambda *_, **__: next(responses))
+
+    downloaded, message = DataGetter.get.__wrapped__(
+        getter, file=file_name, progress=MagicMock(), task=1
+    )
+
+    assert downloaded is True
+    assert message == ""
+    assert file_path.read_bytes() == b"data"
+
+
+def test_get_tolerates_missing_or_malformed_content_length(monkeypatch, tmp_path):
+    """Content-Length absent / chunked / garbled must not crash get().
+
+    AWS S3 always returns a clean integer, but S3-compatible backends
+    sometimes use Transfer-Encoding: chunked (no Content-Length header) or
+    sit behind a proxy that rewrites headers. In those cases the
+    Content-Length truncation guard is skipped and we fall back to the
+    size_stored byte-count check, which still catches truncation.
+    """
+    file_name = "file.bin"
+    file_path = tmp_path / file_name
+    # body length matches size_stored, so size_stored check passes;
+    # this test asserts we don't crash on the int() parse alone.
+    getter = _prepare_data_getter(file_name=file_name, download_path=file_path, size_stored=4)
+
+    monkeypatch.setattr(constants, "DOWNLOAD_MAX_RETRIES", 1)
+
+    # Each entry is what req.headers.get("Content-Length", 0) might return
+    # from a misbehaving server: missing (default 0 substituted), chunked
+    # responses surface as None, and garbled values like "abc" come from
+    # broken proxies that concatenate or rewrite headers.
+    for header_value in (0, None, "abc", "12, 12"):
+        response = _ok_response(body=b"data")
+        response.headers.get.return_value = header_value
+
+        monkeypatch.setattr("dds_cli.data_getter.requests.get", lambda *_, **__: response)
+
+        downloaded, message = DataGetter.get.__wrapped__(
+            getter, file=file_name, progress=MagicMock(), task=1
+        )
+
+        assert downloaded is True, f"failed for Content-Length={header_value!r}: {message}"
+
+
+def test_get_warns_user_about_connection_on_exhausted_retries(monkeypatch, tmp_path, caplog):
+    """After all retries fail, get() must emit a user-facing warning suggesting
+    the user check their internet connection and sleep settings."""
+    file_name = "file.bin"
+    file_path = tmp_path / file_name
+    getter = _prepare_data_getter(file_name=file_name, download_path=file_path, size_stored=100)
+
+    monkeypatch.setattr(constants, "DOWNLOAD_MAX_RETRIES", 2)
+    monkeypatch.setattr(constants, "DOWNLOAD_INITIAL_WAIT", 0)
+
+    truncated_response = _ok_response(body=b"data")
+    truncated_response.headers.get.return_value = 100
+    monkeypatch.setattr("dds_cli.data_getter.requests.get", lambda *_, **__: truncated_response)
+
+    with caplog.at_level(logging.WARNING, logger="dds_cli.data_getter"):
+        DataGetter.get.__wrapped__(getter, file=file_name, progress=MagicMock(), task=1)
+
+    warning_texts = " ".join(r.getMessage() for r in caplog.records if r.levelno == logging.WARNING)
+    assert "internet connection" in warning_texts.lower()
+    assert "sleep" in warning_texts.lower()
+
+
+def test_download_and_verify_raises_on_size_contract_violation(tmp_path):
+    """download_and_verify() must raise RuntimeError when get() returns True but
+    the on-disk file doesn't match size_stored.
+
+    This guards against a future get() refactor that silently breaks the size
+    guarantee and would otherwise let a truncated blob reach decryption,
+    reintroducing the failed_op='crypto' misattribution from the May 2026 incident.
+    """
+    file_name = "file.bin"
+    file_path = tmp_path / file_name
+
+    # Write a file that is the wrong size (2 bytes; size_stored expects 100).
+    file_path.write_bytes(b"xx")
+
+    getter = _prepare_data_getter(file_name=file_name, download_path=file_path, size_stored=100)
+    getter.filehandler.data[file_name]["size_original"] = 80
+    getter.silent = False
+
+    # get() incorrectly claims success despite the on-disk size mismatch.
+    getter.get = MagicMock(return_value=(True, ""))
+
+    progress = MagicMock()
+    progress.add_task.return_value = 1
+
+    # Bypass @verify_proceed and @subpath_required to call the raw function directly.
+    with pytest.raises(RuntimeError, match="get\\(\\) returned True but size mismatch"):
+        DataGetter.download_and_verify.__wrapped__.__wrapped__(
+            getter, file=file_name, progress=progress
+        )
+        assert message == ""