class that keeps track of instances

Hello all,

I'd like some advices from more experienced python users. I want to
have a class in my python application that does not allow multiple
instance with same "name".

I want to have a class (call it kls) that behave at least following way:

1) New instance has to have a property called 'name'
2) When instance is attemped to created, e.g., x=kls(name='myn ame'), and
there already exists an instance with obj.name =='myname', that
pre-existing instance is returned, instead of making new one.
3) A class property 'all' for class gives me a list of all the
instances. So kls.all lets me iterates through all instances.
4) When all the hard-link to an instance is deleted, the instance should
be deleted, just like an instance from any regular class does.

My question is if i can find metaclass or something that allows me to
create such class easily. I tried to search such thing on internet, but
I even don't know how to call this kind of thing. It is in a sense like
singleton, but less restrictive.

Assuming that I have to write it on my own, what should I do? I tried
to implement it using weakref.WeakVal ueDictionary and metaclass, but
instance doesn't disappear when I think it should disappear. I am also
wondering if it is easier to keeping {name:id(obj)} would be a better
solution.

Any other suggestions are very much appreciated as well.

--
yosuke kimura
Center for Energy and Environmental Resources
The Univ. of Texas at Austin, USA

[Hrvoje Niksic]

<yo****@ccwf.cc .utexas.eduwrit es:

1) New instance has to have a property called 'name'
2) When instance is attemped to created, e.g., x=kls(name='myn ame'), and
there already exists an instance with obj.name =='myname', that
pre-existing instance is returned, instead of making new one.
3) A class property 'all' for class gives me a list of all the
instances. So kls.all lets me iterates through all instances.
4) When all the hard-link to an instance is deleted, the instance should
be deleted, just like an instance from any regular class does.

class Meta(type):
all = property(lambda type: type.cache.valu es())

class kls(object):
__metaclass__ = Meta
cache = weakref.WeakVal ueDictionary()
def __new__(cls, name):
if name in kls.cache:
return kls.cache[name]
self = object.__new__( cls)
self.name = name
kls.cache[name] = self
return self

>>x = kls(name='foo')
x

<__main__.kls object at 0xb7d5dc8c>

>>x is kls(name='foo')

True

>>x is kls(name='bar')

False

>>print kls.all # only one instance, 'bar' was short-lived

[<__main__.kls object at 0xb7d5dc8c>]

>>x = 'somethingelse'
print kls.all

[]

Assuming that I have to write it on my own, what should I do? I
tried to implement it using weakref.WeakVal ueDictionary and
metaclass, but instance doesn't disappear when I think it should
disappear. I am also wondering if it is easier to keeping
{name:id(obj)} would be a better solution.

The problem is that, given just an ID, you have no way to get a hold
of the actual object.

[Gabriel Genellina]

On 17 sep, 19:10, <[e-mail] .utexas.eduwrot e:

I'd like some advices from more experienced python users. I want to
have a class in my python application that does not allow multiple
instance with same "name".

I want to have a class (call it kls) that behave at least following way:

1) New instance has to have a property called 'name'
2) When instance is attemped to created, e.g., x=kls(name='myn ame'), and
there already exists an instance with obj.name =='myname', that
pre-existing instance is returned, instead of making new one.

For all of this I would use the __new__ method.

3) A class property 'all' for class gives me a list of all the
instances. So kls.all lets me iterates through all instances.
4) When all the hard-link to an instance is deleted, the instance should
be deleted, just like an instance from any regular class does.

I'd store a WeakValueDictio nary using the name as a key. Instead of a
property 'all', I'd use a method 'get_all_instan ces()' that should
call values() on the weak dictionary.

My question is if i can find metaclass or something that allows me to
create such class easily. I tried to search such thing on internet, but
I even don't know how to call this kind of thing. It is in a sense like
singleton, but less restrictive.

Have you tried the Python Cookbook?

Assuming that I have to write it on my own, what should I do? I tried
to implement it using weakref.WeakVal ueDictionary and metaclass, but
instance doesn't disappear when I think it should disappear. I am also
wondering if it is easier to keeping {name:id(obj)} would be a better
solution.

A WeakValueDictio nary should work. If the instance is not deleted when
you expect, maybe there are other references somewhere, or the garbage
collector didn't run yet.

Ok, finally I wrote an example:

pyfrom weakref import WeakValueDictio nary
py>
pyclass OneOfAKind(obje ct):
.... _instances = WeakValueDictio nary()
.... def __new__(cls, name):
.... inst = cls._instances. get(name, None)
.... if inst is None:
.... inst = cls._instances[name] = super(OneOfAKin d,
cls).__new__(cl s
)
.... inst.name = name
.... return inst
.... @classmethod
.... def get_all_instanc es(cls):
.... return cls._instances. values()
.... __str__ = __repr__ = lambda self: '%s(%r)' %
(self.__class__ .__name__, s
elf.name)
....
pya = OneOfAKind('A')
pyb = OneOfAKind('A')
pyassert b is a
pyc = OneOfAKind('C')
pyassert c is not a
pyprint OneOfAKind.get_ all_instances()
[OneOfAKind('A') , OneOfAKind('C')]
pydel c
pyimport gc
pygc.collect()
17
pyprint OneOfAKind.get_ all_instances()
[OneOfAKind('A')]
pydel a
pydel b
pygc.collect()
0
pyprint OneOfAKind.get_ all_instances()
[]
py>

--
Gabriel Genellina

yo****@ccwf.cc. utexas.edu wrote:

I want to have a class in my python application that does not allow
multiple instance with same "name".

Thank you very much for very quick and precise answers to my questions!
input for garbage collector and id are appreciated as well. I head to
bookstore for the cookbook (O'reily's, right?). i thought it was too
cryptic but maybe time for met to revisit the book.

--
yosuke kimura
Center for Energy and Environmental Resources
The Univ. of Texas at Austin, USA