So, here is a problem:

1. I want to define an abstract class, let's say `AbstractA`, which does not require subclasses to implement any of its methods, but rather to extend its functionality. In terms of Java that would be interface class.
2. Moreover, I want to be able to create an abstract subclass, let's say `AbstractB`, of the `AbstractA` with the same properties, but some methods redefining or extending base class methods.

I don't want though to make class (`AbstractA`) abstract e.g. [through the check of class name in `__init__` or `__new__`](https://stackoverflow.com/questions/50099600/abstract-classes-without-abstract-methods-creating-objects-in-python), because that would require abstract subclass (`AbstractB`) to redefine that method along with it's main functionality, i.e. construction or initialization of a new instance. Or to call `super().__init__(...)` which I'd prefer to avoid as well (maybe I'm wrong here).

So, I want something like that:

```py
class AbstractA:
    def __init__(self):
        # do initialization stuff

    def very_common_method(self, ...):
        # do very common stuff

class AbstractB(AbstractA):
    # do not duplicate initialization stuff here, inherit instead

    def less_common_method(self, ...):
        # do less common stuff

class AX(AbstractA):
    def specific_method_1(self, ...):

class BX(AbstractB):
    def specific_method_2(self, ...):

# Instantiating AbstractA or AbstractB should result in error.
# Instantiating AX or BX should not.

```

Below I have a possible solution.
Is there any disadvantages I overlook? Better solution?

Thanks!