How I ended up doing it.

class C(metaclass=ABCMeta):
    @property
    def x(self):
        ...

    @x.setter
    @abstractmethod
    def x(self, val):
        ...

class D(C):
    @C.x.setter
    def x(self, val):
        ...

Use an alias that subclasses should not override, which calls a setter that subclasses should override:

class A(object, metaclass=abc.ABCMeta):
  @property
  @abc.abstractmethod
  def someData(self):
    pass

  @someData.setter
  def _setSomeData(self, val):
      self.setSomeData(val)

  def setSomeData(self, val):
    self._someData = val

Since self.someData is determined at runtime, not at compile-time, then as long as a subclass only overrides the someData() method, it will always get used as the 'actual' setter.

Usually when using this pattern, the externally-visible variable name is someData, but the internal name is _someData. Because _someData is not a @property, it can be get and set the normal way, without infinitely recurring. You would then proceed to also make a getter:

  @someData.getter
  def _getSomeData(self)
    return self.getSomeData()

  getSomeData(self):
    return self._someData

After some thought, I think the second code snippet does not use the Factory method as it is not concerned with the creation of objects.

However, the code can be refactored to use the Factory method and better communicate the intent:

class CraneInterface(ABC):

    def __init__(self):
        self.__axis = self._make_axis()

    @property
    def axis(self) -> AxisInterface:
        return self.__axis

    @abstractmethod
    def _make_axis(self) -> AxisInterface:
        """
        Factory method: "Subclasses override to change the class of object that will be created"
        """
        pass

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):
        ...

It seems there's a discrepancy here; using @property along with @abstractmethod doesn't seem to enforce classes that inherit from your abc to need to define both setter and getter. Using this:

@property
@abstractmethod
def myProperty(self):
    pass

@myProperty.setter
@abstractmethod
def myProperty(self):
    pass

and then providing an implementation only for the getter in the class works and allows for instantiation:

@property
def myProperty(self):
    return self._myProperty

This is due to the fact that only one name (myProperty) appears in the namespace of the ABC, when you override in the base class, you only need to define this one name.

There's a way around that enforces it. You can create separate abstract methods and pass them on to property directly:

class MyAbstractClass(ABC):

    @abstractmethod
    def getProperty(self):
        pass

    @abstractmethod
    def setProperty(self, val):
        pass

    myAbstractProperty = property(getProperty, setProperty)

Providing an implementation for this abc now requires both getter and setter to have an implementation (both names that have been listed as abstractmethods in MyAbstractClass namespace need to have an implementation):

class MyInstantiatableClass(MyAbstractClass):

    def getProperty(self):
        return self._Property

    def setProperty(self, val):
        self._Property = val
    myAbstractProperty = property(getProperty, setProperty)

Implementing them is exactly the same as any old property. There's no difference there.

The problem is that neither the getter nor the setter is a method of your abstract class; they are attributes of the property, which is a (non-callable) class attribute. Consider this equivalent definition:

def status_getter(self):
    pass

def status_setter(self, value):
    pass

class Component(metaclass=abc.ABCMeta):
    # status = property(...)
    # status.__isabstractmethod__ = True
    status = abstractmethod(property(status_getter, status_setter))

Inheriting a property is quite different from inheriting a method. You are basically replacing the property, because your class itself does not have a reference to either the getter or the setter. Despite the name, abstractmethod does not actually make the property a method; it really does nothing more than add an attribute to whatever it is applied to and return the original value.

So, to ensure that a subclass provides a read/write property, what are you to do? Skip the decorator syntax, define the getter and setter as explicit abstract methods, then define the property explicitly in terms of those private methods.

class Component(metaclass=abc.ABCMeta):
    @abstractmethod
    def _get_status(self):
        pass

    @abstractmethod
    def _set_status(self, v):
        pass

    status = property(lambda self: self._get_status(), lambda self, v: self._set_status(self, v))

Or, you can make use of __init_subclass__ (which postdates abc; its purpose is to allow class initialization that is otherwise only possible via a metaclass).

class Component:
    def __init_subclass(cls, **kwargs):
        super().__init_subclass__(**kwargs)

        try:
            p = cls.status
        except AttributeError:
            raise ValueError("Class does not define 'status' attribute")

        if not isinstance(p, property):
            raise ValueError("'status' is not a property")

        if p.fget is None:
            raise ValueError("'status' has no getter")

        if p.fset is None:
            raise ValueError("'status' has no setter")

This is actually an improvement over abc, in my opinion. If a subclass fails to define a read/write status property, an exception will be raised when the class is defined, not just when you attempt to instantiate the class.