2

So I am working on a Customer class that is supposed to be wrapper for some other classes that retrieve information about a specific customer from a server and from online, as below. 

class Customer:
    def __init__(self, name):
        self.name = name

    @property
    @lru_cache()
    def online_info(self):
       print('retrieving customer online info')
       return Online().search_result(for=self)

    @property
    @lru_cache()
    def server_info(self):
      print('retrieving customer server info')
      return Server().search_result(for=self)

The online and server calls have to be @property decorated. The problem I am facing is when trying to cache the online_info and server_info calls. The cache would somehow have to be at a class level so that even if a news customer is instantiated, the lru_cache wold remember previous calls from other instantiations for the same name call. Note my print statements. This is the behavious I am trying to achieve:

>>> cutomer1 = Customer('John')
>>> customer1.online_info
retrieving customer online info
John Smith has the following info bla bla bla ....

>>> cutomer2 = Customer('John')
>>> customer2.online_info # this one will not be calling the function, lru_cache will return the value saved from customer1.online_info
John Smith has the following info bla bla bla ....

Can someone explain how I achieve this behaviour? Is this possible?

Improve this question
7
  • What if I do Customer('not John').online_info? Should that also use the cached value? Commented Oct 29, 2018 at 13:16
  • @Aran-Fey in that case no, because 'no John' was never called before Commented Oct 29, 2018 at 13:17
  • You can't use lru_cache on properties, or at least, there is no point in using lru_cache there even if you got your decorator order right (which is incorrect as it is now). lru_cache works by looking at the arguments to a function, and here all you have is... nothing, as properties don't take arguments. Commented Oct 29, 2018 at 13:18
  • @Aran-Fey if however you would have another Customer('no John').online info, after initial 'no John' then the values for the second 'no John' will be pulled from the cache and not from the property call Commented Oct 29, 2018 at 13:19
  • @MartijnPieters That's not right. There's the self argument. The code works perfectly fine if the decorators are swapped. Commented Oct 29, 2018 at 13:20

2 Answers 2

Reset to default
2

Instead of caching the property values on the class, I would recommend re-using the same Customer instance for each "John", so that

>>> Customer('John') is Customer('John')
True

This would make Customer a singleton of sorts. Singleton implementations can be found aplenty in this question: Creating a singleton in Python. Borrowing one of those implementations gives us a pseudo-singleton metaclass like this:

class NameSingleton(type):
    def __init__(cls, *args, **kwargs):
        cls._instances = {}

    def __call__(cls, name, *args, **kwargs):
        try:
            return cls._instances[name]
        except KeyError:
            instance = super().__call__(name, *args, **kwargs)
            cls._instances[name] = instance
            return instance

Use this as the metaclass for Customer and you're done:

class Customer(metaclass=NameSingleton):
    def __init__(self, name):
        self.name = name

    ...

Demo:

>>> Customer('John') is Customer('John')
True
>>> Customer('John') is Customer('not John')
False
Improve this answer
Sign up to request clarification or add additional context in comments.

4 Comments

that is an interesing built. However, I am a bit reluctant to use this code because up the chain I am making multiple Customers from a pandas dataframe, then calling the server_info and online_info on multiple threads and I afraid that with a singleton and multithreading, they might stunble on each other
@callmeGuy Well, the worst thing that could happen is that two threads create a John at the same time, and end up with two different John instances. Every caching mechanism has that problem though, whether you're caching Customer instances or property values. If it's a problem, you can wrap the Customer constructor in a threading.Lock.
so if i am creating 2 Customers in the same time and they happen to be of the same value, then the cache will be useless. Is there such thing as a global cache?
@callmeGuy This is a global cache, but it's not thread-safe. It just needs a lock.
0

Assuming that you want to use the calling pattern you present: You want "property" attributes of instances which, when fetched, return information for the customer identified by self.name. But you want that customer information to be cached on a class-wide basis, so if you create two instances with the same self.name, work isn't duplicated between the two instances.

It seems to me that what you want is a "property" attribute whose fget function calls a class method, and the class method caches its results.

This code implements that pattern

import functools

class Customer:
    def __init__(self, name):
        self.name = name

    @property
    def info(self):
       print('retrieving info 1 for', self.name)
       return Customer.info_implement(self.name)

    @classmethod
    @functools.cache
    def info_implement(cls, name):
       print('retrieving info 2 for', name)
       return "info for " + name

customer1 = Customer('John')
print("customer1 info", customer1.info)
print("customer1 info", customer1.info)

customer2 = Customer('John')
print("customer2 info", customer2.info)
print("customer2 info", customer2.info)

and produces this output

retrieving info 1 for John
retrieving info 2 for John
customer1 info info for John
retrieving info 1 for John
customer1 info info for John
retrieving info 1 for John
customer2 info info for John
retrieving info 1 for John
customer2 info info for John
Improve this answer

Comments

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.