Hi,

Is memoize refresh possible ? In order to doesn't have cache interrupt. For example, I set a one day cache and a task that start 10 minutes before cache invalidation to refresh it by myself. But if I delete it and re-run the function, I'll have interruption. Am I clear ? :smile:

Thank you.

Looks like getargspec has been deprecated for python versions >= 3.0. https://docs.python.org/3/library/inspect.html#inspect.getargspec This was throwing some warnings for me when writing unit tests for a project I'm working on. I figured I could silence the warnings or do this PR. Here ya go.

This PR is intended to add support for a boolean convert_to_unicode flag, which will enable us to specify whether or not to convert string-objects to unicode when executing make_cache_key for a particular function that has been memoized.

EDIT: This PR was implemented in order to resolve the following issue when using django-memoize under Python 2:

In [1]: from memoize import memoize

In [2]: import random

In [3]: @memoize(timeout=300)
   ...: def f(key):
   ...:     return random.randrange(100000, 999999)
   ...:

In [4]: f('abc')
Out[4]: 656674

In [5]: f(u'abc')
Out[5]: 749955

In [6]: f('abc')
Out[6]: 656674

In [7]: f(u'abc')
Out[7]: 749955

...in particular, even though 'abc' and u'abc' are logically the same string, we create two separate cache entries simply based on the fact that one key is a str object and the other is a unicode object.

This phenomenon currently affects any piece of the library that makes use of the make_cache_key method (i.e. memoize, delete_memoized, etc.). For example, if we run f('abc') (in one file) and then run delete_memoized(f, u'abc') (in some other file), then the cache entry will not be properly cleared.

I have a function with the following signature:

@memoize(timeout=300) def _start_sequence(self, exam: Exam):

The moment I try to run the function with the annotation I get the following error:

Function has keyword-only arguments or annotations, use getfullargspec() API which can support them

If I remove the type annotation everything works as expected. Given that type annotations have become quite useful with Python 3.5 it would be intrestring to support them.

Unfortunately I see that the required function is only supported in Python 3: inspect.getfullargspec but with some Six magic we can probably make it work.

If you're interested and don't object to the inclusion of Six as an additional dependency I could create a pull request. Let me know!

There are cases where the return value of a function is None and can/should be cached as such.

This preserves the existing behavior of returning None from a memoizer.get (and not caching None return values) unless the user has chosen to memoize None values by instantiating Memoize with memoize_none_values=True.

I believe that the default for this arg could be changed to True, as the only case where users would be affected is if they are accessing memoizer.get directly.

Could you start doing git tags of pypi releases again so it's easy to match up code changes with package releases? The last git tag/GitHub release is currently 1.2.0 from 2015 (https://github.com/tvavrys/django-memoize/releases)

I see the following deprecation warning in Python 3.5.2:

python3.5/site-packages/memoize/__init__.py:28: DeprecationWarning: inspect.getargspec() is deprecated, use inspect.signature() instead argspec = inspect.getargspec(f)

This adds handling of None values. Use case is:

Sample memoized function like:

   @memoize(timeout=100)
   def sample(param):
       return Model.objects.filter(field=param).first()

In case sample function returns None this None is stored in the cache by memoize. However in case of further calls to the sample function, memoize internally does rv = self.get(...) and then if rv is None: then execute function again. This means it treats None as no value in cache. Provided fix changes this behaviour to clearly differentiate between "no value in cache" and "None in cache" situations.

Is it intentional that the *args after the declared arguments are ignored by the memoize decorator, or is that a bug? Below is an example in an ipython shell with python==2.7.6, django==1.4.22 of how memoize isn't taking into account the *args.

In [16]: @memoize()
def func(*args, **kwargs):
    return args, kwargs
   ....:

In [17]: func(1)
Out[17]: ((1,), {})

In [18]: func(2)
Out[18]: ((1,), {})

In [19]: func(1, 2)
Out[19]: ((1,), {})

In [20]: func(1, one=1)
Out[20]: ((1,), {'one': 1})

For instance, it doesn't work with 1.4.

I see that the test_settings were created with Django 1.6, but whether it does work with Django 1.5 (likely it does) and Django 1.7 (not sure) - that's the question.

IMHO, that's something worth mentioning at the very start of the documentation.

I have a use case where I need to memoize using a DatabaseCache backend.

It would be great if Memoizer constructor accepted a cache parameter, allowing the developer to specify a custom cache like: db_memoizer = Memoizer(cache=get_cache('db_cache'))

Also, it would be interesting to add a cache parameter to @memoize decorator. What do you think?

Hello, We found this library useful (thank you!), but we needed it outside a Django context, so we forked it and adapted it. In case you are interested in maintaining the fork please let me know, otherwise we plan to publish the fork ourselves (following the license terms, of course). :)

TypeError object of type 'NoneType' has no len()

https://docs.python.org/3.8/library/inspect.html?highlight=inspect#inspect.getfullargspec https://docs.python.org/3.8/library/inspect.html?highlight=inspect#inspect.getargspec

defaults is an n-tuple of default argument values corresponding to the last n positional parameters, or None if there are no such defaults defined

https://github.com/unhaggle/django-memoize/blob/1ca9af73adf3e5e336aafe85b82993a0a3a66a77/memoize/init.py?_pjax=%23repo-content-pjax-container#L250

elif abs(i - args_len) <= len(argspec.defaults)

Possible fix:

elif abs(i - args_len) <= len(argspec.defaults if argspec.defaults else [])

Something in memoize seems to do a count on the cache_table all the time, why ?

I see this all the time:

SELECT COUNT(*) FROM "cache_table"; args=None

as my table is large it takes 4 seconds on our system.

Hi, I found that @memoize func can't cache a function's result as which the timeout param set.When I set the timeout to 25 * 3600,I found that it ca't cache such a long time(25 hours).Dose this is a bug or something I had missed?