What is monkey patching?

Monkey patching refers to the dynamic modification of a class, module, or even a function during runtime. In Python, this involves altering existing code objects like attributes or methods of classes or modules after they have been loaded.

What is Monkey Patching?

Monkey patching is a technique used to extend or modify the runtime code of a program without directly changing the source code. It allows developers to replace or add methods, attributes, or entire classes dynamically at runtime.

The term 'monkey patch' originated from a 'guerrilla patch', which then evolved into 'gorilla patch' (because it's a brute-force approach) and eventually 'monkey patch'.

How it works (Example)

In Python, anything can be assigned to anything. This dynamic nature allows you to replace methods or attributes of an object, class, or module simply by assigning a new function or value to it.

class MyClass:
    def say_hello(self):
        return "Hello from MyClass!"

def new_say_hello(self):
    return "Hello from the patched method!"

# Original instance
obj = MyClass()
print(obj.say_hello()) # Output: Hello from MyClass!

# Monkey patch the class method
MyClass.say_hello = new_say_hello

# New instance (after patch)
obj_new = MyClass()
print(obj_new.say_hello()) # Output: Hello from the patched method!

# Original instance also reflects the change
print(obj.say_hello()) # Output: Hello from the patched method!

In this example, we replaced the say_hello method of MyClass with new_say_hello at runtime. Any existing or new instances of MyClass will now call the patched method.

Common Use Cases

• Hot-fixes: Quickly apply a fix to a bug in a third-party library without waiting for an official release.
• Testing/Mocking: Replace parts of a system with mock objects during testing to isolate units or simulate behavior.
• Extending functionality: Add new methods or attributes to classes from external libraries where direct modification is not feasible or desirable.
• Adapting legacy code: Modify behavior in older systems without major refactoring.

Pros and Cons

Pros

• Flexibility: Allows dynamic modification of code at runtime.
• Quick fixes: Can be used for immediate bug fixes in production without redeploying entire applications.
• Testing: Facilitates the creation of mocks and stubs for isolated testing environments.

Cons

• Debugging complexity: Changes are made dynamically, making it hard to trace where behavior originates.
• Readability and maintainability: Code becomes less transparent, as the actual implementation might be different from the source code, complicating maintenance.
• Fragility: Patches can break easily if the underlying library or module changes in an update.
• Global impact: Often affects all instances of a class or module, which can lead to unexpected side effects.
• Order dependency: The outcome can depend on the order in which patches are applied.

When to use it (and when not to)

Monkey patching should generally be avoided unless absolutely necessary due to its potential for introducing bugs and making code harder to understand and maintain. It is often considered a 'last resort' or an 'advanced' technique.

It's acceptable in controlled environments like unit testing (using libraries like unittest.mock) for mocking external dependencies or specific hotfixes that cannot wait for an official patch. In application development, prefer dependency injection, subclassing, or official extension points provided by libraries over monkey patching.