semvec/pypi-packages huggingface dataset:
arc_cache 0.1.1
Memoization decorator using an adaptive replacement cache.
License: MIT
Keywords: cache lru memoize arc

arc_cache
=========

Adaptive Replacement Cache - a Python3 decorator

Mostly for self-study purposes. Use at your own risk.

Usage
-----

.. code-block:: python

    from arc_cache import arc_cache

    @arc_cache()
    def my_heavy_function(arg1):
      do_stuff()

Developing
----------

Setup a virtualenv using

.. code-block:: console

    $ pip3 install tox
    $ tox -e develop
    $ . .venv/bin/activate

Testing
-------

Run all tests using

.. code-block:: console

    $ tox

Releasing
---------

.. code-block:: console

    $ python setup.py bdist sdist bdist_wheel
    $ gpg -u ... --detach-sign -a dist/...
    $ twine upload dist/*

References
----------

Python 3.5 (I believe) uses a C-implementation of `lru_cache`.

- `ARC`_ - A Self-Tuning, Low Overhead Replacement Cache (2003)
- `Adaptive Replacement Cache`_ on Wikipedia
- `lru_cache`_ in cpython 3.4

.. _`ARC`: http://citeseer.ist.psu.edu/viewdoc/summary?doi=10.1.1.13.5210
.. _`Adaptive Replacement Cache`: https://en.wikipedia.org/wiki/Adaptive_replacement_cache
.. _`lru_cache`: https://hg.python.org/cpython/file/3.4/Lib/functools.py#l384
collectstupid 15.11.7
A Faster Collect Static (sometimes) for Django
License: MIT

# Collect Stupid - A Faster, Smarter, and Stupider Collect Static for Django

When using `collectstatic` with remote file systems like Amazon S3 it can often
slow down because up to 3 remote operations are needed for each file.

1. Determine file time stamp
2. Delete file if old
3. Copy the new file

collectstupid speeds up your static file deploy with two tricks

1. The Stupid One: Never checks remote file timestamps and never deletes the 
   old file. It just overwrites the file blindly. This saves two remote
   operations.
2. The Smart One: Stores a list of deployed file md5sums on the remote file 
   system. This keeps track of what files need to be deployed and md5sums are 
   only computed at the source for speed. This can be faster than other 
   collectstatic libraries which a lot of times use local cache and thus other 
   developers don't benefit from the last deploy. Also the deployment tracking 
   is more permanent and not subject to cache clearing unless you explicitly 
   need to clear it.

## Installation and Usage

`pip install collectstupid`

Add **collectstupid** to **INSTALLED_APPS**

Run: `python manage.py collectstupid`

## Storage Mixin

Some storage implementations execute an *exists* and *delete* on the storage
class even when using `collectstupid`. You can add the 
**collectstupid.storage.StupidStorageMixin** to your storage class to skip 
those requests.

## Personal Example Where CollectStupid Improved Deployment Speed

For a project, whenever we deployed, a huge amount of memory (+13GB) was used 
and the whole process took more than 30 minutes on a fast Mac and over 2 hours 
on a virtual machine. Through investigation, we found that every check of 
whether a file existed caused the bucket to do a full file list because of a
very inefficient S3 storage implementation. We implemented `collectstupid` and 
after the initial deploy of large files, subsequent deploys went down to less
than 5 minutes. This also cut down memory usage to almost nothing when compared 
to 13GB.

## Settings

`STUPID_DEPLOY_CACHE`: File where md5sums are stored on the remote filesystem

Default: collectstupid-cache.json

## Feature requests

Feel free to open an issue