aiohttp-msal 1.0.6__py3-none-any.whl → 1.0.8__py3-none-any.whl

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 cast
 
 from aiohttp import ClientSession, web
 from aiohttp_session import get_session
@@ -17,15 +16,12 @@ from aiohttp_msal.utils import retry
 
 _LOG = logging.getLogger(__name__)
 
-_T = TypeVar("_T")
-Ts = TypeVarTuple("Ts")
 
-
-def msal_session(
+def msal_session[T, *Ts](
     *callbacks: Callable[[AsyncMSAL], bool | Awaitable[bool]],
     at_least_one: bool | None = False,
 ) -> Callable[
-    [Callable[[*Ts, AsyncMSAL], Awaitable[_T]]], Callable[[*Ts], Awaitable[_T]]
+    [Callable[[*Ts, AsyncMSAL], Awaitable[T]]], Callable[[*Ts], Awaitable[T]]
 ]:
     """Session decorator.
 
@@ -33,10 +29,10 @@ def msal_session(
     """
 
     def check_session(
-        func: Callable[[*Ts, AsyncMSAL], Awaitable[_T]],
-    ) -> Callable[[*Ts], Awaitable[_T]]:
+        func: Callable[[*Ts, AsyncMSAL], Awaitable[T]],
+    ) -> Callable[[*Ts], Awaitable[T]]:
         @wraps(func)
-        async def wrapper(*args: *Ts) -> _T:
+        async def wrapper(*args: *Ts) -> T:
             if len(args) < 1:
                 raise AssertionError("Requires a Request as the first parameter")
             request = cast(web.Request, args[0])
@@ -92,8 +88,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,12 +101,13 @@ async def app_init_redis_session(
     else:
         await check_proxy()
 
-    _LOG.info("Connect to Redis %s", ENV.REDIS)
-    try:
-        ENV.database = from_url(ENV.REDIS)
-        # , encoding="utf-8", decode_responses=True
-    except ConnectionRefusedError as err:
-        raise ConnectionError("Could not connect to REDIS server") from err
+    if ENV.database is None:
+        _LOG.info("Connect to Redis %s", ENV.REDIS)
+        try:
+            ENV.database = from_url(ENV.REDIS)
+            # , encoding="utf-8", decode_responses=True
+        except ConnectionRefusedError as err:
+            raise ConnectionError("Could not connect to REDIS server") from err
 
     storage = redis_storage.RedisStorage(
         ENV.database,
@@ -123,8 +118,8 @@ async def app_init_redis_session(
         secure=True,
         domain=ENV.DOMAIN,
         cookie_name=ENV.COOKIE_NAME,
-        encoder=encoder,
-        decoder=decoder,
+        encoder=ENV.json_dumps,
+        decoder=ENV.json_loads,
     )
     _setup(app, storage)
 
@@ -132,13 +127,13 @@ async def app_init_redis_session(
 @retry
 async def check_proxy() -> None:
     """Test if we have Internet connectivity through proxies etc."""
-    try:
-        async with ClientSession(trust_env=True) as cses:
-            async with cses.get("http://httpbin.org/get") as resp:
+    print("Check Internet connectivity for OAuth", end="", flush=True)
+    async with ClientSession(trust_env=True) as cses:
+        for url in ("https://www.google.com", "http://httpbin.org/get"):
+            async with cses.get(url) as resp:
                 if resp.ok:
+                    print(" ... ok", flush=True)
                     return
-                raise ConnectionError(await resp.text())
-    except Exception as err:
-        raise ConnectionError(
-            "No connection to the Internet. Required for OAuth. Check your Proxy?"
-        ) from err
+    raise ConnectionError(
+        "No connection to the Internet. Required for OAuth. Check your Proxy?"
+    )

aiohttp_msal/msal_async.py

@@ -6,11 +6,10 @@ 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
-from typing import Any, ClassVar, Literal, Self, TypeVar, Unpack, cast
+from typing import Any, ClassVar, Literal, Self, Unpack, cast
 
 import attrs
 from aiohttp import web
@@ -38,12 +37,10 @@ HTTP_PATCH = "patch"
 HTTP_DELETE = "delete"
 HTTP_ALLOWED = [HTTP_GET, HTTP_POST, HTTP_PUT, HTTP_PATCH, HTTP_DELETE]
 
-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 +217,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.json_dumps(kwargs["data"])  # auto convert to json
 
         if not AsyncMSAL.client_session:
             AsyncMSAL.client_session = ClientSession(trust_env=True)

aiohttp_msal/redis_tools.py

@@ -1,17 +1,16 @@
 """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, TypeVar
+from typing import Any
 
 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.json_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.json_loads(sval)
             assert isinstance(val["created"], int)
             assert isinstance(val["session"], dict)
         except Exception as err:
@@ -112,10 +111,7 @@ async def invalid_sessions(redis: Redis, /) -> None:
             await redis.delete(key)
 
 
-T = TypeVar("T", bound=AsyncMSAL)
-
-
-def async_msal_factory(
+def async_msal_factory[T: AsyncMSAL](
     cls: type[T], key: str, created: int, session: dict[str, Any], /
 ) -> T:
     """Create a AsyncMSAL session with a save_callback.
@@ -127,7 +123,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.json_dumps({"created": created, "session": session}))
 
     def save_cache(*args: Any) -> None:
         """Save the token cache to Redis."""
@@ -139,7 +135,7 @@ def async_msal_factory(
     return cls(session, save_callback=save_cache)
 
 
-async def get_session(
+async def get_session[T: AsyncMSAL](
     cls: type[T],
     email: str,
     /,
@@ -163,11 +159,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.json_loads(res)
     if res is not None:
         _LOG.warning("Unexpected type for %s: %s", key, type(res))
     return None
@@ -175,7 +171,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 +185,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/settings.py

@@ -1,5 +1,6 @@
 """Settings."""
 
+import json
 from collections.abc import Awaitable, Callable
 from typing import TYPE_CHECKING, Any
 
@@ -39,8 +40,13 @@ 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()."""
 
+    json_dumps: Callable[[Any], str] = attrs.field(default=json.dumps)
+    json_loads: Callable[[str | bytes | bytearray], Any] = attrs.field(
+        default=json.loads
+    )
+
 
 ENV = MSALSettings()

aiohttp_msal/utils.py

@@ -3,13 +3,10 @@
 import asyncio
 from collections.abc import Awaitable, Callable
 from functools import partial, wraps
-from typing import Any, ParamSpec, TypeVar
+from typing import Any
 
-T = TypeVar("T")
-P = ParamSpec("P")
 
-
-def async_wrap(
+def async_wrap[T](
     func: Callable[..., T],
 ) -> Callable[..., Awaitable[T]]:
     """Wrap a function doing I/O to run in an executor thread."""
@@ -49,17 +46,7 @@ class dict_property(property):
             getattr(instance, self.dict_name, {}).__setitem__(self.prop_name, value)
 
 
-# def dict_property(dict_name: str, prop_name: str) -> property:
-#     """Create properties for a dictionary."""
-#     return property(
-#         fget=lambda self: str(getattr(self, dict_name).get(prop_name, "")),
-#         fset=lambda self, v: getattr(self, dict_name).set(prop_name, v),
-#         fdel=lambda self: getattr(self, dict_name).pop(prop_name, None),
-#         doc=f'self.{dict_name}["{prop_name}"]',
-#     )
-
-
-def retry(func: Callable[P, Awaitable[T]]) -> Callable[P, Awaitable[T]]:
+def retry[T, **P](func: Callable[P, Awaitable[T]]) -> Callable[P, Awaitable[T]]:
     """Retry if tenacity is installed."""
 
     @wraps(func)

{aiohttp_msal-1.0.6.dist-info → aiohttp_msal-1.0.8.dist-info}/METADATA

@@ -1,24 +1,44 @@
 Metadata-Version: 2.3
 Name: aiohttp-msal
-Version: 1.0.6
+Version: 1.0.8
 Summary: Helper Library to use the Microsoft Authentication Library (MSAL) with aiohttp
 Keywords: aiohttp,asyncio,msal,oauth
 Author: Johann Kellerman
 Author-email: Johann Kellerman <kellerza@gmail.com>
-License: MIT
+License: The MIT License (MIT)
+         
+         Copyright (c) 2022-2025 kellerza
+         
+         Permission is hereby granted, free of charge, to any person obtaining a copy
+         of this software and associated documentation files (the "Software"), to deal
+         in the Software without restriction, including without limitation the rights
+         to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+         copies of the Software, and to permit persons to whom the Software is
+         furnished to do so, subject to the following conditions:
+         
+         The above copyright notice and this permission notice shall be included in all
+         copies or substantial portions of the Software.
+         
+         THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+         IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+         FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+         AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+         LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+         OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+         SOFTWARE.
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Natural Language :: English
 Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Requires-Dist: aiohttp>=3.11.18,<3.13
-Requires-Dist: aiohttp-session>=2.12.1,<3
+Requires-Dist: aiohttp-session[aioredis]>=2.12.1,<3
 Requires-Dist: attrs>=25.3,<26
 Requires-Dist: msal>=1.32.3,<2
 Requires-Dist: aiohttp-session[aioredis]>=2.12.1,<3 ; extra == 'aioredis'
-Requires-Python: >=3.11
+Requires-Python: >=3.12
 Project-URL: Homepage, https://github.com/kellerza/aiohttp_msal
 Provides-Extra: aioredis
 Description-Content-Type: text/markdown
@@ -135,8 +155,6 @@ def main()
 ```bash
 uv sync --all-extras
 uv tool install ruff
-uv tool install codespell
-uv tool install pyproject-fmt
 uv tool install prek
 prek install  # add pre-commit hooks
 ```

aiohttp_msal-1.0.8.dist-info/RECORD

@@ -0,0 +1,11 @@
+aiohttp_msal/__init__.py,sha256=TVGbcFLA9GqGz5s43tovcESkJ_lLj1uZvn9IBtYyP0A,4308
+aiohttp_msal/helpers.py,sha256=L0DFIZD9OfCepckfk64ZtxrVX0-y0aAqRFowBYipepE,2474
+aiohttp_msal/msal_async.py,sha256=_7cA3zoj4GJyHuaAVhdlUubjdn2fH7t2ZOglumkqq28,11668
+aiohttp_msal/redis_tools.py,sha256=9U56XgFQgbRSyELP5pBvDVzYaBbkvyNRSWJPCLm-XOM,6637
+aiohttp_msal/routes.py,sha256=Cc6FHqs8dyHSTCC6AaT-yPttSDyBlsngoiz7j9QCKRU,5143
+aiohttp_msal/settings.py,sha256=EwtymlatYZqUqGlAi5-ffyDeCs7UnXpqv9h3qrqtFvE,1762
+aiohttp_msal/settings_base.py,sha256=WBI7HS780i9zKWUy1ZnztDbRsfoDMVr3K-otHZOhNCc,3026
+aiohttp_msal/utils.py,sha256=DhIkS2mqJp87YHTzlOrI0GFpQYDUujIrIYS43QqzovU,1920
+aiohttp_msal-1.0.8.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
+aiohttp_msal-1.0.8.dist-info/METADATA,sha256=F6rgY5s5SmL8x2p_90dEiU88MVu7TllfrgZse8A9ymU,5782
+aiohttp_msal-1.0.8.dist-info/RECORD,,

{aiohttp_msal-1.0.6.dist-info → aiohttp_msal-1.0.8.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: uv 0.8.15
+Generator: uv 0.8.24
 Root-Is-Purelib: true
 Tag: py3-none-any

aiohttp_msal-1.0.6.dist-info/RECORD

@@ -1,11 +0,0 @@
-aiohttp_msal/__init__.py,sha256=bCBQhbjM5IHKnHKzSDkHQ8Lk_YgW3flO11dgaDn8-Yg,4369
-aiohttp_msal/helpers.py,sha256=L0DFIZD9OfCepckfk64ZtxrVX0-y0aAqRFowBYipepE,2474
-aiohttp_msal/msal_async.py,sha256=VG5L6PGBHzRBNg_XfIqvfU1V-Snznv_Srd_kXzBgTts,11702
-aiohttp_msal/redis_tools.py,sha256=vAA3pvMT8jXd1sDL7wUZ8Z1FWO0xfHTWzi3_pnA_f8E,6672
-aiohttp_msal/routes.py,sha256=Cc6FHqs8dyHSTCC6AaT-yPttSDyBlsngoiz7j9QCKRU,5143
-aiohttp_msal/settings.py,sha256=sArlq9vBDMsikLf9sTRw-UXE2_QRK_G-kzmtHvZcbwA,1559
-aiohttp_msal/settings_base.py,sha256=WBI7HS780i9zKWUy1ZnztDbRsfoDMVr3K-otHZOhNCc,3026
-aiohttp_msal/utils.py,sha256=ll303J58nwCEB9QCAm13urUOa6cPqsAE7z_iP9OlRJw,2390
-aiohttp_msal-1.0.6.dist-info/WHEEL,sha256=Jb20R3Ili4n9P1fcwuLup21eQ5r9WXhs4_qy7VTrgPI,79
-aiohttp_msal-1.0.6.dist-info/METADATA,sha256=YvbKSl1STeQhHmyb9n9vKpsoHfalctOKStQIA_NZHNk,4572
-aiohttp_msal-1.0.6.dist-info/RECORD,,