navigator-session 0.4.2__tar.gz → 0.6.2__tar.gz

{navigator-session-0.4.2 → navigator_session-0.6.2}/Makefile

@@ -1,13 +1,11 @@
 venv:
-	python3.10 -m venv .venv
+	python3.11 -m venv .venv
 	echo 'run `source .venv/bin/activate` to start develop Navigator-Session'
 
-setup:
-	pip install wheel==0.38.4
+install:
 	pip install -e .
 
 develop:
-	pip install wheel==0.38.4
 	pip install -e .
 	pip install -Ur docs/requirements-dev.txt
 	flit install --symlink

{navigator-session-0.4.2 → navigator_session-0.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: navigator-session
-Version: 0.4.2
+Version: 0.6.2
 Summary: Navigator Session allows us to store user-specific data into session object.
 Home-page: https://github.com/phenobarbital/navigator-session
 Author: Jesus Lara
@@ -21,11 +21,18 @@ Classifier: Topic :: Database :: Front-Ends
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Framework :: AsyncIO
 Classifier: Framework :: aiohttp
-Requires-Python: >=3.9.16
+Requires-Python: >=3.9.13
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: aiohttp>=3.9.5
+Requires-Dist: asyncio==3.4.3
+Requires-Dist: jsonpickle>=3.0.2
+Requires-Dist: redis>=5.0.4
+Requires-Dist: python_datamodel>=0.7.0
+Requires-Dist: navconfig[default]>=1.7.0
 
 # Navigator_Session #
 

navigator_session-0.6.2/docs/requirements-dev.txt

@@ -0,0 +1,21 @@
+aiounittest==1.4.2
+black==24.3.0
+build==1.0.3
+coverage[toml]==7.2.7
+flit==3.9.0
+hypothesis==6.91.0
+ipython==8.14.0
+lint==1.2.1
+mypy==1.7.1
+pylint==2.16.1
+pyperf==2.6.2
+pytest>=6.0.0
+pytest-asyncio==0.23.2
+pytest-cov==4.0.0
+pytest-cython==0.2.0
+pytest-xdist==3.5.0
+pytest-assume==2.4.3
+sdist==0.0.0
+sphinx==6.1.3
+tox==4.6.4
+twine==5.1.1

{navigator-session-0.4.2 → navigator_session-0.6.2}/navigator_session/__init__.py

@@ -12,6 +12,8 @@ from .conf import (
     AUTH_SESSION_OBJECT,
     SESSION_TIMEOUT,
     SESSION_KEY,
+    SESSION_ID,
+    SESSION_REQUEST_KEY,
     SESSION_URL,
     SESSION_PREFIX,
     SESSION_USER_PROPERTY
@@ -26,6 +28,7 @@ __all__ = (
     'SESSION_URL',
     'SESSION_PREFIX',
     'SESSION_KEY',
+    'SESSION_ID',
     'SESSION_USER_PROPERTY',
 )
 
@@ -37,7 +40,7 @@ async def new_session(request: web.Request, userdata: dict = None) -> SessionDat
     storage = request.get(SESSION_STORAGE)
     if storage is None:
         raise RuntimeError(
-            "Missing Configuration for Session Middleware, please install on Aiohttp Middlewares"
+            "Missing Configuration for NAV Session Middleware."
         )
     session = await storage.new_session(request, userdata)
     if not isinstance(session, SessionData):
@@ -75,7 +78,7 @@ async def get_session(
         storage = request.get(SESSION_STORAGE)
         if storage is None:
             raise RuntimeError(
-                "Missing Configuration for Session Storage, please install Session Middleware."
+                "Missing Configuration of Session Storage, please install it."
             )
         # using the storage session for Load an existing Session
         try:
@@ -90,7 +93,7 @@ async def get_session(
                 f"Error Loading user Session: {err!s}"
             ) from err
         request[SESSION_OBJECT] = session
-        request['session'] = session
+        request[SESSION_REQUEST_KEY] = session
         if new is True and not isinstance(session, SessionData):
             raise RuntimeError(
                 f"Installed {session!r} storage should return session instance "

{navigator-session-0.4.2 → navigator_session-0.6.2}/navigator_session/conf.py

@@ -22,9 +22,12 @@ SESSION_NAME = f"{APP_TITLE}_SESSION"
 JWT_ALGORITHM = config.get("JWT_ALGORITHM", fallback="HS256")
 SESSION_PREFIX = f'{SESSION_PREFIX}_session'
 SESSION_TIMEOUT = config.getint('SESSION_TIMEOUT', fallback=360000)
-SESSION_STORAGE = 'NAVIGATOR_SESSION_STORAGE'
-SESSION_OBJECT = 'NAV_SESSION'
-
+SESSION_STORAGE = config.get(
+    'NAV_SESSION_STORAGE',
+    fallback='NAVIGATOR_SESSION_STORAGE'
+)
+SESSION_OBJECT = config.get('SESSION_OBJECT', fallback='NAV_SESSION')
+SESSION_REQUEST_KEY = config.get('SESSION_REQUEST_KEY', fallback='session')
 
 # SESSION BACKEND:
 SESSION_BACKEND = config.get('SESSION_BACKEND', fallback='redis')
@@ -38,4 +41,5 @@ SESSION_URL = f"{SESSION_BACKEND}://{REDIS_HOST}:{REDIS_PORT}/{REDIS_SESSION_DB}
 # User Attributes:
 SESSION_USER_PROPERTY = config.get('SESSION_USER_PROPERTY', fallback='user')
 SESSION_KEY = config.get('SESSION_KEY', fallback='id')
+SESSION_ID = config.get('SESSION_ID', fallback='session_id')
 SESSION_COOKIE_SECURE = config.get('SESSION_COOKIE_SECURE', fallback='csrf_secure')

{navigator-session-0.4.2 → navigator_session-0.6.2}/navigator_session/data.py

@@ -8,8 +8,11 @@ import jsonpickle
 from jsonpickle.unpickler import loadclass
 from aiohttp import web
 from datamodel import BaseModel
-from navigator_session.conf import SESSION_KEY, SESSION_STORAGE
-
+from .conf import (
+    SESSION_KEY,
+    SESSION_ID,
+    SESSION_STORAGE
+)
 
 class ModelHandler(jsonpickle.handlers.BaseHandler):
     """ModelHandler.
@@ -43,21 +46,27 @@ class SessionData(MutableMapping[str, Any]):
         *args,
         data: Optional[Mapping[str, Any]] = None,
         new: bool = False,
+        id: Optional[str] = None,
         identity: Optional[Any] = None,
         max_age: Optional[int] = None
     ) -> None:
         self._changed = False
         self._data = {}
+        # Unique ID:
+        self._id_ = data.get(SESSION_ID, None) if data else id
+        if not self._id_:
+            self._id_ = uuid.uuid4().hex
+        # Session Identity
         self._identity = data.get(SESSION_KEY, None) if data else identity
         if not self._identity:
-            self._identity = uuid.uuid4().hex
+            self._identity = self._id_
         self._new = new if data != {} else True
         self._max_age = max_age if max_age else None
         created = data.get('created', None) if data else None
-        self._now = pendulum.now('UTC') # time for this instance creation
+        self._now = pendulum.now('UTC')  # time for this instance creation
         self.__created__ = self._now
         now = int(self._now.int_timestamp)
-        self._now = now # time for this instance creation
+        self._now = now  # time for this instance creation
         age = now - created if created else now
         if max_age is not None and age > max_age:
             data = None
@@ -75,9 +84,7 @@ class SessionData(MutableMapping[str, Any]):
         self.args = args
 
     def __repr__(self) -> str:
-        return '<{} [new:{}, created:{}] {!r}>'.format( # pylint: disable=C0209
-            'NAV-Session ', self.new, self.created, self._data
-        )
+        return f'<NAV-Session [new:{self.new}, created:{self.created}] {self._data!r}>'
 
     @property
     def new(self) -> bool:
@@ -87,6 +94,10 @@ class SessionData(MutableMapping[str, Any]):
     def logon_time(self) -> datetime:
         return self.__created__
 
+    @property
+    def session_id(self) -> str:
+        return self._id_
+
     @property
     def identity(self) -> Optional[Any]:  # type: ignore[misc]
         return self._identity

{navigator-session-0.4.2 → navigator_session-0.6.2}/navigator_session/middleware.py

@@ -3,25 +3,27 @@ from collections.abc import Callable, Awaitable
 from aiohttp import web
 from aiohttp.web_middlewares import Handler
 from navconfig.logging import logging
-from navigator_session.conf import (
+from .conf import (
     SESSION_OBJECT,
     SESSION_STORAGE
 )
 from .storages.abstract import AbstractStorage
 from .data import SessionData
 
+
 Middleware = Callable[[web.Request, Handler], Awaitable[web.StreamResponse]]
 
+
 ### Basic Middleware for Session System
 def session_middleware(
-        app: web.Application, # pylint: disable=W0613
+        app: web.Application,  # pylint: disable=W0613
         storage: AbstractStorage
 ) -> Middleware:
     """Middleware to attach Session Storage to every Request."""
     if not isinstance(storage, AbstractStorage):
         raise RuntimeError(
             f"Expected an AbstractStorage got {storage!s}"
-    )
+        )
 
     @web.middleware
     async def middleware(

{navigator-session-0.4.2 → navigator_session-0.6.2}/navigator_session/session.py

@@ -8,10 +8,13 @@ class SessionHandler:
     """Authentication Backend for Navigator."""
     storage: Callable = None
 
-    def __init__(self,storage: str = 'redis', **kwargs) -> None:
+    def __init__(self, storage: str = 'redis', **kwargs) -> None:
         # TODO: Session Support with parametrization (other storages):
+        self._session_object: str = kwargs.get('session_object', 'nav_session')
+        # Logging Object:
+        self.logger = logging.getLogger(self.__class__.__name__)
         if storage == 'redis':
-            self.storage = RedisStorage(**kwargs)
+            self.storage = RedisStorage(logger=self.logger, **kwargs)
         else:
             raise NotImplementedError(
                 f"Cannot load a Session Storage {storage}"
@@ -19,9 +22,9 @@ class SessionHandler:
 
     def setup(self, app: web.Application) -> None:
         if isinstance(app, web.Application):
-            self.app = app # register the app into the Extension
+            self.app = app  # register the app into the Extension
         else:
-            self.app = app.get_app() # Nav Application
+            self.app = app.get_app()  # Nav Application
         ## Configure the Middleware for NAV Session.
         self.app.middlewares.append(
             session_middleware(app, self.storage)
@@ -34,10 +37,9 @@ class SessionHandler:
         self.app.on_cleanup.append(
             self.session_cleanup
         )
-        logging.debug(':::: Session Handler Loaded ::::')
+        self.logger.debug(':::: Session Handler Loaded ::::')
         # register the Auth extension into the app
-        self.app['nav_session'] = self
-
+        self.app[self._session_object] = self
 
     async def session_startup(self, app: web.Application):
         """
@@ -46,7 +48,7 @@ class SessionHandler:
         try:
             await self.storage.on_startup(app)
         except Exception as ex:
-            logging.exception(f'{ex}')
+            self.logger.exception(f'{ex}')
             raise RuntimeError(
                 f"Session Storage Error: cannot start Storage Backend {ex}"
             ) from ex
@@ -58,7 +60,7 @@ class SessionHandler:
         try:
             await self.storage.on_cleanup(app)
         except Exception as ex:
-            logging.exception(f'{ex}')
+            self.logger.exception(f'{ex}')
             raise RuntimeError(
                 f"Session Storage Error: cannot start Storage Backend {ex}"
             ) from ex

navigator_session-0.6.2/navigator_session/storages/__init__.py

@@ -0,0 +1 @@
+"""NAV Session Storage Module."""

{navigator-session-0.4.2 → navigator_session-0.6.2}/navigator_session/storages/abstract.py

@@ -1,19 +1,26 @@
 """Base Class for all Session Storages."""
 import sys
-import abc
+from abc import ABCMeta, abstractmethod
 import uuid
 import time
 import logging
 from typing import Optional
 from aiohttp import web
 from datamodel.parsers.encoders import DefaultEncoder
-from navigator_session.conf import (
+from datamodel.parsers.json import (  # pylint: disable=C0411
+    json_encoder,
+    json_decoder
+)
+from ..conf import (
     SESSION_TIMEOUT,
     SESSION_KEY,
+    SESSION_ID,
     SESSION_OBJECT,
+    SESSION_REQUEST_KEY,
     SESSION_COOKIE_SECURE
 )
-from navigator_session.data import SessionData
+from ..data import SessionData
+
 
 if sys.version_info >= (3, 8):
     from typing import TypedDict
@@ -29,13 +36,14 @@ class _CookieParams(TypedDict, total=False):
     samesite: Optional[str]
     expires: str
 
-class AbstractStorage(metaclass=abc.ABCMeta):
+class AbstractStorage(metaclass=ABCMeta):
 
-    use_cookie: bool = False
+    _use_cookies: bool = False
 
     def __init__(
             self,
             *,
+            logger: Optional[logging.Logger] = None,
             max_age: int = None,
             secure: bool = True,
             domain: Optional[str] = None,
@@ -43,14 +51,17 @@ class AbstractStorage(metaclass=abc.ABCMeta):
             httponly: bool = True,
             samesite: Optional[str] = 'Lax',
             **kwargs
-        ) -> None:
+    ) -> None:
+        if logger is not None:
+            self._logger = logger
+        else:
+            self._logger = logging.getLogger('Nav_Session.Storage')
         if not max_age:
             self.max_age = SESSION_TIMEOUT
         else:
             self.max_age = max_age
-        if 'use_cookie' in kwargs:
-            self.use_cookie = kwargs['use_cookie']
-            del kwargs['use_cookie']
+        # Using session cookies:
+        self._use_cookies = kwargs.get('use_cookies', False)
         # Storage Name
         self.__name__: str = SESSION_COOKIE_SECURE
         self._domain: Optional[str] = domain
@@ -60,8 +71,8 @@ class AbstractStorage(metaclass=abc.ABCMeta):
         self._httponly = httponly
         self._samesite = samesite
         self._objencoder = DefaultEncoder()
-        self._encoder = self._objencoder.dumps
-        self._decoder = self._objencoder.loads
+        self._encoder = json_encoder
+        self._decoder = json_decoder
 
     def id_factory(self) -> str:
         return uuid.uuid4().hex
@@ -70,15 +81,15 @@ class AbstractStorage(metaclass=abc.ABCMeta):
     def cookie_name(self) -> str:
         return self.__name__
 
-    @abc.abstractmethod
+    @abstractmethod
     async def on_startup(self, app: web.Application):
         pass
 
-    @abc.abstractmethod
+    @abstractmethod
     async def on_cleanup(self, app: web.Application):
         pass
 
-    @abc.abstractmethod
+    @abstractmethod
     async def new_session(
         self,
         request: web.Request,
@@ -86,7 +97,7 @@ class AbstractStorage(metaclass=abc.ABCMeta):
     ) -> SessionData:
         pass
 
-    @abc.abstractmethod
+    @abstractmethod
     async def load_session(
         self,
         request: web.Request,
@@ -97,55 +108,66 @@ class AbstractStorage(metaclass=abc.ABCMeta):
     ) -> SessionData:
         pass
 
-    @abc.abstractmethod
+    @abstractmethod
     async def get_session(self, request: web.Request) -> SessionData:
         pass
 
     def empty_session(self) -> SessionData:
-        return SessionData(None, data=None, new=True, max_age=self.max_age)
-
-    @abc.abstractmethod
-    async def save_session(self,
+        return SessionData(
+            None,
+            data=None,
+            new=True,
+            max_age=self.max_age
+        )
+
+    @abstractmethod
+    async def save_session(
+        self,
         request: web.Request,
         response: web.StreamResponse,
         session: SessionData
     ) -> None:
         pass
 
-    @abc.abstractmethod
+    @abstractmethod
     async def invalidate(
         self,
         request: web.Request,
         session: SessionData
     ) -> None:
         """Try to Invalidate the Session in the Storage."""
+        pass
 
     async def forgot(self, request: web.Request, response: web.StreamResponse = None):
-        """Delete a User Session."""
+        """forgot.
+
+        Forgot (delete) a user session.
+        """
         session = await self.get_session(request)
         await self.invalidate(request, session)
-        request["session"] = None
+        request[SESSION_REQUEST_KEY] = None
         try:
             del request[SESSION_KEY]
+            del request[SESSION_ID]
             del request[SESSION_OBJECT]
-        except Exception as err: # pylint: disable=W0703
-            logging.warning(
+        except Exception as err:  # pylint: disable=W0703
+            self._logger.warning(
                 f'Session: Error on Forgot Method: {err}'
             )
         if response is not None:
             # also, forgot the secure Cookie:
-            self.forgot_cooke(response)
+            self.forgot_cookie(response)
 
     def load_cookie(self, request: web.Request) -> str:
         """Getting Cookie from User (if needed)"""
-        if self.use_cookie is True:
+        if self._use_cookies is True:
             cookie = request.cookies.get(self.__name__, None)
             if cookie:
                 return self._decoder(cookie)
         return None
 
-    def forgot_cooke(self, response: web.StreamResponse) -> None:
-        if self.use_cookie is True:
+    def forgot_cookie(self, response: web.StreamResponse) -> None:
+        if self._use_cookies is True:
             response.del_cookie(
                 self.__name__, domain=self._domain, path=self._path
             )
@@ -157,7 +179,7 @@ class AbstractStorage(metaclass=abc.ABCMeta):
         *,
         max_age: Optional[int] = None,
     ) -> None:
-        if self.use_cookie is True:
+        if self._use_cookies is True:
             expires = None
             if max_age is not None:
                 t = time.gmtime(time.time() + max_age)
@@ -180,7 +202,6 @@ class AbstractStorage(metaclass=abc.ABCMeta):
             else:
                 response.set_cookie(self.__name__, cookie_data, **params)
 
-
     def session_info(self, session: SessionData, request: web.Request) -> SessionData:
         """session_info.
             Session Helper for adding more information extracted from Request.
@@ -198,6 +219,6 @@ class AbstractStorage(metaclass=abc.ABCMeta):
             session.headers = request.headers
             session.rel_url = request.rel_url
         except (TypeError, AttributeError, ValueError) as ex:
-            logging.warning(f'Unable to read Request info: {ex}')
+            self._logger.warning(f'Unable to read Request info: {ex}')
         ### modified Session Object:
         return session

{navigator-session-0.4.2 → navigator_session-0.6.2}/navigator_session/storages/cookie.py

@@ -1,4 +1,4 @@
-"""Encrypted JSON Cookie Storage."""
+"""TODO: Encrypted JSON Cookie Storage."""
 import base64
 from typing import (
     Optional,
@@ -24,7 +24,7 @@ class CookieStorage(AbstractStorage):
             path: str = "/",
             secret_key: Union[str, bytes, bytearray, fernet.Fernet] = None,
             **kwargs
-        ) -> None:
+    ) -> None:
         super(
             CookieStorage, self
         ).__init__(
@@ -75,7 +75,8 @@ class CookieStorage(AbstractStorage):
     async def get_session(self, request: web.Request) -> SessionData:
         pass
 
-    async def save_session(self,
+    async def save_session(
+        self,
         request: web.Request,
         response: web.StreamResponse,
         session: SessionData

{navigator-session-0.4.2 → navigator_session-0.6.2}/navigator_session/storages/redis.py

@@ -1,14 +1,15 @@
 """Using Redis for Saving Session Storage."""
 import time
-import logging
 from typing import Optional
 from collections.abc import Callable
 from aiohttp import web
-import aioredis
-from navigator_session.conf import (
+from redis import asyncio as aioredis
+from ..conf import (
     SESSION_URL,
     SESSION_KEY,
+    SESSION_ID,
     SESSION_OBJECT,
+    SESSION_REQUEST_KEY,
     SESSION_STORAGE
 )
 from .abstract import AbstractStorage, SessionData
@@ -24,7 +25,7 @@ class RedisStorage(AbstractStorage):
             domain: Optional[str] = None,
             path: str = "/",
             **kwargs
-        ) -> None:
+    ) -> None:
         self._redis: Callable = None
         super(
             RedisStorage, self
@@ -43,21 +44,27 @@ class RedisStorage(AbstractStorage):
                 decode_responses=True,
                 encoding='utf-8'
             )
-        except Exception as err: # pylint: disable=W0703
-            logging.exception(err, stack_info=True)
+        except Exception as err:  # pylint: disable=W0703
+            self._logger.exception(err, stack_info=True)
             return False
 
     async def on_cleanup(self, app: web.Application):
         try:
-            await self._redis.disconnect(inuse_connections = True)
-        except Exception as ex: # pylint: disable=W0703
-            logging.warning(ex)
+            await self._redis.disconnect(inuse_connections=True)
+        except Exception as ex:  # pylint: disable=W0703
+            self._logger.warning(ex)
 
-    async def get_session(self, request: web.Request, userdata: dict = None) -> SessionData:
+    async def get_session(
+        self,
+        request: web.Request,
+        userdata: dict = None
+    ) -> SessionData:
         try:
             session = request.get(SESSION_OBJECT)
-        except Exception as err: # pylint: disable=W0703
-            logging.debug(f'Redis Storage: Error on get Session: {err!s}')
+        except Exception as err:  # pylint: disable=W0703
+            self._logger.debug(
+                f'Redis Storage: Error on get Session: {err!s}'
+            )
             session = None
         if session is None:
             storage = request.get(SESSION_STORAGE)
@@ -67,28 +74,40 @@ class RedisStorage(AbstractStorage):
                 )
             session = await self.load_session(request, userdata)
         request[SESSION_OBJECT] = session
-        request["session"] = session
+        request[SESSION_REQUEST_KEY] = session
         return session
 
     async def invalidate(self, request: web.Request, session: SessionData) -> None:
         conn = aioredis.Redis(connection_pool=self._redis)
         if not session:
             data = None
-            session_id = request.get(SESSION_KEY, None)
+            session_id = request.get(SESSION_ID, None)
             if session_id:
-                data = await conn.get(session_id)
+                _id_ = f"session:{session_id}"
+                data = await conn.get(_id_)
             if data is None:
                 # nothing to forgot
                 return True
         try:
             # delete the ID of the session
-            await conn.delete(session.identity)
-            session.invalidate() # invalidate this session object
-        except Exception as err: # pylint: disable=W0703
-            logging.error(err)
+            await conn.delete(f"session:{session.session_id}")
+            session.invalidate()  # invalidate this session object
+        except Exception as err:  # pylint: disable=W0703
+            self._logger.error(err)
             return False
         return True
 
+    async def get_session_id(self, conn: aioredis.Redis, identity: str) -> str:
+        """Get Session ID from Redis."""
+        try:
+            session_id = await conn.get(f"user:{identity}")
+        except Exception as err:
+            self._logger.error(
+                f'Redis Storage: Error Getting Session ID: {err!s}'
+            )
+            session_id = None
+        return session_id
+
     async def load_session(
         self,
         request: web.Request,
@@ -106,9 +125,9 @@ class RedisStorage(AbstractStorage):
         ---
         new: if False, new session is not created.
         """
-        # TODO: first: for security, check if cookie csrf_secure exists
+        # first: for security, check if cookie csrf_secure exists
         session_id = None
-        if ignore_cookie is False and  self.use_cookie is True:
+        if ignore_cookie is False and self._use_cookies is True:
             cookie = self.load_cookie(request)
             try:
                 session_id = cookie['session_id']
@@ -118,26 +137,35 @@ class RedisStorage(AbstractStorage):
         try:
             conn = aioredis.Redis(connection_pool=self._redis)
         except Exception as err:
-            logging.exception(
+            self._logger.exception(
                 f'Redis Storage: Error loading Redis Session: {err!s}'
             )
             raise RuntimeError(
                 f'Redis Storage: Error loading Redis Session: {err!s}'
             ) from err
         if session_id is None:
-            session_id = request.get(SESSION_KEY, None)
+            session_id = request.get(SESSION_ID, None)
         if not session_id:
-            session_id = userdata.get(SESSION_KEY, None) if userdata else None
-            # TODO: getting from cookie
+            session_id = userdata.get(SESSION_ID, None) if userdata else None
+        # get session id from redis using identity:
+        session_identity = userdata.get(
+            SESSION_KEY, None) if userdata else request.get(SESSION_KEY, None)
+        if not session_id:
+            session_id = await self.get_session_id(conn, session_identity)
+        print('SESSION IDENTITY IS:', session_identity, session_id)
         if session_id is None and new is False:
+            # No Session was found, returning false:
             return False
         # we need to load session data from redis
-        logging.debug(f':::::: LOAD SESSION FOR {session_id} ::::: ')
+        self._logger.debug(
+            f':::::: LOAD SESSION FOR {session_id} ::::: '
+        )
+        _id_ = f"session:{session_id}"
         try:
-            data = await conn.get(session_id)
-        except Exception as err: # pylint: disable=W0703
-            logging.error(
-                f'Redis Storage: Error Getting Session data: {err!s}'
+            data = await conn.get(_id_)
+        except Exception as err:  # pylint: disable=W0703
+            self._logger.error(
+                f'Redis Storage: Error Getting Session: {err!s}'
             )
             data = None
         if data is None:
@@ -145,46 +173,57 @@ class RedisStorage(AbstractStorage):
                 # create a new session if not exists:
                 return await self.new_session(request, userdata)
             else:
+                # No Session Was Found
                 return False
         try:
             data = self._decoder(data)
             session = SessionData(
-                identity=session_id,
+                id=session_id,
+                identity=session_identity,
                 data=data,
                 new=False,
                 max_age=self.max_age
             )
-        except Exception as err: # pylint: disable=W0703
-            logging.warning(err)
+        except Exception as err:  # pylint: disable=W0703
+            self._logger.warning(
+                f"Error creating Session Data: {err}"
+            )
             session = SessionData(
-                identity=None,
+                id=session_id,
+                identity=session_identity,
                 data=None,
                 new=True,
                 max_age=self.max_age
             )
         ## add other options to session:
         self.session_info(session, request)
-        request[SESSION_KEY] = session_id
         session[SESSION_KEY] = session_id
+        request[SESSION_KEY] = session_identity
+        request[SESSION_ID] = session_id
         request[SESSION_OBJECT] = session
-        request["session"] = session
-        if self.use_cookie is True and response is not None:
+        request[SESSION_REQUEST_KEY] = session
+        if self._use_cookies is True and response is not None:
             cookie_data = {
                 "session_id": session_id
             }
             cookie_data = self._encoder(cookie_data)
-            self.save_cookie(response, cookie_data=cookie_data, max_age=self.max_age)
+            self.save_cookie(
+                response,
+                cookie_data=cookie_data,
+                max_age=self.max_age
+            )
         return session
 
-    async def save_session(self,
+    async def save_session(
+        self,
         request: web.Request,
         response: web.StreamResponse,
         session: SessionData
     ) -> None:
         """Save the whole session in the backend Storage."""
-        session_id = session.identity
+        session_id = session.session_id if session else request.get(SESSION_ID, None)
         if not session_id:
-            session_id = session.get(SESSION_KEY, None)
+            session_id = session.get(SESSION_ID, None)
         if not session_id:
             session_id = self.id_factory()
         if session.empty:
@@ -192,15 +231,14 @@ class RedisStorage(AbstractStorage):
         data = self._encoder(session.session_data())
         max_age = session.max_age
         expire = max_age if max_age is not None else 0
-        # TODO: add expiration on redis to value
         try:
             conn = aioredis.Redis(connection_pool=self._redis)
-            result = await conn.set(
-                session_id, data, expire
+            _id_ = f"session:{session_id}"
+            await conn.set(
+                _id_, data, expire
             )
-        except Exception as err: # pylint: disable=W0703
-            print('Error Saving Session: ', err)
-            logging.exception(err, stack_info=True)
+        except Exception as err:  # pylint: disable=W0703
+            self._logger.exception(err, stack_info=True)
             return False
 
     async def new_session(
@@ -210,53 +248,84 @@ class RedisStorage(AbstractStorage):
         response: web.StreamResponse = None
     ) -> SessionData:
         """Create a New Session Object for this User."""
-        session_id = request.get(SESSION_KEY, None)
+        session_identity = request.get(SESSION_KEY, None)
+        session_id = request.get(SESSION_ID, None)
+        try:
+            conn = aioredis.Redis(connection_pool=self._redis)
+        except Exception as err:
+            self._logger.error(
+                f'Redis Storage: Error loading Redis Session: {err!s}'
+            )
+            raise RuntimeError(
+                f'Redis Storage: Error loading Redis Session: {err!s}'
+            ) from err
+        if not session_id:
+            session_id = await self.get_session_id(conn, session_identity)
         if not session_id:
             try:
-                session_id = data[SESSION_KEY]
+                session_id = data[SESSION_ID]
             except KeyError:
                 session_id = self.id_factory()
-        logging.debug(f':::::: START CREATING A NEW SESSION FOR {session_id} ::::: ')
+        self._logger.debug(
+            f':::::: CREATING A NEW SESSION FOR {session_id} ::::: '
+        )
         if not data:
             data = {}
         # saving this new session on DB
         try:
-            conn = aioredis.Redis(connection_pool=self._redis)
             t = time.time()
             data['created'] = t
             data['last_visit'] = t
-            data["last_visited"] = f"Last visited: {t!s}"
-            data[SESSION_KEY] = session_id
+            data[SESSION_KEY] = session_identity
+            data[SESSION_ID] = session_id
             dt = self._encoder(data)
+            _id_ = f'session:{session_id}'
             result = await conn.set(
-                session_id, dt, self.max_age
+                _id_, dt, self.max_age
+            )
+            self._logger.debug(
+                f'Session Creation: {result}'
+            )
+            # Saving the Session ID on redis:
+            await conn.set(
+                f"user:{session_identity}",
+                session_id,
+                self.max_age
             )
-            logging.info(f'Creation of New Session: {result}')
-        except Exception as err: # pylint: disable=W0703
-            logging.exception(err)
+        except Exception as err:  # pylint: disable=W0703
+            self._logger.exception(err)
             return False
         try:
             session = SessionData(
-                identity=session_id,
+                id=session_id,
+                identity=session_identity,
                 data=data,
                 new=True,
                 max_age=self.max_age
             )
-            if self.use_cookie is True and response is not None:
+            if self._use_cookies is True and response is not None:
                 cookie_data = {
                     "last_visit": t,
                     "session_id": session_id
                 }
+                # TODO: adding crypt
                 cookie_data = self._encoder(cookie_data)
-                self.save_cookie(response, cookie_data=cookie_data, max_age=self.max_age)
-        except Exception as err: # pylint: disable=W0703
-            print(err)
-            logging.exception(f'Error creating Session Data: {err!s}')
+                self.save_cookie(
+                    response,
+                    cookie_data=cookie_data,
+                    max_age=self.max_age
+                )
+        except Exception as err:  # pylint: disable=W0703
+            self._logger.exception(
+                f'Error creating Session Data: {err!s}'
+            )
+            return False
         # Saving Session Object:
         ## add other options to session:
         self.session_info(session, request)
-        session[SESSION_KEY] = session_id
+        session[SESSION_KEY] = session_identity
+        request[SESSION_ID] = session_id
         request[SESSION_OBJECT] = session
-        request[SESSION_KEY] = session_id
-        request["session"] = session
+        request[SESSION_KEY] = session_identity
+        request[SESSION_REQUEST_KEY] = session
         return session

{navigator-session-0.4.2 → navigator_session-0.6.2}/navigator_session/version.py

@@ -5,7 +5,7 @@
 __title__ = 'navigator_session'
 __description__ = ('Navigator Session allows us to store user-specific data '
                    'into session object.')
-__version__ = '0.4.2'
+__version__ = '0.6.2'
 __author__ = 'Jesus Lara'
 __author_email__ = 'jesuslarag@gmail.com'
 __license__ = 'Apache-2.0'

{navigator-session-0.4.2 → navigator_session-0.6.2}/navigator_session.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: navigator-session
-Version: 0.4.2
+Version: 0.6.2
 Summary: Navigator Session allows us to store user-specific data into session object.
 Home-page: https://github.com/phenobarbital/navigator-session
 Author: Jesus Lara
@@ -21,11 +21,18 @@ Classifier: Topic :: Database :: Front-Ends
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Framework :: AsyncIO
 Classifier: Framework :: aiohttp
-Requires-Python: >=3.9.16
+Requires-Python: >=3.9.13
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: aiohttp>=3.9.5
+Requires-Dist: asyncio==3.4.3
+Requires-Dist: jsonpickle>=3.0.2
+Requires-Dist: redis>=5.0.4
+Requires-Dist: python_datamodel>=0.7.0
+Requires-Dist: navconfig[default]>=1.7.0
 
 # Navigator_Session #
 

navigator_session-0.6.2/navigator_session.egg-info/requires.txt

@@ -0,0 +1,6 @@
+aiohttp>=3.9.5
+asyncio==3.4.3
+jsonpickle>=3.0.2
+redis>=5.0.4
+python_datamodel>=0.7.0
+navconfig[default]>=1.7.0

{navigator-session-0.4.2 → navigator_session-0.6.2}/pyproject.toml

@@ -1,8 +1,8 @@
 [build-system]
 requires = [
-    'setuptools==67.5.1',
-    'Cython==0.29.33',
-    'wheel==0.38.4'
+  'setuptools==74.0.0',
+  'Cython==3.0.11',
+  'wheel==0.44.0'
 ]
 
 build-backend = "setuptools.build_meta"
@@ -20,6 +20,7 @@ classifiers=[
   "Programming Language :: Python :: 3.9",
   "Programming Language :: Python :: 3.10",
   "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
   "Programming Language :: Python",
   "Typing :: Typed",
   "Environment :: Web Environment",
@@ -32,7 +33,7 @@ classifiers=[
   "License :: OSI Approved :: BSD License",
 ]
 description-file = "README.md"
-requires-python = ">=3.9.16"
+requires-python = ">=3.9.13"
 
 [tool.pytest.ini_options]
 addopts = [

{navigator-session-0.4.2 → navigator_session-0.6.2}/setup.py

@@ -1,7 +1,8 @@
 #!/usr/bin/env python
 """Navigator-Session.
 
-    Asynchronous library for managing user-specific data into a session object, used by Navigator.
+    Asynchronous library for managing user-specific data into a session object,
+    used by Navigator.
 See:
 https://github.com/phenobarbital/navigator-session
 """
@@ -32,7 +33,9 @@ with open(version, 'r', encoding='utf-8') as meta:
                         '__title__',
                         '__description__',
                         '__author__',
-                        '__license__', '__author_email__'):
+                        '__license__',
+                        '__author_email__'
+            ):
                 v = node.value
                 if name.id == '__version__':
                     __version__ = v.s
@@ -51,7 +54,7 @@ with open(version, 'r', encoding='utf-8') as meta:
 setup(
     name="navigator-session",
     version=__version__,
-    python_requires=">=3.9.16",
+    python_requires=">=3.9.13",
     url="https://github.com/phenobarbital/navigator-session",
     description=__description__,
     keywords=['asyncio', 'session', 'aioredis', 'aiohttp'],
@@ -69,6 +72,7 @@ setup(
         "Programming Language :: Python :: 3.9",
         "Programming Language :: Python :: 3.10",
         "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
         "Framework :: AsyncIO",
         "Framework :: aiohttp",
     ],
@@ -77,20 +81,17 @@ setup(
     packages=find_packages(exclude=["contrib", "docs", "tests"]),
     license=__license__,
     setup_requires=[
-        "wheel==0.38.4",
-        "Cython==0.29.33",
-        "asyncio==3.4.3"
+        'setuptools==74.0.0',
+        'Cython==3.0.11',
+        'wheel==0.44.0'
     ],
     install_requires=[
-        "PyNaCl==1.5.0",
-        "aiohttp==3.8.4",
-        "uvloop==0.17.0",
+        "aiohttp>=3.9.5",
         "asyncio==3.4.3",
-        "navconfig[default]>=1.0.15",
-        "jsonpickle==3.0.1",
-        "aioredis==2.0.1",
-        "pendulum==2.1.2",
-        "python_datamodel>=0.2.1"
+        "jsonpickle>=3.0.2",
+        "redis>=5.0.4",
+        "python_datamodel>=0.7.0",
+        "navconfig[default]>=1.7.0",
     ],
     project_urls={  # Optional
         "Source": "https://github.com/phenobarbital/navigator-session",

navigator-session-0.4.2/docs/requirements-dev.txt

@@ -1,19 +0,0 @@
-aiounittest==1.4.2
-black==23.1.0
-codecov==2.1.12
-coverage[toml]==7.2.1
-flit==3.8.0
-hypothesis==6.68.2
-ipython==8.11.0
-lint==1.2.1
-mypy==1.1.1
-pylint==2.17.0
-sphinx==6.1.3
-pytest>=6.0.0
-pytest-asyncio==0.20.3
-pytest-cov==4.0.0
-pytest-cython==0.2.0
-pytest-xdist==3.2.0
-pytest-assume==2.4.3
-sphinx==6.1.3
-tox==4.4.6

navigator-session-0.4.2/navigator_session/storages/__init__.py

@@ -1,6 +0,0 @@
-"""NAV Session Storage Module."""
-
-# from .redis import RedisStorage
-from .abstract import SessionData
-
-__all__ = ('SessionData', )

navigator-session-0.4.2/navigator_session.egg-info/requires.txt

@@ -1,9 +0,0 @@
-PyNaCl==1.5.0
-aiohttp==3.8.4
-uvloop==0.17.0
-asyncio==3.4.3
-navconfig[default]>=1.0.15
-jsonpickle==3.0.1
-aioredis==2.0.1
-pendulum==2.1.2
-python_datamodel>=0.2.1