nucliadb 2.46.1.post382__py3-none-any.whl → 6.2.1.post2777__py3-none-any.whl

nucliadb/writer/tus/gcs.py

@@ -23,31 +23,33 @@ import asyncio
 import base64
 import json
 import os
+import socket
 import tempfile
 import uuid
 from concurrent.futures import ThreadPoolExecutor
 from copy import deepcopy
-from datetime import datetime
-from typing import AsyncIterator, Optional
+from typing import Optional
 from urllib.parse import quote_plus
 
 import aiohttp
 import backoff
-from nucliadb_protos.resources_pb2 import CloudFile
+import google.auth.compute_engine.credentials  # type: ignore
+import google.auth.transport.requests  # type: ignore
+import google.oauth2.credentials  # type: ignore
+from google.auth.exceptions import DefaultCredentialsError  # type: ignore
 from oauth2client.service_account import ServiceAccountCredentials  # type: ignore
 
 from nucliadb.writer import logger
 from nucliadb.writer.tus.dm import FileDataManager
 from nucliadb.writer.tus.exceptions import (
-    CloudFileNotFound,
     HTTPBadRequest,
-    HTTPNotFound,
     HTTPPreconditionFailed,
     ResumableURINotAvailable,
 )
 from nucliadb.writer.tus.storage import BlobStore, FileStorageManager
 from nucliadb.writer.tus.utils import to_str
-from nucliadb_utils.storages.gcs import CHUNK_SIZE, MIN_UPLOAD_SIZE
+from nucliadb_protos.resources_pb2 import CloudFile
+from nucliadb_utils.storages.gcs import CHUNK_SIZE, MIN_UPLOAD_SIZE, TIMEOUT
 
 
 class GoogleCloudException(Exception):
@@ -61,6 +63,12 @@ MAX_RETRIES = 5
 RETRIABLE_EXCEPTIONS = (
     GoogleCloudException,
     aiohttp.client_exceptions.ClientPayloadError,
+    aiohttp.client_exceptions.ClientConnectorError,
+    aiohttp.client_exceptions.ClientConnectionError,
+    aiohttp.client_exceptions.ClientOSError,
+    aiohttp.client_exceptions.ServerConnectionError,
+    aiohttp.client_exceptions.ServerDisconnectedError,
+    socket.gaierror,
 )
 
 
@@ -69,7 +77,7 @@ class GCloudBlobStore(BlobStore):
     loop = None
     upload_url: str
     object_base_url: str
-    json_credentials: str
+    json_credentials: Optional[str]
     bucket: str
     location: str
     project: str
@@ -83,9 +91,18 @@ class GCloudBlobStore(BlobStore):
         return {"AUTHORIZATION": f"Bearer {token}"}
 
     def _get_access_token(self):
-        access_token = self._credentials.get_access_token()
-        self._creation_access_token = datetime.now()
-        return access_token.access_token
+        if isinstance(
+            self._credentials, google.auth.compute_engine.credentials.Credentials
+        ) or isinstance(self._credentials, google.oauth2.credentials.Credentials):
+            # google default auth object
+            if self._credentials.expired or self._credentials.valid is False:
+                request = google.auth.transport.requests.Request()
+                self._credentials.refresh(request)
+
+            return self._credentials.token
+        else:
+            access_token = self._credentials.get_access_token()
+            return access_token.access_token
 
     async def finalize(self):
         if self.session is not None:
@@ -106,32 +123,35 @@ class GCloudBlobStore(BlobStore):
         self.project = project
         self.bucket_labels = bucket_labels
         self.object_base_url = object_base_url + "/storage/v1/b"
-        self.upload_url = (
-            object_base_url + "/upload/storage/v1/b/{bucket}/o?uploadType=resumable"
-        )  # noqa
-
+        self.upload_url = object_base_url + "/upload/storage/v1/b/{bucket}/o?uploadType=resumable"  # noqa
+        self.json_credentials = json_credentials
         self._credentials = None
 
-        if json_credentials is not None:
-            self.json_credentials_file = os.path.join(
-                tempfile.mkdtemp(), "gcs_credentials.json"
-            )
-            open(self.json_credentials_file, "w").write(
-                base64.b64decode(json_credentials).decode("utf-8")
-            )
+        if self.json_credentials is not None and self.json_credentials.strip() != "":
+            self.json_credentials_file = os.path.join(tempfile.mkdtemp(), "gcs_credentials.json")
+            with open(self.json_credentials_file, "w") as file:
+                file.write(base64.b64decode(self.json_credentials).decode("utf-8"))
             self._credentials = ServiceAccountCredentials.from_json_keyfile_name(
                 self.json_credentials_file, SCOPES
             )
+        else:
+            try:
+                self._credentials, self.project = google.auth.default()
+            except DefaultCredentialsError:
+                logger.warning("Setting up without credentials as couldn't find workload identity")
+                self._credentials = None
 
         loop = asyncio.get_event_loop()
-        self.session = aiohttp.ClientSession(loop=loop)
+        self.session = aiohttp.ClientSession(loop=loop, timeout=TIMEOUT)
 
     async def check_exists(self, bucket_name: str):
         if self.session is None:
             raise AttributeError()
 
         headers = await self.get_access_headers()
-        url = f"{self.object_base_url}/{bucket_name}?project={self.project}"
+        # Using object access url instead of bucket access to avoid
+        # giving admin permission to the SA, needed to GET a bucket
+        url = f"{self.object_base_url}/{bucket_name}/o"
         async with self.session.get(
             url,
             headers=headers,
@@ -170,9 +190,7 @@ class GCloudFileStorageManager(FileStorageManager):
     chunk_size = CHUNK_SIZE
     min_upload_size = MIN_UPLOAD_SIZE
 
-    @backoff.on_exception(
-        backoff.expo, RETRIABLE_EXCEPTIONS, jitter=backoff.random_jitter, max_tries=4
-    )
+    @backoff.on_exception(backoff.expo, RETRIABLE_EXCEPTIONS, jitter=backoff.random_jitter, max_tries=4)
     async def start(self, dm: FileDataManager, path: str, kbid: str):
         """Init an upload.
 
@@ -180,12 +198,15 @@ class GCloudFileStorageManager(FileStorageManager):
         _resumable_uri : uri to resumable upload
         _uri : finished uploaded image
         """
+
         if self.storage.session is None:
             raise AttributeError()
 
-        upload_file_id = dm.get("upload_file_id", str(uuid.uuid4()))
+        upload_file_id = dm.get("upload_file_id")
         if upload_file_id is not None:
             await self.delete_upload(upload_file_id, kbid)
+        else:
+            upload_file_id = str(uuid.uuid4())
 
         bucket = self.storage.get_bucket_name(kbid)
         init_url = "{}&name={}".format(
@@ -230,13 +251,9 @@ class GCloudFileStorageManager(FileStorageManager):
                 raise GoogleCloudException(text)
             resumable_uri = call.headers["Location"]
 
-        await dm.update(
-            resumable_uri=resumable_uri, upload_file_id=upload_file_id, path=path
-        )
+        await dm.update(resumable_uri=resumable_uri, upload_file_id=upload_file_id, path=path)
 
-    @backoff.on_exception(
-        backoff.expo, RETRIABLE_EXCEPTIONS, jitter=backoff.random_jitter, max_tries=4
-    )
+    @backoff.on_exception(backoff.expo, RETRIABLE_EXCEPTIONS, jitter=backoff.random_jitter, max_tries=4)
     async def delete_upload(self, uri, kbid):
         bucket = self.storage.get_bucket_name(kbid)
 
@@ -259,8 +276,7 @@ class GCloudFileStorageManager(FileStorageManager):
                 if resp.status not in (200, 204, 404):
                     if resp.status == 404:
                         logger.error(
-                            f"Attempt to delete not found gcloud: {data}, "
-                            f"status: {resp.status}",
+                            f"Attempt to delete not found gcloud: {data}, " f"status: {resp.status}",
                             exc_info=True,
                         )
                     else:
@@ -268,9 +284,7 @@ class GCloudFileStorageManager(FileStorageManager):
         else:
             raise AttributeError("No valid uri")
 
-    @backoff.on_exception(
-        backoff.expo, RETRIABLE_EXCEPTIONS, jitter=backoff.random_jitter, max_tries=4
-    )
+    @backoff.on_exception(backoff.expo, RETRIABLE_EXCEPTIONS, jitter=backoff.random_jitter, max_tries=4)
     async def _append(self, dm: FileDataManager, data, offset):
         if self.storage.session is None:
             raise AttributeError()
@@ -335,9 +349,7 @@ class GCloudFileStorageManager(FileStorageManager):
                 break
         return count
 
-    @backoff.on_exception(
-        backoff.expo, RETRIABLE_EXCEPTIONS, jitter=backoff.random_jitter, max_tries=4
-    )
+    @backoff.on_exception(backoff.expo, RETRIABLE_EXCEPTIONS, jitter=backoff.random_jitter, max_tries=4)
     async def finish(self, dm: FileDataManager):
         if dm.size == 0:
             if self.storage.session is None:
@@ -363,46 +375,6 @@ class GCloudFileStorageManager(FileStorageManager):
         await dm.finish()
         return path
 
-    async def iter_data(self, uri, kbid: str, headers: Optional[dict[str, str]] = None):
-        if self.storage.session is None:
-            raise AttributeError()
-        if headers is None:
-            headers = {}
-
-        url = "{}/{}/o/{}".format(
-            self.storage.object_base_url,
-            self.storage.get_bucket_name(kbid),
-            quote_plus(uri),
-        )
-        headers_auth = await self.storage.get_access_headers()
-        headers.update(headers_auth)
-        async with self.storage.session.get(
-            url, headers=headers, params={"alt": "media"}, timeout=-1
-        ) as api_resp:
-            if api_resp.status not in (200, 206):
-                text = await api_resp.text()
-                if api_resp.status == 404:
-                    raise CloudFileNotFound("Google cloud file not found")
-                elif api_resp.status == 401:
-                    logger.warning(f"Invalid google cloud credentials error: {text}")
-                    raise HTTPNotFound(
-                        detail=f"Google cloud invalid credentials: {text}"
-                    )
-                raise GoogleCloudException(f"{api_resp.status}: {text}")
-            while True:
-                chunk = await api_resp.content.read(1024 * 1024)
-                if len(chunk) > 0:
-                    yield chunk
-                else:
-                    break
-
-    async def read_range(
-        self, uri: str, kbid: str, start: int, end: int
-    ) -> AsyncIterator[bytes]:
-        """
-        Iterate through ranges of data
-        """
-        async for chunk in self.iter_data(
-            uri, kbid, headers={"Range": f"bytes={start}-{end - 1}"}
-        ):
-            yield chunk
+    def validate_intermediate_chunk(self, uploaded_bytes: int):
+        if uploaded_bytes < self.min_upload_size:
+            raise ValueError(f"Intermediate chunks cannot be smaller than {self.min_upload_size} bytes")

nucliadb/writer/tus/local.py

@@ -22,14 +22,13 @@ from __future__ import annotations
 import json
 import os
 import uuid
-from typing import AsyncIterator
+from typing import Any
 
 import aiofiles
-from nucliadb_protos.resources_pb2 import CloudFile
 
 from nucliadb.writer.tus.dm import FileDataManager
-from nucliadb.writer.tus.exceptions import CloudFileNotFound
 from nucliadb.writer.tus.storage import BlobStore, FileStorageManager
+from nucliadb_protos.resources_pb2 import CloudFile
 from nucliadb_utils.storages import CHUNK_SIZE
 
 
@@ -50,51 +49,24 @@ class LocalFileStorageManager(FileStorageManager):
         bucket = self.storage.get_bucket_name(kbid)
         upload_file_id = dm.get("upload_file_id", str(uuid.uuid4()))
         init_url = self.get_file_path(bucket, upload_file_id)
-        metadata_init_url = self.metadata_key(init_url)
         metadata = {
             "FILENAME": dm.filename,
             "CONTENT_TYPE": dm.content_type,
             "SIZE": dm.size,
         }
-        async with aiofiles.open(metadata_init_url, "w+") as resp:
-            await resp.write(json.dumps(metadata))
+        await self.set_metadata(kbid, upload_file_id, metadata)
 
         async with aiofiles.open(init_url, "wb+") as aio_fi:
             await aio_fi.write(b"")
 
-        await dm.update(upload_file_id=upload_file_id, path=path, bucket=bucket)
+        await dm.update(upload_file_id=upload_file_id, path=path, bucket=bucket, kbid=kbid)
 
-    async def iter_data(self, uri, kbid: str, headers=None):
-        bucket = self.storage.get_bucket_name(kbid)
-        file_path = self.get_file_path(bucket, uri)
-        async with aiofiles.open(file_path) as resp:
-            data = await resp.read(CHUNK_SIZE)
-            while data is not None:
-                yield data
-                data = await resp.read(CHUNK_SIZE)
-
-    async def read_range(
-        self, uri: str, kbid: str, start: int, end: int
-    ) -> AsyncIterator[bytes]:
-        """
-        Iterate through ranges of data
-        """
+    async def set_metadata(self, kbid: str, upload_file_id: str, metadata: dict[str, Any]):
         bucket = self.storage.get_bucket_name(kbid)
-        file_path = self.get_file_path(bucket, uri)
-        try:
-            async with aiofiles.open(file_path, "rb") as resp:
-                await resp.seek(start)
-                count = 0
-                data = await resp.read(CHUNK_SIZE)
-                while data and count < end:
-                    if count + len(data) > end:
-                        new_end = end - count
-                        data = data[:new_end]
-                    yield data
-                    count += len(data)
-                    data = await resp.read(CHUNK_SIZE)
-        except FileNotFoundError:
-            raise CloudFileNotFound()
+        init_url = self.get_file_path(bucket, upload_file_id)
+        metadata_init_url = self.metadata_key(init_url)
+        async with aiofiles.open(metadata_init_url, "w+") as resp:
+            await resp.write(json.dumps(metadata))
 
     async def append(self, dm: FileDataManager, iterable, offset) -> int:
         count = 0
@@ -118,6 +90,15 @@ class LocalFileStorageManager(FileStorageManager):
         upload_file_id = dm.get("upload_file_id")
         from_url = self.get_file_path(bucket, upload_file_id)
 
+        if dm.size > 0:
+            kbid = dm.get("kbid")
+            metadata = {
+                "FILENAME": dm.filename,
+                "CONTENT_TYPE": dm.content_type,
+                "SIZE": dm.size,
+            }
+            await self.set_metadata(kbid, upload_file_id, metadata)
+
         path = dm.get("path")
         to_url = self.get_file_path(bucket, path)
         to_url_dirs = os.path.dirname(to_url)
@@ -138,6 +119,9 @@ class LocalFileStorageManager(FileStorageManager):
         file_path = self.get_file_path(bucket, uri)
         os.remove(file_path)
 
+    def validate_intermediate_chunk(self, uploaded_bytes: int):
+        pass
+
 
 class LocalBlobStore(BlobStore):
     def __init__(self, local_testing_files: str):

nucliadb/writer/tus/s3.py

@@ -19,21 +19,22 @@
 #
 from __future__ import annotations
 
+import base64
 import uuid
 from contextlib import AsyncExitStack
-from typing import AsyncIterator, Optional
+from typing import Optional
 
 import aiobotocore  # type: ignore
 import aiohttp
-import backoff  # type: ignore
+import backoff
 import botocore  # type: ignore
 from aiobotocore.session import AioSession  # type: ignore
-from nucliadb_protos.resources_pb2 import CloudFile
 
 from nucliadb.writer import logger
 from nucliadb.writer.tus.dm import FileDataManager
-from nucliadb.writer.tus.exceptions import CloudFileNotFound, ResumableURINotAvailable
+from nucliadb.writer.tus.exceptions import ResumableURINotAvailable
 from nucliadb.writer.tus.storage import BlobStore, FileStorageManager
+from nucliadb_protos.resources_pb2 import CloudFile
 from nucliadb_utils.storages.s3 import (
     CHUNK_SIZE,
     MIN_UPLOAD_SIZE,
@@ -53,9 +54,7 @@ class S3FileStorageManager(FileStorageManager):
     chunk_size = CHUNK_SIZE
     min_upload_size = MIN_UPLOAD_SIZE
 
-    @backoff.on_exception(
-        backoff.expo, RETRIABLE_EXCEPTIONS, jitter=backoff.random_jitter, max_tries=3
-    )
+    @backoff.on_exception(backoff.expo, RETRIABLE_EXCEPTIONS, jitter=backoff.random_jitter, max_tries=3)
     async def _abort_multipart(self, dm: FileDataManager):
         try:
             mpu = dm.get("mpu")
@@ -72,21 +71,25 @@ class S3FileStorageManager(FileStorageManager):
         if dm.get("mpu") is not None:
             await self._abort_multipart(dm)
 
+        custom_metadata: dict[str, str] = {
+            "base64_filename": base64.b64encode((dm.filename or "").encode()).decode(),
+            "content_type": dm.content_type or "",
+            "size": str(dm.size),
+        }
+
         await dm.update(
             path=path,
             upload_file_id=upload_file_id,
             multipart={"Parts": []},
             block=1,
-            mpu=await self._create_multipart(path, bucket),
+            mpu=await self._create_multipart(path, bucket, custom_metadata),
             bucket=bucket,
         )
 
-    @backoff.on_exception(
-        backoff.expo, RETRIABLE_EXCEPTIONS, jitter=backoff.random_jitter, max_tries=3
-    )
-    async def _create_multipart(self, path, bucket):
+    @backoff.on_exception(backoff.expo, RETRIABLE_EXCEPTIONS, jitter=backoff.random_jitter, max_tries=3)
+    async def _create_multipart(self, path, bucket, custom_metadata: dict[str, str]):
         return await self.storage._s3aioclient.create_multipart_upload(
-            Bucket=bucket, Key=path
+            Bucket=bucket, Key=path, Metadata=custom_metadata
         )
 
     async def append(self, dm: FileDataManager, iterable, offset) -> int:
@@ -96,16 +99,12 @@ class S3FileStorageManager(FileStorageManager):
             size += len(chunk)
             part = await self._upload_part(dm, chunk)
             multipart = dm.get("multipart")
-            multipart["Parts"].append(
-                {"PartNumber": dm.get("block"), "ETag": part["ETag"]}
-            )
+            multipart["Parts"].append({"PartNumber": dm.get("block"), "ETag": part["ETag"]})
             await dm.update(multipart=multipart, block=dm.get("block") + 1)
 
         return size
 
-    @backoff.on_exception(
-        backoff.expo, RETRIABLE_EXCEPTIONS, jitter=backoff.random_jitter, max_tries=3
-    )
+    @backoff.on_exception(backoff.expo, RETRIABLE_EXCEPTIONS, jitter=backoff.random_jitter, max_tries=3)
     async def _upload_part(self, dm: FileDataManager, data):
         mpu = dm.get("mpu")
         if mpu is None:
@@ -128,18 +127,14 @@ class S3FileStorageManager(FileStorageManager):
         await dm.finish()
         return path
 
-    @backoff.on_exception(
-        backoff.expo, RETRIABLE_EXCEPTIONS, jitter=backoff.random_jitter, max_tries=3
-    )
+    @backoff.on_exception(backoff.expo, RETRIABLE_EXCEPTIONS, jitter=backoff.random_jitter, max_tries=3)
     async def _complete_multipart_upload(self, dm: FileDataManager):
         # if blocks is 0, it means the file is of zero length so we need to
         # trick it to finish a multiple part with no data.
         if dm.get("block") == 1:
             part = await self._upload_part(dm, b"")
             multipart = dm.get("multipart")
-            multipart["Parts"].append(
-                {"PartNumber": dm.get("block"), "ETag": part["ETag"]}
-            )
+            multipart["Parts"].append({"PartNumber": dm.get("block"), "ETag": part["ETag"]})
             await dm.update(multipart=multipart, block=dm.get("block") + 1)
         await self.storage._s3aioclient.complete_multipart_upload(
             Bucket=dm.get("bucket"),
@@ -148,45 +143,10 @@ class S3FileStorageManager(FileStorageManager):
             MultipartUpload=dm.get("multipart"),
         )
 
-    @backoff.on_exception(
-        backoff.expo, RETRIABLE_EXCEPTIONS, jitter=backoff.random_jitter, max_tries=3
-    )
+    @backoff.on_exception(backoff.expo, RETRIABLE_EXCEPTIONS, jitter=backoff.random_jitter, max_tries=3)
     async def _download(self, uri: str, kbid: str, **kwargs):
         bucket = self.storage.get_bucket_name(kbid)
-        return await self.storage._s3aioclient.get_object(
-            Bucket=bucket, Key=uri, **kwargs
-        )
-
-    async def iter_data(
-        self, uri: str, kbid: str, headers: Optional[dict[str, str]] = None
-    ):
-        if headers is None:
-            headers = {}
-        try:
-            downloader = await self._download(uri, kbid, **headers)
-        except self.storage._s3aioclient.exceptions.NoSuchKey:
-            raise CloudFileNotFound()
-
-        # we do not want to timeout ever from this...
-        # downloader['Body'].set_socket_timeout(999999)
-        stream = downloader["Body"]
-        data = await stream.read(CHUNK_SIZE)
-        while True:
-            if not data:
-                break
-            yield data
-            data = await stream.read(CHUNK_SIZE)
-
-    async def read_range(
-        self, uri, kbid: str, start: int, end: int
-    ) -> AsyncIterator[bytes]:
-        """
-        Iterate through ranges of data
-        """
-        async for chunk in self.iter_data(
-            uri, kbid, headers={"Range": f"bytes={start}-{end - 1}"}
-        ):
-            yield chunk
+        return await self.storage._s3aioclient.get_object(Bucket=bucket, Key=uri, **kwargs)
 
     async def delete_upload(self, uri: str, kbid: str):
         bucket = self.storage.get_bucket_name(kbid)
@@ -198,6 +158,10 @@ class S3FileStorageManager(FileStorageManager):
         else:
             raise AttributeError("No valid uri")
 
+    def validate_intermediate_chunk(self, uploaded_bytes: int):
+        if uploaded_bytes % self.min_upload_size != 0:
+            raise ValueError(f"Intermediate chunks need to be multiples of {self.min_upload_size} bytes")
+
 
 class S3BlobStore(BlobStore):
     async def check_exists(self, bucket_name: str) -> bool:
@@ -213,9 +177,7 @@ class S3BlobStore(BlobStore):
     async def create_bucket(self, bucket):
         exists = await self.check_exists(bucket)
         if not exists:
-            await create_bucket(
-                self._s3aioclient, bucket, self.bucket_tags, self.region_name
-            )
+            await create_bucket(self._s3aioclient, bucket, self.bucket_tags, self.region_name)
         return exists
 
     async def finalize(self):
@@ -247,9 +209,7 @@ class S3BlobStore(BlobStore):
             verify=verify_ssl,
             use_ssl=ssl,
             region_name=region_name,
-            config=aiobotocore.config.AioConfig(
-                None, max_pool_connections=max_pool_connections
-            ),
+            config=aiobotocore.config.AioConfig(None, max_pool_connections=max_pool_connections),
         )
         session = AioSession()
         self._s3aioclient = await self._exit_stack.enter_async_context(

nucliadb/writer/tus/storage.py

@@ -21,15 +21,8 @@ from __future__ import annotations
 
 from typing import AsyncIterator, Optional
 
-from lru import LRU  # type: ignore
-from nucliadb_protos.resources_pb2 import CloudFile
-from starlette.responses import StreamingResponse
-
-from nucliadb.writer import logger
 from nucliadb.writer.tus.dm import FileDataManager
-from nucliadb.writer.tus.exceptions import HTTPRangeNotSatisfiable
-
-CACHED_BUCKETS = LRU(50)  # type: ignore
+from nucliadb_protos.resources_pb2 import CloudFile
 
 
 class BlobStore:
@@ -56,14 +49,9 @@ class FileStorageManager:
     chunk_size: int
     min_upload_size: Optional[int] = None
 
-    def __init__(self, storage):
+    def __init__(self, storage: BlobStore):
         self.storage = storage
 
-    def read_range(
-        self, uri: str, kbid: str, start: int, end: int
-    ) -> AsyncIterator[bytes]:
-        raise NotImplementedError()
-
     def iter_data(
         self, uri: str, kbid: str, headers: Optional[dict[str, str]] = None
     ) -> AsyncIterator[bytes]:
@@ -81,48 +69,6 @@ class FileStorageManager:
     async def delete_upload(self, uri, kbid):
         raise NotImplementedError()
 
-    async def full_download(self, content_length, content_type, upload_id):
-        return StreamingResponse(
-            self.iter_data(upload_id),
-            media_type=content_type,
-            headers={
-                "Content-Length": str(content_length),
-                "Content-Type": content_type,
-            },
-        )
-
-    async def range_download(
-        self, content_length, content_type, upload_id, range_header
-    ):
-        try:
-            start, _, end = range_header.split("bytes=")[-1].partition("-")
-            start = int(start)
-            if len(end) == 0:
-                # bytes=0- is valid
-                end = content_length - 1
-            end = int(end) + 1  # python is inclusive, http is exclusive
-        except (IndexError, ValueError):
-            # range errors fallback to full download
-            raise HTTPRangeNotSatisfiable(detail=f"Range not parsable {range_header}")
-        if start > end or start < 0:
-            raise HTTPRangeNotSatisfiable(detail="Invalid range {start}-{end}")
-        if end > content_length:
-            raise HTTPRangeNotSatisfiable(
-                detail="Invalid range {start}-{end}, too large end value"
-            )
-
-        logger.debug(f"Range request: {range_header}")
-        headers = {
-            "Content-Range": f"bytes {start}-{end - 1}/{content_length}",
-            "Content-Type": content_type,
-        }
-
-        return StreamingResponse(
-            self.read_range(upload_id, start, end),
-            media_type=content_type,
-            headers=headers,
-        )
-
     async def iterate_body_chunks(self, request, chunk_size):
         partial = b""
         remaining = b""
@@ -146,3 +92,6 @@ class FileStorageManager:
 
         if partial or remaining:
             yield partial + remaining
+
+    def validate_intermediate_chunk(self, uploaded_bytes: int):
+        raise NotImplementedError()