OpenQuizz
Une application de gestion des contenus pédagogiques
SessionInterface Class Reference
Inheritance diagram for SessionInterface:
Collaboration diagram for SessionInterface:

Public Member Functions

def make_null_session (self, app)
 
def is_null_session (self, obj)
 
def get_cookie_domain (self, app)
 
def get_cookie_path (self, app)
 
def get_cookie_httponly (self, app)
 
def get_cookie_secure (self, app)
 
def get_cookie_samesite (self, app)
 
def get_expiration_time (self, app, session)
 
def should_set_cookie (self, app, session)
 
def open_session (self, app, request)
 
def save_session (self, app, session, response)
 

Static Public Attributes

 null_session_class
 
 pickle_based
 

Detailed Description

The basic interface you have to implement in order to replace the
default session interface which uses werkzeug's securecookie
implementation.  The only methods you have to implement are
:meth:`open_session` and :meth:`save_session`, the others have
useful defaults which you don't need to change.

The session object returned by the :meth:`open_session` method has to
provide a dictionary like interface plus the properties and methods
from the :class:`SessionMixin`.  We recommend just subclassing a dict
and adding that mixin::

    class Session(dict, SessionMixin):
        pass

If :meth:`open_session` returns ``None`` Flask will call into
:meth:`make_null_session` to create a session that acts as replacement
if the session support cannot work because some requirement is not
fulfilled.  The default :class:`NullSession` class that is created
will complain that the secret key was not set.

To replace the session interface on an application all you have to do
is to assign :attr:`flask.Flask.session_interface`::

    app = Flask(__name__)
    app.session_interface = MySessionInterface()

.. versionadded:: 0.8

Member Function Documentation

◆ get_cookie_domain()

def get_cookie_domain (   self,
  app 
)
Returns the domain that should be set for the session cookie.

Uses ``SESSION_COOKIE_DOMAIN`` if it is configured, otherwise
falls back to detecting the domain based on ``SERVER_NAME``.

Once detected (or if not set at all), ``SESSION_COOKIE_DOMAIN`` is
updated to avoid re-running the logic.

◆ get_cookie_httponly()

def get_cookie_httponly (   self,
  app 
)
Returns True if the session cookie should be httponly.  This
currently just returns the value of the ``SESSION_COOKIE_HTTPONLY``
config var.

◆ get_cookie_path()

def get_cookie_path (   self,
  app 
)
Returns the path for which the cookie should be valid.  The
default implementation uses the value from the ``SESSION_COOKIE_PATH``
config var if it's set, and falls back to ``APPLICATION_ROOT`` or
uses ``/`` if it's ``None``.

◆ get_cookie_samesite()

def get_cookie_samesite (   self,
  app 
)
Return ``'Strict'`` or ``'Lax'`` if the cookie should use the
``SameSite`` attribute. This currently just returns the value of
the :data:`SESSION_COOKIE_SAMESITE` setting.

◆ get_cookie_secure()

def get_cookie_secure (   self,
  app 
)
Returns True if the cookie should be secure.  This currently
just returns the value of the ``SESSION_COOKIE_SECURE`` setting.

◆ get_expiration_time()

def get_expiration_time (   self,
  app,
  session 
)
A helper method that returns an expiration date for the session
or ``None`` if the session is linked to the browser session.  The
default implementation returns now + the permanent session
lifetime configured on the application.

◆ is_null_session()

def is_null_session (   self,
  obj 
)
Checks if a given object is a null session.  Null sessions are
not asked to be saved.

This checks if the object is an instance of :attr:`null_session_class`
by default.

◆ make_null_session()

def make_null_session (   self,
  app 
)
Creates a null session which acts as a replacement object if the
real session support could not be loaded due to a configuration
error.  This mainly aids the user experience because the job of the
null session is to still support lookup without complaining but
modifications are answered with a helpful error message of what
failed.

This creates an instance of :attr:`null_session_class` by default.

◆ open_session()

def open_session (   self,
  app,
  request 
)
This method has to be implemented and must either return ``None``
in case the loading failed because of a configuration error or an
instance of a session object which implements a dictionary like
interface + the methods and attributes on :class:`SessionMixin`.

Reimplemented in SecureCookieSessionInterface.

◆ save_session()

def save_session (   self,
  app,
  session,
  response 
)
This is called for actual sessions returned by :meth:`open_session`
at the end of the request.  This is still called during a request
context so if you absolutely need access to the request you can do
that.

Reimplemented in SecureCookieSessionInterface.

◆ should_set_cookie()

def should_set_cookie (   self,
  app,
  session 
)
Used by session backends to determine if a ``Set-Cookie`` header
should be set for this session cookie for this response. If the session
has been modified, the cookie is set. If the session is permanent and
the ``SESSION_REFRESH_EACH_REQUEST`` config is true, the cookie is
always set.

This check is usually skipped if the session was deleted.

.. versionadded:: 0.11

Field Documentation

◆ null_session_class

null_session_class
static

◆ pickle_based

pickle_based
static

The documentation for this class was generated from the following file: