aiohttp-msal 1.0.5__tar.gz → 1.0.7__tar.gz

{aiohttp_msal-1.0.5 → aiohttp_msal-1.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: aiohttp-msal
-Version: 1.0.5
+Version: 1.0.7
 Summary: Helper Library to use the Microsoft Authentication Library (MSAL) with aiohttp
 Keywords: aiohttp,asyncio,msal,oauth
 Author: Johann Kellerman

{aiohttp_msal-1.0.5 → aiohttp_msal-1.0.7}/pyproject.toml

@@ -4,7 +4,7 @@ requires = [ "uv-build" ]  # >=0.5.15,<0.6
 
 [project]
 name = "aiohttp-msal"
-version = "1.0.5"
+version = "1.0.7"
 description = "Helper Library to use the Microsoft Authentication Library (MSAL) with aiohttp"
 readme = "README.md"
 keywords = [ "aiohttp", "asyncio", "msal", "oauth" ]

{aiohttp_msal-1.0.5 → aiohttp_msal-1.0.7}/src/aiohttp_msal/__init__.py

@@ -1,11 +1,10 @@
 """aiohttp_msal."""
 
-import json
 import logging
 from collections.abc import Awaitable, Callable
 from functools import wraps
 from inspect import getfullargspec, iscoroutinefunction
-from typing import Any, TypeVar, TypeVarTuple, cast
+from typing import TypeVar, TypeVarTuple, cast
 
 from aiohttp import ClientSession, web
 from aiohttp_session import get_session
@@ -15,7 +14,7 @@ from aiohttp_msal.msal_async import AsyncMSAL
 from aiohttp_msal.settings import ENV
 from aiohttp_msal.utils import retry
 
-_LOGGER = logging.getLogger(__name__)
+_LOG = logging.getLogger(__name__)
 
 _T = TypeVar("_T")
 Ts = TypeVarTuple("Ts")
@@ -92,8 +91,6 @@ async def app_init_redis_session(
     app: web.Application,
     max_age: int = 3600 * 24 * 90,
     check_proxy_cb: Callable[[], Awaitable[None]] | None = None,
-    encoder: Callable[[object], str] = json.dumps,
-    decoder: Callable[[str], Any] = json.loads,
 ) -> None:
     """Init an aiohttp_session with Redis storage helper.
 
@@ -107,7 +104,7 @@ async def app_init_redis_session(
     else:
         await check_proxy()
 
-    _LOGGER.info("Connect to Redis %s", ENV.REDIS)
+    _LOG.info("Connect to Redis %s", ENV.REDIS)
     try:
         ENV.database = from_url(ENV.REDIS)
         # , encoding="utf-8", decode_responses=True
@@ -123,8 +120,8 @@ async def app_init_redis_session(
         secure=True,
         domain=ENV.DOMAIN,
         cookie_name=ENV.COOKIE_NAME,
-        encoder=encoder,
-        decoder=decoder,
+        encoder=ENV.dumps,
+        decoder=ENV.loads,
     )
     _setup(app, storage)
 

{aiohttp_msal-1.0.5 → aiohttp_msal-1.0.7}/src/aiohttp_msal/msal_async.py

@@ -6,7 +6,6 @@ Once you have the OAuth tokens store in the session, you are free to make reques
 """
 
 import asyncio
-import json
 import logging
 from collections.abc import Callable
 from functools import cached_property, partialmethod
@@ -43,7 +42,7 @@ T = TypeVar("T")
 
 @attrs.define(slots=False)
 class AsyncMSAL:
-    """AsycMSAL class.
+    """AsyncMSAL class.
 
     Authorization Code Flow Helper. Learn more about auth-code-flow at
     https://learn.microsoft.com/en-us/entra/identity-platform/v2-oauth2-auth-code-flow
@@ -220,7 +219,7 @@ class AsyncMSAL:
         elif method in [HTTP_POST, HTTP_PUT, HTTP_PATCH]:
             headers["Content-type"] = "application/json"
             if "data" in kwargs:
-                kwargs["data"] = json.dumps(kwargs["data"])  # auto convert to json
+                kwargs["data"] = ENV.dumps(kwargs["data"])  # auto convert to json
 
         if not AsyncMSAL.client_session:
             AsyncMSAL.client_session = ClientSession(trust_env=True)

{aiohttp_msal-1.0.5 → aiohttp_msal-1.0.7}/src/aiohttp_msal/redis_tools.py

@@ -1,19 +1,18 @@
 """Redis tools for sessions."""
 
 import asyncio
-import json
 import logging
 import time
 from collections.abc import AsyncGenerator
 from contextlib import AsyncExitStack, asynccontextmanager
-from typing import Any
+from typing import Any, TypeVar
 
 from redis.asyncio import Redis, from_url
 
 from aiohttp_msal.msal_async import AsyncMSAL
-from aiohttp_msal.settings import ENV as MENV
+from aiohttp_msal.settings import ENV
 
-_LOGGER = logging.getLogger(__name__)
+_LOG = logging.getLogger(__name__)
 
 SES_KEYS = ("mail", "name", "m_mail", "m_name")
 
@@ -21,22 +20,23 @@ SES_KEYS = ("mail", "name", "m_mail", "m_name")
 @asynccontextmanager
 async def get_redis() -> AsyncGenerator[Redis, None]:
     """Get a Redis connection."""
-    if MENV.database:
-        _LOGGER.debug("Using redis from environment")
-        yield MENV.database
+    if ENV.database:
+        _LOG.debug("Using redis from environment")
+        yield ENV.database
         return
-    _LOGGER.info("Connect to Redis %s", MENV.REDIS)
-    redis = from_url(MENV.REDIS)  # decode_responses=True not allowed aiohttp_session
-    MENV.database = redis
+    _LOG.info("Connect to Redis %s", ENV.REDIS)
+    redis = from_url(ENV.REDIS)  # decode_responses=True not allowed aiohttp_session
+    ENV.database = redis
     try:
         yield redis
     finally:
-        MENV.database = None  # type:ignore[assignment]
+        ENV.database = None  # type:ignore[assignment]
         await redis.close()
 
 
 async def session_iter(
     redis: Redis,
+    /,
     *,
     match: dict[str, str] | None = None,
     key_match: str | None = None,
@@ -49,14 +49,14 @@ async def session_iter(
     if match and not all(isinstance(v, str) for v in match.values()):
         raise ValueError("match values must be strings")
     async for key in redis.scan_iter(
-        count=100, match=key_match or f"{MENV.COOKIE_NAME}*"
+        count=100, match=key_match or f"{ENV.COOKIE_NAME}*"
     ):
         if not isinstance(key, str):
             key = key.decode()
         sval = await redis.get(key)
         created, ses = 0, {}
         try:
-            val = json.loads(sval)  # type: ignore[arg-type]
+            val = ENV.loads(sval)  # type: ignore[arg-type]
             created = int(val["created"])
             ses = val["session"]
         except Exception:
@@ -74,7 +74,7 @@ async def session_iter(
 
 
 async def session_clean(
-    redis: Redis, *, max_age: int = 90, expected_keys: dict[str, Any] | None = None
+    redis: Redis, /, *, max_age: int = 90, expected_keys: dict[str, Any] | None = None
 ) -> None:
     """Clear session entries older than max_age days."""
     rem, keep = 0, 0
@@ -89,30 +89,35 @@ async def session_clean(
                 keep += 1
     finally:
         if rem:
-            _LOGGER.info("Sessions removed: %s (%s total)", rem, keep)
+            _LOG.info("Sessions removed: %s (%s total)", rem, keep)
         else:
-            _LOGGER.debug("No sessions removed (%s total)", keep)
+            _LOG.debug("No sessions removed (%s total)", keep)
 
 
-async def invalid_sessions(redis: Redis) -> None:
+async def invalid_sessions(redis: Redis, /) -> None:
     """Find & clean invalid sessions."""
-    async for key in redis.scan_iter(count=100, match=f"{MENV.COOKIE_NAME}*"):
+    async for key in redis.scan_iter(count=100, match=f"{ENV.COOKIE_NAME}*"):
         if not isinstance(key, str):
             key = key.decode()
         sval = await redis.get(key)
         if sval is None:
             continue
         try:
-            val: dict = json.loads(sval)
+            val: dict = ENV.loads(sval)
             assert isinstance(val["created"], int)
             assert isinstance(val["session"], dict)
         except Exception as err:
-            _LOGGER.warning("Removing session %s: %s", key, err)
+            _LOG.warning("Removing session %s: %s", key, err)
             await redis.delete(key)
 
 
-def _session_factory(key: str, created: int, session: dict) -> AsyncMSAL:
-    """Create a AsyncMSAL session.
+T = TypeVar("T", bound=AsyncMSAL)
+
+
+def async_msal_factory(
+    cls: type[T], key: str, created: int, session: dict[str, Any], /
+) -> T:
+    """Create a AsyncMSAL session with a save_callback.
 
     When get_token refreshes the token retrieved from Redis, the save_cache callback
     will be responsible to update the cache in Redis.
@@ -121,7 +126,7 @@ def _session_factory(key: str, created: int, session: dict) -> AsyncMSAL:
     async def async_save_cache(_: dict) -> None:
         """Save the token cache to Redis."""
         async with get_redis() as rd2:
-            await rd2.set(key, json.dumps({"created": created, "session": session}))
+            await rd2.set(key, ENV.dumps({"created": created, "session": session}))
 
     def save_cache(*args: Any) -> None:
         """Save the token cache to Redis."""
@@ -130,12 +135,17 @@ def _session_factory(key: str, created: int, session: dict) -> AsyncMSAL:
         except RuntimeError:
             asyncio.run(async_save_cache(*args))
 
-    return AsyncMSAL(session, save_callback=save_cache)
+    return cls(session, save_callback=save_cache)
 
 
 async def get_session(
-    email: str, *, redis: Redis | None = None, scope: str = ""
-) -> AsyncMSAL:
+    cls: type[T],
+    email: str,
+    /,
+    *,
+    redis: Redis | None = None,
+    scope: str = "",
+) -> T:
     """Get a session from Redis."""
     cnt = 0
     async with AsyncExitStack() as stack:
@@ -143,34 +153,34 @@ async def get_session(
             redis = await stack.enter_async_context(get_redis())
         async for key, created, session in session_iter(redis, match={"mail": email}):
             cnt += 1
-            if scope and scope not in str(session.get("token_cache")).lower():
+            if scope and scope not in str(session.get(cls.token_cache_key)).lower():
                 continue
-            return _session_factory(key, created, session)
+            return async_msal_factory(cls, key, created, session)
     msg = f"Session for {email}"
     if not scope:
         raise ValueError(f"{msg} not found")
     raise ValueError(f"{msg} with scope {scope} not found ({cnt} checked)")
 
 
-async def redis_get_json(key: str) -> list | dict | None:
+async def redis_get_json(key: str) -> list[Any] | dict[str, Any] | None:
     """Get a key from redis."""
-    res = await MENV.database.get(key)
+    res = await ENV.database.get(key)
     if isinstance(res, str | bytes | bytearray):
-        return json.loads(res)
+        return ENV.loads(res)
     if res is not None:
-        _LOGGER.warning("Unexpected type for %s: %s", key, type(res))
+        _LOG.warning("Unexpected type for %s: %s", key, type(res))
     return None
 
 
 async def redis_get(key: str) -> str | None:
     """Get a key from redis."""
-    res = await MENV.database.get(key)
+    res = await ENV.database.get(key)
     if isinstance(res, str):
         return res
     if isinstance(res, bytes | bytearray):
         return res.decode()
     if res is not None:
-        _LOGGER.warning("Unexpected type for %s: %s", key, type(res))
+        _LOG.warning("Unexpected type for %s: %s", key, type(res))
     return None
 
 
@@ -178,22 +188,22 @@ async def redis_set_set(key: str, new_set: set[str]) -> None:
     """Set the value of a set in redis."""
     cur_set = set(
         s if isinstance(s, str) else s.decode()
-        for s in await MENV.database.smembers(key)
+        for s in await ENV.database.smembers(key)
     )
     dif = list(cur_set - new_set)
     if dif:
-        _LOGGER.warning("%s: removing %s", key, dif)
-        await MENV.database.srem(key, *dif)
+        _LOG.warning("%s: removing %s", key, dif)
+        await ENV.database.srem(key, *dif)
 
     dif = list(new_set - cur_set)
     if dif:
-        _LOGGER.info("%s: adding %s", key, dif)
-        await MENV.database.sadd(key, *dif)
+        _LOG.info("%s: adding %s", key, dif)
+        await ENV.database.sadd(key, *dif)
 
 
-async def redis_scan(match_str: str) -> list[str]:
+async def redis_scan_keys(match_str: str) -> list[str]:
     """Return a list of matching keys."""
     return [
         s if isinstance(s, str) else s.decode()
-        async for s in MENV.database.scan_iter(match=match_str)
+        async for s in ENV.database.scan_iter(match=match_str)
     ]

{aiohttp_msal-1.0.5 → aiohttp_msal-1.0.7}/src/aiohttp_msal/settings.py

@@ -1,5 +1,6 @@
 """Settings."""
 
+import json
 from collections.abc import Awaitable, Callable
 from typing import TYPE_CHECKING, Any
 
@@ -39,8 +40,11 @@ class MSALSettings(SettingsBase):
 
     REDIS: str = "redis://redis1:6379"
     """OPTIONAL: Redis database connection used by app_init_redis_session()."""
-    database: "Redis" = attrs.field(init=False)
+    database: "Redis" = attrs.field(init=False, default=None)
     """Store the Redis connection when using app_init_redis_session()."""
 
+    dumps: Callable[[Any], str] = attrs.field(default=json.dumps)
+    loads: Callable[[str | bytes | bytearray], Any] = attrs.field(default=json.loads)
+
 
 ENV = MSALSettings()