Make function in class only accessible without calling the class

user_8708364 0
Viewed 537

Let's say I have this class:

class A:
    def __init__(self, a):
        self.a = a
    @classmethod
    def foo(self):
        return 'hello world!'

I use @classmethod, so that I can directly call the function without calling the class:

>>> A.foo()
'hello world!'
>>>

But now I am wondering, since I still can access it with calling the class:

>>> A(1).foo()
'hello world!'
>>>

Would I be able to make it that it would raise an error if the function foo is called from a called class. And only let it to be called without calling the class, like A.foo().

So if I do:

A(1).foo()

It should give an error.

class-method python-3.x function class python
2 Answers

The functionality of how classmethod, staticmethod and in fact normal methods are lookedup / bound is implemented via descriptors. Similarly, one can define a descriptor that forbids lookup/binding on an instance.

A naive implementation of such a descriptor checks whether it is looked up via an instance and raises an error in this case:

class NoInstanceMethod:
    """Descriptor to forbid that other descriptors can be looked up on an instance"""
    def __init__(self, descr, name=None):
        self.descr = descr
        self.name = name

    def __set_name__(self, owner, name):
        self.name = name

    def __get__(self, instance, owner):
        # enforce the instance cannot look up the attribute at all
        if instance is not None:
            raise AttributeError(f"{type(instance).__name__!r} has no attribute {self.name!r}")
        # invoke any descriptor we are wrapping
        return self.descr.__get__(instance, owner)

This can be applied on top of other descriptors to prevent them from being looked up on an instance. Prominently, it can be combined with classmethod or staticmethod to prevent using them on an instance:

class A:
    def __init__(self, a):
        self.a = a
    @NoInstanceMethod
    @classmethod
    def foo(cls):
        return 'hello world!'


A.foo()     # Stdout: hello world!
A(1).foo()  # AttributeError: 'A' object has no attribute 'foo'

The above NoInstanceMethod is "naive" in that it does not take care of propagating descriptor calls other than __get__ to its wrapped descriptor. For example, one could propagate __set_name__ calls to allow the wrapped descriptor to know its name.

Since descriptors are free to (not) implement any of the descriptor methods, this can be supported but needs appropriate error handling. Extend the NoInstanceMethod to support whatever descriptor methods are needed in practice.

user_53499160

A workaround is to override its value upon initialization of a class object to make sure it wouldn't be called from self.

def raise_(exc):
    raise exc

class A:
    STRICTLY_CLASS_METHODS = [
        "foo",
    ]

    def __init__(self, a):
        self.a = a

        for method in self.STRICTLY_CLASS_METHODS:
            # Option 1: Using generator.throw() to raise exception. See https://www.python.org/dev/peps/pep-0342/#new-generator-method-throw-type-value-none-traceback-none
            # setattr(self, method, lambda *args, **kwargs: (_ for _ in ()).throw(AttributeError(method)))

            # Option 2: Using a function to raise exception
            setattr(self, method, lambda *args, **kwargs: raise_(AttributeError(method)))

    @classmethod
    def foo(cls):
        return 'hello world!'

    def bar(self):
        return 'hola mundo!', self.a

Output

>>> A.foo()
'hello world!'
>>> a = A(123)
>>> a.bar()
('hola mundo!', 123)
>>> a.foo()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 11, in <lambda>
  File "<stdin>", line 2, in raise_
AttributeError: foo
>>> a.bar()
('hola mundo!', 123)
>>> A(45).bar()
('hola mundo!', 45)
>>> A(6789).foo()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 11, in <lambda>
  File "<stdin>", line 2, in raise_
AttributeError: foo
>>> A.foo()
'hello world!'
user_110438250
Related