I want to be able to create a subtype of weakref.

Motivation: I use a trick to non-intrusively keep one 
Python object (ward) alive as long as another one 
(custodian) is: I build a weak reference to the 
custodian whose kill function object holds a reference 
to the ward. I "leak" the weakref, but the function 
decrements its refcount so it will eventually die. 
This scheme costs an extra allocation for the function 
object, and because there is a function object at all, 
there's no opportunity to re-use the weakref (please 
document this part of the re-use behavior, BTW!)

I also want the re-use algorithm to check for object 
and type equality so that I can avoid creating 
multiple such references.

Logged In: YES 
user_id=21627

This is what the WeakKeyDictionary is for: use the custodian
as the key, and the ward as the value.

Logged In: YES 
user_id=52572

I wouldn't want to use WeakKeyDictionary directly for this, 
since I'm using it in a fairly time-critical place in C++ 
code. I could do the same thing with a proper subtype of 
dictionary using C++ code, and that's fine if you have a 
guarantee that a custodian has only one ward. Otherwise you 
need to use a collection of wards as the value, which again 
costs an extra allocation for the common case where a 
custodian really does have only one ward. Yes, it would be 
amortized over the number of wards for any custodian, but 
as I say the common case will have one ward per custodian. 
So I'd still really like to have weakref subclassing.

Does anyone still care about this?

Closing as nobody replied to msg71508.

You can create weakref subclasses anyway now.