Don't redefine a sub TypeVar for UP and AP protocols

Author: frankie567

fastapi_users_db_sqlalchemy/__init__.py

@@ -1,9 +1,9 @@
 """FastAPI Users database adapter for SQLAlchemy."""
 import uuid
-from typing import Any, Dict, Generic, Optional, Type, TypeVar
+from typing import Any, Dict, Generic, Optional, Type
 
 from fastapi_users.db.base import BaseUserDatabase
-from fastapi_users.models import ID, OAP
+from fastapi_users.models import ID, OAP, UP
 from sqlalchemy import Boolean, Column, ForeignKey, Integer, String, func, select
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.ext.declarative import declared_attr
@@ -29,9 +29,6 @@ class SQLAlchemyBaseUserTable(Generic[ID]):
     is_verified: bool = Column(Boolean, default=False, nullable=False)
 
 
-UP_SQLALCHEMY = TypeVar("UP_SQLALCHEMY", bound=SQLAlchemyBaseUserTable)
-
-
 class SQLAlchemyBaseUserTableUUID(SQLAlchemyBaseUserTable[UUID_ID]):
     id: UUID_ID = Column(GUID, primary_key=True, default=uuid.uuid4)
 
@@ -58,9 +55,7 @@ def user_id(cls):
         return Column(GUID, ForeignKey("user.id", ondelete="cascade"), nullable=False)
 
 
-class SQLAlchemyUserDatabase(
-    Generic[UP_SQLALCHEMY, ID], BaseUserDatabase[UP_SQLALCHEMY, ID]
-):
+class SQLAlchemyUserDatabase(Generic[UP, ID], BaseUserDatabase[UP, ID]):
     """
     Database adapter for SQLAlchemy.
 
@@ -70,32 +65,30 @@ class SQLAlchemyUserDatabase(
     """
 
     session: AsyncSession
-    user_table: Type[UP_SQLALCHEMY]
+    user_table: Type[UP]
     oauth_account_table: Optional[Type[SQLAlchemyBaseOAuthAccountTable]]
 
     def __init__(
         self,
         session: AsyncSession,
-        user_table: Type[UP_SQLALCHEMY],
+        user_table: Type[UP],
         oauth_account_table: Optional[Type[SQLAlchemyBaseOAuthAccountTable]] = None,
     ):
         self.session = session
         self.user_table = user_table
         self.oauth_account_table = oauth_account_table
 
-    async def get(self, id: ID) -> Optional[UP_SQLALCHEMY]:
+    async def get(self, id: ID) -> Optional[UP]:
         statement = select(self.user_table).where(self.user_table.id == id)
         return await self._get_user(statement)
 
-    async def get_by_email(self, email: str) -> Optional[UP_SQLALCHEMY]:
+    async def get_by_email(self, email: str) -> Optional[UP]:
         statement = select(self.user_table).where(
             func.lower(self.user_table.email) == func.lower(email)
         )
         return await self._get_user(statement)
 
-    async def get_by_oauth_account(
-        self, oauth: str, account_id: str
-    ) -> Optional[UP_SQLALCHEMY]:
+    async def get_by_oauth_account(self, oauth: str, account_id: str) -> Optional[UP]:
         if self.oauth_account_table is None:
             raise NotImplementedError()
 
@@ -107,30 +100,26 @@ async def get_by_oauth_account(
         )
         return await self._get_user(statement)
 
-    async def create(self, create_dict: Dict[str, Any]) -> UP_SQLALCHEMY:
+    async def create(self, create_dict: Dict[str, Any]) -> UP:
         user = self.user_table(**create_dict)
         self.session.add(user)
         await self.session.commit()
         await self.session.refresh(user)
         return user
 
-    async def update(
-        self, user: UP_SQLALCHEMY, update_dict: Dict[str, Any]
-    ) -> UP_SQLALCHEMY:
+    async def update(self, user: UP, update_dict: Dict[str, Any]) -> UP:
         for key, value in update_dict.items():
             setattr(user, key, value)
         self.session.add(user)
         await self.session.commit()
         await self.session.refresh(user)
         return user
 
-    async def delete(self, user: UP_SQLALCHEMY) -> None:
+    async def delete(self, user: UP) -> None:
         await self.session.delete(user)
         await self.session.commit()
 
-    async def add_oauth_account(
-        self, user: UP_SQLALCHEMY, create_dict: Dict[str, Any]
-    ) -> UP_SQLALCHEMY:
+    async def add_oauth_account(self, user: UP, create_dict: Dict[str, Any]) -> UP:
         if self.oauth_account_table is None:
             raise NotImplementedError()
 
@@ -145,8 +134,8 @@ async def add_oauth_account(
         return user
 
     async def update_oauth_account(
-        self, user: UP_SQLALCHEMY, oauth_account: OAP, update_dict: Dict[str, Any]
-    ) -> UP_SQLALCHEMY:
+        self, user: UP, oauth_account: OAP, update_dict: Dict[str, Any]
+    ) -> UP:
         if self.oauth_account_table is None:
             raise NotImplementedError()
 
@@ -157,7 +146,7 @@ async def update_oauth_account(
         await self.session.refresh(user)
         return user
 
-    async def _get_user(self, statement: Select) -> Optional[UP_SQLALCHEMY]:
+    async def _get_user(self, statement: Select) -> Optional[UP]:
         results = await self.session.execute(statement)
         user = results.first()
         if user is None:

fastapi_users_db_sqlalchemy/access_token.py

@@ -1,8 +1,8 @@
 import uuid
 from datetime import datetime
-from typing import Any, Dict, Generic, Optional, Type, TypeVar
+from typing import Any, Dict, Generic, Optional, Type
 
-from fastapi_users.authentication.strategy.db import AccessTokenDatabase
+from fastapi_users.authentication.strategy.db import AP, AccessTokenDatabase
 from fastapi_users.models import ID
 from sqlalchemy import Column, ForeignKey, String, select
 from sqlalchemy.ext.asyncio import AsyncSession
@@ -23,18 +23,13 @@ class SQLAlchemyBaseAccessTokenTable(Generic[ID]):
     user_id: ID
 
 
-AP_SQLALCHEMY = TypeVar("AP_SQLALCHEMY", bound=SQLAlchemyBaseAccessTokenTable)
-
-
 class SQLAlchemyBaseAccessTokenTableUUID(SQLAlchemyBaseAccessTokenTable[uuid.UUID]):
     @declared_attr
     def user_id(cls):
         return Column(GUID, ForeignKey("user.id", ondelete="cascade"), nullable=False)
 
 
-class SQLAlchemyAccessTokenDatabase(
-    Generic[AP_SQLALCHEMY], AccessTokenDatabase[AP_SQLALCHEMY]
-):
+class SQLAlchemyAccessTokenDatabase(Generic[AP], AccessTokenDatabase[AP]):
     """
     Access token database adapter for SQLAlchemy.
 
@@ -45,14 +40,14 @@ class SQLAlchemyAccessTokenDatabase(
     def __init__(
         self,
         session: AsyncSession,
-        access_token_table: Type[AP_SQLALCHEMY],
+        access_token_table: Type[AP],
     ):
         self.session = session
         self.access_token_table = access_token_table
 
     async def get_by_token(
         self, token: str, max_age: Optional[datetime] = None
-    ) -> Optional[AP_SQLALCHEMY]:
+    ) -> Optional[AP]:
         statement = select(self.access_token_table).where(
             self.access_token_table.token == token
         )
@@ -65,23 +60,21 @@ async def get_by_token(
             return None
         return access_token[0]
 
-    async def create(self, create_dict: Dict[str, Any]) -> AP_SQLALCHEMY:
+    async def create(self, create_dict: Dict[str, Any]) -> AP:
         access_token = self.access_token_table(**create_dict)
         self.session.add(access_token)
         await self.session.commit()
         await self.session.refresh(access_token)
         return access_token
 
-    async def update(
-        self, access_token: AP_SQLALCHEMY, update_dict: Dict[str, Any]
-    ) -> AP_SQLALCHEMY:
+    async def update(self, access_token: AP, update_dict: Dict[str, Any]) -> AP:
         for key, value in update_dict.items():
             setattr(access_token, key, value)
         self.session.add(access_token)
         await self.session.commit()
         await self.session.refresh(access_token)
         return access_token
 
-    async def delete(self, access_token: AP_SQLALCHEMY) -> None:
+    async def delete(self, access_token: AP) -> None:
         await self.session.delete(access_token)
         await self.session.commit()