Small fixes.

app/core/celery/tasks.py

@@ -30,4 +30,4 @@ def create_chain_to_notify_inactive_users() -> None:
         ),
         send_inactive_users_email,
     )
-    task_chain.apply_async()
+    task_chain.delay()

app/core/celery/utils.py

@@ -10,7 +10,7 @@
 )
 
 from core.constants import INACTIVE_DAYS, SortMonotony, SortType
-from core.rabbitmq.utils import get_movie_service, get_user_service
+from core.utils import get_movie_service, get_user_service
 from schemas.movie import MovieFilter
 
 

app/core/rabbitmq/consumers.py

@@ -7,7 +7,7 @@
 
 from cache_services import GenreCacheService, MovieCacheService
 from core.constants import AnyPydanticType
-from core.rabbitmq.utils import get_genre_cache_service, get_movie_cache_service
+from core.utils import get_genre_cache_service, get_movie_cache_service
 from schemas.genre import GenrePartialUpdate
 from schemas.movie import MoviePartialUpdate
 

app/core/rabbitmq/utils.py → app/core/utils.py

@@ -25,6 +25,13 @@ async def get_session() -> AsyncGenerator[AsyncSession]:
         yield session
 
 
+@asynccontextmanager
+async def get_user_service() -> AsyncGenerator[UserService]:
+    async with get_session() as session:
+        user_service = UserService(session)
+        yield user_service
+
+
 @asynccontextmanager
 async def get_genre_service() -> AsyncGenerator[GenreService]:
     async with get_session() as session, get_rabbitmq_service() as rabbitmq_service:
@@ -38,26 +45,13 @@ async def get_genre_redis_client() -> AsyncGenerator[RedisClient]:
         yield redis_client
 
 
-@asynccontextmanager
-async def get_watch_history_redis_client() -> AsyncGenerator[RedisClient]:
-    async for redis_client in get_watch_history_redis_client_dependency():
-        yield redis_client
-
-
 @asynccontextmanager
 async def get_genre_redis_service() -> AsyncGenerator[RedisService]:
     async with get_genre_redis_client() as redis_client:
         redis_service = RedisService(redis_client)
         yield redis_service
 
 
-@asynccontextmanager
-async def get_watch_history_redis_service() -> AsyncGenerator[RedisService]:
-    async with get_watch_history_redis_client() as redis_client:
-        cache_service = RedisService(redis_client)
-        yield cache_service
-
-
 @asynccontextmanager
 async def get_genre_cache_service() -> AsyncGenerator[GenreCacheService]:
     async with (
@@ -88,6 +82,19 @@ async def get_movie_redis_service() -> AsyncGenerator[RedisService]:
         yield cache_service
 
 
+@asynccontextmanager
+async def get_watch_history_redis_client() -> AsyncGenerator[RedisClient]:
+    async for redis_client in get_watch_history_redis_client_dependency():
+        yield redis_client
+
+
+@asynccontextmanager
+async def get_watch_history_redis_service() -> AsyncGenerator[RedisService]:
+    async with get_watch_history_redis_client() as redis_client:
+        cache_service = RedisService(redis_client)
+        yield cache_service
+
+
 @asynccontextmanager
 async def get_movie_cache_service() -> AsyncGenerator[MovieCacheService]:
     async with (
@@ -101,10 +108,3 @@ async def get_movie_cache_service() -> AsyncGenerator[MovieCacheService]:
             cache_service_for_watch_history,
         )
         yield movie_cache_service
-
-
-@asynccontextmanager
-async def get_user_service() -> AsyncGenerator[UserService]:
-    async with get_session() as session:
-        user_service = UserService(session)
-        yield user_service

app/services/auth.py

@@ -1,4 +1,5 @@
-import random
+import asyncio
+import secrets
 from typing import cast
 
 from packages.celery.constants import Queue, TaskType
@@ -133,7 +134,6 @@ async def verify_register_user(
             key=key,
             schema=UserCreate,
         )
-        # user_create_data = UserCreate.model_validate_json(user_create_data_json)
         user = await self.user_service.create_user(cast(UserCreate, user_create_data))
         await self.auth_redis_service.delete(key)
         return create_auth_token(user)
@@ -238,37 +238,49 @@ async def verify_confirmation_code(
             is_integer=True,
         )
         if count_confirm_code_attempts == MAX_CONFIRM_CODE_ATTEMPTS:
-            await self.auth_redis_service.delete(key)
-            await self.auth_redis_service.delete(attempt_counter_key)
+            await asyncio.gather(
+                self.auth_redis_service.delete(key),
+                self.auth_redis_service.delete(attempt_counter_key),
+            )
 
         if confirmation_code != sent_confirmation_code:
             raise InvalidEmailConfirmationCodeError(
                 email=email,
                 confirmation_code=confirmation_code,
             )
+        await self.auth_redis_service.delete(key)
+
+    @staticmethod
+    def generate_confirmation_code() -> str:
+        confirmation_code_list = [str(secrets.randbelow(10)) for _ in range(6)]
+        confirmation_code = "".join(confirmation_code_list)
+        return confirmation_code
 
     async def create_confirmation_code(
         self,
         email: EmailStr,
         confirmation_code_type: ConfirmationCodeType,
     ) -> str:
-        confirmation_code = "".join(
-            [str(random.randint(0, 9)) for _ in range(6)],  # noqa: S311
-        )
+        confirmation_code = self.generate_confirmation_code()
         key_list = [confirmation_code_type.value, email]
         key = ":".join(key_list)
         attempt_counter_key_list = [key, ATTEMPT_FIELD]
         attempt_counter_key = ":".join(attempt_counter_key_list)
-        await self.auth_redis_service.set(
+
+        set_confirmation_code = self.auth_redis_service.set(
             key=key,
             value=confirmation_code,
             ttl=60,
         )
-        await self.auth_redis_service.set(
+        set_confirmation_code_attempt_counter = self.auth_redis_service.set(
             key=attempt_counter_key,
             value=0,
             ttl=60,
         )
+        await asyncio.gather(
+            set_confirmation_code,
+            set_confirmation_code_attempt_counter,
+        )
         return confirmation_code
 
     async def recover_account(