There's a whole matrix of these and I'm wondering why the matrix is currently sparse rather than implementing them all.  Or rather, why we can't stack them as:

class foo(object):
    @classmethod
    @property
    def bar(cls, ...):
        ...

Essentially the permutation are, I think: {'unadorned'|abc.abstract}{'normal'|static|class}{method|property|non-callable attribute}.

concreteness	implicit first arg	type	name	comments
{unadorned}	{unadorned}	method	def foo():	exists now
{unadorned}	{unadorned}	property	@property	exists now
{unadorned}	{unadorned}	non-callable attribute	x = 2	exists now
{unadorned}	static	method	@staticmethod	exists now
{unadorned}	static	property	@staticproperty	proposing
{unadorned}	static	non-callable attribute	{degenerate case - variables don't have arguments}	unnecessary
{unadorned}	class	method	@classmethod	exists now
{unadorned}	class	property	@classproperty or @classmethod;@property	proposing
{unadorned}	class	non-callable attribute	{degenerate case - variables don't have arguments}	unnecessary
abc.abstract	{unadorned}	method	@abc.abstractmethod	exists now
abc.abstract	{unadorned}	property	@abc.abstractproperty	exists now
abc.abstract	{unadorned}	non-callable attribute	@abc.abstractattribute or @abc.abstract;@attribute	proposing
abc.abstract	static	method	@abc.abstractstaticmethod	exists now
abc.abstract	static	property	@abc.staticproperty	proposing
abc.abstract	static	non-callable attribute	{degenerate case - variables don't have arguments}	unnecessary
abc.abstract	class	method	@abc.abstractclassmethod	exists now
abc.abstract	class	property	@abc.abstractclassproperty	proposing
abc.abstract	class	non-callable attribute	{degenerate case - variables don't have arguments}	unnecessary

I think the meanings of the new ones are pretty straightforward, but in case they are not...

@staticproperty - like @property only without an implicit first argument.  Allows the property to be called directly from the class without requiring a throw-away instance.

@classproperty - like @property, only the implicit first argument to the method is the class.  Allows the property to be called directly from the class without requiring a throw-away instance.

@abc.abstractattribute - a simple, non-callable variable that must be overridden in subclasses

@abc.abstractstaticproperty - like @abc.abstractproperty only for @staticproperty

@abc.abstractclassproperty - like @abc.abstractproperty only for @classproperty

--rich