bpo-19072 (python#8405) allows `classmethod` to wrap other descriptors, but this doesnot work when the wrapped descriptor mimics classmethod.  The current PR fixesthis.In Python 3.8 and before, one could create a callable descriptor such that thisworks as expected (see Lib/test/test_decorators.py for examples):```pythonclass A:    @myclassmethod    def f1(cls):        return cls@classmethod    @myclassmethod    def f2(cls):        return cls```In Python 3.8 and before, `A.f2()` return `A`. Currently in Python 3.9, itreturns `type(A)`.  This PR make `A.f2()` return `A` again.As ofpython#8405, classmethod calls `obj.__get__(type)` if `obj` has `__get__`.This allows one to chain `@classmethod` and `@property` together.  Whenusing classmethod-like descriptors, it's the second argument to `__get__`--theowner or the type--that is important, but this argument is currently missing.Since it is None, the "owner" argument is assumed to be the type of the firstargument, which, in this case, is wrong (we want `A`, not `type(A)`).This PR updates classmethod to call `obj.__get__(type, type)` if `obj` has`__get__`.

Patch by Erik Welch.bpo-19072 (python#8405) allows `classmethod` to wrap other descriptors, but this doesnot work when the wrapped descriptor mimics classmethod.  The current PR fixesthis.In Python 3.8 and before, one could create a callable descriptor such that thisworks as expected (see Lib/test/test_decorators.py for examples):```pythonclass A:    @myclassmethod    def f1(cls):        return cls@classmethod    @myclassmethod    def f2(cls):        return cls```In Python 3.8 and before, `A.f2()` return `A`. Currently in Python 3.9, itreturns `type(A)`.  This PR make `A.f2()` return `A` again.As ofpython#8405, classmethod calls `obj.__get__(type)` if `obj` has `__get__`.This allows one to chain `@classmethod` and `@property` together.  Whenusing classmethod-like descriptors, it's the second argument to `__get__`--theowner or the type--that is important, but this argument is currently missing.Since it is None, the "owner" argument is assumed to be the type of the firstargument, which, in this case, is wrong (we want `A`, not `type(A)`).This PR updates classmethod to call `obj.__get__(type, type)` if `obj` has`__get__`.Co-authored-by: Erik Welch <erik.n.welch@gmail.com>

…rs (#27115)Patch by Erik Welch.bpo-19072 (#8405) allows `classmethod` to wrap other descriptors, but this doesnot work when the wrapped descriptor mimics classmethod.  The current PR fixesthis.In Python 3.8 and before, one could create a callable descriptor such that thisworks as expected (see Lib/test/test_decorators.py for examples):```pythonclass A:    @myclassmethod    def f1(cls):        return cls@classmethod    @myclassmethod    def f2(cls):        return cls```In Python 3.8 and before, `A.f2()` return `A`. Currently in Python 3.9, itreturns `type(A)`.  This PR make `A.f2()` return `A` again.As of#8405, classmethod calls `obj.__get__(type)` if `obj` has `__get__`.This allows one to chain `@classmethod` and `@property` together.  Whenusing classmethod-like descriptors, it's the second argument to `__get__`--theowner or the type--that is important, but this argument is currently missing.Since it is None, the "owner" argument is assumed to be the type of the firstargument, which, in this case, is wrong (we want `A`, not `type(A)`).This PR updates classmethod to call `obj.__get__(type, type)` if `obj` has`__get__`.Co-authored-by: Erik Welch <erik.n.welch@gmail.com>

…rs (pythonGH-27115)Patch by Erik Welch.bpo-19072 (pythonGH-8405) allows `classmethod` to wrap other descriptors, but this doesnot work when the wrapped descriptor mimics classmethod.  The current PR fixesthis.In Python 3.8 and before, one could create a callable descriptor such that thisworks as expected (see Lib/test/test_decorators.py for examples):```pythonclass A:    @myclassmethod    def f1(cls):        return cls@classmethod    @myclassmethod    def f2(cls):        return cls```In Python 3.8 and before, `A.f2()` return `A`. Currently in Python 3.9, itreturns `type(A)`.  This PR make `A.f2()` return `A` again.As ofpythonGH-8405, classmethod calls `obj.__get__(type)` if `obj` has `__get__`.This allows one to chain `@classmethod` and `@property` together.  Whenusing classmethod-like descriptors, it's the second argument to `__get__`--theowner or the type--that is important, but this argument is currently missing.Since it is None, the "owner" argument is assumed to be the type of the firstargument, which, in this case, is wrong (we want `A`, not `type(A)`).This PR updates classmethod to call `obj.__get__(type, type)` if `obj` has`__get__`.Co-authored-by: Erik Welch <erik.n.welch@gmail.com>(cherry picked from commitb83861f)Co-authored-by: Łukasz Langa <lukasz@langa.pl>

…rs (GH-27115) (GH-27162)Patch by Erik Welch.bpo-19072 (GH-8405) allows `classmethod` to wrap other descriptors, but this doesnot work when the wrapped descriptor mimics classmethod.  The current PR fixesthis.In Python 3.8 and before, one could create a callable descriptor such that thisworks as expected (see Lib/test/test_decorators.py for examples):```pythonclass A:    @myclassmethod    def f1(cls):        return cls@classmethod    @myclassmethod    def f2(cls):        return cls```In Python 3.8 and before, `A.f2()` return `A`. Currently in Python 3.9, itreturns `type(A)`.  This PR make `A.f2()` return `A` again.As ofGH-8405, classmethod calls `obj.__get__(type)` if `obj` has `__get__`.This allows one to chain `@classmethod` and `@property` together.  Whenusing classmethod-like descriptors, it's the second argument to `__get__`--theowner or the type--that is important, but this argument is currently missing.Since it is None, the "owner" argument is assumed to be the type of the firstargument, which, in this case, is wrong (we want `A`, not `type(A)`).This PR updates classmethod to call `obj.__get__(type, type)` if `obj` has`__get__`.Co-authored-by: Erik Welch <erik.n.welch@gmail.com>(cherry picked from commitb83861f)