navigator-session 0.5.7__py3-none-any.whl → 0.6.0__py3-none-any.whl

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/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/data.py

@@ -8,8 +8,11 @@ import jsonpickle
 from jsonpickle.unpickler import loadclass
 from aiohttp import web
 from datamodel import BaseModel
-from .conf import SESSION_KEY, SESSION_STORAGE
-
+from .conf import (
+    SESSION_KEY,
+    SESSION_ID,
+    SESSION_STORAGE
+)
 
 class ModelHandler(jsonpickle.handlers.BaseHandler):
     """ModelHandler.
@@ -43,14 +46,20 @@ 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
@@ -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/middleware.py

@@ -10,8 +10,10 @@ from .conf import (
 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

navigator_session/session.py

@@ -10,8 +10,11 @@ class SessionHandler:
 
     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}"
@@ -34,9 +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):
         """
@@ -45,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
@@ -57,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/storages/__init__.py

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

navigator_session/storages/abstract.py

@@ -1,16 +1,22 @@
 """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 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 ..data import SessionData
@@ -30,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,
@@ -45,13 +52,16 @@ class AbstractStorage(metaclass=abc.ABCMeta):
             samesite: Optional[str] = 'Lax',
             **kwargs
     ) -> 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
@@ -61,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
@@ -71,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,
@@ -87,7 +97,7 @@ class AbstractStorage(metaclass=abc.ABCMeta):
     ) -> SessionData:
         pass
 
-    @abc.abstractmethod
+    @abstractmethod
     async def load_session(
         self,
         request: web.Request,
@@ -98,14 +108,19 @@ 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
+        return SessionData(
+            None,
+            data=None,
+            new=True,
+            max_age=self.max_age
+        )
+
+    @abstractmethod
     async def save_session(
         self,
         request: web.Request,
@@ -114,40 +129,45 @@ class AbstractStorage(metaclass=abc.ABCMeta):
     ) -> 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(
+            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
             )
@@ -159,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)
@@ -199,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/storages/cookie.py

@@ -1,4 +1,4 @@
-"""Encrypted JSON Cookie Storage."""
+"""TODO: Encrypted JSON Cookie Storage."""
 import base64
 from typing import (
     Optional,

navigator_session/storages/redis.py

@@ -1,6 +1,5 @@
 """Using Redis for Saving Session Storage."""
 import time
-import logging
 from typing import Optional
 from collections.abc import Callable
 from aiohttp import web
@@ -8,7 +7,9 @@ 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
@@ -44,14 +45,14 @@ class RedisStorage(AbstractStorage):
                 encoding='utf-8'
             )
         except Exception as err:  # pylint: disable=W0703
-            logging.exception(err, stack_info=True)
+            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)
+            self._logger.warning(ex)
 
     async def get_session(
         self,
@@ -61,7 +62,9 @@ class RedisStorage(AbstractStorage):
         try:
             session = request.get(SESSION_OBJECT)
         except Exception as err:  # pylint: disable=W0703
-            logging.debug(f'Redis Storage: Error on get Session: {err!s}')
+            self._logger.debug(
+                f'Redis Storage: Error on get Session: {err!s}'
+            )
             session = None
         if session is None:
             storage = request.get(SESSION_STORAGE)
@@ -71,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)
+            await conn.delete(f"session:{session.session_id}")
             session.invalidate()  # invalidate this session object
         except Exception as err:  # pylint: disable=W0703
-            logging.error(err)
+            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,
@@ -110,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']
@@ -122,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_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 = userdata.get(SESSION_KEY, None) if userdata else None
-            # TODO: getting from cookie
+            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)
+            data = await conn.get(_id_)
         except Exception as err:  # pylint: disable=W0703
-            logging.error(
-                f'Redis Storage: Error Getting Session data: {err!s}'
+            self._logger.error(
+                f'Redis Storage: Error Getting Session: {err!s}'
             )
             data = None
         if data is None:
@@ -149,35 +173,45 @@ 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)
+            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(
@@ -187,9 +221,9 @@ class RedisStorage(AbstractStorage):
         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:
@@ -197,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)
+            self._logger.exception(err, stack_info=True)
             return False
 
     async def new_session(
@@ -215,43 +248,67 @@ 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)
+            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,
@@ -259,12 +316,16 @@ class RedisStorage(AbstractStorage):
                     max_age=self.max_age
                 )
         except Exception as err:  # pylint: disable=W0703
-            logging.exception(f'Error creating Session Data: {err!s}')
+            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/version.py

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

{navigator_session-0.5.7.dist-info → navigator_session-0.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: navigator-session
-Version: 0.5.7
+Version: 0.6.0
 Summary: Navigator Session allows us to store user-specific data into session object.
 Home-page: https://github.com/phenobarbital/navigator-session
 Author: Jesus Lara

navigator_session-0.6.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+navigator_session/__init__.py,sha256=U1MtM30ccs5N6c_lzUYFRS5NURz6kheDC8jZmRL_2yc,3056
+navigator_session/conf.py,sha256=Pe8qsukmt5cXXPc3hwFphSWF5xCIpZfeFQ8JhICEnow,1695
+navigator_session/data.py,sha256=9bNj_tBGvyqOpcYP8MSKt--5DG5TlTIrYwbQYK7cfAM,6037
+navigator_session/middleware.py,sha256=_bQKfD81BxNZTGuyGTc4yh7y1Rb95I-y2hM1ihE4wCk,1944
+navigator_session/session.py,sha256=CG-TjsmQqjuk6N7GCYNgQTCkrXptgq-swHDiemgHmKI,2398
+navigator_session/version.py,sha256=N6sPpSUtraKYGwgN10X5nuZUoj-0nIuKu8709Z7EquQ,394
+navigator_session/storages/__init__.py,sha256=kTcHfqps5LmnDpFAktxevPuSIwRbnrcMmB7Uygq4axQ,34
+navigator_session/storages/abstract.py,sha256=wTv0yWMVXTwrzA_bjexcwI7c6_W3tzosXlMOIZIQrBM,6503
+navigator_session/storages/cookie.py,sha256=VILzVCatKlDhMoQDoE2y0u6s7lp4wbdep5Oc0NfIJcg,2474
+navigator_session/storages/redis.py,sha256=W-3I_hpabDToLOl7nVrIupV3Taf_IQUO_t8BP6EscYk,11506
+navigator_session-0.6.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+navigator_session-0.6.0.dist-info/METADATA,sha256=j2GJylJ5csGzsI__0pmCqh0xmQh8223niPIx7Ee_2dE,2339
+navigator_session-0.6.0.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+navigator_session-0.6.0.dist-info/top_level.txt,sha256=ZpOEy3wLKGsxG2rc0nHqcqJCV3HIOG_XCfE6mtsYYYY,18
+navigator_session-0.6.0.dist-info/RECORD,,

navigator_session-0.5.7.dist-info/RECORD

@@ -1,15 +0,0 @@
-navigator_session/__init__.py,sha256=xsmc90K04EgQEtYidPN7bsXn0WIqw6GucNwy138Mmno,3038
-navigator_session/conf.py,sha256=PwCGoYpg_2MEq5_zObvbx4yXKf7AIKObO-lzTh2AvxM,1466
-navigator_session/data.py,sha256=tD40x16dujarX3F1RMPAuYqDP3oiG_8kyqLNYyD3Ik4,5798
-navigator_session/middleware.py,sha256=7RO83pz4q16_56GvmbswEukbDZQ0JutJdVdF4UHbEw8,1942
-navigator_session/session.py,sha256=I6qWkMbqIpVX1RjxmccGsk1sCcqWZ_ZBVGwLXjV8wjw,2188
-navigator_session/version.py,sha256=XNGR1srIFz8RhkuogeeZHcBM4wHg9PZ-z8ZUoVbepPE,394
-navigator_session/storages/__init__.py,sha256=ln0Xli0lppUopDMrvQGt69BFtUAe1Grmy2DGkEpANNU,132
-navigator_session/storages/abstract.py,sha256=5nqEF0I0G3p4pcTNfOQYspbXp-U7QJntJWVsKYDu9KY,6043
-navigator_session/storages/cookie.py,sha256=_qL5kIGbT4rtCMze4yj1h4J7Zauz_e7HnorPnFbi90w,2468
-navigator_session/storages/redis.py,sha256=qk8V3FGYDLbfTT851NOU864hSsgup661b8GY1u_uhtQ,9345
-navigator_session-0.5.7.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-navigator_session-0.5.7.dist-info/METADATA,sha256=bRuE-fKSuYIWaW04qQptq9fBln1lfCz6HqMkTgmzYmw,2339
-navigator_session-0.5.7.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-navigator_session-0.5.7.dist-info/top_level.txt,sha256=ZpOEy3wLKGsxG2rc0nHqcqJCV3HIOG_XCfE6mtsYYYY,18
-navigator_session-0.5.7.dist-info/RECORD,,