xn-auth 0.2.0__tar.gz → 0.2.2.dev1__tar.gz

{xn_auth-0.2.0/xn_auth.egg-info → xn_auth-0.2.2.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: xn-auth
-Version: 0.2.0
+Version: 0.2.2.dev1
 Summary: Auth adapter for XN-Api framework
 Author-email: Artemiev <mixartemev@gmail.com>
 License: MIT

{xn_auth-0.2.0 → xn_auth-0.2.2.dev1}/x_auth/__init__.py

@@ -2,7 +2,7 @@ import logging
 from datetime import timedelta
 
 from fastapi import HTTPException as BaseHTTPException
-from fastapi.openapi.models import HTTPBearer, SecuritySchemeType
+from fastapi.openapi.models import HTTPBase, SecuritySchemeType
 from fastapi.security.base import SecurityBase
 from fastapi.security.utils import get_authorization_scheme_param
 from jose import jwt, JWTError
@@ -46,13 +46,17 @@ class AuthException(HTTPException, AuthenticationError):
         super().__init__(reason=reason, parent=parent, status_=status_, hdrs=hdrs)
 
 
-class BearerBase(SecurityBase):
-    """HTTP Bearer token authentication"""
+class BearerModel(HTTPBase):
+    type_: SecuritySchemeType = SecuritySchemeType.http
+    scheme: str = "bearer"
+
 
-    scheme_name = "bearer"
+class BearerSecurity(SecurityBase):
+    """HTTP Bearer token authentication"""
 
-    def __init__(self, auto_error: bool = True, type_: SecuritySchemeType = SecuritySchemeType.http):
-        self.model = HTTPBearer(type=type_)
+    def __init__(self, model: BearerModel = BearerModel(), auto_error: bool = True, scheme_name: str = None):
+        self.model = model
+        self.scheme_name = scheme_name or self.__class__.__name__
         self.auto_error = auto_error
 
     async def __call__(self, conn: HTTPConnection) -> str | None:
@@ -63,7 +67,7 @@ class BearerBase(SecurityBase):
                 raise AuthException(reason=AuthFailReason.header, parent="Not authenticated")
             else:
                 return None
-        if scheme.lower() != "bearer":
+        if scheme.lower() != self.model.scheme:
             if self.auto_error:
                 raise AuthException(reason=AuthFailReason.scheme, parent="Not Bearer scheme")
             else:

{xn_auth-0.2.0 → xn_auth-0.2.2.dev1}/x_auth/backend.py

@@ -1,12 +1,12 @@
 from starlette.authentication import AuthenticationBackend, AuthCredentials
 from starlette.requests import HTTPConnection
 
-from x_auth import jwt_decode, BearerBase
+from x_auth import jwt_decode, BearerSecurity
 from x_auth.pydantic import AuthUser
 
 
 class AuthBackend(AuthenticationBackend):
-    def __init__(self, secret: str, auth_scheme: BearerBase):
+    def __init__(self, secret: str, auth_scheme: BearerSecurity):
         self.auth_scheme = auth_scheme
         self.secret = secret
 
@@ -15,4 +15,3 @@ class AuthBackend(AuthenticationBackend):
             verify_exp: bool = conn.scope["path"] != "/refresh"
             user: AuthUser = jwt_decode(token, self.secret, verify_exp)
             return AuthCredentials(scopes=user.role.scopes()), user
-        return None

{xn_auth-0.2.0 → xn_auth-0.2.2.dev1}/x_auth/depend.py

@@ -5,11 +5,11 @@ from fastapi.security import SecurityScopes
 from starlette.requests import HTTPConnection
 
 from x_auth.enums import AuthFailReason, UserStatus, Scope
-from x_auth import BearerBase, AuthUser, AuthException
+from x_auth import AuthUser, AuthException, BearerSecurity
 
 
 class Depend:
-    def __init__(self, scheme: BearerBase):
+    def __init__(self, scheme: BearerSecurity):
         # For Depends
         def get_authenticated_user(conn: HTTPConnection, _: str | None = Depends(scheme)) -> AuthUser:
             if not conn.user.is_authenticated:

{xn_auth-0.2.0 → xn_auth-0.2.2.dev1}/x_auth/router.py

@@ -4,7 +4,7 @@ from x_auth.backend import AuthBackend
 
 from x_auth.depend import Depend
 from x_auth.enums import FailReason, AuthFailReason
-from x_auth import jwt_encode, HTTPException, AuthException, BearerBase
+from x_auth import jwt_encode, HTTPException, AuthException, BearerSecurity
 from x_auth.model import User
 from x_auth.pydantic import AuthUser, UserReg, Token
 
@@ -12,37 +12,39 @@ from x_auth.pydantic import AuthUser, UserReg, Token
 class AuthRouter:
     expires = timedelta(minutes=15)
 
-    def __init__(self, secret: str, db_user_model: type(User) = User, scheme: BearerBase = BearerBase(False)):
+    def __init__(self, secret: str, db_user_model: type(User) = User, scheme: BearerSecurity = BearerSecurity()):
         self.depend = Depend(scheme)
-
-        # API ENDOINTS
-        def _user2tok(user: AuthUser) -> Token:
-            return Token(access_token=jwt_encode(user, secret, self.expires), user=user)
-
-        # api reg endpoint
-        async def reg(user_reg_input: UserReg) -> Token:
-            data = user_reg_input.model_dump()
-            try:
-                db_user: User = await db_user_model.create(**data)
-            except IntegrityError as e:
-                raise HTTPException(FailReason.body, e)
-            user: AuthUser = AuthUser.model_validate(db_user, from_attributes=True)
-            return _user2tok(user)
+        self.secret = secret
+        self.db_user_model = db_user_model
 
         # api refresh token
         async def refresh(auth_user: AuthUser = self.depend.AUTHENTICATED) -> Token:
             try:
-                db_user: User = await User[auth_user.id]
+                db_user: User = await self.db_user_model[auth_user.id]
                 auth_user = AuthUser.model_validate(db_user, from_attributes=True)
             except ConfigurationError:
                 raise AuthException(AuthFailReason.username, f"Not inicialized user model: {User})", 500)
             except Exception:
                 raise AuthException(AuthFailReason.username, f"No user#{auth_user.id}({auth_user.username})", 404)
 
-            return _user2tok(auth_user)
+            return self._user2tok(auth_user)
 
         self.routes: dict[str, tuple[callable, str]] = {
-            "reg": (reg, "POST"),
+            "reg": (self.reg, "POST"),
             "refresh": (refresh, "GET"),
         }
         self.backend = AuthBackend(secret, scheme)
+
+    # API ENDOINTS
+    def _user2tok(self, user: AuthUser) -> Token:
+        return Token(access_token=jwt_encode(user, self.secret, self.expires), user=user)
+
+    # api reg endpoint
+    async def reg(self, user_reg_input: UserReg) -> Token:
+        data = user_reg_input.model_dump()
+        try:
+            db_user: User = await self.db_user_model.create(**data)
+        except IntegrityError as e:
+            raise HTTPException(FailReason.body, e)
+        user: AuthUser = AuthUser.model_validate(db_user, from_attributes=True)
+        return self._user2tok(user)

{xn_auth-0.2.0 → xn_auth-0.2.2.dev1/xn_auth.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: xn-auth
-Version: 0.2.0
+Version: 0.2.2.dev1
 Summary: Auth adapter for XN-Api framework
 Author-email: Artemiev <mixartemev@gmail.com>
 License: MIT