aiohttp-msal 0.7.0__py3-none-any.whl → 1.0.0__py3-none-any.whl

aiohttp_msal/__init__.py

@@ -1,9 +1,10 @@
 """aiohttp_msal."""
 
 import logging
-import typing
+from collections.abc import Awaitable, Callable
 from functools import wraps
 from inspect import getfullargspec, iscoroutinefunction
+from typing import TypeVar, TypeVarTuple, cast
 
 from aiohttp import ClientSession, web
 from aiohttp_session import get_session
@@ -14,49 +15,63 @@ from aiohttp_msal.settings import ENV
 
 _LOGGER = logging.getLogger(__name__)
 
-VERSION = "0.7.0"
+_T = TypeVar("_T")
+Ts = TypeVarTuple("Ts")
 
 
 def msal_session(
-    *callbacks: typing.Callable[[AsyncMSAL], bool | typing.Awaitable[bool]],
+    *callbacks: Callable[[AsyncMSAL], bool | Awaitable[bool]],
     at_least_one: bool | None = False,
-) -> typing.Callable:
+) -> Callable[
+    [Callable[[*Ts, AsyncMSAL], Awaitable[_T]]], Callable[[*Ts], Awaitable[_T]]
+]:
     """Session decorator.
 
     Arguments can include a list of function to perform login tests etc.
     """
 
-    def _session(func: typing.Callable) -> typing.Callable:
+    def check_session(
+        func: Callable[[*Ts, AsyncMSAL], Awaitable[_T]],
+    ) -> Callable[[*Ts], Awaitable[_T]]:
         @wraps(func)
-        async def __session(request: web.Request) -> typing.Callable:
+        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])
             ses = AsyncMSAL(session=await get_session(request))
             for c_b in callbacks:
                 _ok = await c_b(ses) if iscoroutinefunction(c_b) else c_b(ses)
-                if at_least_one and _ok:
-                    break
-                if not at_least_one and not _ok:
+
+                if at_least_one:
+                    if _ok:
+                        return await func(*args, ses)
+                elif not _ok:
                     raise web.HTTPForbidden
-            return await func(request=request, ses=ses)
+
+            if at_least_one:
+                raise web.HTTPForbidden
+            return await func(*args, ses)
 
         assert iscoroutinefunction(func), f"Function needs to be a coroutine: {func}"
         spec = getfullargspec(func)
         assert "ses" in spec.args, f"Function needs to accept a session 'ses': {func}"
-        return __session
+        return wrapper
 
-    return _session
+    return check_session
 
 
-def authenticated(ses: AsyncMSAL) -> bool:
+def auth_ok(ses: AsyncMSAL) -> bool:
     """Test if session was authenticated."""
     return bool(ses.mail)
 
 
 def auth_or(
-    *args: typing.Callable[[AsyncMSAL], bool | typing.Awaitable[bool]]
-) -> typing.Callable[[AsyncMSAL], typing.Awaitable[bool]]:
+    *args: Callable[[AsyncMSAL], bool | Awaitable[bool]],
+) -> Callable[[AsyncMSAL], Awaitable[bool]]:
     """Ensure either of the methods is valid. An alternative to at_least_one=True.
 
-    Arguments can include a list of function to perform login tests etc."""
+    Arguments can include a list of function to perform login tests etc.
+    """
 
     async def or_auth(ses: AsyncMSAL) -> bool:
         """Or."""
@@ -74,11 +89,10 @@ def auth_or(
 async def app_init_redis_session(
     app: web.Application, max_age: int = 3600 * 24 * 90
 ) -> None:
-    """OPTIONAL: Initialize aiohttp_session with Redis storage.
+    """Init an aiohttp_session with Redis storage helper.
 
     You can initialize your own aiohttp_session & storage provider.
     """
-    # pylint: disable=import-outside-toplevel
     from aiohttp_session import redis_storage
     from redis.asyncio import from_url
 
@@ -86,7 +100,7 @@ async def app_init_redis_session(
 
     _LOGGER.info("Connect to Redis %s", ENV.REDIS)
     try:
-        ENV.database = from_url(ENV.REDIS)  # pylint: disable=no-member
+        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
@@ -112,7 +126,7 @@ async def check_proxy() -> None:
                 if resp.ok:
                     return
                 raise ConnectionError(await resp.text())
-    except Exception as err:  # pylint: disable=broad-except
+    except Exception as err:
         raise ConnectionError(
             "No connection to the Internet. Required for OAuth. Check your Proxy?"
         ) from err

aiohttp_msal/msal_async.py

@@ -7,16 +7,24 @@ Once you have the OAuth tokens store in the session, you are free to make reques
 
 import asyncio
 import json
-from functools import partial, wraps
-from typing import Any, Callable, Literal
+from collections.abc import Callable
+from functools import partial, partialmethod, wraps
+from typing import Any, ClassVar, Literal, Unpack
 
 from aiohttp import web
-from aiohttp.client import ClientResponse, ClientSession, _RequestContextManager
+from aiohttp.client import (
+    ClientResponse,
+    ClientSession,
+    _RequestContextManager,
+    _RequestOptions,
+)
+from aiohttp.typedefs import StrOrURL
 from aiohttp_session import Session
 from msal import ConfidentialClientApplication, SerializableTokenCache
 
 from aiohttp_msal.settings import ENV
 
+HttpMethods = Literal["get", "post", "put", "patch", "delete"]
 HTTP_GET = "get"
 HTTP_POST = "post"
 HTTP_PUT = "put"
@@ -62,24 +70,23 @@ class AsyncMSAL:
     Use until such time as MSAL Python gets a true async version.
     """
 
-    _token_cache: SerializableTokenCache = None
-    _app: ConfidentialClientApplication = None
-    _clientsession: ClientSession = None  # type: ignore
+    _token_cache: SerializableTokenCache
+    _app: ConfidentialClientApplication
+    client_session: ClassVar[ClientSession | None] = None
 
     def __init__(
         self,
-        session: Session | dict[str, str],
-        save_cache: Callable[[Session | dict[str, str]], None] | None = None,
+        session: Session | dict[str, Any],
+        save_callback: Callable[[Session | dict[str, Any]], None] | None = None,
     ):
         """Init the class.
 
-        **save_token_cache** will be called if the token cache changes. Optional.
+        **save_callback** will be called if the token cache changes. Optional.
           Not required when the session parameter is an aiohttp_session.Session.
         """
         self.session = session
-        if save_cache:
-            self.save_token_cache = save_cache
-        if not isinstance(session, (Session, dict)):
+        self.save_callback = save_callback
+        if not isinstance(session, Session | dict):
             raise ValueError(f"session or dict-like object required {session}")
 
     @property
@@ -110,12 +117,12 @@ class AsyncMSAL:
             )
         return self._app
 
-    def _save_token_cache(self) -> None:
+    def save_token_cache(self) -> None:
         """Save the token cache if it changed."""
         if self.token_cache.has_state_changed:
             self.session[TOKEN_CACHE] = self.token_cache.serialize()
-            if hasattr(self, "save_token_cache"):
-                self.save_token_cache(self.token_cache)
+            if self.save_callback:
+                self.save_callback(self.session)
 
     def build_auth_code_flow(
         self,
@@ -125,8 +132,8 @@ class AsyncMSAL:
         **kwargs: Any,
     ) -> str:
         """First step - Start the flow."""
-        self.session[TOKEN_CACHE] = None  # type: ignore
-        self.session[USER_EMAIL] = None  # type: ignore
+        self.session[TOKEN_CACHE] = None
+        self.session[USER_EMAIL] = None
         self.session[FLOW_CACHE] = res = self.app.initiate_auth_code_flow(
             scopes or DEFAULT_SCOPES,
             redirect_uri=redirect_uri,
@@ -149,10 +156,9 @@ class AsyncMSAL:
             raise web.HTTPBadRequest(text=str(result["error"]))
         if "id_token_claims" not in result:
             raise web.HTTPBadRequest(text=f"Expected id_token_claims in {result}")
-        self._save_token_cache()
-        self.session[USER_EMAIL] = result.get("id_token_claims").get(
-            "preferred_username"
-        )
+        self.save_token_cache()
+        if tok := result.get("id_token_claims"):
+            self.session[USER_EMAIL] = tok.get("preferred_username")
 
     async def async_acquire_token_by_auth_code_flow(self, auth_response: Any) -> None:
         """Second step - Acquire token, async version."""
@@ -167,7 +173,7 @@ class AsyncMSAL:
             result = self.app.acquire_token_silent(
                 scopes=scopes or DEFAULT_SCOPES, account=accounts[0]
             )
-            self._save_token_cache()
+            self.save_token_cache()
             return result
         return None
 
@@ -175,7 +181,9 @@ class AsyncMSAL:
         """Acquire a token based on username."""
         return await asyncio.get_event_loop().run_in_executor(None, self.get_token)
 
-    async def request(self, method: str, url: str, **kwargs: Any) -> ClientResponse:
+    async def request(
+        self, method: HttpMethods, url: StrOrURL, **kwargs: Unpack[_RequestOptions]
+    ) -> ClientResponse:
         """Make a request to url using an oauth session.
 
         :param str url: url to send request to
@@ -184,16 +192,14 @@ class AsyncMSAL:
         :return: Response of the request
         :rtype: aiohttp.Response
         """
-        if not self._clientsession:
-            AsyncMSAL._clientsession = ClientSession(trust_env=True)
-
         token = await self.async_get_token()
         if token is None:
             raise web.HTTPClientError(text="No login token available.")
 
         kwargs = kwargs.copy()
         # Ensure headers exist & make a copy
-        kwargs["headers"] = headers = dict(kwargs.get("headers", {}))
+        headers = dict[str, str](kwargs.get("headers") or {})  # type:ignore[arg-type]
+        kwargs["headers"] = headers
 
         headers["Authorization"] = "Bearer " + token["access_token"]
 
@@ -207,17 +213,27 @@ class AsyncMSAL:
             if "data" in kwargs:
                 kwargs["data"] = json.dumps(kwargs["data"])  # auto convert to json
 
-        response = await self._clientsession.request(method, url, **kwargs)
+        if not AsyncMSAL.client_session:
+            AsyncMSAL.client_session = ClientSession(trust_env=True)
+
+        return await AsyncMSAL.client_session.request(method, url, **kwargs)
+
+    def request_ctx(
+        self, method: HttpMethods, url: StrOrURL, **kwargs: Unpack[_RequestOptions]
+    ) -> _RequestContextManager:
+        """Request context manager."""
+        return _RequestContextManager(self.request(method, url, **kwargs))
 
-        return response
+    get = partialmethod(request_ctx, HTTP_GET)
+    post = partialmethod(request_ctx, HTTP_POST)
 
-    def get(self, url: str, **kwargs: Any):  # type:ignore
-        """GET Request."""
-        return _RequestContextManager(self.request(HTTP_GET, url, **kwargs))
+    # def get(self, url: str, **kwargs: Any) -> _RequestContextManager:
+    #     """GET Request."""
+    #     return _RequestContextManager(self.request(HTTP_GET, url, **kwargs))
 
-    def post(self, url: str, **kwargs: Any):  # type:ignore
-        """POST request."""
-        return _RequestContextManager(self.request(HTTP_POST, url, **kwargs))
+    # def post(self, url: str, **kwargs: Any) -> _RequestContextManager:
+    #     """POST request."""
+    #     return _RequestContextManager(self.request(HTTP_POST, url, **kwargs))
 
     @property
     def mail(self) -> str:

aiohttp_msal/redis_tools.py

@@ -4,8 +4,9 @@ import asyncio
 import json
 import logging
 import time
+from collections.abc import AsyncGenerator
 from contextlib import AsyncExitStack, asynccontextmanager
-from typing import Any, AsyncGenerator, Optional
+from typing import Any
 
 from redis.asyncio import Redis, from_url
 
@@ -30,15 +31,15 @@ async def get_redis() -> AsyncGenerator[Redis, None]:
     try:
         yield redis
     finally:
-        MENV.database = None  # type:ignore
+        MENV.database = None  # type:ignore[assignment]
         await redis.close()
 
 
 async def session_iter(
     redis: Redis,
     *,
-    match: Optional[dict[str, str]] = None,
-    key_match: Optional[str] = None,
+    match: dict[str, str] | None = None,
+    key_match: str | None = None,
 ) -> AsyncGenerator[tuple[str, int, dict[str, Any]], None]:
     """Iterate over the Redis keys to find a specific session.
 
@@ -55,10 +56,10 @@ async def session_iter(
         sval = await redis.get(key)
         created, ses = 0, {}
         try:
-            val = json.loads(sval)  # type: ignore
+            val = json.loads(sval)  # type: ignore[arg-type]
             created = int(val["created"])
             ses = val["session"]
-        except Exception:  # pylint: disable=broad-except
+        except Exception:
             pass
         if match:
             # Ensure we match all the supplied terms
@@ -73,7 +74,7 @@ async def session_iter(
 
 
 async def session_clean(
-    redis: Redis, *, max_age: int = 90, expected_keys: Optional[dict] = 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
@@ -93,11 +94,29 @@ async def session_clean(
             _LOGGER.debug("No sessions removed (%s total)", keep)
 
 
-def _session_factory(key: str, created: str, session: dict) -> AsyncMSAL:
+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}*"):
+        if not isinstance(key, str):
+            key = key.decode()
+        sval = await redis.get(key)
+        if sval is None:
+            continue
+        try:
+            val: dict = json.loads(sval)
+            assert isinstance(val["created"], int)
+            assert isinstance(val["session"], dict)
+        except Exception as err:
+            _LOGGER.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.
 
     When get_token refreshes the token retrieved from Redis, the save_cache callback
-    will be responsible to update the cache in Redis."""
+    will be responsible to update the cache in Redis.
+    """
 
     async def async_save_cache(_: dict) -> None:
         """Save the token cache to Redis."""
@@ -111,11 +130,11 @@ def _session_factory(key: str, created: str, session: dict) -> AsyncMSAL:
         except RuntimeError:
             asyncio.run(async_save_cache(*args))
 
-    return AsyncMSAL(session, save_cache=save_cache)
+    return AsyncMSAL(session, save_callback=save_cache)
 
 
 async def get_session(
-    email: str, *, redis: Optional[Redis] = None, scope: str = ""
+    email: str, *, redis: Redis | None = None, scope: str = ""
 ) -> AsyncMSAL:
     """Get a session from Redis."""
     cnt = 0
@@ -126,7 +145,7 @@ async def get_session(
             cnt += 1
             if scope and scope not in str(session.get("token_cache")).lower():
                 continue
-            return _session_factory(key, str(created), session)
+            return _session_factory(key, created, session)
     msg = f"Session for {email}"
     if not scope:
         raise ValueError(f"{msg} not found")
@@ -136,7 +155,7 @@ async def get_session(
 async def redis_get_json(key: str) -> list | dict | None:
     """Get a key from redis."""
     res = await MENV.database.get(key)
-    if isinstance(res, (str, bytes, bytearray)):
+    if isinstance(res, str | bytes | bytearray):
         return json.loads(res)
     if res is not None:
         _LOGGER.warning("Unexpected type for %s: %s", key, type(res))
@@ -148,7 +167,7 @@ async def redis_get(key: str) -> str | None:
     res = await MENV.database.get(key)
     if isinstance(res, str):
         return res
-    if isinstance(res, (bytes, bytearray)):
+    if isinstance(res, bytes | bytearray):
         return res.decode()
     if res is not None:
         _LOGGER.warning("Unexpected type for %s: %s", key, type(res))

aiohttp_msal/routes.py

@@ -1,14 +1,15 @@
 """The user blueprint."""
 
 import time
+from collections.abc import Mapping, Sequence
 from inspect import iscoroutinefunction
-from typing import Any, Mapping, Sequence
+from typing import Any
 from urllib.parse import urljoin
 
 from aiohttp import web
 from aiohttp_session import get_session, new_session
 
-from aiohttp_msal import _LOGGER, ENV, authenticated, msal_session
+from aiohttp_msal import _LOGGER, ENV, auth_ok, msal_session
 from aiohttp_msal.msal_async import FLOW_CACHE, AsyncMSAL
 from aiohttp_msal.user_info import get_manager_info, get_user_info
 
@@ -63,8 +64,7 @@ async def user_authorized(request: web.Request) -> web.Response:
     # Ensure all expected variables were returned...
     if not all(auth_response.get(k) for k in ["code", "session_state", "state"]):
         msg.append(
-            "<b>Expecting code,state,session_state in post body.</b>"
-            f"auth_response: {auth_response}"
+            f"<b>Expecting code,state,session_state in post body.</b>auth_response: {auth_response}"
         )
 
     if not request.cookies.get(ENV.COOKIE_NAME):
@@ -83,7 +83,7 @@ async def user_authorized(request: web.Request) -> web.Response:
     if not msg:
         try:
             await aiomsal.async_acquire_token_by_auth_code_flow(auth_response)
-        except Exception as err:  # pylint: disable=broad-except
+        except Exception as err:
             msg.append(
                 "<b>Could not get token</b> - async_acquire_token_by_auth_code_flow"
             )
@@ -95,7 +95,7 @@ async def user_authorized(request: web.Request) -> web.Response:
         try:
             await get_user_info(aiomsal)
             await get_manager_info(aiomsal)
-        except Exception as err:  # pylint: disable=broad-except
+        except Exception as err:
             msg.append("Could not get org info from MS graph")
             msg.append(str(err))
         if session.get("mail"):
@@ -145,14 +145,14 @@ async def user_debug(request: web.Request) -> web.Response:
     return web.json_response(debug)
 
 
-ENV.info["authenticated"] = authenticated
+ENV.info["authenticated"] = auth_ok
 
 
 @ROUTES.get("/user/info")
 @msal_session()
 async def user_info(request: web.Request, ses: AsyncMSAL) -> web.Response:
     """User info handler."""
-    if not authenticated(ses):
+    if not auth_ok(ses):
         return web.json_response({"authenticated": False})
 
     debug = request.query.get("debug", False)
@@ -182,7 +182,7 @@ async def user_info(request: web.Request, ses: AsyncMSAL) -> web.Response:
 
 @ROUTES.get("/user/logout")
 @ROUTES.get("/user/logout/{to:.+$}")
-@msal_session(authenticated)
+@msal_session(auth_ok)
 async def user_logout(request: web.Request, ses: AsyncMSAL) -> web.Response:
     """Redirect to MS graph login page."""
     ses.session.clear()
@@ -196,13 +196,12 @@ async def user_logout(request: web.Request, ses: AsyncMSAL) -> web.Response:
         _to = get_route(request, _to)
 
     return web.HTTPFound(
-        "https://login.microsoftonline.com/common/oauth2/logout?"
-        f"post_logout_redirect_uri={_to}"
+        f"https://login.microsoftonline.com/common/oauth2/logout?post_logout_redirect_uri={_to}"
     )  # redirect
 
 
 @ROUTES.get("/user/photo")
-@msal_session(authenticated)
+@msal_session(auth_ok)
 async def user_photo(request: web.Request, ses: AsyncMSAL) -> web.StreamResponse:
     """Photo."""
     async with ses.get("https://graph.microsoft.com/v1.0/me/photo/$value") as res:

aiohttp_msal/settings.py

@@ -1,43 +1,47 @@
 """Settings."""
 
-from typing import TYPE_CHECKING, Any, Awaitable, Callable
+from collections.abc import Awaitable, Callable
+from typing import TYPE_CHECKING, Any
 
-from aiohttp_msal.settings_base import SettingsBase, Var
+import attrs
+
+from aiohttp_msal.settings_base import VAR_REQ, VAR_REQ_HIDE, SettingsBase
 
 if TYPE_CHECKING:
     from redis.asyncio import Redis
 else:
-    Redis = Any
+    Redis = None
 
 
+@attrs.define
 class MSALSettings(SettingsBase):
     """Settings."""
 
-    SP_APP_ID = Var(str, required=True)
+    SP_APP_ID: str = attrs.field(metadata=VAR_REQ, default="")
     """SharePoint Application ID."""
-    SP_APP_PW = Var(str, required=True)
+    SP_APP_PW: str = attrs.field(metadata=VAR_REQ_HIDE, default="")
     """SharePoint Application Secret."""
-    SP_AUTHORITY = Var(str, required=True)
+    SP_AUTHORITY: str = attrs.field(metadata=VAR_REQ, default="")
     """SharePoint Authority URL.
 
     Examples:
     "https://login.microsoftonline.com/common"  # For multi-tenant app
     "https://login.microsoftonline.com/Tenant_Name_or_UUID_Here"."""
 
-    DOMAIN = "mydomain.com"
+    DOMAIN: str = "mydomain.com"
     """Your domain. Used by routes & Redis functions."""
 
-    COOKIE_NAME = "AIOHTTP_SESSION"
+    COOKIE_NAME: str = "AIOHTTP_SESSION"
     """The name of the cookie with the session identifier."""
 
-    login_callback: list[Callable[[Any], Awaitable[Any]]] = []
+    login_callback: list[Callable[[Any], Awaitable[Any]]] = attrs.field(factory=list)
     """A list of callbacks to execute on successful login."""
-    info: dict[str, Callable[[Any], Any | Awaitable[Any]]] = {}
+    info: dict[str, Callable[[Any], Any | Awaitable[Any]]] = attrs.field(factory=dict)
     """List of attributes to return in /user/info."""
 
-    REDIS = "redis://redis1:6379"
+    REDIS: str = "redis://redis1:6379"
     """OPTIONAL: Redis database connection used by app_init_redis_session()."""
-    database: Redis = None  # type: ignore
+    database: Redis = None  # type: ignore[assignment]
     """Store the Redis connection when using app_init_redis_session()."""
 
 

aiohttp_msal/settings_base.py

@@ -1,29 +1,25 @@
 """Settings Base."""
 
-from __future__ import annotations
 import logging
 import os
 from pathlib import Path
-from typing import Any, Type
+from typing import Any
 
+import attrs
 
-class Var:  # pylint: disable=too-few-public-methods
-    """Variable settings."""
+KEY_REQ = "required"
+KEY_HIDE = "hide"
+VAR_REQ_HIDE = {KEY_REQ: True, KEY_HIDE: True}
+VAR_REQ = {KEY_REQ: True}
+VAR_HIDE = {KEY_HIDE: True}
 
-    @staticmethod
-    def from_value(val: Any) -> Var:
-        """Ensure the return is an instance of Var."""
-        return val if isinstance(val, Var) else Var(type(val))
 
-    def __init__(
-        self, var_type: Type, hidden: bool = False, required: bool = False
-    ) -> None:
-        """Init class."""
-        self.v_type = var_type
-        self.hide = hidden
-        self.required = required
+def _is_hidden(atr: attrs.Attribute) -> bool:
+    """Is this field hidden."""
+    return bool(atr.metadata.get(KEY_HIDE))
 
 
+@attrs.define
 class SettingsBase:
     """Retrieve Settings from environment variables.
 
@@ -34,50 +30,64 @@ class SettingsBase:
     convert environment variables to match the type of the value here.
     """
 
-    _vars: dict[str, Var] = {}
-    _env_prefix = ""
+    _env_prefix: str = attrs.field(init=False, default="")
+
+    def _get_fields(self) -> dict[str, attrs.Attribute]:
+        """Get env."""
+        res: list[attrs.Attribute] = [
+            a for a in attrs.fields(self.__class__) if a.name.isupper()
+        ]
+
+        dirs = [f for f in dir(self) if f.isupper()]
+        if len(dirs) != len(res):
+            for atr in res:
+                dirs.remove(atr.name)
+            raise AssertionError(f"There are UPPERCASE fields without a type!: {dirs}")
+
+        return {f"{self._env_prefix}{a.name}": a for a in res}
 
     def load(self, environment_prefix: str = "") -> None:
         """Initialize."""
-        self._env_prefix = environment_prefix
         logger = logging.getLogger(__name__)
-        attrs = [a for a in dir(self) if not a.startswith("_") and a.upper() == a]
-        for name in attrs:
-            curv = getattr(self, name)
-            newv: Any = os.getenv(environment_prefix + name.upper())
-            if isinstance(curv, Var):
-                self._vars[name] = curv
-            info = self._vars.get(name) or Var(type(curv))
-            if not newv:
-                if info.required:
-                    raise ValueError(f"Required value for {name} not provided")
+        self._env_prefix = environment_prefix.upper()
+        for ename, atr in self._get_fields().items():
+            newv = os.getenv(ename)
+            if newv is None:
+                if atr.metadata.get(KEY_REQ):
+                    raise ValueError(f"Required value missing: {ename}")
                 continue
             if newv.startswith('"') and newv.endswith('"'):
                 newv = newv.strip('"')
-            logger.debug("ENV %s = %s", name, "***" if info.hide else newv)
-
-            if issubclass(info.v_type, bool):
-                newv = newv.upper() in ("1", "TRUE")
-            elif issubclass(info.v_type, int):
-                newv = int(newv)
-            elif issubclass(info.v_type, Path):
-                newv = Path(newv)
-            elif issubclass(info.v_type, bytes):
-                newv = newv.encode()
-
-            if name.endswith("_URI") and not newv.endswith("/"):
-                newv += "/"
-            setattr(self, name, newv)
-
-    def to_dict(self, as_string: bool = False) -> dict[str, Any]:
+
+            curv = getattr(self, atr.name)
+            v_type = atr.type or type(curv)
+
+            if issubclass(v_type, bool):
+                setattr(self, atr.name, newv.upper() in ("1", "TRUE"))
+            elif issubclass(v_type, int):
+                setattr(self, atr.name, int(newv))
+            elif issubclass(v_type, Path):
+                setattr(self, atr.name, Path(newv))
+            elif issubclass(v_type, bytes):
+                setattr(self, atr.name, newv.encode())
+            else:
+                if atr.name.endswith("_URI") and not newv.endswith("/"):
+                    newv += "/"
+                setattr(self, atr.name, newv)
+
+            logger.debug(
+                "ENV %s%s = %s",
+                self._env_prefix,
+                atr.name,
+                "***" if atr.metadata.get(KEY_HIDE) else getattr(self, atr.name),
+            )
+
+    def asdict(self, as_string: bool = False) -> dict[str, Any]:
         """Get all variables."""
         res = {}
-        for name in vars(self):
-            if name.startswith("_") or name.upper() != name:
-                continue
-            curv = getattr(self, name)
-            info = self._vars.get(name) or Var(type(curv))
-            if info.hide:
+        for ename, atr in self._get_fields().items():
+            curv = getattr(self, atr.name)
+            if atr.metadata.get(KEY_HIDE):
                 continue
-            res[self._env_prefix + name] = str(curv) if as_string else curv
+            res[ename] = str(curv) if as_string else curv
         return res

aiohttp_msal/user_info.py

@@ -1,24 +1,28 @@
 """Graph User Info."""
 
 import asyncio
+from collections.abc import Awaitable, Callable
 from functools import wraps
-from typing import Any, Callable
+from typing import ParamSpec, TypeVar
 
 from aiohttp_msal.msal_async import AsyncMSAL
 
+_T = TypeVar("_T")
+_P = ParamSpec("_P")
 
-def retry(func: Callable) -> Callable:
+
+def retry(func: Callable[_P, Awaitable[_T]]) -> Callable[_P, Awaitable[_T]]:
     """Retry if tenacity is installed."""
 
     @wraps(func)
-    async def _retry(*args: Any, **kwargs: Any) -> Any:
+    async def _retry(*args: _P.args, **kwargs: _P.kwargs) -> _T:
         """Retry the request."""
         retries = [2, 4, 8]
         while True:
             try:
                 res = await func(*args, **kwargs)
                 return res
-            except Exception as err:  # pylint: disable=broad-except
+            except Exception as err:
                 if retries:
                     await asyncio.sleep(retries.pop())
                 else:

{aiohttp_msal-0.7.0.dist-info → aiohttp_msal-1.0.0.dist-info}/METADATA

@@ -1,37 +1,27 @@
-Metadata-Version: 2.1
-Name: aiohttp_msal
-Version: 0.7.0
+Metadata-Version: 2.3
+Name: aiohttp-msal
+Version: 1.0.0
 Summary: Helper Library to use the Microsoft Authentication Library (MSAL) with aiohttp
-Home-page: https://github.com/kellerza/aiohttp_msal
+Keywords: aiohttp,asyncio,msal,oauth
 Author: Johann Kellerman
-Author-email: kellerza@gmail.com
+Author-email: Johann Kellerman <kellerza@gmail.com>
 License: MIT
-Keywords: msal,oauth,aiohttp,asyncio
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Natural Language :: English
-Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Requires-Python: >=3.10
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: aiohttp>=3.11.18,<3.13
+Requires-Dist: aiohttp-session>=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
+Project-URL: Homepage, https://github.com/kellerza/aiohttp_msal
+Provides-Extra: aioredis
 Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: msal >=1.30.0
-Requires-Dist: aiohttp-session >=2.12
-Requires-Dist: aiohttp >=3.8
-Provides-Extra: redis
-Requires-Dist: aiohttp-session[aioredis] >=2.12 ; extra == 'redis'
-Provides-Extra: tests
-Requires-Dist: black ==24.8.0 ; extra == 'tests'
-Requires-Dist: pylint ==3.2.6 ; extra == 'tests'
-Requires-Dist: flake8 ; extra == 'tests'
-Requires-Dist: pytest-aiohttp ; extra == 'tests'
-Requires-Dist: pytest ; extra == 'tests'
-Requires-Dist: pytest-cov ; extra == 'tests'
-Requires-Dist: pytest-asyncio ; extra == 'tests'
-Requires-Dist: pytest-env ; extra == 'tests'
 
 # aiohttp_msal Python library
 
@@ -139,3 +129,12 @@ def main()
     # ...
     # use the Graphclient
 ```
+
+## Development
+
+```bash
+uv sync --all-extras
+uv tool install ruff
+uv tool install codespell
+uv tool install pyproject-fmt
+```

aiohttp_msal-1.0.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+aiohttp_msal/__init__.py,sha256=867ca27f2272908ecd32f33ddcaac722c4e5aeb7c2554ae929d6d128be86b9bc,4027
+aiohttp_msal/msal_async.py,sha256=8efdf9608c55e41f99ed66294a18303192e921739f49986cf90a015b07a50c55,9470
+aiohttp_msal/redis_tools.py,sha256=ea40b0d3fcc341cbc872c25a3df1becc752f4f7bf392b37248d4d5e72d6d7241,6539
+aiohttp_msal/routes.py,sha256=f305368d4f6a4a5a87e5fabd92f901647020af141d981f83bed402f969576e1d,8135
+aiohttp_msal/settings.py,sha256=b6d6ea19bd97d6bec3b0bbca6f50250c32816195a32301cb1c8f926bef0afa52,1562
+aiohttp_msal/settings_base.py,sha256=b516e3829851d6dbc70ab14271f394868140c949eafd79c90553b834d88f74d8,3150
+aiohttp_msal/user_info.py,sha256=b4efaf03f9313ec787b1e5b136584673f3650df80919d7f538c09a1a6bc37fc4,1875
+aiohttp_msal-1.0.0.dist-info/WHEEL,sha256=76443c98c0efcfdd1191eac5fa1d8223dba1c474dbd47676674a255e7ca48770,79
+aiohttp_msal-1.0.0.dist-info/METADATA,sha256=dd4a69bc47da5e6c559fda12c41505fdc047c8edde36d498d25a93fc0b7b4ec8,4478
+aiohttp_msal-1.0.0.dist-info/RECORD,,

aiohttp_msal-1.0.0.dist-info/WHEEL

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

aiohttp_msal-0.7.0.dist-info/LICENSE

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2022-2024 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.

aiohttp_msal-0.7.0.dist-info/RECORD

@@ -1,18 +0,0 @@
-aiohttp_msal/__init__.py,sha256=MnIsA6r73i_pJ0QTJp2zN1cWZfRBVdM1w7NMQoupjE0,3714
-aiohttp_msal/msal_async.py,sha256=afvfh7gZrXk5KO7Umb9jAnQu4jdg_iVlgaTnxS3JgNM,8899
-aiohttp_msal/redis_tools.py,sha256=zgRACVxm2wPkbEHtA6VmArsd-QQlKn-crlq1XlFbjEY,5919
-aiohttp_msal/routes.py,sha256=JNz0tn-avHUiUmI-YeprY7XyVQNnHRdb2kQFynCTBy0,8228
-aiohttp_msal/settings.py,sha256=hWVJdtqcdAkqqN5I4GINJIZSFGhEuoBImM26NrhqY_M,1341
-aiohttp_msal/settings_base.py,sha256=m4tmurnq8xipVNAa-Dh4ii9Rsu6gg39F4aDJNHPLwiI,2919
-aiohttp_msal/user_info.py,sha256=fijBUbl5g1AVgrpOl-2ZY-eQCCWcu4YqcA0QaMQrcWw,1766
-tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/test_init.py,sha256=olI80lEHoG9Bf2owq3lyfJHp6OPYdsoN_jzlrNY0GYk,76
-tests/test_msal_async.py,sha256=7-G6dO3_qWb8zxqC6_SqMMubCBbEERZy513P7UM4vmw,365
-tests/test_redis_tools.py,sha256=uFpPSe6atbDVAuh1_OUtFgeZwyuLDspp42_EECJDSPg,1869
-tests/test_settings.py,sha256=z-qtUs1zl5Q9NEux051eebyPnArLZ_OfZu65FKz0N4Y,333
-aiohttp_msal-0.7.0.dist-info/LICENSE,sha256=BwqFEcF0Ij49hDZx4A_5CzsKnfU_twRjrm87JFwydFc,1080
-aiohttp_msal-0.7.0.dist-info/METADATA,sha256=HylVcQ1RI0eH12hBat9J-zA4ICtNgAKEbOTkJOpvtgM,4724
-aiohttp_msal-0.7.0.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
-aiohttp_msal-0.7.0.dist-info/top_level.txt,sha256=QPWOi5JtacVEdbaU5bJExc9o-cCT2Lufx0QhUpsv5_E,19
-aiohttp_msal-0.7.0.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-aiohttp_msal-0.7.0.dist-info/RECORD,,

aiohttp_msal-0.7.0.dist-info/WHEEL

@@ -1,5 +0,0 @@
-Wheel-Version: 1.0
-Generator: setuptools (72.1.0)
-Root-Is-Purelib: true
-Tag: py3-none-any
-

aiohttp_msal-0.7.0.dist-info/top_level.txt

@@ -1,2 +0,0 @@
-aiohttp_msal
-tests

aiohttp_msal-0.7.0.dist-info/zip-safe

@@ -1 +0,0 @@
-

tests/test_init.py

@@ -1,4 +0,0 @@
-"""Init."""
-
-import aiohttp_msal  # noqa
-import aiohttp_msal.routes  # noqa

tests/test_msal_async.py

@@ -1,12 +0,0 @@
-"""Test the AsyncMSAL class."""
-
-from aiohttp_msal.msal_async import AsyncMSAL, Session
-
-
-def test_ses():
-    session = Session(None, new=True, data={"session": {"mail": "j@k", "name": "j"}})
-    ses = AsyncMSAL(session)
-    assert str(ses.name) == "j"
-    assert str(ses.mail) == "j@k"
-    assert str(ses.manager_mail) == ""
-    assert str(ses.manager_name) == ""

tests/test_redis_tools.py

@@ -1,60 +0,0 @@
-"""Test redis tools."""
-
-from json import dumps
-from typing import AsyncGenerator
-from unittest.mock import AsyncMock, MagicMock, Mock, call
-
-import pytest
-
-from aiohttp_msal.redis_tools import Redis, session_iter
-
-
-@pytest.fixture
-def redis() -> Redis:
-    """Get a redis Mock instance."""
-    testdata = {
-        "a": dumps({"created": 1, "session": {"key": "a", "a": 1, "b": "2a"}}),
-        "b": dumps({"created": 2, "session": {"key": "b", "a": 1, "b": "2b"}}),
-        "c": dumps({"created": 3, "session": {"key": "c", "a": 5, "b": "6c"}}),
-    }
-
-    async def scan_iter(*, count: int, match: str) -> AsyncGenerator[str, None]:
-        """Mock keys."""
-        assert count == 100
-        assert match == "a*"
-        for key in testdata:
-            yield key
-
-    red = Mock()
-    red.scan_iter = MagicMock(side_effect=scan_iter)
-    red.get = AsyncMock(side_effect=list(testdata.values()))
-    return red
-
-
-@pytest.mark.asyncio
-async def test_session_iter_fail(redis: Redis) -> None:
-    """Test session iter."""
-    match = {"a": 1}
-    with pytest.raises(ValueError):
-        async for _ in session_iter(redis, match=match, key_match="a*"):
-            pass
-
-    match = {"a": "1"}
-    async for _ in session_iter(redis, match=match, key_match="a*"):
-        assert False, "no match expected"
-
-
-@pytest.mark.asyncio
-async def test_session_iter(redis: Redis) -> None:
-    """Test session iter."""
-    match = {"b": "2"}
-    expected = ["a", "b"]
-    async for key, created, ses in session_iter(redis, match=match, key_match="a*"):
-        assert expected.pop(0) == key
-        assert key == ses["key"]
-        assert created in (1, 2)
-        assert key in ("a", "b")
-
-    assert redis.scan_iter.call_args[1]["match"] == "a*"
-    assert redis.scan_iter.call_args[1]["count"] == 100
-    assert redis.scan_iter.call_args_list == [call(count=100, match="a*")]

tests/test_settings.py

@@ -1,11 +0,0 @@
-from aiohttp_msal.settings import ENV, Var
-
-
-def test_load():
-    assert ENV.DOMAIN == "mydomain.com"
-    assert isinstance(ENV.SP_APP_ID, Var)
-    ENV.load("X_")
-    assert ENV.SP_APP_ID == "i1"
-    assert ENV.SP_APP_PW == "p1"
-    ENV.load()
-    assert ENV.to_dict() == {"SP_APP_ID": "i2", "SP_APP_PW": "p2", "SP_AUTHORITY": "a2"}