Metadata-Version: 2.4
Name: cachetools
Version: 6.2.4
Summary: Extensible memoizing collections and decorators
Author-email: Thomas Kemmer <tkemmer@computer.org>
Maintainer-email: Thomas Kemmer <tkemmer@computer.org>
License-Expression: MIT
Project-URL: Homepage, 
Classifier: Development Status :: 5 - Production/Stable
Classifier: Intended Audience :: Developers
Classifier: Operating System :: OS Independent
Classifier: Programming Language :: Python
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.9
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
Classifier: Programming Language :: Python :: 3.13
Classifier: Programming Language :: Python :: 3.14
Classifier: Topic :: Software Development :: Libraries :: Python Modules
Requires-Python: >=3.9
Description-Content-Type: text/x-rst
License-File: LICENSE
Dynamic: license-file

cachetools
========================================================================

.. image:: 
   :target: 
   :alt: Latest PyPI version

.. image:: 
   :target: 
   :alt: CI build status

.. image:: 
   :target: 
   :alt: Documentation build status

.. image:: 
   :target: 
   :alt: Test coverage

.. image:: 
   :target: 
   :alt: Libraries.io SourceRank

.. image:: 
   :target: 
   :alt: License

.. image:: 
   :target: 
   :alt: Code style: black


This module provides various memoizing collections and decorators,
including variants of the Python Standard Library's `@lru_cache`_
function decorator.

.. code-block:: python

   from cachetools import cached, LRUCache, TTLCache

   # speed up calculating Fibonacci numbers with dynamic programming
   @cached(cache={})
   def fib(n):
       return n if n < 2 else fib(n - 1) + fib(n - 2)

   # cache least recently used Python Enhancement Proposals
   @cached(cache=LRUCache(maxsize=32))
   def get_pep(num):
       url = '
       with urllib.request.urlopen(url) as s:
           return s.read()

   # cache weather data for no longer than ten minutes
   @cached(cache=TTLCache(maxsize=1024, ttl=600))
   def get_weather(place):
       return owm.weather_at_place(place).get_weather()

For the purpose of this module, a *cache* is a mutable_ mapping_ of a
fixed maximum size.  When the cache is full, i.e. by adding another
item the cache would exceed its maximum size, the cache must choose
which item(s) to discard based on a suitable `cache algorithm`_.

This module provides multiple cache classes based on different cache
algorithms, as well as decorators for easily memoizing function and
method calls.


Installation
------------------------------------------------------------------------

cachetools is available from PyPI_ and can be installed by running::

  pip install cachetools

Typing stubs for this package are provided by typeshed_ and can be
installed by running::

  pip install types-cachetools


Project Resources
------------------------------------------------------------------------

- `Documentation`_
- `Issue tracker`_
- `Source code`_
- `Change log`_


Related Projects
------------------------------------------------------------------------

- asyncache_: Helpers to use cachetools_ with asyncio.
- cachetools-async_: Helpers to use cachetools_ with asyncio.
- cacheing_: Pure Python Cacheing Library.
- CacheToolsUtils_: Stackable cache classes for sharing, encryption,
  statistics *and more* on top of cachetools_, redis_ and memcached_.
- shelved-cache_: Persistent cache implementation for Python
  cachetools_.


License
------------------------------------------------------------------------

Copyright (c) 2014-2025 Thomas Kemmer.

Licensed under the `MIT License`_.


.. _@lru_cache: 
.. _mutable: 
.. _mapping: 
.. _cache algorithm: 

.. _PyPI: 
.. _typeshed: 
.. _Documentation: 
.. _Issue tracker: 
.. _Source code: 
.. _Change log: 
.. _MIT License: 

.. _asyncache: 
.. _cachetools-async: 
.. _cacheing: 
.. _CacheToolsUtils: 
.. _shelved-cache: 
.. _cachetools: 
.. _redis: 
.. _memcached: 
