ref: make it better, faster, stronger

Author: emptybutton

.env.template

@@ -19,5 +19,5 @@ async def __call__(
         /,
     ) -> None:
         """
-        :raises iam.application.ports.map.NotUniqueUserNameError:
-        """
+        :raises app_name_snake_case.application.ports.map.NotUniqueUserNameError:
+        """  # noqa: E501

src/app_name_snake_case/application/ports/map.py

@@ -2,12 +2,12 @@
 from uuid import UUID
 
 
-class UserIDSigning[SignedIDDataT](ABC):
+class UserIDSigning[SignedUserIDT](ABC):
     @abstractmethod
-    async def signed_user_id_when(self, *, user_id: UUID) -> SignedIDDataT:
+    async def signed_user_id(self, user_id: UUID, /) -> SignedUserIDT:
         ...
 
     @abstractmethod
-    async def user_id_when(
-        self, *, signed_user_id: SignedIDDataT
+    async def user_id(
+        self, signed_user_id: SignedUserIDT, /
     ) -> UUID | None: ...

src/app_name_snake_case/application/ports/user_id_signing.py

@@ -13,7 +13,7 @@
 from app_name_snake_case.application.ports.user_views import UserViews
 from app_name_snake_case.application.ports.users import Users
 from app_name_snake_case.entities.core.user import (
-    registered_user_when,
+    registered_user,
 )
 
 
@@ -46,24 +46,22 @@ async def __call__(
         """  # noqa: E501
 
         if signed_user_id is not None:
-            user_id = await self.user_id_signing.user_id_when(
-                signed_user_id=signed_user_id
-            )
+            user_id = await self.user_id_signing.user_id(signed_user_id)
 
             if user_id is not None:
                 raise RegisteredUserToRegisterUserError
 
-        registered_user = registered_user_when(user_name=user_name)
+        registered_user_ = registered_user(user_name=user_name)
 
         async with self.transaction:
             try:
-                await self.map(registered_user)
+                await self.map(registered_user_)
             except NotUniqueUserNameError as error:
                 raise TakenUserNameToRegisterUserError from error
 
-            view = await self.user_views.view_of_user(just(registered_user))
+            view = await self.user_views.view_of_user(just(registered_user_))
 
-        signed_user_id = await self.user_id_signing.signed_user_id_when(
-            user_id=just(registered_user).id
+        signed_user_id = await self.user_id_signing.signed_user_id(
+            just(registered_user_).id
         )
         return Output(signed_user_id=signed_user_id, user_view=view)

src/app_name_snake_case/application/register_user.py

@@ -17,9 +17,7 @@ async def __call__(
         if signed_user_id is None:
             user_id = None
         else:
-            user_id = await self.user_id_signing.user_id_when(
-                signed_user_id=signed_user_id
-            )
+            user_id = await self.user_id_signing.user_id(signed_user_id)
 
         async with self.transaction:
             return await self.user_views.view_of_user_with_id(user_id)

src/app_name_snake_case/application/view_user.py

@@ -9,5 +9,5 @@ class User(IdentifiedValue[UUID]):
     name: str
 
 
-def registered_user_when(*, user_name: str) -> New[User]:
+def registered_user(user_name: str) -> New[User]:
     return new(User(id=uuid4(), name=user_name))

src/app_name_snake_case/entities/core/user.py

@@ -10,7 +10,7 @@ class NotUTCTimeError(Exception): ...
 @dataclass(kw_only=True, frozen=True)
 class Time:
     """
-    :raises iam.entities.time.time.NotUTCTimeError:
+    :raises app_name_snake_case.entities.time.time.NotUTCTimeError:
     """
 
     datetime: datetime_cls

src/app_name_snake_case/entities/time/time.py

@@ -4,21 +4,19 @@
 
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from app_name_snake_case.infrastructure.app_name_snake_case.in_memory_storage import (  # noqa: E501
+from app_name_snake_case.infrastructure.in_memory_storage import (
     TransactionalInMemoryStorage,
 )
 
 
 @asynccontextmanager
-async def in_postgres_transaction_when(
-    *, session: AsyncSession
-) -> AsyncIterator[None]:
+async def in_postgres_transaction(session: AsyncSession) -> AsyncIterator[None]:
     async with session.begin():
         yield
 
 
 @asynccontextmanager
-async def in_memory_transaction_for(
+async def in_memory_transaction(
     storages: Sequence[TransactionalInMemoryStorage[Any]]
 ) -> AsyncIterator[None]:
     for storage in storages:

src/app_name_snake_case/infrastructure/__init__.py

@@ -7,28 +7,26 @@
 from app_name_snake_case.application.ports.user_id_signing import (
     UserIDSigning,
 )
-from app_name_snake_case.infrastructure.app_name_snake_case.alias import JWT
+from app_name_snake_case.infrastructure.alias import JWT
 
 
 @dataclass(kw_only=True, frozen=True, slots=True)
 class UserIDSigningAsIdentification(UserIDSigning[UUID | None]):
-    async def signed_user_id_when(self, *, user_id: UUID) -> UUID:
+    async def signed_user_id(self, user_id: UUID) -> UUID:
         return user_id
 
-    async def user_id_when(self, *, signed_user_id: UUID | None) -> UUID | None:
+    async def user_id_when(self, signed_user_id: UUID | None) -> UUID | None:
         return signed_user_id
 
 
 @dataclass(kw_only=True, frozen=True, slots=True)
 class UserIDSigningToHS256JWT(UserIDSigning[JWT]):
     secret: str = field(repr=False)
 
-    async def signed_user_id_when(self, *, user_id: UUID) -> JWT:
+    async def signed_user_id(self, user_id: UUID) -> JWT:
         return pyjwt.encode({"id": user_id.hex}, self.secret, algorithm="HS256")
 
-    async def user_id_when(self, *, signed_user_id: JWT) -> UUID | None:
-        jwt = signed_user_id
-
+    async def user_id(self, jwt: JWT) -> UUID | None:
         try:
             user_data: dict[str, Any]
             user_data = pyjwt.decode(jwt, self.secret, algorithms="HS256")