CODEWITHSUNDEEP
python-3.xpython-decoratorsclass-method
Paebbels
Paebbels

Reputation: 16221

Can I derive from classmethod in Python?

I have a special statemachine implemented in Python, which uses class methods as state representation.

class EntityBlock(Block):
  def __init__(self, name):
    self._name = name

  @classmethod
  def stateKeyword1(cls, parserState : ParserState):
    pass

  @classmethod
  def stateWhitespace1(cls, parserState : ParserState):
    token = parserState.Token
    if isinstance(token, StringToken):
      if (token <= "generate"):
        parserState.NewToken = GenerateKeyword(token)
        parserState.NewBlock = cls(....)
      else:
        raise TokenParserException("....", token)
    raise TokenParserException("....", token)

  @classmethod
  def stateDelimiter(cls, parserState : ParserState):
    pass

Visit GitHub for full source code off pyVHDLParser.

When I debug my parser FSM, I get the statenames printed as:

State: <bound method Package.stateParse of <class 'pyVHDLParser.DocumentModel.Sequential.Package.Package'>>

I would like to get better reports, so I would like to overwrite the default behavior of __repr__ of each bound method object.

Yes, I could write a metaclass or apply a second decorator, but I was questioning myself:
Is it possible to derive from classmethod and have only one decorator called e.g. state?

According to PyCharm's builtins.py (a collection of dummy code for Python's builtins), classmethod is a class-based decorator.

Upvotes: 2

Views: 173

Answers (1)

Blckknght
Blckknght

Reputation: 104722

Yes, you can write your own class that derives from classmethod if you want. It's a bit complicated though. You'll need to implement the descriptor protocol (overriding classmethod's implementation of __get__) so that it returns an instance of another custom class that behaves like a bound method object. Unfortunately, you can't inherit from Python's builtin bound method type (I'm not sure why not).

Probably the best approach then is to wrap one of the normal method objects in an instance of a custom class. I'm not sure how much of the method API you need to replicate though, so that might get a bit complicated. (Do you need your states to be comparable to one another? Do they need to be hashable? Picklable?)

Anyway, here's a bare bones implementation that does the minimum amount necessary to get a working method (plus the new repr):

class MethodWrapper:
    def __init__(self, name, method):
        self.name = name if name is not None else repr(method)
        self.method = method

    def __call__(self, *args, **kwargs):
        return self.method(*args, **kwargs)

    def __repr__(self):
        return self.name

class State(classmethod):
    def __init__(self, func):
        self.name = None
        super().__init__(func)

    def __set_name__(self, owner, name):
        self.name = "{}.{}".format(owner.__name__, name)

    def __get__(self, owner, instance):
        method = super().__get__(owner, instance)
        return MethodWrapper(self.name, method)

And a quick demo of it in action:

>>> class Foo:
    @State
    def foo(cls):
        print(cls)

>>> Foo.foo
Foo.foo
>>> Foo.foo()
<class '__main__.Foo'>
>>> f = Foo()
>>> f.foo()
<class '__main__.Foo'>

Note that the __set_name__ method used by the State descriptor is only called by Python 3.6. Without that new feature, it would be much more difficult for the descriptor to learn its own name (you might need to make a decorator factory that takes the name as an argument).

Upvotes: 1

Related Questions