Module Expr Str ImportFrom alias ClassDef bases body Expr Str decorator_list ClassDef bases NameLoad body Expr Str FunctionDef arguments args NameParam defaults vararg kwarg body Assign NameStore Call AttributeLoad Call NameLoad attr NameLoad NameLoad NameLoad Assign AttributeStore NameLoad attr Dict Return NameLoad decorator_list FunctionDef arguments args NameParam defaults vararg kwarg body Assign NameStore Call NameLoad AttributeLoad NameLoad attr AttributeLoad NameLoad attr BinOpAdd TupleLoad NameLoad NameLoad NameLoad TryExcept body Return SubscriptLoad AttributeLoad NameLoad attr Index NameLoad handlers ExceptHandler type NameLoad body Assign SubscriptStore AttributeLoad NameLoad attr Index NameLoad NameStore Call AttributeLoad Call NameLoad attr NameLoad NameLoad Return NameLoad decorator_list decorator_list
N/A N/A 
Defines the `CachedType` metaclass.

See its documentation for more details.
 python_toolbox.sleek_reffing SleekCallArgs SelfPlaceholder N/A N/A N/A Placeholder for `self` when storing call-args. N/A CachedType N/A type N/A N/A 
    A metaclass for sharing instances.
        
    For example, if you have a class like this:
    
        class Grokker(object, metaclass=caching.CachedType):
            def __init__(self, a, b=2):
                self.a = a
                self.b = b
                
    Then all the following calls would result in just one instance:
    
        Grokker(1) is Grokker(1, 2) is Grokker(b=2, a=1) is Grokker(1, **{})
    
    This metaclass understands keyword arguments.
    
    All the arguments are sleekreffed to prevent memory leaks. Sleekref is a
    variation of weakref. Sleekref is when you try to weakref an object, but if
    it's non-weakreffable, like a `list` or a `dict`, you maintain a normal,
    strong reference to it. (See documentation of
    `python_toolbox.sleek_reffing` for more details.) Thanks to sleekreffing
    you can avoid memory leaks when using weakreffable arguments, but if you
    ever want to use non-weakreffable arguments you are still able to.
    (Assuming you don't mind the memory leaks.)
     __new__ N/A N/A mcls N/A args kwargs N/A N/A result N/A N/A N/A super __new__ mcls args kwargs N/A N/A result __cache N/A N/A result N/A __call__ N/A N/A cls N/A args kwargs N/A N/A sleek_call_args N/A SleekCallArgs N/A cls __cache N/A cls __init__ N/A N/A SelfPlaceholder args kwargs N/A N/A N/A N/A N/A cls __cache N/A sleek_call_args N/A N/A N/A KeyError N/A N/A N/A N/A cls __cache N/A sleek_call_args value N/A N/A N/A super __call__ args kwargs N/A value N/A N/A