mdb-engine 0.1.6__py3-none-any.whl → 0.1.7__py3-none-any.whl

mdb_engine/auth/restrictions.py

@@ -27,9 +27,7 @@ from .users import get_app_user
 logger = logging.getLogger(__name__)
 
 
-def is_demo_user(
-    user: Optional[Dict[str, Any]] = None, email: Optional[str] = None
-) -> bool:
+def is_demo_user(user: Optional[Dict[str, Any]] = None, email: Optional[str] = None) -> bool:
     """
     Check if a user is a demo user.
 
@@ -85,9 +83,7 @@ async def _get_sub_auth_user(
         if not (config and users_config.get("enabled", False)):
             return None
 
-        app_user = await get_app_user(
-            request, slug_id, db, config, allow_demo_fallback=False
-        )
+        app_user = await get_app_user(request, slug_id, db, config, allow_demo_fallback=False)
         if not app_user:
             return None
 
@@ -119,9 +115,7 @@ async def _get_authenticated_user(
 
     # Try sub-auth if platform auth didn't work
     if get_app_db_func and get_app_config_func:
-        return await _get_sub_auth_user(
-            request, slug_id, get_app_config_func, get_app_db_func
-        )
+        return await _get_sub_auth_user(request, slug_id, get_app_config_func, get_app_db_func)
 
     return None
 
@@ -158,9 +152,7 @@ def _validate_dependencies(
 
 async def require_non_demo_user(
     request: Request,
-    get_app_config_func: Optional[
-        Callable[[Request, str, Dict], Awaitable[Dict]]
-    ] = None,
+    get_app_config_func: Optional[Callable[[Request, str, Dict], Awaitable[Dict]]] = None,
     get_app_db_func: Optional[Callable[[Request], Awaitable[Any]]] = None,
 ) -> Dict[str, Any]:
     """
@@ -189,9 +181,7 @@ async def require_non_demo_user(
     if get_app_db_func and get_app_config_func:
         _validate_dependencies(get_app_config_func, get_app_db_func)
 
-    user = await _get_authenticated_user(
-        request, slug_id, get_app_config_func, get_app_db_func
-    )
+    user = await _get_authenticated_user(request, slug_id, get_app_config_func, get_app_db_func)
 
     # Check if user is demo
     if user and is_demo_user(user):
@@ -215,9 +205,7 @@ async def require_non_demo_user(
 
 async def block_demo_users(
     request: Request,
-    get_app_config_func: Optional[
-        Callable[[Request, str, Dict], Awaitable[Dict]]
-    ] = None,
+    get_app_config_func: Optional[Callable[[Request, str, Dict], Awaitable[Dict]]] = None,
     get_app_db_func: Optional[Callable[[Request], Awaitable[Any]]] = None,
 ):
     """
@@ -253,15 +241,11 @@ async def block_demo_users(
 
     # Check sub-auth if platform auth didn't work
     if not user and get_app_db_func and get_app_config_func and slug_id:
-        user = await _get_sub_auth_user(
-            request, slug_id, get_app_config_func, get_app_db_func
-        )
+        user = await _get_sub_auth_user(request, slug_id, get_app_config_func, get_app_db_func)
 
     # Block if demo user (only if user exists)
     if user and is_demo_user(user):
-        logger.info(
-            f"Demo user '{user.get('email')}' blocked from accessing: {request.url.path}"
-        )
+        logger.info(f"Demo user '{user.get('email')}' blocked from accessing: {request.url.path}")
         raise HTTPException(
             status_code=status.HTTP_403_FORBIDDEN,
             detail="Demo users cannot access this endpoint. Demo mode is read-only.",

mdb_engine/auth/session_manager.py

@@ -13,8 +13,11 @@ from typing import Any, Dict, List, Optional
 from bson.objectid import ObjectId
 
 try:
-    from pymongo.errors import (ConnectionFailure, OperationFailure,
-                                ServerSelectionTimeoutError)
+    from pymongo.errors import (
+        ConnectionFailure,
+        OperationFailure,
+        ServerSelectionTimeoutError,
+    )
 except ImportError:
     ConnectionFailure = Exception
     OperationFailure = Exception
@@ -120,9 +123,7 @@ class SessionManager:
                 # Remove oldest inactive session
                 await self.cleanup_inactive_sessions(user_id)
                 # Check again
-                active_sessions = await self.get_user_sessions(
-                    user_id, active_only=True
-                )
+                active_sessions = await self.get_user_sessions(user_id, active_only=True)
                 if len(active_sessions) >= self.max_sessions:
                     # Force remove oldest session
                     if active_sessions:
@@ -168,9 +169,7 @@ class SessionManager:
             ValueError,
             TypeError,
         ) as e:
-            logger.error(
-                f"Error creating session for user {user_id}: {e}", exc_info=True
-            )
+            logger.error(f"Error creating session for user {user_id}: {e}", exc_info=True)
             return None
 
     async def update_session_activity(
@@ -205,14 +204,10 @@ class SessionManager:
             ValueError,
             TypeError,
         ) as e:
-            logger.error(
-                f"Error updating session activity for {refresh_jti}: {e}", exc_info=True
-            )
+            logger.error(f"Error updating session activity for {refresh_jti}: {e}", exc_info=True)
             return False
 
-    async def get_session_by_refresh_token(
-        self, refresh_jti: str
-    ) -> Optional[Dict[str, Any]]:
+    async def get_session_by_refresh_token(self, refresh_jti: str) -> Optional[Dict[str, Any]]:
         """
         Get session by refresh token JWT ID.
 
@@ -223,9 +218,7 @@ class SessionManager:
             Session document or None if not found
         """
         try:
-            session = await self.collection.find_one(
-                {"refresh_jti": refresh_jti, "active": True}
-            )
+            session = await self.collection.find_one({"refresh_jti": refresh_jti, "active": True})
             return session
         except (
             OperationFailure,
@@ -267,9 +260,7 @@ class SessionManager:
             stored_fingerprint = session.get("session_fingerprint")
 
             if not stored_fingerprint:
-                strict_mode = (
-                    strict if strict is not None else self.fingerprinting_strict
-                )
+                strict_mode = strict if strict is not None else self.fingerprinting_strict
                 return not strict_mode
 
             return stored_fingerprint == current_fingerprint
@@ -313,9 +304,7 @@ class SessionManager:
             if active_only:
                 query["active"] = True
 
-            sessions = (
-                await self.collection.find(query).sort("last_seen", -1).to_list(None)
-            )
+            sessions = await self.collection.find(query).sort("last_seen", -1).to_list(None)
             return sessions
         except (
             OperationFailure,
@@ -324,9 +313,7 @@ class SessionManager:
             ValueError,
             TypeError,
         ) as e:
-            logger.error(
-                f"Error getting sessions for user {user_id}: {e}", exc_info=True
-            )
+            logger.error(f"Error getting sessions for user {user_id}: {e}", exc_info=True)
             return []
 
     async def revoke_session(self, session_id: Any) -> bool:
@@ -400,9 +387,7 @@ class SessionManager:
             ValueError,
             TypeError,
         ) as e:
-            logger.error(
-                f"Error revoking sessions for user {user_id}: {e}", exc_info=True
-            )
+            logger.error(f"Error revoking sessions for user {user_id}: {e}", exc_info=True)
             return 0
 
     async def cleanup_inactive_sessions(self, user_id: Optional[str] = None) -> int: