3 ™(ƒh0ã@sÔddlmZddlZddlZddlZddlmZmZddlmZddl m Z ddl m Z ddl mZddlmZmZmZdd lmZmZdd lmZejejZGd d „d eƒZGd d„deƒZGdd„deƒZdS)é)Úunicode_literalsN)ÚdatetimeÚ timedelta)Úsettings)ÚSuspiciousSession)ÚSuspiciousOperation)Útimezone)Úconstant_time_compareÚget_random_stringÚ salted_hmac)Ú force_bytesÚ force_text)Ú import_stringc@seZdZdZdS)Ú CreateErrorz‡ Used internally as a consistent exception type to catch from save (see the docstring for SessionBase.save() for details). N)Ú__name__Ú __module__Ú __qualname__Ú__doc__©rrúI/tmp/pip-install-q3hcpn_q/Django/django/contrib/sessions/backends/base.pyrsrc@seZdZdZdS)Ú UpdateErrorzF Occurs if Django tries to update a session that was deleted. N)rrrrrrrrrsrc@sšeZdZdZdZdZeƒZdZdd„Zdd„Z d d „Z d d „Z d d„Z d[dd„Z efdd„Zdd„Zdd„Zdd„Zdd„Zdd„Zdd„Zdd „Zd!d"„Zd#d$„Zd%d&„Zd'd(„Zd)d*„Zd+d,„Zd-d.„Zd/d0„Zd1d2„Zd3d4„Zd5d6„Z d7d8„Z!d9d:„Z"d;d<„Z#d=d>„Z$e%e#ƒZ&e%e#e$ƒZ'd\d@dA„Z(e%e(ƒZ)dBdC„Z*dDdE„Z+dFdG„Z,dHdI„Z-dJdK„Z.dLdM„Z/dNdO„Z0dPdQ„Z1d]dRdS„Z2d^dTdU„Z3dVdW„Z4e5dXdY„ƒZ6dS)_Ú SessionBasez- Base class for all Session classes. Z testcookieZworkedNcCs"||_d|_d|_ttjƒ|_dS)NF)Ú _session_keyÚaccessedÚmodifiedrrZSESSION_SERIALIZERÚ serializer)ÚselfÚ session_keyrrrÚ__init__/szSessionBase.__init__cCs ||jkS)N)Ú_session)rÚkeyrrrÚ __contains__5szSessionBase.__contains__cCs |j|S)N)r)rr rrrÚ __getitem__8szSessionBase.__getitem__cCs||j|<d|_dS)NT)rr)rr ÚvaluerrrÚ __setitem__;s zSessionBase.__setitem__cCs|j|=d|_dS)NT)rr)rr rrrÚ __delitem__?szSessionBase.__delitem__cCs|jj||ƒS)N)rÚget)rr Údefaultrrrr&CszSessionBase.getcCs8|jp||jk|_||jkr fn|f}|jj|f|žŽS)N)rrÚ_SessionBase__not_givenÚpop)rr r'Úargsrrrr)FszSessionBase.popcCs,||jkr|j|Sd|_||j|<|SdS)NT)rr)rr r#rrrÚ setdefaultKs    zSessionBase.setdefaultcCs|j||j<dS)N)ÚTEST_COOKIE_VALUEÚTEST_COOKIE_NAME)rrrrÚset_test_cookieSszSessionBase.set_test_cookiecCs|j|jƒ|jkS)N)r&r-r,)rrrrÚtest_cookie_workedVszSessionBase.test_cookie_workedcCs ||j=dS)N)r-)rrrrÚdelete_test_cookieYszSessionBase.delete_test_cookiecCsd|jj}t||ƒjƒS)Nzdjango.contrib.sessions)Ú __class__rr Ú hexdigest)rr#Zkey_saltrrrÚ_hash\s zSessionBase._hashcCs4|jƒj|ƒ}|j|ƒ}tj|jƒd|ƒjdƒS)zHReturns the given session dictionary serialized and encoded as a string.ó:Úascii)rÚdumpsr3Úbase64Ú b64encodeÚencodeÚdecode)rZ session_dictÚ serializedÚhashrrrr9`s zSessionBase.encodecCs¢tjt|ƒƒ}yD|jddƒ\}}|j|ƒ}t|jƒ|ƒsBtdƒ‚n|jƒj |ƒSWnJt k rœ}z.t |t ƒrŽt jd|jjƒ}|jt|ƒƒiSd}~XnXdS)Nr4ézSession data corruptedzdjango.security.%s)r7Ú b64decoder Úsplitr3r r:rrÚloadsÚ ExceptionÚ isinstancerÚloggingÚ getLoggerr1rÚwarningr )rZ session_dataZ encoded_datar<r;Z expected_hashÚeÚloggerrrrr:fs   zSessionBase.decodecCs|jj|ƒd|_dS)NT)rÚupdater)rZdict_rrrrHxs zSessionBase.updatecCs ||jkS)N)r)rr rrrÚhas_key|szSessionBase.has_keycCs |jjƒS)N)rÚkeys)rrrrrJszSessionBase.keyscCs |jjƒS)N)rÚvalues)rrrrrK‚szSessionBase.valuescCs |jjƒS)N)rÚitems)rrrrrL…szSessionBase.itemscCs |jjƒS)N)rÚiterkeys)rrrrrMˆszSessionBase.iterkeyscCs |jjƒS)N)rÚ itervalues)rrrrrN‹szSessionBase.itervaluescCs |jjƒS)N)rÚ iteritems)rrrrrOŽszSessionBase.iteritemscCsi|_d|_d|_dS)NT)Ú_session_cacherr)rrrrÚclear‘szSessionBase.clearc Cs.yt|jƒ o|j Stk r(dSXdS)zBReturns True when there is no session_key and the session is emptyTN)ÚboolrrPÚAttributeError)rrrrÚis_empty™szSessionBase.is_emptycCs xtdtƒ}|j|ƒsPqW|S)z*Returns session key that isn't being used.é )r ÚVALID_KEY_CHARSÚexists)rrrrrÚ_get_new_session_key s   z SessionBase._get_new_session_keycCs|jdkr|jƒ|_|jS)N)rrX)rrrrÚ_get_or_create_session_key¨s  z&SessionBase._get_or_create_session_keycCs|ot|ƒdkS)z” Key must be truthy and at least 8 characters long. 8 characters is an arbitrary lower bound for some minimal key security. é)Úlen)rr rrrÚ_validate_session_key­sz!SessionBase._validate_session_keycCs|jS)N)Ú_SessionBase__session_key)rrrrÚ_get_session_key´szSessionBase._get_session_keycCs|j|ƒr||_nd|_dS)zV Validate session key on assignment. Invalid values will set to None. N)r\r])rr#rrrÚ_set_session_key·s zSessionBase._set_session_keyFc CsHd|_y|jStk r@|jdks*|r2i|_n |jƒ|_YnX|jS)z  Lazily loads session from storage (unless "no_load" is True, when only an empty dict is stored) and stores it in the current instance. TN)rrPrSrÚload)rZno_loadrrrÚ _get_sessionÃszSessionBase._get_sessioncKs†y |d}Wntk r(tjƒ}YnXy |d}Wntk rT|jdƒ}YnX|s`tjSt|tƒsn|S||}|jd|j S)zÕGet the number of seconds until the session expires. Optionally, this function accepts `modification` and `expiry` keyword arguments specifying the modification and expiry of the session. Ú modificationÚexpiryÚ_session_expiryi€Q) ÚKeyErrorrÚnowr&rÚSESSION_COOKIE_AGErBrÚdaysÚseconds)rÚkwargsrbrcÚdeltarrrÚget_expiry_ageÔs   zSessionBase.get_expiry_agecKs|y |d}Wntk r(tjƒ}YnXy |d}Wntk rT|jdƒ}YnXt|tƒrd|S|sntj}|t|dS)zÔGet session the expiry date (as a datetime object). Optionally, this function accepts `modification` and `expiry` keyword arguments specifying the modification and expiry of the session. rbrcrd)ri) rerrfr&rBrrrgr)rrjrbrcrrrÚget_expiry_dateís   zSessionBase.get_expiry_datec CsN|dkr,y |d=Wntk r&YnXdSt|tƒrBtjƒ|}||d<dS)a+ Sets a custom expiration for the session. ``value`` can be an integer, a Python ``datetime`` or ``timedelta`` object or ``None``. If ``value`` is an integer, the session will expire after that many seconds of inactivity. If set to ``0`` then the session will expire on browser close. If ``value`` is a ``datetime`` or ``timedelta`` object, the session will expire at that specific future time. If ``value`` is ``None``, the session uses the global session expiry policy. Nrd)rerBrrrf)rr#rrrÚ set_expirys   zSessionBase.set_expirycCs"|jdƒdkrtjS|jdƒdkS)a Returns ``True`` if the session is set to expire when the browser closes, and ``False`` if there's an expiry date. Use ``get_expiry_date()`` or ``get_expiry_age()`` to find the actual expiry date/age, if there is one. rdNr)r&rZSESSION_EXPIRE_AT_BROWSER_CLOSE)rrrrÚget_expire_at_browser_closesz'SessionBase.get_expire_at_browser_closecCs|jƒ|jƒd|_dS)ze Removes the current session data from the database and regenerates the key. N)rQÚdeleter)rrrrÚflush(szSessionBase.flushcCs,|j}|j}|jƒ||_|r(|j|ƒdS)zV Creates a new session key, while retaining the current session data. N)rPrÚcreaterp)rÚdatar rrrÚ cycle_key1s zSessionBase.cycle_keycCs tdƒ‚dS)zG Returns True if the given session_key already exists. z9subclasses of SessionBase must provide an exists() methodN)ÚNotImplementedError)rrrrrrW>szSessionBase.existscCs tdƒ‚dS)zÆ Creates a new session instance. Guaranteed to create a new object with a unique key and will have saved the result once (with empty data) before the method returns. z8subclasses of SessionBase must provide a create() methodN)ru)rrrrrrDszSessionBase.createcCs tdƒ‚dS)a Saves the session data. If 'must_create' is True, a new session object is created (otherwise a CreateError exception is raised). Otherwise, save() only updates an existing object and does not create one (an UpdateError is raised). z6subclasses of SessionBase must provide a save() methodN)ru)rZ must_createrrrÚsaveLszSessionBase.savecCs tdƒ‚dS)z} Deletes the session data under this key. If the key is None, the current session key value is used. z8subclasses of SessionBase must provide a delete() methodN)ru)rrrrrrpUszSessionBase.deletecCs tdƒ‚dS)zB Loads the session data and returns a dictionary. z6subclasses of SessionBase must provide a load() methodN)ru)rrrrr`\szSessionBase.loadcCs tdƒ‚dS)a Remove expired sessions from the session store. If this operation isn't possible on a given backend, it should raise NotImplementedError. If it isn't necessary, because the backend has a built-in expiration mechanism, it should be a no-op. z.This backend does not support clear_expired().N)ru)ÚclsrrrÚ clear_expiredbs zSessionBase.clear_expired)N)N)F)F)N)7rrrrr-r,Úobjectr(rr!r"r$r%r&r)r+r.r/r0r3r9r:rHrIrJrKrLrMrNrOrQrTrXrYr\r^r_ÚpropertyrrrarrlrmrnrorqrtrWrrrvrpr`Ú classmethodrxrrrrr&sb          r) Ú __future__rr7rCÚstringrrZ django.confrZ"django.contrib.sessions.exceptionsrZdjango.core.exceptionsrZ django.utilsrZdjango.utils.cryptor r r Zdjango.utils.encodingr r Zdjango.utils.module_loadingrÚascii_lowercaseÚdigitsrVrArrryrrrrrÚs