def install_cache(cache_name='cache', backend=None, expire_after=None, allowable_codes=(200,), allowable_methods=('GET',), session_factory=CachedSession, **backend_options): """ Installs cache for all ``Requests`` requests by monkey-patching ``Session`` Parameters are the same as in :class:`CachedSession`. Additional parameters: :param session_factory: Session factory. It must be class which inherits :class:`CachedSession` (default) """ if backend: backend = backends.create_backend(backend, cache_name, backend_options) class _ConfiguredCachedSession(session_factory): def __init__(self): super(_ConfiguredCachedSession, self).__init__( cache_name=cache_name, backend=backend, expire_after=expire_after, allowable_codes=allowable_codes, allowable_methods=allowable_methods, **backend_options ) _patch_session_factory(_ConfiguredCachedSession)
def install_cache( cache_name="cache", backend=None, expire_after=None, allowable_codes=(200,), allowable_methods=("GET",), session_factory=CachedSession, **backend_options ): """ Installs cache for all ``Requests`` requests by monkey-patching ``Session`` Parameters are the same as in :class:`CachedSession`. Additional parameters: :param session_factory: Session factory. It should inherit :class:`CachedSession` (default) """ if backend: backend_options["expire_after"] = expire_after backend = backends.create_backend(backend, cache_name, backend_options) _patch_session_factory( lambda: session_factory( cache_name=cache_name, backend=backend, allowable_codes=allowable_codes, allowable_methods=allowable_methods, **backend_options ) )
def __init__(self, cache_name='cache', backend=None, expire_after=None, allowable_codes=(200, ), allowable_methods=('GET', ), filter_fn=lambda r: True, old_data_on_error=False, **backend_options): """ :param cache_name: for ``sqlite`` backend: cache file will start with this prefix, e.g ``cache.sqlite`` for ``mongodb``: it's used as database name for ``redis``: it's used as the namespace. This means all keys are prefixed with ``'cache_name:'`` :param backend: cache backend name e.g ``'sqlite'``, ``'mongodb'``, ``'redis'``, ``'memory'``. (see :ref:`persistence`). Or instance of backend implementation. Default value is ``None``, which means use ``'sqlite'`` if available, otherwise fallback to ``'memory'``. :param expire_after: ``timedelta`` or number of seconds after cache will be expired or `None` (default) to ignore expiration :type expire_after: float :param allowable_codes: limit caching only for response with this codes (default: 200) :type allowable_codes: tuple :param allowable_methods: cache only requests of this methods (default: 'GET') :type allowable_methods: tuple :param filter_fn: function to apply to each response; the response is only cached if this returns `True`. Note that this function does not not modify the cached response in any way. :type filter_fn: function :kwarg backend_options: options for chosen backend. See corresponding :ref:`sqlite <backends_sqlite>`, :ref:`mongo <backends_mongo>` and :ref:`redis <backends_redis>` backends API documentation :param include_get_headers: If `True` headers will be part of cache key. E.g. after get('some_link', headers={'Accept':'application/json'}) get('some_link', headers={'Accept':'application/xml'}) is not from cache. :param ignored_parameters: List of parameters to be excluded from the cache key. Useful when requesting the same resource through different credentials or access tokens, passed as parameters. :param old_data_on_error: If `True` it will return expired cached response if update fails """ self.cache = backends.create_backend(backend, cache_name, backend_options) self._cache_name = cache_name if expire_after is not None and not isinstance(expire_after, timedelta): expire_after = timedelta(seconds=expire_after) self._cache_expire_after = expire_after self._cache_allowable_codes = allowable_codes self._cache_allowable_methods = allowable_methods self._filter_fn = filter_fn self._return_old_data_on_error = old_data_on_error self._is_cache_disabled = False super(CachedSession, self).__init__()
def __init__(self, cache_name='cache', backend=None, expire_after=None, allowable_codes=(200,), allowable_methods=('GET',), ignored_parameters=None, old_data_on_error=False, **backend_options): """ :param cache_name: for ``sqlite`` backend: cache file will start with this prefix, e.g ``cache.sqlite`` for ``mongodb``: it's used as database name for ``redis``: it's used as the namespace. This means all keys are prefixed with ``'cache_name:'`` :param backend: cache backend name e.g ``'sqlite'``, ``'mongodb'``, ``'redis'``, ``'memory'``. (see :ref:`persistence`). Or instance of backend implementation. Default value is ``None``, which means use ``'sqlite'`` if available, otherwise fallback to ``'memory'``. :param expire_after: ``timedelta`` or number of seconds after cache will be expired or `None` (default) to ignore expiration :type expire_after: float :param allowable_codes: limit caching only for response with this codes (default: 200) :type allowable_codes: tuple :param allowable_methods: cache only requests of this methods (default: 'GET') :type allowable_methods: tuple :kwarg backend_options: options for chosen backend. See corresponding :ref:`sqlite <backends_sqlite>`, :ref:`mongo <backends_mongo>` and :ref:`redis <backends_redis>` backends API documentation :param include_get_headers: If `True` headers will be part of cache key. E.g. after get('some_link', headers={'Accept':'application/json'}) get('some_link', headers={'Accept':'application/xml'}) is not from cache. :param ignored_parameters: List of parameters to be excluded from the cache key. Useful when requesting the same resource through different credentials or access tokens, passed as parameters. :param old_data_on_error: If `True` it will return expired cached response if update fails """ if backend is None or isinstance(backend, basestring): self.cache = backends.create_backend(backend, cache_name, backend_options) else: self.cache = backend self._cache_name = cache_name if expire_after is not None and not isinstance(expire_after, timedelta): expire_after = timedelta(seconds=expire_after) self._cache_expire_after = expire_after self._cache_allowable_codes = allowable_codes self._cache_allowable_methods = allowable_methods self._cache_ignored_parameters = ignored_parameters self._return_old_data_on_error = old_data_on_error self._is_cache_disabled = False super(CachedSession, self).__init__()
def __init__( self, cache_name="cache", backend=None, expire_after=None, allowable_codes=(200,), allowable_methods=("GET",), **backend_options ): """ :param cache_name: for ``sqlite`` backend: cache file will start with this prefix, e.g ``cache.sqlite`` for ``mongodb``: it's used as database name for ``redis``: it's used as the namespace. This means all keys are prefixed with ``'cache_name:'`` :param backend: cache backend name e.g ``'sqlite'``, ``'mongodb'``, ``'redis'``, ``'memory'``. (see :ref:`persistence`). Or instance of backend implementation. Default value is ``None``, which means use ``'sqlite'`` if available, otherwise fallback to ``'memory'``. :param expire_after: number of seconds after cache will be expired or `None` (default) to ignore expiration :type expire_after: float :param allowable_codes: limit caching only for response with this codes (default: 200) :type allowable_codes: tuple :param allowable_methods: cache only requests of this methods (default: 'GET') :type allowable_methods: tuple :kwarg backend_options: options for chosen backend. See corresponding :ref:`sqlite <backends_sqlite>`, :ref:`mongo <backends_mongo>` and :ref:`redis <backends_redis>` backends API documentation """ backend_options["expire_after"] = expire_after if backend is None or isinstance(backend, basestring): self.cache = backends.create_backend(backend, cache_name, backend_options) else: self.cache = backend self._cache_expire_after = expire_after self._cache_expire_after_override = {} self._cache_throttle = {} self._cache_allowable_codes = allowable_codes self._cache_allowable_methods = allowable_methods self._is_cache_disabled = False super(CachedSession, self).__init__()
def __init__(self, cache_name='cache', backend=None, expire_after=None, allowable_codes=(200,), allowable_methods=('GET',), **backend_options): """ :param cache_name: for ``sqlite`` backend: cache file will start with this prefix, e.g ``cache.sqlite`` for ``mongodb``: it's used as database name for ``redis``: it's used as the namespace. This means all keys are prefixed with ``'cache_name:'`` :param backend: cache backend name e.g ``'sqlite'``, ``'mongodb'``, ``'redis'``, ``'memory'``. (see :ref:`persistence`). Or instance of backend implementation. Default value is ``None``, which means use ``'sqlite'`` if available, otherwise fallback to ``'memory'``. :param expire_after: ``timedelta`` or number of seconds after cache will be expired or `None` (default) to ignore expiration :type expire_after: float :param allowable_codes: limit caching only for response with this codes (default: 200) :type allowable_codes: tuple :param allowable_methods: cache only requests of this methods (default: 'GET') :type allowable_methods: tuple :kwarg backend_options: options for chosen backend. See corresponding :ref:`sqlite <backends_sqlite>`, :ref:`mongo <backends_mongo>` and :ref:`redis <backends_redis>` backends API documentation :param include_get_headers: If `True` headers will be part of cache key. E.g. after get('some_link', headers={'Accept':'application/json'}) get('some_link', headers={'Accept':'application/xml'}) is not from cache. """ if backend is None or isinstance(backend, basestring): self.cache = backends.create_backend(backend, cache_name, backend_options) else: self.cache = backend self._cache_name = cache_name if expire_after is not None and not isinstance(expire_after, timedelta): expire_after = timedelta(seconds=expire_after) self._cache_expire_after = expire_after self._cache_allowable_codes = allowable_codes self._cache_allowable_methods = allowable_methods self._is_cache_disabled = False super(CachedSession, self).__init__()
def install_cache(cache_name='cache', backend=None, expire_after=None, allowable_codes=(200, ), allowable_methods=('GET', ), session_factory=CachedSession, **backend_options): """ Installs cache for all ``Requests`` requests by monkey-patching ``Session`` Parameters are the same as in :class:`CachedSession`. Additional parameters: :param session_factory: Session factory. It should inherit :class:`CachedSession` (default) """ if backend: backend = backends.create_backend(backend, cache_name, backend_options) _patch_session_factory( lambda: session_factory(cache_name=cache_name, backend=backend, expire_after=expire_after, allowable_codes=allowable_codes, allowable_methods=allowable_methods, **backend_options))