Na}{

File Content: `flup_session.py`

# (c) 2005 Ian Bicking and contributors; written for Paste (http://pythonpaste.org)
# Licensed under the MIT license: http://www.opensource.org/licenses/mit-license.php

"""
Creates a session object.

In your application, use::

    environ['paste.flup_session_service'].session

This will return a dictionary.  The contents of this dictionary will
be saved to disk when the request is completed.  The session will be
created when you first fetch the session dictionary, and a cookie will
be sent in that case.  There's current no way to use sessions without
cookies, and there's no way to delete a session except to clear its
data.
"""

from paste import httpexceptions
from paste import wsgilib
import flup.middleware.session
flup_session = flup.middleware.session

# This is a dictionary of existing stores, keyed by a tuple of
# store type and parameters
store_cache = {}

class NoDefault(object):
    pass

class SessionMiddleware(object):

    session_classes = {
        'memory': (flup_session.MemorySessionStore,
                   [('session_timeout', 'timeout', int, 60)]),
        'disk': (flup_session.DiskSessionStore,
                 [('session_timeout', 'timeout', int, 60),
                  ('session_dir', 'storeDir', str, '/tmp/sessions')]),
        'shelve': (flup_session.ShelveSessionStore,
                   [('session_timeout', 'timeout', int, 60),
                    ('session_file', 'storeFile', str,
                     '/tmp/session.shelve')]),
        }


    def __init__(self, app,
                 global_conf=None,
                 session_type=NoDefault,
                 cookie_name=NoDefault,
                 **store_config
                 ):
        self.application = app
        if session_type is NoDefault:
            session_type = global_conf.get('session_type', 'disk')
        self.session_type = session_type
        try:
            self.store_class, self.store_args = self.session_classes[self.session_type]
        except KeyError:
            raise KeyError(
                "The session_type %s is unknown (I know about %s)"
                % (self.session_type,
                   ', '.join(self.session_classes.keys())))
        kw = {}
        for config_name, kw_name, coercer, default in self.store_args:
            value = coercer(store_config.get(config_name, default))
            kw[kw_name] = value
        self.store = self.store_class(**kw)
        if cookie_name is NoDefault:
            cookie_name = global_conf.get('session_cookie', '_SID_')
        self.cookie_name = cookie_name
        
    def __call__(self, environ, start_response):
        service = flup_session.SessionService(
            self.store, environ, cookieName=self.cookie_name,
            fieldName=self.cookie_name)
        environ['paste.flup_session_service'] = service

        def cookie_start_response(status, headers, exc_info=None):
            service.addCookie(headers)
            return start_response(status, headers, exc_info)

        try:
            app_iter = self.application(environ, cookie_start_response)
        except httpexceptions.HTTPException, e:
            headers = (e.headers or {}).items()
            service.addCookie(headers)
            e.headers = dict(headers)
            service.close()
            raise
        except:
            service.close()
            raise

        return wsgilib.add_close(app_iter, service.close)
            
def make_session_middleware(app, global_conf,
                            session_type=NoDefault,
                            cookie_name=NoDefault,
                            **store_config):
    """
    Wraps the application in a session-managing middleware.
    The session service can then be found in
    ``environ['paste.flup_session_service']``
    """
    return SessionMiddleware(
        app, global_conf=global_conf,
        session_type=session_type, cookie_name=cookie_name,
        **store_config)

Name	Size	Permission
__pycache__	---	0755
auth	---	0755
cowbell	---	0755
debug	---	0755
evalexception	---	0755
exceptions	---	0755
util	---	0755
cascade.py	4508 bytes	0644
cgiapp.py	9590 bytes	0644
cgitb_catcher.py	3752 bytes	0644
config.py	4312 bytes	0644
errordocument.py	13777 bytes	0644
fileapp.py	13608 bytes	0644
fixture.py	57992 bytes	0644
fixture.py.stdlib	58075 bytes	0644
flup_session.py	3941 bytes	0644
gzipper.py	3692 bytes	0644
httpexceptions.py	24222 bytes	0644
httpheaders.py	43090 bytes	0644
httpserver.py	55662 bytes	0644
lint.py	14999 bytes	0644
modpython.py	7976 bytes	0644
pony.py	2279 bytes	0644
progress.py	8162 bytes	0644
proxy.py	10181 bytes	0644
recursive.py	14664 bytes	0644
registry.py	22193 bytes	0644
reloader.py	6010 bytes	0644
request.py	14145 bytes	0644
response.py	7659 bytes	0644
session.py	11335 bytes	0644
transaction.py	4362 bytes	0644
translogger.py	4812 bytes	0644
url.py	14624 bytes	0644
urlmap.py	9032 bytes	0644
urlparser.py	26424 bytes	0644
wsgilib.py	20134 bytes	0644
wsgiwrappers.py	22165 bytes	0644

File Content: flup_session.py

File Content: `flup_session.py`