import asyncio from collections.abc import AsyncIterator, Awaitable, Callable, Sequence from datetime import UTC, datetime, timedelta from typing import Any from dishka import Provider, Scope, provide from messenger.attachments.application.errors import ObjectMissingError from messenger.attachments.application.ports import ObjectContent, ObjectStorage, StoredObject from messenger.shared.application.errors import Unavailable class NullLogger: __slots__ = () def info(self, event: str, /, **fields: Any) -> None: ... def warning(self, event: str, /, **fields: Any) -> None: ... def error(self, event: str, /, **fields: Any) -> None: ... class FrozenClock: __slots__ = ("_current",) def __init__(self, start: datetime) -> None: self._current = start def now(self) -> datetime: self._current += timedelta(microseconds=1) return self._current async def pieces(data: bytes, size: int = 65_536, delay: float = 0.0) -> AsyncIterator[bytes]: for start in range(0, len(data), size): await asyncio.sleep(delay) yield data[start : start + size] class MemoryObjectStorage: __slots__ = ("after_page", "after_put", "delay", "failing", "modified", "objects") def __init__(self) -> None: self.objects: dict[str, tuple[bytes, str]] = {} self.modified: dict[str, datetime] = {} self.failing = False self.delay = 0.0 self.after_put: Callable[[str], Awaitable[None]] | None = None self.after_page: Callable[[], Awaitable[None]] | None = None async def put(self, key: str, data: bytes, content_type: str) -> None: if self.failing: raise Unavailable("S3 недоступно") self.objects[key] = (bytes(data), content_type) self.modified[key] = datetime.now(UTC) if self.after_put is not None: await self.after_put(key) async def listing(self, prefix: str, page_size: int) -> AsyncIterator[Sequence[StoredObject]]: if self.failing: raise Unavailable("S3 недоступно") keys = sorted(key for key in self.objects if key.startswith(prefix)) for start in range(0, len(keys), page_size): yield [self._stored(key) for key in keys[start : start + page_size]] if self.after_page is not None: await self.after_page() async def stat(self, key: str) -> StoredObject | None: return self._stored(key) if key in self.objects else None def _stored(self, key: str) -> StoredObject: return StoredObject(key, len(self.objects[key][0]), self.modified[key]) async def open(self, key: str) -> ObjectContent: if self.failing: raise Unavailable("S3 недоступно") if key not in self.objects: raise ObjectMissingError(key) data = self.objects[key][0] return ObjectContent(size=len(data), chunks=pieces(data, delay=self.delay)) async def read(self, key: str) -> bytes: content = await self.open(key) return b"".join([chunk async for chunk in content.chunks]) async def copy(self, source: str, target: str) -> None: if self.failing: raise Unavailable("S3 недоступно") if source not in self.objects: raise ObjectMissingError(source) self.objects[target] = self.objects[source] async def delete(self, key: str) -> None: if self.failing: raise Unavailable("S3 недоступно") self.objects.pop(key, None) self.modified.pop(key, None) class MemoryStorageProvider(Provider): @provide(scope=Scope.APP) def storage(self) -> ObjectStorage: return MemoryObjectStorage() class RecordingPublisher: __slots__ = ("events",) def __init__(self) -> None: self.events: list[Any] = [] async def publish(self, events: Sequence[Any]) -> None: self.events.extend(events)