Evolving Code: Adding Features with Backward Compatibility in Python

Lesson 5

Backward Compatibility: Practice

Welcome back! Today, we'll master what we learned about backward compatibility in practice. Get prepared to apply all the knowledge on practice tasks, but first let's look at two examples and analyze them.

Task 1: Enhancing a Complex Data Processing Function with Default Parameters

Let's say that initially, we have a complex data processing function designed to operate on a list of dictionaries, applying a transformation that converts all string values within the dictionaries to uppercase. Here's the initial version:

Python
1def process_data(items):
2    processed_items = []
3    for item in items:
4        processed_item = {key: value.upper() if type(value) is str else value for key, value in item.items()}
5        processed_items.append(processed_item)
6    for item in processed_items[:3]:  # Display the first 3 items for brevity
7        print(f"Processed Item: {item}")

We intend to expand this function, adding capabilities to filter the items based on a condition and allow for custom transformations. The aim is to retain backward compatibility while introducing these enhancements. Here's the updated approach:

Python
1def process_data(items, condition=lambda x: True, transform=None):
2    processed_items = []
3    for item in items:
4        if condition(item):  # Apply condition to filter items
5            if transform:
6                processed_item = transform(item)  # Apply custom transformation if provided
7            else:
8                # Default transformation: Convert string values to uppercase
9                processed_item = {key: value.upper() if type(value) is str else value for key, value in item.items()}
10            processed_items.append(processed_item)
11    for item in processed_items[:3]:  # Display the first 3 items for brevity
12        print(f"Processed Item: {item}")
13
14# Default behavior - convert string values to uppercase
15process_data([{"name": "apple", "quantity": 10}, {"name": "orange", "quantity": 5}])
16
17# Custom filter - select items with a quantity greater than 5
18process_data([{"name": "apple", "quantity": 10}, {"name": "orange", "quantity": 5}], condition=lambda x: x["quantity"] > 5)
19
20# Custom transformation - convert names to uppercase and multiply the quantity by 2
21custom_transform = lambda item: {key: value.upper() if type(key) == "name" else value * 2 for key, value in item.items()}
22process_data([{"name": "apple", "quantity": 10}, {"name": "orange", "quantity": 5}], transform=custom_transform)

In the evolved version, we've introduced two optional parameters: condition, a lambda function to filter the input list based on a given condition, and transform, a lambda function for custom transformations of the filtered items. The default behavior processes all items, converting string values to uppercase, which ensures that the original function's behavior is maintained for existing code paths. This robust enhancement strategy facilitates adding new features to a function with significant complexity while preserving backward compatibility, showcasing an advanced application of evolving software capabilities responsively and responsibly.

Task 2: Using the Adapter Design Pattern for Backward Compatibility

Imagine now that we are building a music player, and recently, the market demands have grown. Now, users expect support not just for MP3 and WAV but also for FLAC files within our music player system. This development poses a unique challenge: How do we extend our music player's capabilities to embrace this new format without altering its established interface or the Adapter we've already implemented for WAV support?

Let's say that we currently have a MusicPlayer class that can only play MP3 files:

Python
1class MusicPlayer:
2    def play(self, file):
3        if file.endswith(".mp3"):
4            print(f"Playing {file} as mp3.")
5        else:
6            print("File format not supported.")

Let's approach this challenge by introducing a composite adapter, a design that encapsulates multiple adapters or strategies to extend functionality in a modular and maintainable manner.

Python
1class MusicPlayerAdapter:
2    def __init__(self, player: MusicPlayer):
3        self.player = player
4        self.format_adapters = {
5            ".wav": self.convert_and_play_wav,
6            ".flac": self.convert_and_play_flac,
7        }
8        
9    def play(self, file):
10        file_extension = file[file.rfind("."):].lower()
11        adapter_func = self.format_adapters.get(file_extension)
12        
13        if adapter_func:
14            adapter_func(file)
15        else:
16            self.player.play(file)
17    
18    def convert_and_play_wav(self, file):
19        # Simulate conversion
20        converted_file = file.replace(".wav", ".mp3")
21        print(f"Converting {file} to {converted_file} and playing as mp3...")
22        self.player.play(converted_file)
23    
24    def convert_and_play_flac(self, file):
25        # Simulate conversion
26        converted_file = file.replace(".flac", ".mp3")
27        print(f"Converting {file} to {converted_file} and playing as mp3...")
28        self.player.play(converted_file)
29
30# Upgraded music player with enhanced functionality through the composite adapter
31legacy_player = MusicPlayer()
32enhanced_player = MusicPlayerAdapter(legacy_player)
33enhanced_player.play("song.mp3")  # Supported directly
34enhanced_player.play("song.wav")  # Supported through adaptation
35enhanced_player.play("song.flac")  # Newly supported through additional adaptation

This sophisticated adaptation strategy ensures that we can extend the MusicPlayer to include support for additional file formats without disturbing its original code or the initial adapter pattern's implementation. The AdvancedMusicPlayerAdapter thus acts as a unified interface to the legacy MusicPlayer, capable of handling various formats by determining the appropriate conversion strategy based on the file type.

Summary and Practice

Great job! You've delved into backward compatibility while learning how to utilize default parameters and the Adapter Design Pattern. Get ready for some hands-on practice to consolidate these concepts! Remember, practice makes perfect. Happy Coding!

Enjoy this lesson? Now it's time to practice with Cosmo!

Practice is how you turn knowledge into actual skills.