adding __getitem__ accessor to Python class method

We can make SomeInstance class with a getter that returns MyClass‘s instance by invoking the descriptor and setting it as a class attribute when init‘ing MyClass. Here MyClass._instance is the instance of MyClass (it’s MyClass‘s self), which we can pass to the instance method my_other_method within the decorated computed_typed_value method:

class SomeInstance:
    def __get__(self, instance, owner):
        if instance is None:
            print('instance is None')
            return self
        print(f'getting instance of {owner.__name__} via {self.__class__.__name__}')
        return instance

class MyClass:
    _instance = SomeInstance()
    def __init__(self):
        MyClass._instance = self._instance
        print(f'MyClass._instance type is {type(MyClass._instance)}')

    def my_other_method(self):
        print('Doing some other things!')
        return 3

    @typedmethod
    def compute_typed_value(self, value, *args, **kwargs):
        print(self, args, kwargs)
        result = TypedMethod.requested_type(kwargs)(value)
        print(result)
        x = MyClass._instance.my_other_method()
        print(x)
        return result

a = MyClass()
a.compute_typed_value[int]('12345')

Outputs:

wrapping compute_typed_value with a Typed Method: <function MyClass.compute_typed_value at 0x7f5dce1ed790>
<function MyClass.compute_typed_value at 0x7f5dce1ed790>
getting instance of MyClass via SomeInstance
MyClass._instance type is <class '__main__.MyClass'>
getting typed value: <class 'int'>
WRAPPER 12345 () {'__requested_type': <class 'int'>}
('12345',) {'__requested_type': <class 'int'>}
<__main__.TypedMethod object at 0x7f5deed5a7c0> () {'__requested_type': <class 'int'>}
12345
Doing some other things!
3
12345

Your code is doing some odd stuff with __call__ that doesn’t quite work. Fixing those issues will likely make self refer to what you expect in compute_typed_value.

The main problems:

• Assigning a new function to the __call__ attribute of an instance doesn’t work to change the object’s behavior when it’s actually called. You attempt this twice, but the TypedMethod object’s hard-coded __call__ method is getting called instead of any of the other things you try (you first set _method.__call__ and separately wrapper to be called, neither of which make much sense to me).
• Your typed_method decorator returns the TypedMethod object it creates, rather than the wrapper function. Because TypedMethod is not a descriptor, there’s no binding logic for MyClass.compute_typed_value, so there’s no good way for the instance of MyClass to get passed in anywhere. Normally this works because functions are descriptors, returning bound method objects. However, it’s going to be a bit complicated to make that work here, since you want a __getattr__ to work on the bound object.

So, I think you should change things up to use two different classes.

The first is a descriptor class, that when looked up, has binding behavior so that you can get the self value to pass in to the method. When bound, it returns an instance of the second class.

The second class handles the indexing by type. It has a __getitem__ method, which returns a partial that passes both the self value that the first class captured, and the type that it has been indexed with (as a secret keyword argument).

Here’s what that looks like:

class typedmethod:
    def __init__(self, method):
        self.method = method

    def __get__(self, instance, owner=None):
        if instance is None: return self # class lookup
        return TypeIndexer(instance, self.method)

class TypeIndexer:
    def __init__(self, instance, method):
        self.instance = instance
        self.method = method

    def __getitem__(self, type):
        return partial(method, self.instance, _secret_kwarg=type)

I’ve left out the logic to hide the name _secret_kwarg in a class variable somewhere, and to have a public API for getting it out of a kwargs dict. It would actually be a whole lot easier if you just passed the type in to the method as a public argument. Maybe make it the first positional arguement after self, or a kwarg with a meaningful name? The fact that the user doesn’t actually supply it directly wouldn’t be much more confusing than TypedMethod.requested_type(kwargs)(value) is now.

Of course, if we follow that logic to its conclusion, you could rewrite the whole obj.method[type](args) pattern to be obj.method(type, args) and it would be a whole lot easier.

Applying your concept to a class has a giant roadblock. This is what the decorator does:

    def typewrap(func):
        def wrapper(self, *args, **kwargs):
            #...do type checking

            #call decorated method
            func(self, *args, **kwargs)
            
        #there is no `self` of `func` to store
        #and scope is changing
        #`self` of `func` is abandoned here
        return TypedMethod(wrapper)

You need a reference to self of func that you can pass to TypedMethod, before wrapper is run, but it doesn’t exist yet. It also won’t exist, because wrapper will be called from the TypedMethod instance, instead of your class instance.

If you get rid of the class scope, your idea becomes very simple to implement. A bunch of your original logic is not necessary (mainly __call__). Here is an example:

from functools import partial

class TypedMethod:
    def __init__(self, callback):
        self._cb = callback

    def __getitem__(self, key):
        if not isinstance(key, type):
            raise TypeError("key must be an instance of `type`")
            
        return partial(self._cb, key)
       
       
def typedmethod(func):
    def wrapper(argtype:type, *args, **kwargs):
        #test all arguments
        for arg in args:
            if not isinstance(arg, argtype):
                raise TypeError(f"all arguments must be of type: {argtype.__name__}")
        for _,v in kwargs.items():
            if not isinstance(v, argtype):
                raise TypeError(f"all arguments must be of type: {argtype.__name__}")
                
        #call wrapped method
        func(*args, **kwargs)
        
    #assign wrapper as the callback
    return TypedMethod(wrapper)

def dofunc(a):
    print(a)
    
@typedmethod
def dotype(x,y,z,a):
    print(x,y,z)
    dofunc(a)

dotype[int](22, 35, 2, a=12345)
#22, 35, 2
#12345

In response to this answer. There are a number of issues.

Firstly, none of the below code is necessary, nor any other spot that uses it. It’s just an arbitrary layer that’s in the way.

class subscriptable:
    _parent_instance = None
    _SUBSCRIPT_KEY = '___SUBSCRIPT_KEY'
    _HAS_SUBSCRIPTABLE_METHODS = '___HAS_SUBSCRIPTABLE_METHODS'

    def __str__(self):
        return f"<{self.__class__.__name__} {self._method}>"
    
    @classmethod
    def has_key(cls, foo_kwargs):
        """A utility method to determine whether the provided kwargs has the expected subscript key"""
        return cls._SUBSCRIPT_KEY in foo_kwargs
    
    @classmethod
    def key(cls, foo_kwargs:dict):
        """A utility method that allows the subscript key to be consumed by the wrapped method, without needing to know the inner workings"""
        return foo_kwargs.pop(cls._SUBSCRIPT_KEY, None)

Secondly, there is no place in any of your code that is actually doing anything regarding the type you set. I’m going to assume that you want the method/function to only accept that type. If so:

class subscriptable:
    def __init__(self, callback:callable):
        self._cb = callback
        
    def __post_init__(self, parent):
        self._cb = MethodType(self._cb, parent)
             
    def __getitem__(self, argtype:type, *args, **kwargs):
        if not isinstance(argtype, type):
            raise TypeError("key must be an instance of `type`")
            
        return partial(self.__call__, argtype)
    
    def __call__(self, argtype:type, *args, **kwargs):
        #check all arguments against type
        for arg in args:
            if not isinstance(arg, argtype):
                raise TypeError(f"all arguments must be of type: {argtype.__name__}")

        for _,v in kwargs.items():
            if not isinstance(v, argtype):
                raise TypeError(f"all arguments must be of type: {argtype.__name__}")
         
        return self._cb(*args, **kwargs)
    
    @classmethod
    def container(cls, C):
        init = C.__init__
        @wraps(init)
        def __init__(self, *args, **kwargs):
            for name in dir(self):
                X = getattr(self, name)
                if isinstance(X, cls):
                    X.__post_init__(self)
            init(self, *args, **kwargs)
        C.__init__ = __init__
        return C

@subscriptable.container        
class MyClass:
    @subscriptable
    def compute_typed_value(self, *args, **kwargs):
        print(self, args, kwargs)
        self.my_other_method()

    def my_other_method(self):
        print('Doing some other things!')

value = MyClass().compute_typed_value[int](12345)

@subscriptable
def other_typed_value(*args, **kwargs):
    print(args, kwargs)

value = other_typed_value[int](12345)

I never thought I would use a Python class this way, but if the
pattern fits…

You’re wrapping classes with methods and methods with classes to solve a problem that you created. What pattern does this fit?