Python Program for Key Value pair using argparse

When developing Python applications, it's often necessary to create programs that accept key-value pairs as input arguments. Key-value pairs provide a flexible way to pass data to a program, allowing customization and parameterization. Fortunately, Python offers a powerful module named argparse that simplifies the process of building command-line interfaces, including handling key-value pairs.

When it comes to building command-line interfaces in Python, the argparse module is an incredibly useful tool. It simplifies the process of handling command-line arguments and provides a clean and intuitive way to define and parse them.

The argparse module offers a wide range of functionalities, including handling different types of arguments, providing usage messages, handling default values, and much more.

Building the Python Program

Let's start by creating a new Python file, key_value_parser.py, and import the necessary modules −

import argparse

Next, we need to define the command-line arguments that our program will accept. In this case, we want to allow key-value pairs. We can achieve this by specifying two separate arguments: one for the key and another for the value. Add the following code to the key_value_parser.py file −

def main():
   parser = argparse.ArgumentParser(description='Key-Value Pair Parser')
   parser.add_argument('-k', '--key', type=str, help='Key')
   parser.add_argument('-v', '--value', type=str, help='Value')
   args = parser.parse_args()
    
   if args.key and args.value:
      print(f'Key: {args.key}')
      print(f'Value: {args.value}')
   else:
      parser.print_help()

In the above code, we defined a function called main() to encapsulate our program logic. This is a common practice that allows us to reuse or import this code into other modules if needed.

We create an instance of the argparse.ArgumentParser class and assign it to the variable parser. We pass a string to the description parameter, which provides a brief explanation of what our program does.

Running the Program

To test our program, we can execute it from the command line by passing key-value pairs as arguments. Here's an example −

$ python key_value_parser.py --key name --value John
Key: name
Value: John

In the above example, we passed --key name to specify the key and --value John to specify the value. The program then prints the provided key and value.

If we forget to provide either the key or the value, the program will display the help message −

$ python key_value_parser.py --key name
usage: key_value_parser.py [-h] [-k KEY] [-v VALUE]
key_value_parser.py: error: argument -v/--value is required

Handling Edge Cases and Error Handling

In this section, let's explore additional scenarios and enhance our program's robustness. We'll address the following cases −

Handling Cases where the Key or Value is Missing

Currently, our program displays the help message if either the key or value is missing. Let's enhance the error handling and provide more descriptive error messages to guide the user on correct usage. We can modify the main() function as follows −

def main():
   parser = argparse.ArgumentParser(description='Key-Value Pair Parser')
   parser.add_argument('-k', '--key', type=str, help='Key', required=True)
   parser.add_argument('-v', '--value', type=str, help='Value', required=True)
   args = parser.parse_args()
    
   print(f'Key: {args.key}')
   print(f'Value: {args.value}')

By setting the required parameter to True for both the key and value arguments, we indicate that they are mandatory. If the user fails to provide either the key or value, argparse will automatically display an error message and the usage help.

Validating the Key or Value Format

Depending on the requirements of your program, you might want to validate the format of the key or value. For example, if the key should always be an alphanumeric string, we can add a validation check. Similarly, if the value should be a valid email address, we can implement validation accordingly. Let's demonstrate the validation for an alphanumeric key −

import re

def main():
   parser = argparse.ArgumentParser(description='Key-Value Pair Parser')
   parser.add_argument('-k', '--key', type=str, help='Key', required=True)
   parser.add_argument('-v', '--value', type=str, help='Value', required=True)
   args = parser.parse_args()
    
   key_pattern = re.compile(r'^[a-zA-Z0-9]+$')
   if not key_pattern.match(args.key):
      print('Error: Invalid key format. The key must be alphanumeric.')
      return
    
   print(f'Key: {args.key}')
   print(f'Value: {args.value}')

In the above code, we import the re module to work with regular expressions. We define a regular expression pattern key_pattern that matches alphanumeric strings using the ^[a-zA-Z0-9]+$ pattern. If the provided key does not match this pattern, we display an error message and exit the program.

Dealing with Duplicate Keys

If your program needs to handle multiple key-value pairs, you might encounter scenarios where duplicate keys are provided. Consider how you want to handle such cases. Do you want to overwrite the existing value with the new one, or should it be treated as an error?

You can maintain a dictionary to store the key-value pairs and check for duplicates before updating the dictionary. Here's an example implementation −

def main():
   parser = argparse.ArgumentParser(description='Key-Value Pair Parser')
   parser.add_argument('-k', '--key', type=str, help='Key', required=True)
   parser.add_argument('-v', '--value', type=str, help='Value', required=True)
   args = parser.parse_args()
    
   # Store key-value pairs in a dictionary
   key_value_dict = {}

   if args.key in key_value_dict:
      print(f'Warning: Duplicate key "{args.key}" found. Overwriting the previous value.')
   key_value_dict[args.key] = args.value

   # Print all key-value pairs
   print('Key-Value Pairs:')
   for key, value in key_value_dict.items():
      print(f'Key: {key}, Value: {value}')

In the above code, we create a dictionary key_value_dict to store the key-value pairs. Before adding a new key-value pair, we check if the key already exists in the dictionary. If a duplicate key is found, we display a warning message and proceed to overwrite the previous value with the new one.

Error Handling and Exception Catching

To ensure our program handles potential errors and exceptions gracefully, it's important to implement appropriate error handling. We can use try-except blocks to catch and handle any unexpected issues during the execution of our program. Here's an example −

def main():
   try:
      parser = argparse.ArgumentParser(description='Key-Value Pair Parser')
      parser.add_argument('-k', '--key', type=str, help='Key', required=True)
      parser.add_argument('-v', '--value', type=str, help='Value', required=True)
      args = parser.parse_args()
        
      # Rest of the program logic...

   except Exception as e:
      print(f'An error occurred: {str(e)}')

if __name__ == '__main__':
   main()

In the above code, we wrap the program logic within a try block and include an except block to catch any exceptions that may occur. If an exception is raised during the execution, it will be caught, and an appropriate error message will be displayed.

Conclusion

The use of argparse in Python programs provides an effective and efficient way to handle key-value pair inputs from the command line. By utilizing the argparse module, developers can easily define command-line arguments and their associated values, allowing for a more user-friendly and organized interface.