__getitem__ method on (meta)classes

[ron]

Why doesn't this work?

def foo(lst): .... class baz(object):
.... def __getitem__(cls , idx): return cls.lst[idx]
.... __getitem__=cla ssmethod(__geti tem__)
.... baz.lst = lst
.... return baz
.... f = foo([1,2,3])
f[0] Traceback (most recent call last):
File "<stdin>", line 1, in ?
TypeError: unsubscriptable object f.__getitem__(0 ) 1

I thought x[y] and x.__getitem__(y ) were supposed to always be
synonymous.

Thanks,
rg

[Simon Percivall]

Well, they're not synonymous. At least not in that context. If you
haven't already tried it, what you're doing will fail for instances as
well. Look in typeobject.c to see why. The gist of it is that the
special methods are looked up on the type rather than the instance (on
the metaclass rather than on the class, in your case), so the internal
lookup mechanism ignore instance attributes completely in this case.

[Bengt Richter]

On 14 Mar 2005 17:43:53 -0800, ro*@flownet.com wrote:

Why doesn't this work?

def foo(lst):... class baz(object):
... def __getitem__(cls , idx): return cls.lst[idx]
... __getitem__=cla ssmethod(__geti tem__)
... baz.lst = lst
... return baz
... f = foo([1,2,3])
f[0]Traceback (most recent call last):
File "<stdin>", line 1, in ?
TypeError: unsubscriptable object f.__getitem__(0 )1

I thought x[y] and x.__getitem__(y ) were supposed to always be
synonymous.

Yes, but what was your "x"?
Note:

def foo(lst): ... class baz(object):
... def __getitem__(cls , idx): return cls.lst[idx]
... __getitem__ = classmethod(__g etitem__)
... baz.lst = lst
... return baz
... f = foo([1,2,3])
f <class '__main__.baz'>

Your "x" was the baz *class*, and the baz *class* is not subscriptable *itself*,
even though it defines subscripting for its instances.
To be ordinarily subscriptable, type(f).__getit em__ would have to succeed, which it doesn't:
type(f) <type 'type'> type(f).__getit em__ Traceback (most recent call last):
File "<stdin>", line 1, in ?
AttributeError: type object 'type' has no attribute '__getitem__'

However, a baz instance is different:
finst = f()
finst <__main__.baz object at 0x02EF168C>

Its type does have a __getitem__ attribute:
type(finst).__g etitem__ <bound method type.__getitem_ _ of <class '__main__.baz'> >

I think "bound method" is a bit of a misnomer for a classmethod, though
it is a method, and it is bound, just to the class instead of the instance.
(see below)
type(finst).__g etitem__(0) 1

Or straightforward indexing syntax:
finst[0], finst[1], finst[2] (1, 2, 3)

Contrast with the way an ordinary method repr's when you access it
via class and instance:
class C(object): ... def ordinary_method (self): return 'Hi'
... c=C()
C.ordinary_meth od <unbound method C.ordinary_meth od> c.ordinary_meth od <bound method C.ordinary_meth od of <__main__.C object at 0x02EF164C>> c.ordinary_meth od() 'Hi' C.ordinary_meth od <unbound method C.ordinary_meth od> C.ordinary_meth od(c) 'Hi'

Note the difference between ordinary and classmethod:
type(c).ordinar y_method <unbound method C.ordinary_meth od> type(finst).__g etitem__

<bound method type.__getitem_ _ of <class '__main__.baz'> >

BTW, I see a class factory, but no "(meta)"cla ss per se.

Regards,
Bengt Richter

[Leif K-Brooks]

ro*@flownet.com wrote:

Why doesn't this work?

def foo(lst):
... class baz(object):
... def __getitem__(cls , idx): return cls.lst[idx]
... __getitem__=cla ssmethod(__geti tem__)
... baz.lst = lst
... return baz
...

I thought x[y] and x.__getitem__(y ) were supposed to always be
synonymous.

No, with new-style classes, x[y] and type(x).__getit em__(y) are
synonymous. This works:

def foo(lst): .... class bar(type):
.... def __getitem__(sel f, index):
.... return self.lst[index]
.... class baz(object):
.... __metaclass__ = bar
.... baz.lst = lst
.... return baz
.... foo([1,2,3])[0]

1

[Michele Simionato]

Leif Brooks:

with new-style classes, x[y] and type(x).__getit em__(y) are
synonymous.

Yes, but check the discussion around SF789262. The call ``x[y]`` is
converted to ``type(x).__get item__(x,y)``
*only if* ``__getitem__`` is explicitely defined in ``type(x)``. If
``type(x)`` does not define ``__getitem__`` directly, but only
indirectly via delegation (i.e. overriding ``__getattribut e__``),
then the second form (i.e. ``type(x).__get item__(x,y)``) works but
not the first one (i.e. ``x[y]`` raises an error).

Michele Simionato

[Ron Garret]

In article <39************ *@individual.ne t>,
Leif K-Brooks <eu*****@ecritt ers.biz> wrote:

ro*@flownet.com wrote:

Why doesn't this work?

>def foo(lst):

... class baz(object):
... def __getitem__(cls , idx): return cls.lst[idx]
... __getitem__=cla ssmethod(__geti tem__)
... baz.lst = lst
... return baz
...

I thought x[y] and x.__getitem__(y ) were supposed to always be
synonymous.

No, with new-style classes, x[y] and type(x).__getit em__(y) are
synonymous.

Ah.

Did you mean type(x).__getit em__(x,y)?

And where is this documented?

rg

[Ron Garret]

In article <42************ ****@news.oz.ne t>,
bo**@oz.net (Bengt Richter) wrote:

On 14 Mar 2005 17:43:53 -0800, ro*@flownet.com wrote:

Why doesn't this work?

> def foo(lst):... class baz(object):
... def __getitem__(cls , idx): return cls.lst[idx]
... __getitem__=cla ssmethod(__geti tem__)
... baz.lst = lst
... return baz
...

> f = foo([1,2,3])
> f[0]

Traceback (most recent call last):
File "<stdin>", line 1, in ?
TypeError: unsubscriptable object

> f.__getitem__(0 )

1

>

I thought x[y] and x.__getitem__(y ) were supposed to always be
synonymous.

Yes, but what was your "x"?
Note:

>>> def foo(lst): ... class baz(object):
... def __getitem__(cls , idx): return cls.lst[idx]
... __getitem__ = classmethod(__g etitem__)
... baz.lst = lst
... return baz
... >>> f = foo([1,2,3])
>>> f

<class '__main__.baz'>

Your "x" was the baz *class*, and the baz *class* is not subscriptable
*itself*,

But why not? __getitem__ is a class method, not an instance method.

(You can treat that as a rhetorical question. I know the answer already
from other postings in this thread.)
BTW, I see a class factory, but no "(meta)"cla ss per se.

That's because I took out extraneous code to not distract from the
problem I was having, and in the process took out all the useful stuff
:-)

What I'm really trying to do is to create enumerated types such that if:

e1 = enum(lst) and v = e1(x)

then

(x in lst) and (e1[v] == x)

In other words, I want to map values onto their representations using
the () operator, and representations onto their values using the []
operator. That requires me to define the [] operator on the enumerated
classes themselves. So my actual code was:

def enum(vals):
class enum(object):
def __init__(self, val):
try:
self.val = type(self).vals .index(val)
except:
raise TypeError, "%s is not a valid %s" % (val, type(self))
def __getitem__(sel f, index): return self.vals.index (index)
__getitem__=cla ssmethod(__geti tem__)
enum.vals = vals
return enum
(Actually, what I'm really trying to do is create a whole hierarchy of
static type descriptors and automatically generate database schema from
those descriptors, but that's a story for another day.)

Thanks for all the responses.

rg

[Steven Bethard]

Ron Garret wrote:

What I'm really trying to do is to create enumerated types such that if:

e1 = enum(lst) and v = e1(x)

then

(x in lst) and (e1[v] == x)

Use a class with __call__ and __getitem__:

py> class enum(object):
.... def __init__(self, vals):
.... self.vals = vals
.... def __call__(self, val):
.... return self.vals.index (val)
.... def __getitem__(sel f, index):
.... return self.vals[index]
....
py> lst = 'abcd'
py> x = 'b'
py> e1 = enum(lst)
py> v = e1(x)
py> (x in lst) and (e1[v] == x)
True

STeVe

[Bengt Richter]

On Mon, 14 Mar 2005 22:00:38 -0800, Ron Garret <rN*******@flow net.com> wrote:

In article <39************ *@individual.ne t>,
Leif K-Brooks <eu*****@ecritt ers.biz> wrote:

ro*@flownet.com wrote:

> Why doesn't this work?
>
>
>>>>def foo(lst):
>
> ... class baz(object):
> ... def __getitem__(cls , idx): return cls.lst[idx]
> ... __getitem__=cla ssmethod(__geti tem__)
> ... baz.lst = lst
> ... return baz
> ...
>
> I thought x[y] and x.__getitem__(y ) were supposed to always be
> synonymous.
No, with new-style classes, x[y] and type(x).__getit em__(y) are
synonymous.

Ah.

Did you mean type(x).__getit em__(x,y)?

Not if x is a classmethod, since type(x).__getit em__ gets you a bound-to-the-class method
instead of the usual unbound method, which would want the x instance as the first argument.

def foo(lst): ... class baz(object):
... def __getitem__(cls , idx): return cls.lst[idx]
... __getitem__=cla ssmethod(__geti tem__)
... baz.lst = lst
... return baz
... f = foo([1,2,3])()
type(f).__getit em__ <bound method type.__getitem_ _ of <class '__main__.baz'> > type(f).__getit em__(0) 1

Leaving out the classmethod:
def foo(lst): ... class baz(object):
... def __getitem__(cls , idx): return cls.lst[idx]
... baz.lst = lst
... return baz
... f = foo([1,2,3])()
type(f).__getit em__ <unbound method baz.__getitem__ > type(f).__getit em__(f, 0)

1
And where is this documented?

Between the lines in my previous post ;-)
Regards,
Bengt Richter

[Ron Garret]

In article <rN************ *************** **@news.gha.cha rtermi.net>,
Ron Garret <rN*******@flow net.com> wrote:

Wow, this is really cool:

What I'm really trying to do is to create enumerated types...

And the code I ended up with is:

# Inheriting from type, not object, is the key:
class enum_metaclass( type):
def __getitem__(sel f, index):
return self.vals[index]

def enum(vals):
class enum(object):
__metaclass__ = enum_metaclass
def __init__(self, val):
try:
self.val = type(self).vals .index(val)
except:
raise TypeError, "%s is not a valid %s" % (val, type(self))
enum.vals = vals
return enum
So now I can do, e.g.:

e1 = enum(['a','b','c'])
e1('a') <__main__.enu m object at 0x393c50> e1('x') Traceback (most recent call last):
File "<stdin>", line 1, in ?
File "<stdin>", line 8, in __init__
TypeError: x is not a valid <class '__main__.enum' >
But I can also do this:
for x in e1: print x ....
a
b
c

Note that there's no __iter__ method anywhere! It makes an interesting
little puzzle to figure out why this works. (It totally blew me away
when I first tried it. Took me about five minutes of head scratching to
figure it out.)

rg