"specialdic t" module

[Georg Brandl]

Hello,

in follow-up to the recent "dictionary accumulator" thread, I wrote a
little module with several subclassed dicts.

Comments (e.g. makes it sense to use super), corrections, etc.? Is this
PEP material?

Docstrings, Documentation and test cases are to be provided later.

mfg
Georg

----------------------------------------------------------------------

class defaultdict(dic t):
# _defaulttype: 0=no default, 1=defaultvalue, 2=defaultfactor y
__slots__ = ['_defaulttype', '_default']

def __init__(self, *args, **kwargs):
self._defaultty pe = 0

super(defaultdi ct, self).__init__( self, *args, **kwargs)

def setdefaultvalue (self, value):
self._defaultty pe = 1
self._default = value

def setdefaultfacto ry(self, factory, *args, **kwargs):
if not callable(factor y):
raise TypeError, 'default factory must be a callable'
self._defaultty pe = 2
self._default = (factory, args, kwargs)

def cleardefault(se lf):
self._defaultty pe = 0

def __getitem__(sel f, key):
try:
return super(defaultdi ct, self).__getitem __(key)
except KeyError:
if self._defaultty pe == 0:
raise
elif self._defaultty pe == 1:
return self.setdefault (key, self._default)
else:
return self.setdefault (key,
self._default[0](*self._default[1], **self._default[2]))

class keytransformdic t(dict):
__slots__ = ['_transformer']

def __init__(self, *args, **kwargs):
self._transform er = lambda x: x

super(keytransf ormdict, self).__init__( self, *args, **kwargs)

def settransformer( self, transformer):
if not callable(transf ormer):
raise TypeError, 'transformer must be a callable'
self._transform er = transformer

def __setitem__(sel f, key, value):
super(keytransf ormdict, self).__setitem __(self,
self._transform er(key), value)

def __getitem__(sel f, key):
return super(keytransf ormdict, self).__getitem __(self,
self._transform er(key))

def __delitem__(sel f, key):
super(keytransf ormdict, self).__delitem __(self,
self._transform er(key))

class sorteddict(dict ):
def __iter__(self):
for key in sorted(super(so rteddict, self).__iter__( self)):
yield key

def keys(self):
return list(self.iterk eys())

def items(self):
return list(self.iteri tems())

def values(self):
return list(self.iterv alues())

def iterkeys(self):
return iter(self)

def iteritems(self) :
return ((key, self[key]) for key in self)

def itervalues(self ):
return (self[key] for key in self)

if __name__ == '__main__':
x = sorteddict(a=1, b=3, c=2)

print x.keys()
print x.values()
print x.items()

[Jeff Epler]

The software you used to post this message wrapped some of the lines of
code. For example:

def __delitem__(sel f, key):
super(keytransf ormdict, self).__delitem __(self,
self._transform er(key))

In defaultdict, I wonder whether everything should be viewed as a
factory:
def setdefaultvalue (self, value):
def factory(): return value
self.setdefault factory(factory )

and the "no-default" mode would either cease to exist, or
def cleardefault(se lf):
def factory():
raise KeyError, "key does not exist and no default defined"
self.setdefault factory(factory )
(too bad that the key isn't available in the factory, this degrades the
quality of the error messge)

if so, __getitem__ becomes simpler:
__slots__ = ['_default']
def __getitem__(sel f, key):
try:
return super(defaultdi ct, self).__getitem __(key)
except KeyError:
return self.setdefault (key, apply(*self._de fault))

I don't ever have an itch for sorted dictionaries, as far as I can
remember, and I don't immediately understand the use of
keytransformdic t. Can you give an example of it?

Jeff

-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.2.6 (GNU/Linux)

iD8DBQFCUCb2Jd0 1MZaTXX0RAujvAJ 4mi7cu3l85k0eeT Usd42UDtGVAzACg p1um
6Iq2DhOo529q83o RXqquZ5I=
=Ytjv
-----END PGP SIGNATURE-----

[Georg Brandl]

Jeff Epler wrote:

The software you used to post this message wrapped some of the lines of
code. For example:

def __delitem__(sel f, key):
super(keytransf ormdict, self).__delitem __(self,
self._transform er(key))

Somehow I feared that this would happen.
In defaultdict, I wonder whether everything should be viewed as a
factory:
def setdefaultvalue (self, value):
def factory(): return value
self.setdefault factory(factory )
That's a reasonable approach. __init__ must be changed too, but this
shouldn't hurt too badly.
and the "no-default" mode would either cease to exist, or
def cleardefault(se lf):
def factory():
raise KeyError, "key does not exist and no default defined"
self.setdefault factory(factory )
(too bad that the key isn't available in the factory, this degrades the
quality of the error messge)
That can be worked around with a solution in __getitem__, see below.
if so, __getitem__ becomes simpler:
__slots__ = ['_default']
def __getitem__(sel f, key):
try:
return super(defaultdi ct, self).__getitem __(key)
except KeyError:
return self.setdefault (key, apply(*self._de fault))
You are peculating the kwargs. Also, apply() is on the verge of being
deprecated, so better not use it.

def __getitem__(sel f, key):
try:
return super(defaultdi ct, self).__getitem __(key)
except KeyError, err:
try:
return self.setdefault (key,
self._default[0](*self._default[1],
**self._default[2]))
except KeyError:
raise err

Although I'm not sure whether KeyError would be the right one to raise
(perhaps a custom error?).
I don't ever have an itch for sorted dictionaries, as far as I can
remember, and I don't immediately understand the use of
keytransformdic t. Can you give an example of it?

See the thread "Case-insensitive dict, non-destructive, fast, anyone?",
starting at 04/01/05 12:38.

mfg
Georg

[Michael Spencer]

Georg Brandl wrote:

Hello,

in follow-up to the recent "dictionary accumulator" thread, I wrote a
little module with several subclassed dicts.

Comments (e.g. makes it sense to use super), corrections, etc.? Is this
PEP material?

Docstrings, Documentation and test cases are to be provided later.

mfg
Georg

Georg:

A few reactions:

1. Given that these are specializations , why not have:

class defaultvaluedic t(dict):
...

class defaultfactoryd ict(dict):
...

rather than having to jump through hoops to make one implementation satisfy both
cases

2. I would really prefer to have the default value specified in the constructor

I realize that this is tricky due to the kw arguments of dict.__init__, but I
would favor either breaking compatibility with that interface, or adopting some
workaround to make something like d= defaultvaluedic t(__default__ = 0) possible.

One worksaround would be to store the default in the dict, not as an attribute
of the dict. By default the default value would be associated with the key
"__default_ _", but that keyname could be changed for the (I guess very few)
cases where that key conflicted with non-default content of the dict. Then
dict.__init__ would simply take __default__ = value as a keyword argument, as it
does today, and __getitem__ for a missing key would return
dict.__getitem_ _(self, "__default_ _")

Alternatively, you could provide factory functions to construct the defaultdict.
Someone (Michele?) recently posted an implementation of this

3. Can you work in the tally and listappend methods that started this whole
thread off?

4. On super, no I don't think it's necessary or particularly desirable. These
specializations have a close association with dict. dict.method(sel f,...) feels
more appropriate in this case.

Michael

[Georg Brandl]

Michael Spencer wrote:

1. Given that these are specializations , why not have:

class defaultvaluedic t(dict):
...

class defaultfactoryd ict(dict):
...

rather than having to jump through hoops to make one implementation satisfy both
cases
I think I like Jeff's approach more (defaultvalues are just special
cases of default factories); there aren't many "hoops" required.
Apart from that, the names just get longer ;)
2. I would really prefer to have the default value specified in the constructor

I realize that this is tricky due to the kw arguments of dict.__init__, but I
would favor either breaking compatibility with that interface, or adopting some
workaround to make something like d= defaultvaluedic t(__default__ = 0) possible.
Too much specialcased for my liking.
One worksaround would be to store the default in the dict, not as an attribute
of the dict. By default the default value would be associated with the key
"__default_ _", but that keyname could be changed for the (I guess very few)
cases where that key conflicted with non-default content of the dict. Then
dict.__init__ would simply take __default__ = value as a keyword argument, as it
does today, and __getitem__ for a missing key would return
dict.__getitem_ _(self, "__default_ _")
I thought about this too (providing a singleton instance named Default,
just like None is, and using it as a key), but you would have to
special-case the (iter)keys,valu es,items methods to exclude the default
- definitely too much work, and too much magic.
Alternatively, you could provide factory functions to construct the defaultdict.
Someone (Michele?) recently posted an implementation of this
Yes, I think this could be reasonable.
3. Can you work in the tally and listappend methods that started this whole
thread off?
They aren't necessary any longer.

Use defaultdict.set defaultvalue(0) instead of the tally approach and
defaultdict.set defaultfactory( list) instead of listappend.
4. On super, no I don't think it's necessary or particularly desirable. These
specializations have a close association with dict. dict.method(sel f,...) feels
more appropriate in this case.

Any other opinions on this?

Thanks for the comments,

mfg
Georg

[Michael Spencer]

Georg Brandl wrote:

I think I like Jeff's approach more (defaultvalues are just special
cases of default factories); there aren't many "hoops" required.
Apart from that, the names just get longer ;)
Yes Jeff's approach does simplify the implementation and more-or-less eliminates
my complexity objection

But why do you write:

def __getitem__(sel f, key):
try:
return super(defaultdi ct, self).__getitem __(key)
except KeyError, err:
try:
return self.setdefault (key,
self._default[0](*self._default[1],
**self._default[2]))
except KeyError:
raise err

rather than:

def __getitem__(sel f, key):
return self.setdefault (key,
self._default[0](*self._default[1],
**self._default[2]))

(which could catch AttributeError in the case of _default not set)
I'm sure there's a reason, but I can't see it.

2. I would really prefer to have the default value specified in the constructor ....

Too much specialcased for my liking.
It does set up some gotchas I concede ;-)
....

Alternatively , you could provide factory functions to construct the defaultdict.
Someone (Michele?) recently posted an implementation of this

Yes, I think this could be reasonable.

....though this would more naturally complement a fixed-default dictionary IMO
Your design permits - even encourages (by providing convenient setters) the
default to change over the lifetime of the dictionary. I'm not sure whether
that's good or bad, but it's a feature worth discussing.
3. Can you work in the tally and listappend methods that started this whole
thread off?

They aren't necessary any longer.

Use defaultdict.set defaultvalue(0) instead of the tally approach and
defaultdict.set defaultfactory( list) instead of listappend.

Oops, I see what you mean... then use += or append as required. I still prefer
the clarity of tally for its specific use-case, but it does suffer from lack of
generality.

Michael

[Georg Brandl]

Michael Spencer wrote:

Georg Brandl wrote:

I think I like Jeff's approach more (defaultvalues are just special
cases of default factories); there aren't many "hoops" required.
Apart from that, the names just get longer ;)

Yes Jeff's approach does simplify the implementation and more-or-less eliminates
my complexity objection

But why do you write:

def __getitem__(sel f, key):
try:
return super(defaultdi ct, self).__getitem __(key)
except KeyError, err:
try:
return self.setdefault (key,
self._default[0](*self._default[1],
**self._default[2]))
except KeyError:
raise err

rather than:

def __getitem__(sel f, key):
return self.setdefault (key,
self._default[0](*self._default[1],
**self._default[2]))

(which could catch AttributeError in the case of _default not set)
I'm sure there's a reason, but I can't see it.

In your version, the default factory is called every time a value is
retrieved, which might be a performance problem.

Alternativel y, you could provide factory functions to construct the defaultdict.
Someone (Michele?) recently posted an implementation of this

Yes, I think this could be reasonable.

...though this would more naturally complement a fixed-default dictionary IMO
Your design permits - even encourages (by providing convenient setters) the
default to change over the lifetime of the dictionary. I'm not sure whether
that's good or bad, but it's a feature worth discussing.

It's certainly more in the spirit of Python -- we're consenting adults,
and so we are allowed to change the default.

mfg
Georg

[Michele Simionato]

Michael Spencer:

Alternatively, you could provide factory functions to construct the defaultdict. Someone (Michele?) recently posted an implementation of this

Yes, here is the link for the ones who missed that thread:

http://groups-beta.google.com/group/...67d30b796423c7

[Michele Simionato]

About not using super: you might have problems in multiple inheritance.
Suppose I want to use both your defaultdict and a thirdpartdict. A
subclass

class mydict(defaultd ict, thirdpartdict):
pass

would not work if thirdpartdict requires a non-trivial __init__ , since
without super in defaultdict.__i nit__ you would just call dict.__init__
and not thirdpartdict.

Michele Simionato

[Georg Brandl]

Michele Simionato wrote:

About not using super: you might have problems in multiple inheritance.
Suppose I want to use both your defaultdict and a thirdpartdict. A
subclass

class mydict(defaultd ict, thirdpartdict):
pass

would not work if thirdpartdict requires a non-trivial __init__ , since
without super in defaultdict.__i nit__ you would just call dict.__init__
and not thirdpartdict.

Right. I thought about a combined defaultdict/keytransformdic t,
which seems to be easy to create with the current implementation:

class defaultkeytrans formdict(defaul tdict, keytransformdic t):
pass

At least I hope so. This is another argument against the initializing
of defaultfactory or keytransformer in __init__.

mfg
Georg

Here comes the current module (keytransformdi ct should be working now
for all dict methods):

# specialdict - subclasses of dict for common tasks
#

class NoDefaultGiven( Exception):
pass

class defaultdict(dic t):
__slots__ = ['_default']

def __init__(self, *args, **kwargs):
self._defaultty pe = 0

super(defaultdi ct, self).__init__( *args, **kwargs)

def setdefaultvalue (self, value):
def defaultfactory( ):
return value
self._default = (defaultfactory , (), {})

def setdefaultfacto ry(self, factory, *args, **kwargs):
if not callable(factor y):
raise TypeError, 'default factory must be a callable'
self._default = (factory, args, kwargs)

def cleardefault(se lf):
def defaultfactory( ):
raise NoDefaultGiven
self._default = (defaultfactory , (), {})

def __getitem__(sel f, key):
try:
return super(defaultdi ct, self).__getitem __(key)
except KeyError, err:
try:
return self.setdefault (key, self._default[0](*self._default[1], **self._default[2]))
except NoDefaultGiven:
raise err

class keytransformdic t(dict):
__slots__ = ['_transformer']

def __init__(self, *args, **kwargs):
self._transform er = lambda x: x

super(keytransf ormdict, self).__init__( *args, **kwargs)

def settransformer( self, transformer):
if not callable(transf ormer):
raise TypeError, 'transformer must be a callable'
self._transform er = transformer

def __setitem__(sel f, key, value):
print "setitem"
super(keytransf ormdict, self).__setitem __(self._transf ormer(key), value)

def __getitem__(sel f, key):
print "getitem"
return super(keytransf ormdict, self).__getitem __(self._transf ormer(key))

def __delitem__(sel f, key):
super(keytransf ormdict, self).__delitem __(self._transf ormer(key))

def has_key(self, key):
return super(keytransf ormdict, self).has_key(s elf._transforme r(key))

def __contains__(se lf, key):
return self.has_key(ke y)

def get(self, key, default):
return super(keytransf ormdict, self).get(self. _transformer(ke y), default)

def setdefault(self , key, default):
return super(keytransf ormdict, self).setdefaul t(self._transfo rmer(key), default)

def pop(self, key, default):
return super(keytransf ormdict, self).pop(self. _transfomer(key ), default)

def update(self, other=None, **kwargs):
if other is not None:
if hasattr(other, "keys"):
super(keytransf ormdict, self).update((s elf._transforme r(k), other[k]) for k in other.keys())
else:
super(keytransf ormdict, self).update((s elf._transforme r(k), v) for (k, v) in other)
if kwargs:
super(keytransf ormdict, self).update((s elf._transforme r(k), v) for (k, v) in kwargs.iteritem s())

class sorteddict(dict ):
def __iter__(self):
for key in sorted(super(so rteddict, self).__iter__( )):
yield key

def keys(self):
return list(self.iterk eys())

def items(self):
return list(self.iteri tems())

def values(self):
return list(self.iterv alues())

def iterkeys(self):
return iter(self)

def iteritems(self) :
return ((key, self[key]) for key in self)

def itervalues(self ):
return (self[key] for key in self)