stestagg / fin Goto Github PK

When fin.cache.method is used on a classmethod, the cached values are shared between all subclasses in a non-stable fashion. For example:

class A(object):
  BAR = 1
  @classmethod
  @fin.cache.method
  def foo(cls):
    return cls.BAR

class B(A):
  BAR = 2

If the following code is then run:

print A.foo()
print B.foo()

then the output is:

1
1

If, however, this is run instead:

print B.foo()
print A.foo()

then the output is:

2
1

This is due to the naive way fin.cache stores cached values in the dict of the class. It will only create a new cache dictionary on the object if an existing one isn't found, this breaks even more thoroughly when classmethod caches and instance caches are mixed.

The obvious way around this is to interact with the dict attribute directly, unfortunately class objects use a 'dictproxy' object for their dict attribute, which doesn't allow item assignment directly, preventing such simple manipulation.

The approach that should work would be to /test/ for attribute presence by using "in" on the dict directly:

CACHE_KEY in obj.__dict__

rather than:

 hasattr(obj, CACHE_KEY)

And then to use setattr() to write the new cache if this test fails.

Does this have a use?

It is honestly just a single class, called Exception, which inherits Pythons Exception, and then does absolutely nothing.

This looks like a big waste of time and just obfuscates what it actually is when you could just use Python's standard Exception class.

Sorry if this isn't welcome! I just came to take a look from mu as I was interested in what fin is. Found the exception module quite curious.