safe-s3-storage 0.1.0__tar.gz

safe_s3_storage-0.1.0/.github/dependabot.yml

@@ -0,0 +1,6 @@
+version: 2
+updates:
+  - package-ecosystem: github-actions
+    directory: /
+    schedule:
+      interval: monthly

safe_s3_storage-0.1.0/.github/workflows/workflow.yml

@@ -0,0 +1,19 @@
+name: CI Pipeline
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+  release:
+    types:
+      - published
+
+jobs:
+  ci:
+    uses: community-of-python/community-workflow/.github/workflows/preset.yml@main
+    with:
+      python-version: '["3.12","3.13"]'
+    secrets: inherit

safe_s3_storage-0.1.0/.gitignore

@@ -0,0 +1,7 @@
+.coverage
+.venv
+dist
+uv.lock
+.mypy_cache
+.ruff_cache
+__pycache__

safe_s3_storage-0.1.0/Justfile

@@ -0,0 +1,25 @@
+default: install lint test
+
+install:
+    uv lock --upgrade
+    uv sync --frozen --all-groups
+
+lint:
+    uv run --group lint auto-typing-final .
+    uv run --group lint ruff check
+    uv run --group lint ruff format
+    uv run --group lint mypy .
+
+lint-ci:
+    uv run --group lint auto-typing-final .
+    uv run --group lint ruff format --check
+    uv run --group lint ruff check --no-fix
+    uv run --group lint mypy .
+
+test *args:
+    uv run pytest {{ args }}
+
+publish:
+    rm -rf dist
+    uv build
+    uv publish --token $PYPI_TOKEN

safe_s3_storage-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Community of python
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

safe_s3_storage-0.1.0/PKG-INFO

@@ -0,0 +1,34 @@
+Metadata-Version: 2.4
+Name: safe-s3-storage
+Version: 0.1.0
+Summary: S3 safe storage
+Author: community-of-python
+License-File: LICENSE
+Keywords: antivirus,kaspersky,s3,upload
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Communications :: File Sharing
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Requires-Dist: aioboto3
+Requires-Dist: httpx
+Requires-Dist: puremagic
+Requires-Dist: pydantic
+Requires-Dist: pyvips
+Requires-Dist: pyvips-binary
+Requires-Dist: stamina
+Requires-Dist: types-aioboto3[s3]
+Description-Content-Type: text/markdown
+
+# safe-s3-storage
+
+S3 tools for uploading files to S3 safely (antivirus check, etc) as well as downloading and deleting files.
+
+## How To Use
+
+```
+uv add safe-s3-storage
+poetry add safe-s3-storage
+```

safe_s3_storage-0.1.0/README.md

@@ -0,0 +1,10 @@
+# safe-s3-storage
+
+S3 tools for uploading files to S3 safely (antivirus check, etc) as well as downloading and deleting files.
+
+## How To Use
+
+```
+uv add safe-s3-storage
+poetry add safe-s3-storage
+```

safe_s3_storage-0.1.0/pyproject.toml

@@ -0,0 +1,77 @@
+[project]
+name = "safe-s3-storage"
+description = "S3 safe storage"
+readme = "README.md"
+keywords = ["s3", "kaspersky", "antivirus", "upload"]
+classifiers = [
+    "Natural Language :: English",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries",
+    "Topic :: Communications :: File Sharing",
+    "Typing :: Typed",
+]
+authors = [{ name = "community-of-python" }]
+dynamic = ["version"]
+requires-python = ">=3.12"
+dependencies = [
+    "httpx",
+    "aioboto3",
+    "types-aioboto3[s3]",
+    "stamina",
+    "pydantic",
+    "pyvips",
+    "pyvips-binary",
+    "puremagic",
+]
+
+[dependency-groups]
+dev = ["anyio", "faker", "pytest", "pytest-cov"]
+lint = [{ include-group = "dev" }, "auto-typing-final", "mypy", "ruff"]
+
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[tool.hatch.version]
+source = "vcs"
+
+[tool.ruff]
+fix = true
+unsafe-fixes = true
+line-length = 120
+
+[tool.ruff.format]
+docstring-code-format = true
+
+[tool.ruff.lint]
+select = ["ALL"]
+ignore = [
+    "EM",
+    "FBT",
+    "TRY003",
+    "D1",
+    "D203",
+    "D213",
+    "G004",
+    "FA",
+    "COM812",
+    "ISC001",
+]
+
+[tool.ruff.lint.isort]
+no-lines-before = ["standard-library", "local-folder"]
+known-third-party = []
+known-local-folder = []
+lines-after-imports = 2
+
+[tool.ruff.lint.extend-per-file-ignores]
+"tests/*.py" = ["S101", "S311"]
+
+[tool.pytest.ini_options]
+addopts = "--cov=."
+
+[tool.coverage.report]
+skip_covered = true
+show_missing = true
+exclude_also = ["if typing.TYPE_CHECKING:"]

safe_s3_storage-0.1.0/safe_s3_storage/__init__.py

@@ -0,0 +1,17 @@
+from safe_s3_storage import exceptions
+from safe_s3_storage.file_validator import FileValidator, ImageConversionFormat, ValidatedFile
+from safe_s3_storage.kaspersky_scan_engine import KasperskyScanEngineClient
+from safe_s3_storage.s3_base import BaseS3Service
+from safe_s3_storage.s3_upload import SafeS3FilesUploader, UploadedFile
+
+
+__all__ = [
+    "BaseS3Service",
+    "FileValidator",
+    "ImageConversionFormat",
+    "KasperskyScanEngineClient",
+    "SafeS3FilesUploader",
+    "UploadedFile",
+    "ValidatedFile",
+    "exceptions",
+]

safe_s3_storage-0.1.0/safe_s3_storage/exceptions.py

@@ -0,0 +1,33 @@
+import dataclasses
+
+
+@dataclasses.dataclass
+class BaseError(Exception):
+    def __str__(self) -> str:
+        return self.__repr__().replace(self.__class__.__name__, "")
+
+
+@dataclasses.dataclass
+class KasperskyScanEngineThreatDetectedError(BaseError):
+    response: bytes
+    file_name: str
+
+
+@dataclasses.dataclass
+class NotAllowedMimeTypeError(BaseError):
+    file_name: str
+    mime_type: str
+    allowed_mime_types: list[str]
+
+
+@dataclasses.dataclass
+class TooLargeFileError(BaseError):
+    file_name: str
+    mime_type: str
+    max_size: int
+
+
+@dataclasses.dataclass
+class FailedToConvertImageError(BaseError):
+    file_name: str
+    mime_type: str

safe_s3_storage-0.1.0/safe_s3_storage/file_validator.py

@@ -0,0 +1,108 @@
+import dataclasses
+import enum
+import typing
+
+import puremagic
+import pyvips  # type: ignore[import-untyped]
+
+from safe_s3_storage import exceptions
+from safe_s3_storage.kaspersky_scan_engine import KasperskyScanEngineClient
+
+
+@dataclasses.dataclass(kw_only=True, slots=True, frozen=True)
+class ValidatedFile:
+    file_name: str
+    file_content: bytes
+    file_size: int
+    mime_type: str
+
+
+def _is_image(mime_type: str) -> bool:
+    return mime_type.startswith("image/")
+
+
+class ImageConversionFormat(enum.Enum):
+    # mime type, file extension
+    jpeg = ("image/jpeg", "jpg")
+    webp = ("image/webp", "webp")
+
+
+def _split_file_base_name_and_extensions(file_name: str) -> tuple[str, str | None]:
+    split_result: typing.Final = file_name.rsplit(".", 1) or [file_name]
+    return split_result[0], None if len(split_result) == 1 else split_result[1]
+
+
+@dataclasses.dataclass(kw_only=True, slots=True, frozen=True)
+class FileValidator:
+    kaspersky_scan_engine: KasperskyScanEngineClient | None = None
+    allowed_mime_types: list[str]
+    scan_images_with_antivirus: bool = True
+    max_file_size_bytes: int = 10 * 1024 * 1024  # 10 MB
+    max_image_size_bytes: int = 50 * 1024 * 1024  # 50 MB
+    image_conversion_format: ImageConversionFormat = ImageConversionFormat.webp
+    image_quality: int = 85
+
+    def _validate_mime_type(self, *, file_name: str, file_content: bytes) -> str:
+        try:
+            mime_type = puremagic.from_string(file_content, mime=True)
+        except puremagic.PureError:
+            # unlike python-magic, puremagic doesn't recognize if text is binary
+            try:
+                file_content.decode()
+            except UnicodeDecodeError:
+                mime_type = "application/octet-stream"
+            else:
+                mime_type = "text/plain"
+        if mime_type in self.allowed_mime_types:
+            return mime_type
+        raise exceptions.NotAllowedMimeTypeError(
+            file_name=file_name, mime_type=mime_type, allowed_mime_types=self.allowed_mime_types
+        )
+
+    def _validate_file_size(self, *, file_name: str, file_content: bytes, mime_type: str) -> int:
+        content_size: typing.Final = len(file_content)
+        max_size: typing.Final = self.max_image_size_bytes if _is_image(mime_type) else self.max_file_size_bytes
+        if content_size > max_size:
+            raise exceptions.TooLargeFileError(file_name=file_name, mime_type=mime_type, max_size=max_size)
+        return content_size
+
+    def _convert_image(self, validated_file: ValidatedFile) -> ValidatedFile:
+        if not _is_image(validated_file.mime_type):
+            return validated_file
+
+        try:
+            pyvips_image: typing.Final[pyvips.Image] = pyvips.Image.new_from_buffer(
+                validated_file.file_content, options=""
+            )
+            new_file_content: typing.Final = typing.cast(
+                "bytes",
+                pyvips_image.write_to_buffer(f".{self.image_conversion_format.value[1]}", Q=self.image_quality),
+            )
+        except pyvips.Error as pyvips_error:
+            raise exceptions.FailedToConvertImageError(
+                file_name=validated_file.file_name, mime_type=validated_file.mime_type
+            ) from pyvips_error
+
+        file_base_name, _file_extension = _split_file_base_name_and_extensions(validated_file.file_name)
+        return ValidatedFile(
+            file_name=f"{file_base_name}.{self.image_conversion_format.value[1]}",
+            file_content=new_file_content,
+            file_size=len(new_file_content),
+            mime_type=self.image_conversion_format.value[0],
+        )
+
+    async def validate_file(self, *, file_name: str, file_content: bytes) -> ValidatedFile:
+        mime_type: typing.Final = self._validate_mime_type(file_name=file_name, file_content=file_content)
+        file_size: typing.Final = self._validate_file_size(
+            file_name=file_name, file_content=file_content, mime_type=mime_type
+        )
+        validated_file: typing.Final = self._convert_image(
+            ValidatedFile(file_name=file_name, file_content=file_content, mime_type=mime_type, file_size=file_size)
+        )
+        if self.kaspersky_scan_engine:
+            is_image: typing.Final = _is_image(validated_file.mime_type)
+            if (is_image and self.scan_images_with_antivirus) or not is_image:
+                await self.kaspersky_scan_engine.scan_memory(
+                    file_name=validated_file.file_name, file_content=validated_file.file_content
+                )
+        return validated_file

safe_s3_storage-0.1.0/safe_s3_storage/kaspersky_scan_engine.py

@@ -0,0 +1,55 @@
+import base64
+import dataclasses
+import enum
+import typing
+
+import httpx
+import pydantic
+import stamina
+
+from safe_s3_storage.exceptions import KasperskyScanEngineThreatDetectedError
+
+
+class KasperskyScanEngineRequest(pydantic.BaseModel):
+    timeout: str
+    object: str
+    name: str
+
+
+# https://support.kaspersky.ru/scan-engine/2.1/193001
+class KasperskyScanEngineScanResult(enum.StrEnum):
+    CLEAN = enum.auto()
+    DETECT = enum.auto()
+    DISINFECTED = enum.auto()
+    DELETED = enum.auto()
+    NON_SCANNED = enum.auto()
+    SERVER_ERROR = enum.auto()
+
+
+class KasperskyScanEngineResponse(pydantic.BaseModel):
+    scanResult: KasperskyScanEngineScanResult  # noqa: N815
+
+
+@dataclasses.dataclass(kw_only=True, slots=True, frozen=True)
+class KasperskyScanEngineClient:
+    httpx_client: httpx.AsyncClient
+    service_url: str
+    client_name: str
+    timeout_ms: int = 10000
+    max_retries: int = 3
+
+    async def _send_scan_memory_request(self, payload: dict[str, typing.Any]) -> bytes:
+        response: typing.Final = await self.httpx_client.post(url=self.service_url, json=payload)
+        response.raise_for_status()
+        return response.content
+
+    async def scan_memory(self, *, file_name: str, file_content: bytes) -> None:
+        payload: typing.Final = KasperskyScanEngineRequest(
+            timeout=str(self.timeout_ms), object=base64.b64encode(file_content).decode(), name=self.client_name
+        ).model_dump(mode="json")
+        response: typing.Final = await stamina.retry(on=httpx.HTTPError, attempts=self.max_retries)(
+            self._send_scan_memory_request
+        )(payload)
+        validated_response: typing.Final = KasperskyScanEngineResponse.model_validate_json(response)
+        if validated_response.scanResult == KasperskyScanEngineScanResult.DETECT:
+            raise KasperskyScanEngineThreatDetectedError(response=response, file_name=file_name)

safe_s3_storage-0.1.0/safe_s3_storage/s3_base.py

@@ -0,0 +1,10 @@
+import dataclasses
+
+from types_aiobotocore_s3 import S3Client
+
+
+@dataclasses.dataclass(kw_only=True, slots=True, frozen=True)
+class BaseS3Service:
+    s3_client: S3Client
+    bucket_name: str
+    max_retries: int = 3

safe_s3_storage-0.1.0/safe_s3_storage/s3_upload.py

@@ -0,0 +1,43 @@
+import dataclasses
+import typing
+
+import botocore
+import botocore.exceptions
+import stamina
+
+from safe_s3_storage.file_validator import FileValidator, ValidatedFile
+from safe_s3_storage.s3_base import BaseS3Service
+
+
+@dataclasses.dataclass(kw_only=True, slots=True, frozen=True)
+class UploadedFile(ValidatedFile):
+    s3_path: str
+
+
+@dataclasses.dataclass(kw_only=True, slots=True, frozen=True)
+class SafeS3FilesUploader(BaseS3Service):
+    file_validator: FileValidator
+    s3_key_generator: typing.Callable[[ValidatedFile], str] = lambda file_context: file_context.file_name
+    s3_metadata_generator: typing.Callable[[ValidatedFile], typing.Mapping[str, str]] = lambda _file_context: {}
+
+    async def upload_file(self, *, file_name: str, file_content: bytes) -> UploadedFile:
+        validated_file: typing.Final = await self.file_validator.validate_file(
+            file_name=file_name, file_content=file_content
+        )
+        s3_key: typing.Final = self.s3_key_generator(validated_file)
+
+        await stamina.retry(on=botocore.exceptions.BotoCoreError, attempts=self.max_retries)(self.s3_client.put_object)(
+            Body=validated_file.file_content,
+            Bucket=self.bucket_name,
+            Key=s3_key,
+            ContentType=validated_file.mime_type,
+            Metadata=self.s3_metadata_generator(validated_file),
+        )
+
+        return UploadedFile(
+            file_name=validated_file.file_name,
+            file_content=validated_file.file_content,
+            file_size=validated_file.file_size,
+            mime_type=validated_file.mime_type,
+            s3_path=f"{self.bucket_name}/{s3_key}",
+        )

safe_s3_storage-0.1.0/tests/conftest.py

@@ -0,0 +1,22 @@
+import typing
+
+import faker
+import pytest
+import stamina
+
+
+@pytest.fixture(scope="session", autouse=True)
+def anyio_backend() -> str:
+    return "asyncio"
+
+
+@pytest.fixture(scope="session", autouse=True)
+def deactivate_retries() -> None:
+    stamina.set_active(False)
+
+
+MIME_OCTET_STREAM: typing.Final = "application/octet-stream"
+
+
+def generate_binary_content(faker: faker.Faker) -> bytes:
+    return faker.binary(length=faker.pyint(min_value=10, max_value=100))

safe_s3_storage-0.1.0/tests/test_exceptions.py

@@ -0,0 +1,15 @@
+import typing
+
+import faker
+
+from safe_s3_storage.exceptions import KasperskyScanEngineThreatDetectedError
+from tests.conftest import generate_binary_content
+
+
+def test_exception_str(faker: faker.Faker) -> None:
+    response: typing.Final = generate_binary_content(faker)
+    file_name: typing.Final = faker.file_name()
+    assert (
+        str(KasperskyScanEngineThreatDetectedError(response=response, file_name=file_name))
+        == f"({response=}, {file_name=})"
+    )

safe_s3_storage-0.1.0/tests/test_file_validator.py

@@ -0,0 +1,146 @@
+import random
+import typing
+
+import faker
+import httpx
+import pytest
+
+from safe_s3_storage import exceptions
+from safe_s3_storage.file_validator import FileValidator, ImageConversionFormat
+from safe_s3_storage.kaspersky_scan_engine import (
+    KasperskyScanEngineClient,
+    KasperskyScanEngineResponse,
+    KasperskyScanEngineScanResult,
+)
+from tests.conftest import MIME_OCTET_STREAM, generate_binary_content
+
+
+@pytest.fixture
+def png_file() -> bytes:
+    return (
+        b"\x89PNG\r\n\x1a\n"  # PNG signature
+        b"\x00\x00\x00\r"  # IHDR chunk length
+        b"IHDR"  # IHDR chunk type
+        b"\x00\x00\x00\x01"  # width: 1
+        b"\x00\x00\x00\x01"  # height: 1
+        b"\x08"  # bit depth: 8
+        b"\x06"  # color type: RGBA
+        b"\x00"  # compression method
+        b"\x00"  # filter method
+        b"\x00"  # interlace method
+        b"\x1f\x15\xc4\x89"  # CRC for IHDR
+        b"\x00\x00\x00\x0a"  # IDAT chunk length
+        b"IDAT"  # IDAT chunk type
+        b"\x78\x9c\x63\x60\x00\x00\x00\x02\x00\x01"  # compressed image data (deflate)
+        b"\x5d\xc6\x2d\xb4"  # CRC for IDAT
+        b"\x00\x00\x00\x00"  # IEND chunk length
+        b"IEND"  # IEND chunk type
+        b"\xae\x42\x60\x82"  # CRC for IEND
+    )
+
+
+def get_mocked_kaspersky_scan_engine_client(*, faker: faker.Faker, ok_response: bool) -> KasperskyScanEngineClient:
+    if ok_response:
+        all_scan_results: typing.Final[list[KasperskyScanEngineScanResult]] = list(KasperskyScanEngineScanResult)
+        all_scan_results.remove(KasperskyScanEngineScanResult.DETECT)
+        scan_result = random.choice(all_scan_results)
+    else:
+        scan_result = KasperskyScanEngineScanResult.DETECT
+
+    scan_response: typing.Final = KasperskyScanEngineResponse(scanResult=scan_result)
+    return KasperskyScanEngineClient(
+        service_url=faker.url(schemes=["http"]),
+        client_name=faker.pystr(),
+        httpx_client=httpx.AsyncClient(
+            transport=httpx.MockTransport(lambda _: httpx.Response(200, json=scan_response.model_dump(mode="json")))
+        ),
+    )
+
+
+class TestFileValidator:
+    async def test_fails_to_validate_mime_type(self, faker: faker.Faker) -> None:
+        with pytest.raises(exceptions.NotAllowedMimeTypeError):
+            await FileValidator(allowed_mime_types=["image/jpeg"]).validate_file(
+                file_name=faker.file_name(), file_content=generate_binary_content(faker)
+            )
+
+    async def test_fails_to_validate_file_size(self, faker: faker.Faker) -> None:
+        with pytest.raises(exceptions.TooLargeFileError):
+            await FileValidator(allowed_mime_types=[MIME_OCTET_STREAM], max_file_size_bytes=0).validate_file(
+                file_name=faker.file_name(), file_content=generate_binary_content(faker)
+            )
+
+    async def test_fails_to_validate_image_size(self, faker: faker.Faker, png_file: bytes) -> None:
+        with pytest.raises(exceptions.TooLargeFileError):
+            await FileValidator(allowed_mime_types=["image/png"], max_image_size_bytes=0).validate_file(
+                file_name=faker.file_name(), file_content=png_file
+            )
+
+    async def test_fails_to_convert_image(self, faker: faker.Faker, png_file: bytes) -> None:
+        with pytest.raises(exceptions.FailedToConvertImageError):
+            await FileValidator(allowed_mime_types=["image/png"]).validate_file(
+                file_name=faker.file_name(), file_content=png_file[:50]
+            )
+
+    @pytest.mark.parametrize("image_conversion_format", list(ImageConversionFormat))
+    async def test_ok_image(
+        self, faker: faker.Faker, png_file: bytes, image_conversion_format: ImageConversionFormat
+    ) -> None:
+        file_base_name: typing.Final = faker.pystr()
+
+        validated_file: typing.Final = await FileValidator(
+            allowed_mime_types=["image/png"], image_conversion_format=image_conversion_format
+        ).validate_file(file_name=f"{file_base_name}.{faker.file_extension()}", file_content=png_file)
+
+        assert validated_file.file_name == f"{file_base_name}.{image_conversion_format.value[1]}"
+        assert validated_file.file_content != png_file
+        assert validated_file.file_size == len(validated_file.file_content)
+        assert validated_file.mime_type == image_conversion_format.value[0]
+
+    @pytest.mark.parametrize("binary", [True, False])
+    async def test_ok_not_image(self, faker: faker.Faker, binary: bool) -> None:
+        file_name: typing.Final = faker.file_name()
+        file_content: typing.Final = generate_binary_content(faker) if binary else faker.pystr().encode()
+
+        validated_file: typing.Final = await FileValidator(
+            allowed_mime_types=[MIME_OCTET_STREAM if binary else "text/plain"]
+        ).validate_file(file_name=file_name, file_content=file_content)
+
+        assert validated_file.file_name == file_name
+        assert validated_file.file_content == file_content
+        assert validated_file.file_size == len(file_content)
+        assert validated_file.mime_type == MIME_OCTET_STREAM if binary else "text/plain"
+
+    @pytest.mark.parametrize("ok_response", [True, False])
+    async def test_antivirus_skips_images(self, faker: faker.Faker, png_file: bytes, ok_response: bool) -> None:
+        await FileValidator(
+            kaspersky_scan_engine=get_mocked_kaspersky_scan_engine_client(faker=faker, ok_response=ok_response),
+            scan_images_with_antivirus=False,
+            allowed_mime_types=["image/png"],
+        ).validate_file(file_name=faker.file_name(), file_content=png_file)
+
+    async def test_antivirus_fails_on_files(self, faker: faker.Faker) -> None:
+        with pytest.raises(exceptions.KasperskyScanEngineThreatDetectedError):
+            await FileValidator(
+                kaspersky_scan_engine=get_mocked_kaspersky_scan_engine_client(faker=faker, ok_response=False),
+                allowed_mime_types=[MIME_OCTET_STREAM],
+            ).validate_file(file_name=faker.file_name(), file_content=generate_binary_content(faker))
+
+    async def test_antivirus_fails_on_images(self, faker: faker.Faker, png_file: bytes) -> None:
+        with pytest.raises(exceptions.KasperskyScanEngineThreatDetectedError):
+            await FileValidator(
+                kaspersky_scan_engine=get_mocked_kaspersky_scan_engine_client(faker=faker, ok_response=False),
+                allowed_mime_types=["image/png"],
+            ).validate_file(file_name=faker.file_name(), file_content=png_file)
+
+    async def test_antivirus_passes_on_files(self, faker: faker.Faker) -> None:
+        await FileValidator(
+            kaspersky_scan_engine=get_mocked_kaspersky_scan_engine_client(faker=faker, ok_response=True),
+            allowed_mime_types=[MIME_OCTET_STREAM],
+        ).validate_file(file_name=faker.file_name(), file_content=generate_binary_content(faker))
+
+    async def test_antivirus_passes_on_images(self, faker: faker.Faker, png_file: bytes) -> None:
+        await FileValidator(
+            kaspersky_scan_engine=get_mocked_kaspersky_scan_engine_client(faker=faker, ok_response=True),
+            allowed_mime_types=["image/png"],
+        ).validate_file(file_name=faker.file_name(), file_content=png_file)

safe_s3_storage-0.1.0/tests/test_s3_upload.py

@@ -0,0 +1,67 @@
+import typing
+from unittest import mock
+
+import faker
+
+from safe_s3_storage.file_validator import FileValidator
+from safe_s3_storage.s3_upload import SafeS3FilesUploader, UploadedFile
+from tests.conftest import MIME_OCTET_STREAM, generate_binary_content
+
+
+class TestSafeS3FilesUploader:
+    async def test_ok_with_defaults(self, faker: faker.Faker) -> None:
+        s3_client_mock: typing.Final = mock.AsyncMock()
+        file_name: typing.Final = faker.file_name()
+        bucket_name: typing.Final = faker.pystr()
+        file_content: typing.Final = generate_binary_content(faker)
+
+        uploaded_file: typing.Final = await SafeS3FilesUploader(
+            file_validator=FileValidator(allowed_mime_types=[MIME_OCTET_STREAM]),
+            s3_client=s3_client_mock,
+            bucket_name=bucket_name,
+        ).upload_file(file_name=file_name, file_content=file_content)
+
+        assert uploaded_file == UploadedFile(
+            file_content=file_content,
+            file_name=file_name,
+            file_size=len(file_content),
+            mime_type=MIME_OCTET_STREAM,
+            s3_path=f"{bucket_name}/{file_name}",
+        )
+        s3_client_mock.put_object.assert_called_once_with(
+            Body=file_content,
+            Bucket=bucket_name,
+            Key=file_name,
+            ContentType=MIME_OCTET_STREAM,
+            Metadata={},
+        )
+
+    async def test_ok_with_custom_key_generator(self, faker: faker.Faker) -> None:
+        s3_client_mock: typing.Final = mock.AsyncMock()
+        file_name: typing.Final = faker.file_name()
+        file_name_prefix: typing.Final = faker.pystr()
+        bucket_name: typing.Final = faker.pystr()
+
+        uploaded_file: typing.Final = await SafeS3FilesUploader(
+            file_validator=FileValidator(allowed_mime_types=[MIME_OCTET_STREAM]),
+            s3_client=s3_client_mock,
+            bucket_name=bucket_name,
+            s3_key_generator=lambda file_context: file_name_prefix + file_context.file_name,
+        ).upload_file(file_name=file_name, file_content=generate_binary_content(faker))
+
+        assert uploaded_file.s3_path == f"{bucket_name}/{file_name_prefix}{file_name}"
+        assert s3_client_mock.put_object.mock_calls[0].kwargs["Key"] == file_name_prefix + file_name
+
+    async def test_ok_with_custom_metadata_generator(self, faker: faker.Faker) -> None:
+        s3_client_mock: typing.Final = mock.AsyncMock()
+        file_name: typing.Final = faker.file_name()
+        file_original_name_key: typing.Final = faker.pystr()
+
+        await SafeS3FilesUploader(
+            file_validator=FileValidator(allowed_mime_types=[MIME_OCTET_STREAM]),
+            s3_client=s3_client_mock,
+            bucket_name=faker.pystr(),
+            s3_metadata_generator=lambda file_context: {file_original_name_key: file_context.file_name},
+        ).upload_file(file_name=file_name, file_content=generate_binary_content(faker))
+
+        assert s3_client_mock.put_object.mock_calls[0].kwargs["Metadata"] == {file_original_name_key: file_name}