Common subclass design pattern in Python

The following simple sample code demonstrates a design pattern that I saw in an open source Python project.

Class OrderService:

def place_order (self, article name, amount):
available_amount = self.get_available_amount (item_name)
if amount> available amount:
print (f "There are not enough items available.")
otherwise:
Self-removal (product name, number)
print ("The order was successfully received.")


Class InventoryService:

def __init __ (self):
self._current_inventory = {
"Apple": 100
"Strawberry": 10
}

def get_available_amount (self, item_name):
Return self._current_inventory[item_name]

    def remove (yourself, article name, amount):
self._current_inventory[item_name] - = amount


Class CustomerService (OrderService, InventoryService):

def __init __ (self):
super (CustomerService, itself) .__ init __ ()


customer_service = CustomerService ()
customer_service.place_order ("strawberry", 9)
customer_service.place_order ("strawberry", 10)

There are two services here: ordering service and InventoryService, both implemented by a Python class. ordering service has some dependencies on InventoryService and the resolution of the dependency is made using a common subclass (Customer service) for her.

Personally, I liked this design pattern very much because it makes adding new services and handling dependencies between them very easy, while avoiding a single, overly large class.

On the other hand, the IDE I used (PyCharm) shows a warning of the methods that are not in the class in which they are called (eg. get_available_amount). This makes navigation a bit more difficult. In addition, one must either use the general subclass, even if only some of the services are actually used, or create a new common subclass for all the services they want to use + their dependencies. I do not think these disadvantages are as significant as the benefits.

Do you agree with me that this is a useful pattern and should be used in similar scenarios, or may you mention other disadvantages or alternative solutions? Have you ever seen this pattern used in other projects?