Python3 currency abstract class (without the permission to be instantiated directly)

Question

I'm a newbie python developer who accidentally studied the concept of Abstract classes and I found it pretty much helpful to implement due to the SOLID principles.

At the very moment of testing and learning the concept, I found out that using a abstract class also as an mix-in class would be a great Idea, so I decided to implement the __init__ method in the base abstract class.

As I am new to the concept, I don't know if this is a good implementation for making reusable software:

#!usr/bin/env python3
# -*- coding: utf-8 -*-

"""Dependency inversion learning file | By : KhodeNima |
2023/10/25
"""


from decimal import (
    Decimal
)

from abc import (
    ABC,
)

class BaseCurrency(ABC):
    def __init__(self, value_by_dollar : Decimal):
        """The base currency class

        Args:
            - value_by_dollar (Decimal): The value of the currency in Dollar.
        """

        self.__name = self.__class__.__name__
        self.value_by_dollar = value_by_dollar

    @property
    def name(self):
        return self._name
    
    @name.setter
    def name(self, name : str):

        if name == "BaseCurrency":
            raise PermissionError("The BaseCurrency class can only be inherited | ( Not instantiated )")
        
        return name

    

class Dirham(BaseCurrency):
    ...


some_decimal_value = Decimal('10.0')
dirham_1 = Dirham(value_by_dollar=some_decimal_value)

Answer 1

Constructor

The idea behind Abstract Base Classes is that they can't be instantiated by themselves, only their subclasses can. However, we would still use __init__ to ensure that attributes of class instances are set properly. In your case, that would be both _name and value_by_dollar.

If that is all that is needed in a constructor, then subclasses don't even need to provide their own constructor. Calling __init__ in that case redirects to the base class' implementation. Otherwise, remember to call super().init() to explicitly call the superclass constructor.

Coupling the class name with the instance attribute __name self.__name = self.__class__.__name__ is a bad practice. There is no reason why they should be coupled - and you're defining a setter so that coupling can fall apart later.

A better idea would be to ask for the currency name in the constructor of the base class. Then, in subclasses, we would call super().__init__() by providing a string as the currency name. This enables you to change the _name attribute without changing the class names of the subclasses.

Also, a side note: there is a typo when setting _name (note the double underscore)!

Name Property Getter and Setter

Here, you provide a default for both implementations. Note that you haven't defined any of them as abc.abstractmethod (link), indicating that subclasses need not override them. Classes inheriting from ABC cannot be instantiated unless all abstract methods or properties are implemented. However, since you provided implementations for all methods, BaseCurrency can be instantiated.

In addition the name setter explicitly checks the _name attribute of the instance to avoid the setter to be called. This puts a cognitive load on you to change the condition if you ever change the BaseCurrency to be called something else.

Thankfully, there is an easy fix for both of these - declare the setter as an abstract method:

@name.setter
@abstractmethod
def name(self, name : str):
    pass

Since you have an abstract method now, BaseCurrency cannot be instantiated. Also, subclasses need to implement their own name setter which eliminates the need to check if the calling class is the base one.

This also means you actually need to provide a body to the Dirham class. Usually, empty subclasses of an abstract class tell you either you don't need an abstract class (everything can be done through instantiation) or you are doing too much in the abstract class that should be left to the subclasses. And an abstract class with no abstract methods (that is, without places that need to be filled in for the class to do something) is abstract only in name.