Answer Henry's question but using an over-engineered example. 😀

god-level.py

'''
God level craftsman code
The example below combines 3-4 different software ideas - 
1. Functional programming (also known as Composition Over Inheritance) - 
   even though I'm using OOP constructs (classes, methods, etc.), most of the 
   functionality is pluggable/replaceable. Pure OOP lovers will hate the code below.
   But we're not theorists, we're engineers - we're only interested in getting the job done
   in the best possible way.
   
2. Clean code - You can just search for it. 
   a. https://medium.com/swlh/what-is-clean-code-463d25fa6e0b
   b. https://x-team.com/blog/principles-clean-code/
   
3. Domain Driven Design - this is a huge field by itself in software engineering
   https://martinfowler.com/tags/domain%20driven%20design.html
   Martin Fowler is one of the biggest names in software architecture
   
4. Dependency Injection
Please also ignore any errors as I just typed up this code on Github. 
I wanted to show the ideas behind good OOP code.
'''

# signup.py

class SignupHandler:
    def init(self, repo: IUserRepository, hasher: IHasher):
        self.repo = repo
        self.hasher = hasher

    def handle(self, command: SignupCommand):
        if self.repo.exists(command.email):
            raise UserAlreadyExistsError

        user = self.repo.findOrCreate(command.email)
        user.hashed_password = self.hasher.hash(command.password)
        self.repo.save(user)

class SignupCommand:
    def init(self, email: str, password: str):
        self.email = email
        self.password = password
 
# hashing.py

class IHasher:
    def hash(self, plain_text_password: str) -> str:
        raise NotImplementedError
        
class Md5Hasher(IHasher):
    def hash(self, plain_text_password: str) -> str:
        return hashlib.md5(plain_text_password.encode('utf-8')).hexdigest()
      
      
      
# main.py (composition root)

repository = UserRepository(MySqlContext()) 

hasher = Md5Hasher()
signup = SignupHandler(repository, hasher)

signup.handle(SignupCommand('[email protected]', 'myawesomepassword'))



'''
Now let's say we get a new requirement - 
Use Sha256 instead of MD5
I say, no problem.
'''

# sha256.py

class Sha256(IHasher):
    def hash(self, plain_text_password: str) -> str:
        return sha256(plain_text_password.encode('utf-8')).hexdigest()
      
# change main.py 
# hasher = Md5Hasher() 
hasher = Sha256()

#### DONE ####

'''
Now let's say we get a new requirement - 
1. Include a random salt in Sha256 hashing
2. Also, I have left the job. And you have come in to replace me.
You say, no problem. 
You look at the SignupHandler code and notice it
requires a IHasher interface as an argument.
And IHasher only needs to implement one method - hash
So you create a new file and add your new hashing code in it.
'''

# sha256_with_salt.py

class Sha512Salted(IHasher)
    def hash(self, plain_text_password: str) -> str:
        salt = uuid.uuid4().hex
        return hashlib.sha512(plain_text_password + salt).hexdigest()
      
# change main.py 
# hasher = Md5Hasher() 
# hasher = Sha256()
hasher = Sha512Salted()

#### DONE #### 


'''
To meet the requirements of changes in hashing types, 
notice how you didn't need to go line-by-line through the database code or the signup logic.
You only created a simple class that implements IHasher. And then plugged this class in
the composition root (main.py) when you instantiated SignupHandler. 
Minimal changes to working code needed.
It's good to point out a few things - 
1. Whether we use OOP constructs (such as classes) is not important.
2. The same ideas can be implemented using functions only. 
   However, oop constructs help a lot.
3. The important thing is to enable changes to code in an easy way.
   Like our IHasher example above. 
   A real life example would be how easy it is to change the batteries (which are expected 
   to need replacement at some point) in our laptops. Compare this to trying to change the motherboard.
'''