feat: add avatars

src/presentation/dependencies/__init__.py

@@ -1,6 +1,7 @@
 from src.presentation.dependencies.commands import (
     get_get_me_command,
     get_set_phone_command,
+    get_set_avatar_command,
     get_set_encrypted_mnemonic_start_command,
     get_set_encrypted_mnemonic_complete_command,
     get_update_bank_details_start_command,

src/presentation/dependencies/commands.py

@@ -1,11 +1,12 @@
 from fastapi import Depends
 from src.application.abstractions import IUnitOfWork
-from src.application.commands import GetMeCommand, SetPhoneCommand, SetEncryptedMnemonicStartCommand, SetEncryptedMnemonicCompleteCommand, UpdateBankDetailsStartCommand, UpdateBankDetailsCompleteCommand, ChangePasswordStartCommand, ChangePasswordCompleteCommand, ChangeEmailStartCommand, ChangeEmailConfirmOldCommand, ChangeEmailCompleteCommand
-from src.application.contracts import ILogger, ICache, IQueueMessanger, IHashService
+from src.application.commands import GetMeCommand, SetPhoneCommand, SetAvatarCommand, SetEncryptedMnemonicStartCommand, SetEncryptedMnemonicCompleteCommand, UpdateBankDetailsStartCommand, UpdateBankDetailsCompleteCommand, ChangePasswordStartCommand, ChangePasswordCompleteCommand, ChangeEmailStartCommand, ChangeEmailConfirmOldCommand, ChangeEmailCompleteCommand
+from src.application.contracts import ILogger, ICache, IQueueMessanger, IHashService, IS3
 from src.presentation.dependencies.cache import get_cache
 from src.presentation.dependencies.logger import get_logger
 from src.presentation.dependencies.queue_messanger import get_rabbit
 from src.presentation.dependencies.security import get_hash_service
+from src.presentation.dependencies.s3_storage import get_s3_storage
 from src.presentation.dependencies.unit_of_work import get_unit_of_work
 
 
@@ -25,6 +26,15 @@ def get_set_phone_command(
     return SetPhoneCommand(logger=logger, unit_of_work=unit_of_work, cache=cache)
 
 
+def get_set_avatar_command(
+    logger: ILogger = Depends(get_logger),
+    unit_of_work: IUnitOfWork = Depends(get_unit_of_work),
+    cache: ICache = Depends(get_cache),
+    s3: IS3 = Depends(get_s3_storage),
+) -> SetAvatarCommand:
+    return SetAvatarCommand(unit_of_work=unit_of_work, logger=logger, cache=cache, s3=s3)
+
+
 def get_set_encrypted_mnemonic_start_command(
     logger: ILogger = Depends(get_logger),
     unit_of_work: IUnitOfWork = Depends(get_unit_of_work),

src/presentation/dependencies/s3_storage.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from src.application.contracts import IS3
+from src.application.domain.exceptions import ServiceUnavailableException
+from src.infrastructure.config import settings
+from src.infrastructure.storage.s3_service import S3Service
+
+_s3singleton: IS3 | None = None
+
+
+def get_s3_storage() -> IS3:
+    global _s3singleton
+    if _s3singleton is not None:
+        return _s3singleton
+    if not settings.S3_BUCKET.strip():
+        raise ServiceUnavailableException(message='S3 is not configured')
+    endpoint = settings.S3_ENDPOINT_URL.strip()
+    pub = settings.S3_PUBLIC_BASE_URL.strip()
+    if not pub and not endpoint:
+        raise ServiceUnavailableException(message='Set S3_ENDPOINT_URL (or S3_PUBLIC_BASE_URL for a custom CDN base)')
+    ak = settings.S3_ACCESS_KEY_ID.strip() or None
+    sk = settings.S3_SECRET_ACCESS_KEY.strip() or None
+    _s3singleton = S3Service(
+        bucket=settings.S3_BUCKET.strip(),
+        region=settings.S3_REGION.strip() or 'us-east-1',
+        access_key_id=ak,
+        secret_access_key=sk,
+        public_base_url=pub if pub else None,
+        endpoint_url=endpoint if endpoint else None,
+        use_reg_ru_website_public_host=settings.S3_REGRU_PUBLIC_WEBSITE_HOST,
+    )
+    return _s3singleton

src/presentation/routing/account.py

@@ -1,4 +1,4 @@
-from fastapi import APIRouter, Request, Depends
+from fastapi import APIRouter, Depends, Request
 from fastapi.responses import ORJSONResponse
 from starlette import status
 from src.application.commands.get_me import GetMeCommand
@@ -8,37 +8,42 @@ from src.presentation.decorators import require_access_token
 from src.presentation.dependencies.commands import get_get_me_command
 from src.presentation.dependencies.logger import get_logger
 from src.presentation.decorators import csrf_protect
+from src.presentation.schemas.api_errors import ApiErrorPayload, ApiValidationErrorsPayload
+from src.presentation.schemas.me_public import MeUserPublicResponse
+from src.presentation.serializers import me_user_public
 
 account_router = APIRouter()
 
-@account_router.get(path='/', response_class=ORJSONResponse, status_code=status.HTTP_200_OK)
+
+@account_router.get(
+    path='/',
+    response_class=ORJSONResponse,
+    status_code=status.HTTP_200_OK,
+    response_model=MeUserPublicResponse,
+    summary='Текущий пользователь',
+    description='Возвращает профиль авторизованного пользователя. Защита CSRF: cookie csrf_token и заголовок X-CSRF-Token с тем же значением.',
+    responses={
+        status.HTTP_401_UNAUTHORIZED: {
+            'description': 'Не передан или неверен access token.',
+            'model': ApiErrorPayload,
+        },
+        status.HTTP_403_FORBIDDEN: {
+            'description': 'Ошибка проверки CSRF (нет пары cookie/заголовка, несовпадение или просрочен токен).',
+            'model': ApiErrorPayload,
+        },
+        status.HTTP_422_UNPROCESSABLE_ENTITY: {
+            'description': 'Ошибка валидации входных данных (например, заголовков).',
+            'model': ApiValidationErrorsPayload,
+        },
+    },
+)
 @csrf_protect()
 async def me(
         request: Request,
         auth: AuthContext = Depends(require_access_token),
         command: GetMeCommand = Depends(get_get_me_command),
         logger: ILogger = Depends(get_logger),
-):
+) -> MeUserPublicResponse:
     user = await command(user_id=auth.user_id)
     logger.info(f'Get user: {user.id}')
-    return ORJSONResponse(
-        status_code=status.HTTP_200_OK,
-        content={
-            'id': user.id,
-            'email': user.email,
-            'first_name': user.first_name,
-            'middle_name': user.middle_name,
-            'last_name': user.last_name,
-            'birth_date': str(user.birth_date) if user.birth_date else None,
-            'encrypted_mnemonic': user.encrypted_mnemonic,
-            'phone': user.phone,
-            'passport_data': user.passport_data,
-            'inn': user.inn,
-            'erc20': user.erc20,
-            'kyc_verified': user.kyc_verified,
-            'is_deleted': user.is_deleted,
-            'created_at': user.created_at.isoformat() if user.created_at else None,
-            'updated_at': user.updated_at.isoformat() if user.updated_at else None,
-            'kyc_verified_at': user.kyc_verified_at.isoformat() if user.kyc_verified_at else None,
-        }
-    )
+    return me_user_public(user)

src/presentation/routing/account_settings.py

@@ -1,27 +1,50 @@
-from fastapi import APIRouter, Request, Depends
+from fastapi import APIRouter, Depends, Request
 from fastapi.responses import ORJSONResponse
 from starlette import status
-from src.application.commands import SetPhoneCommand, SetEncryptedMnemonicStartCommand, SetEncryptedMnemonicCompleteCommand, UpdateBankDetailsStartCommand, UpdateBankDetailsCompleteCommand, ChangePasswordStartCommand, ChangePasswordCompleteCommand, ChangeEmailStartCommand, ChangeEmailConfirmOldCommand, ChangeEmailCompleteCommand
+from src.application.commands import SetPhoneCommand, SetAvatarCommand
 from src.application.domain.dto import AuthContext
 from src.presentation.decorators import require_access_token
 from src.presentation.dependencies import (
+    get_set_avatar_command,
     get_set_phone_command,
-    get_set_encrypted_mnemonic_start_command,
-    get_set_encrypted_mnemonic_complete_command,
-    get_update_bank_details_start_command,
-    get_update_bank_details_complete_command,
-    get_change_password_start_command,
-    get_change_password_complete_command,
-    get_change_email_start_command,
-    get_change_email_confirm_old_command,
-    get_change_email_complete_command,
 )
-from src.presentation.schemas import SetPhoneRequest, EncryptedMnemonicConfirmRequest, BankConfirmRequest, ChangePasswordConfirmRequest, ChangeEmailConfirmOldRequest, ChangeEmailCompleteRequest
+from src.presentation.schemas import SetAvatarRequest, SetPhoneRequest
+from src.presentation.schemas.api_errors import ApiErrorPayload, ApiValidationErrorsPayload
+from src.presentation.schemas.me_public import SetAvatarPublicResponse
+from src.presentation.serializers import me_user_public
 
 
 account_settings_router = APIRouter(prefix='/settings')
 
 
+_SET_AVATAR_ERROR_RESPONSES: dict[int, dict[str, object]] = {
+    status.HTTP_400_BAD_REQUEST: {
+        'description': 'Битый или неподдерживаемый формат изображения, либо Base64 ошибочный.',
+        'model': ApiErrorPayload,
+    },
+    status.HTTP_401_UNAUTHORIZED: {
+        'description': 'Не передан или неверен access token.',
+        'model': ApiErrorPayload,
+    },
+    status.HTTP_404_NOT_FOUND: {
+        'description': 'Учётная запись не найдена.',
+        'model': ApiErrorPayload,
+    },
+    status.HTTP_422_UNPROCESSABLE_ENTITY: {
+        'description': 'Тело запроса не соответствует схеме (например, неверный Base64 или превышен размер).',
+        'model': ApiValidationErrorsPayload,
+    },
+    status.HTTP_500_INTERNAL_SERVER_ERROR: {
+        'description': 'Внутренняя ошибка сервера; клиенту отдаётся обобщённое сообщение.',
+        'model': ApiErrorPayload,
+    },
+    status.HTTP_503_SERVICE_UNAVAILABLE: {
+        'description': 'S3 не сконфигурирован, ошибка записи в хранилище или временная недоступность сервиса.',
+        'model': ApiErrorPayload,
+    },
+}
+
+
 @account_settings_router.patch(path='/phone', response_class=ORJSONResponse, status_code=status.HTTP_200_OK)
 async def set_phone(
     request: Request,
@@ -33,118 +56,143 @@ async def set_phone(
     return ORJSONResponse(status_code=status.HTTP_200_OK, content={'phone': user.phone})
 
 
-@account_settings_router.post(path='/encrypted-mnemonic/start', response_class=ORJSONResponse, status_code=status.HTTP_200_OK)
-async def encrypted_mnemonic_start(
+@account_settings_router.patch(
+    path='/avatar',
+    response_class=ORJSONResponse,
+    status_code=status.HTTP_200_OK,
+    response_model=SetAvatarPublicResponse,
+    summary='Обновить аватар',
+    description=(
+        'Принимает фото в Base64, сохраняет как WebP в объектном хранилище и записывает публичный URL в профиль.'
+    ),
+    response_description=(
+        'Профиль пользователя в том же формате, что и GET /me, плюс размер сохранённого WebP.'
+    ),
+    responses=_SET_AVATAR_ERROR_RESPONSES,
+)
+async def set_avatar(
     request: Request,
+    body: SetAvatarRequest,
     auth: AuthContext = Depends(require_access_token),
-    command: SetEncryptedMnemonicStartCommand = Depends(get_set_encrypted_mnemonic_start_command),
-):
-    result = await command(user_id=auth.user_id)
-    return {'success': result}
+    command: SetAvatarCommand = Depends(get_set_avatar_command),
+) -> SetAvatarPublicResponse:
+    user, webp_size = await command(user_id=auth.user_id, image_bytes=body.decoded_bytes)
+    pub = me_user_public(user)
+    return SetAvatarPublicResponse(**pub.model_dump(), webp_size_bytes=webp_size)
 
-
-@account_settings_router.post(path='/encrypted-mnemonic/complete', response_class=ORJSONResponse, status_code=status.HTTP_200_OK)
-async def encrypted_mnemonic_complete(
-    request: Request,
-    body: EncryptedMnemonicConfirmRequest,
-    auth: AuthContext = Depends(require_access_token),
-    command: SetEncryptedMnemonicCompleteCommand = Depends(get_set_encrypted_mnemonic_complete_command),
-):
-    user = await command(
-        user_id=auth.user_id,
-        code=body.code,
-        encrypted_mnemonic=body.encrypted_mnemonic,
-    )
-    return {'encrypted_mnemonic': user.encrypted_mnemonic}
-
-
-@account_settings_router.post(path='/email/start', response_class=ORJSONResponse, status_code=status.HTTP_200_OK)
-async def change_email_start(
-    request: Request,
-    auth: AuthContext = Depends(require_access_token),
-    command: ChangeEmailStartCommand = Depends(get_change_email_start_command),
-):
-    result = await command(user_id=auth.user_id)
-    return {'success': result}
-
-
-@account_settings_router.post(path='/email/confirm-old', response_class=ORJSONResponse, status_code=status.HTTP_200_OK)
-async def change_email_confirm_old(
-    request: Request,
-    body: ChangeEmailConfirmOldRequest,
-    auth: AuthContext = Depends(require_access_token),
-    command: ChangeEmailConfirmOldCommand = Depends(get_change_email_confirm_old_command),
-):
-    result = await command(user_id=auth.user_id, code=body.code, new_email=body.new_email)
-    return {'success': result}
-
-
-@account_settings_router.post(path='/email/complete', response_class=ORJSONResponse, status_code=status.HTTP_200_OK)
-async def change_email_complete(
-    request: Request,
-    body: ChangeEmailCompleteRequest,
-    auth: AuthContext = Depends(require_access_token),
-    command: ChangeEmailCompleteCommand = Depends(get_change_email_complete_command),
-):
-    result = await command(user_id=auth.user_id, code=body.code)
-    return {'success': result}
-
-
-@account_settings_router.post(path='/password/start', response_class=ORJSONResponse, status_code=status.HTTP_200_OK)
-async def change_password_start(
-    request: Request,
-    auth: AuthContext = Depends(require_access_token),
-    command: ChangePasswordStartCommand = Depends(get_change_password_start_command),
-):
-    result = await command(user_id=auth.user_id)
-    return {'success': result}
-
-
-@account_settings_router.post(path='/password/complete', response_class=ORJSONResponse, status_code=status.HTTP_200_OK)
-async def change_password_complete(
-    request: Request,
-    body: ChangePasswordConfirmRequest,
-    auth: AuthContext = Depends(require_access_token),
-    command: ChangePasswordCompleteCommand = Depends(get_change_password_complete_command),
-):
-    result = await command(
-        user_id=auth.user_id,
-        code=body.code,
-        new_password=body.new_password,
-        confirm_password=body.confirm_password,
-    )
-    return {'success': result}
-
-
-@account_settings_router.post(path='/bank/start', response_class=ORJSONResponse, status_code=status.HTTP_200_OK)
-async def bank_details_start(
-    request: Request,
-    auth: AuthContext = Depends(require_access_token),
-    command: UpdateBankDetailsStartCommand = Depends(get_update_bank_details_start_command),
-):
-    result = await command(user_id=auth.user_id)
-    return {'success': result}
-
-
-@account_settings_router.post(path='/bank/complete', response_class=ORJSONResponse, status_code=status.HTTP_200_OK)
-async def bank_details_complete(
-    request: Request,
-    body: BankConfirmRequest,
-    auth: AuthContext = Depends(require_access_token),
-    command: UpdateBankDetailsCompleteCommand = Depends(get_update_bank_details_complete_command),
-):
-    user = await command(
-        user_id=auth.user_id,
-        code=body.code,
-        passport_data=body.passport_data,
-        inn=body.inn,
-        erc20=body.erc20,
-    )
-    return ORJSONResponse(
-        status_code=status.HTTP_200_OK,
-        content={
-            'passport_data': user.passport_data,
-            'inn': user.inn,
-            'erc20': user.erc20,
-        },
-    )
+#
+# @account_settings_router.post(path='/encrypted-mnemonic/start', response_class=ORJSONResponse, status_code=status.HTTP_200_OK)
+# async def encrypted_mnemonic_start(
+#     request: Request,
+#     auth: AuthContext = Depends(require_access_token),
+#     command: SetEncryptedMnemonicStartCommand = Depends(get_set_encrypted_mnemonic_start_command),
+# ):
+#     result = await command(user_id=auth.user_id)
+#     return {'success': result}
+#
+#
+# @account_settings_router.post(path='/encrypted-mnemonic/complete', response_class=ORJSONResponse, status_code=status.HTTP_200_OK)
+# async def encrypted_mnemonic_complete(
+#     request: Request,
+#     body: EncryptedMnemonicConfirmRequest,
+#     auth: AuthContext = Depends(require_access_token),
+#     command: SetEncryptedMnemonicCompleteCommand = Depends(get_set_encrypted_mnemonic_complete_command),
+# ):
+#     user = await command(
+#         user_id=auth.user_id,
+#         code=body.code,
+#         encrypted_mnemonic=body.encrypted_mnemonic,
+#     )
+#     return {'encrypted_mnemonic': user.encrypted_mnemonic}
+#
+#
+# @account_settings_router.post(path='/email/start', response_class=ORJSONResponse, status_code=status.HTTP_200_OK)
+# async def change_email_start(
+#     request: Request,
+#     auth: AuthContext = Depends(require_access_token),
+#     command: ChangeEmailStartCommand = Depends(get_change_email_start_command),
+# ):
+#     result = await command(user_id=auth.user_id)
+#     return {'success': result}
+#
+#
+# @account_settings_router.post(path='/email/confirm-old', response_class=ORJSONResponse, status_code=status.HTTP_200_OK)
+# async def change_email_confirm_old(
+#     request: Request,
+#     body: ChangeEmailConfirmOldRequest,
+#     auth: AuthContext = Depends(require_access_token),
+#     command: ChangeEmailConfirmOldCommand = Depends(get_change_email_confirm_old_command),
+# ):
+#     result = await command(user_id=auth.user_id, code=body.code, new_email=body.new_email)
+#     return {'success': result}
+#
+#
+# @account_settings_router.post(path='/email/complete', response_class=ORJSONResponse, status_code=status.HTTP_200_OK)
+# async def change_email_complete(
+#     request: Request,
+#     body: ChangeEmailCompleteRequest,
+#     auth: AuthContext = Depends(require_access_token),
+#     command: ChangeEmailCompleteCommand = Depends(get_change_email_complete_command),
+# ):
+#     result = await command(user_id=auth.user_id, code=body.code)
+#     return {'success': result}
+#
+#
+# @account_settings_router.post(path='/password/start', response_class=ORJSONResponse, status_code=status.HTTP_200_OK)
+# async def change_password_start(
+#     request: Request,
+#     auth: AuthContext = Depends(require_access_token),
+#     command: ChangePasswordStartCommand = Depends(get_change_password_start_command),
+# ):
+#     result = await command(user_id=auth.user_id)
+#     return {'success': result}
+#
+#
+# @account_settings_router.post(path='/password/complete', response_class=ORJSONResponse, status_code=status.HTTP_200_OK)
+# async def change_password_complete(
+#     request: Request,
+#     body: ChangePasswordConfirmRequest,
+#     auth: AuthContext = Depends(require_access_token),
+#     command: ChangePasswordCompleteCommand = Depends(get_change_password_complete_command),
+# ):
+#     result = await command(
+#         user_id=auth.user_id,
+#         code=body.code,
+#         new_password=body.new_password,
+#         confirm_password=body.confirm_password,
+#     )
+#     return {'success': result}
+#
+#
+# @account_settings_router.post(path='/bank/start', response_class=ORJSONResponse, status_code=status.HTTP_200_OK)
+# async def bank_details_start(
+#     request: Request,
+#     auth: AuthContext = Depends(require_access_token),
+#     command: UpdateBankDetailsStartCommand = Depends(get_update_bank_details_start_command),
+# ):
+#     result = await command(user_id=auth.user_id)
+#     return {'success': result}
+#
+#
+# @account_settings_router.post(path='/bank/complete', response_class=ORJSONResponse, status_code=status.HTTP_200_OK)
+# async def bank_details_complete(
+#     request: Request,
+#     body: BankConfirmRequest,
+#     auth: AuthContext = Depends(require_access_token),
+#     command: UpdateBankDetailsCompleteCommand = Depends(get_update_bank_details_complete_command),
+# ):
+#     user = await command(
+#         user_id=auth.user_id,
+#         code=body.code,
+#         passport_data=body.passport_data,
+#         inn=body.inn,
+#         erc20=body.erc20,
+#     )
+#     return ORJSONResponse(
+#         status_code=status.HTTP_200_OK,
+#         content={
+#             'passport_data': user.passport_data,
+#             'inn': user.inn,
+#             'erc20': user.erc20,
+#         },
+#     )

src/presentation/schemas/__init__.py

@@ -1,3 +1,4 @@
+from src.presentation.schemas.avatar import SetAvatarRequest
 from src.presentation.schemas.phone import SetPhoneRequest
 from src.presentation.schemas.bank import BankUpdateRequest, BankConfirmRequest
 from src.presentation.schemas.encrypted_mnemonic import EncryptedMnemonicConfirmRequest

src/presentation/schemas/api_errors.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from pydantic import BaseModel, Field
+
+
+class ApiErrorPayload(BaseModel):
+    detail: str = Field(description='Текстовое описание ошибки для клиента')
+
+
+class ValidationErrorDetailItem(BaseModel):
+    loc: list[str | int] = Field(description='Путь к полю, вызвавшему ошибку')
+    msg: str = Field(description='Сообщение')
+    type: str = Field(description='Тип ошибки валидации')
+
+
+class ApiValidationErrorsPayload(BaseModel):
+    detail: list[ValidationErrorDetailItem] = Field(
+        description='Список ошибок валидации тела или параметров запроса'
+    )

src/presentation/schemas/avatar.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+from typing import Any
+
+import base64
+import binascii
+
+from pydantic import BaseModel, Field, model_validator
+
+
+AVATAR_MAX_BYTES = 10 * 1024 * 1024
+
+_IMAGE_SIGNATURES = (
+    b'\xff\xd8\xff',
+    b'\x89PNG\r\n\x1a\n',
+    b'GIF87a',
+    b'GIF89a',
+)
+
+
+def _avatar_payload_to_bytes(photo_base64: str) -> bytes:
+    s = photo_base64.strip()
+    if not s:
+        raise ValueError('photo_base64 must not be empty')
+    if s.startswith('data:'):
+        parts = s.split(',', 1)
+        if len(parts) != 2:
+            raise ValueError('Invalid data URL')
+        s = parts[1].strip()
+    try:
+        data = base64.b64decode(s, validate=True)
+    except binascii.Error as exc:
+        raise ValueError('Invalid base64') from exc
+    if len(data) > AVATAR_MAX_BYTES:
+        raise ValueError(f'Photo must not exceed {AVATAR_MAX_BYTES} bytes')
+    if len(data) < 12:
+        raise ValueError('Photo data is too small')
+    ok = False
+    for sig in _IMAGE_SIGNATURES:
+        if data.startswith(sig):
+            ok = True
+            break
+    if not ok and data.startswith(b'RIFF') and len(data) > 12 and data[8:12] == b'WEBP':
+        ok = True
+    if not ok:
+        raise ValueError('Photo must be JPEG, PNG, GIF or WebP')
+    return data
+
+
+class SetAvatarRequest(BaseModel):
+    photo_base64: str = Field(
+        ...,
+        description='Изображение JPEG, PNG, GIF или WebP в Base64; допустим data URL (data:image/...;base64,...). Максимум 10 МБ после декодирования.',
+    )
+    decoded_bytes: bytes = Field(exclude=True)
+
+    @model_validator(mode='before')
+    @classmethod
+    def _decode_input(cls, data: Any):
+        if not isinstance(data, dict):
+            return data
+        raw = data.get('photo_base64')
+        if raw is None:
+            return data
+        if not isinstance(raw, str):
+            raise ValueError('photo_base64 must be a string')
+        stripped = raw.strip()
+        decoded = _avatar_payload_to_bytes(stripped)
+        return {'photo_base64': stripped, 'decoded_bytes': decoded}

src/presentation/schemas/me_public.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+from datetime import date, datetime
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from src.application.domain.entities import UserEntity
+
+
+class MeUserPublicResponse(BaseModel):
+    model_config = ConfigDict(from_attributes=False)
+
+    id: str | None = Field(None, description='Идентификатор пользователя')
+    email: str | None = Field(None, description='Email')
+    first_name: str | None = Field(None, description='Имя')
+    middle_name: str | None = Field(None, description='Отчество')
+    last_name: str | None = Field(None, description='Фамилия')
+    birth_date: date | None = Field(None, description='Дата рождения')
+    encrypted_mnemonic: str | None = Field(None, description='Шифрованная мнемоника')
+    phone: str | None = Field(None, description='Телефон')
+    passport_data: str | None = Field(None, description='Паспортные данные')
+    inn: str | None = Field(None, description='ИНН')
+    erc20: str | None = Field(None, description='ERC-20 адрес')
+    avatar_link: str | None = Field(None, description='HTTPS-ссылка на текущий аватар в хранилище')
+    kyc_verified: bool | None = Field(None, description='Признак пройденного KYC')
+    is_deleted: bool | None = Field(None, description='Удалён ли аккаунт')
+    created_at: datetime | None = Field(None, description='Время создания записи')
+    updated_at: datetime | None = Field(None, description='Время последнего обновления')
+    kyc_verified_at: datetime | None = Field(None, description='Время подтверждения KYC')
+
+    @classmethod
+    def from_user(cls, user: UserEntity) -> MeUserPublicResponse:
+        return cls(
+            id=user.id,
+            email=user.email,
+            first_name=user.first_name,
+            middle_name=user.middle_name,
+            last_name=user.last_name,
+            birth_date=user.birth_date,
+            encrypted_mnemonic=user.encrypted_mnemonic,
+            phone=user.phone,
+            passport_data=user.passport_data,
+            inn=user.inn,
+            erc20=user.erc20,
+            avatar_link=user.avatar_link,
+            kyc_verified=user.kyc_verified,
+            is_deleted=user.is_deleted,
+            created_at=user.created_at,
+            updated_at=user.updated_at,
+            kyc_verified_at=user.kyc_verified_at,
+        )
+
+
+class SetAvatarPublicResponse(MeUserPublicResponse):
+    webp_size_bytes: int = Field(
+        ...,
+        ge=0,
+        description='Размер сохранённого файла аватара в формате WebP, байты',
+    )

src/presentation/serializers/__init__.py

@@ -0,0 +1 @@
+from src.presentation.serializers.me_user import me_user_payload, me_user_public

src/presentation/serializers/me_user.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from src.application.domain.entities import UserEntity
+
+from src.presentation.schemas.me_public import MeUserPublicResponse
+
+
+def me_user_public(user: UserEntity) -> MeUserPublicResponse:
+    return MeUserPublicResponse.from_user(user)
+
+
+def me_user_payload(user: UserEntity) -> dict:
+    return me_user_public(user).model_dump(mode='json')