Since Python 3.3 a bug was fixed meaning the property() decorator is now correctly identified as abstract when applied to an abstract method.

Note: Order matters, you have to use @property above @abstractmethod

Python 3.3+: (python docs):

from abc import ABC, abstractmethod

class C(ABC):
    @property
    @abstractmethod
    def my_abstract_property(self):
        ...

Python 2: (python docs)

from abc import ABCMeta, abstractproperty

class C:
    __metaclass__ = ABCMeta

    @abstractproperty
    def my_abstract_property(self):
        ...

import abc
from typing import ClassVar

from pydantic import BaseModel
from devtools import debug

class Fruit(BaseModel, abc.ABC):
    @property
    @abc.abstractmethod
    def type(self) -> str:
        """The name of the type of fruit."""

class Apple(Fruit):
    type: ClassVar[str] = "apple"
    size: int

a = Apple(size=4)
debug(a, a.type)

Unless you want to allow type to be changed when creating a model instance, in which case just make it a field on Fruit.

If you want greet to be a property, you still need to use the @property decorator in your implementation:

class Foo(FooBase):
    @property
    def greet(self):
        return 'hello'

All that an ABC metaclass does is test wether or not you have provided the same name in the concrete class; it doesn't care if it is a method or a property or a regular attribute.

Because it doesn't care, it doesn't magically apply property decorators either. This is a good thing; perhaps in a specific implementation a static attribute is enough to satisfy the requirement, and a property would be overkill.

The purpose of a ABC metaclass is to help you detect gaps in your implementation; it never was intended to enforce the types of the attributes.

Note that before Python 3.3 you can not combine a @property with an @abstractmethod. You would have to use an @abstractproperty decorator instead. There is an ambiguity there when your property needs more than a simple getter in that case; Python 3.3 covers that case much better (see issue 11610 for the painful details).

Python 3.3+

from abc import ABCMeta, abstractmethod


class A(metaclass=ABCMeta):
    def __init__(self):
        # ...
        pass

    @property
    @abstractmethod
    def a(self):
        pass

    @abstractmethod
    def b(self):
        pass


class B(A):
    a = 1

    def b(self):
        pass

Failure to declare a or b in the derived class B will raise a TypeError such as:

TypeError: Can't instantiate abstract class B with abstract methods a

Python 2.7

There is an @abstractproperty decorator for this:

from abc import ABCMeta, abstractmethod, abstractproperty


class A:
    __metaclass__ = ABCMeta

    def __init__(self):
        # ...
        pass

    @abstractproperty
    def a(self):
        pass

    @abstractmethod
    def b(self):
        pass


class B(A):
    a = 1

    def b(self):
        pass