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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: aiohttp-msal
-Version: 1.0.6
+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.6 → 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.6"
+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.6 → 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
@@ -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.
 
@@ -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.6 → 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.6 → aiohttp_msal-1.0.7}/src/aiohttp_msal/redis_tools.py

@@ -1,7 +1,6 @@
 """Redis tools for sessions."""
 
 import asyncio
-import json
 import logging
 import time
 from collections.abc import AsyncGenerator
@@ -11,7 +10,7 @@ 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
 
 _LOG = logging.getLogger(__name__)
 
@@ -21,17 +20,17 @@ SES_KEYS = ("mail", "name", "m_mail", "m_name")
 @asynccontextmanager
 async def get_redis() -> AsyncGenerator[Redis, None]:
     """Get a Redis connection."""
-    if MENV.database:
+    if ENV.database:
         _LOG.debug("Using redis from environment")
-        yield MENV.database
+        yield ENV.database
         return
-    _LOG.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()
 
 
@@ -50,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:
@@ -97,14 +96,14 @@ async def session_clean(
 
 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:
@@ -127,7 +126,7 @@ def async_msal_factory(
     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."""
@@ -163,11 +162,11 @@ async def get_session(
     raise ValueError(f"{msg} with scope {scope} not found ({cnt} checked)")
 
 
-async def redis_get_json(key: str) -> list[str] | dict[str, Any] | 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:
         _LOG.warning("Unexpected type for %s: %s", key, type(res))
     return None
@@ -175,7 +174,7 @@ async def redis_get_json(key: str) -> list[str] | dict[str, Any] | 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):
@@ -189,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:
         _LOG.warning("%s: removing %s", key, dif)
-        await MENV.database.srem(key, *dif)
+        await ENV.database.srem(key, *dif)
 
     dif = list(new_set - cur_set)
     if dif:
         _LOG.info("%s: adding %s", key, dif)
-        await MENV.database.sadd(key, *dif)
+        await ENV.database.sadd(key, *dif)
 
 
 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.6 → 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()