5 Best Ways to Validate Delivery Operations in Python

by

💡 Problem Formulation: In logistics or e-commerce applications, it’s critical to verify that delivery operations, including addresses, dispatch times, and parcel tracking, adhere to specific stipulations. Given an input of delivery details, the desired output is a boolean value indicating whether each operation is valid per the defined criteria.

Method 1: Using Regular Expressions

Regular expressions in Python are a powerful way to validate strings. Method 1 leverages the re module to check whether delivery details match specified patterns for valid operations. This method is preferred for its efficiency and flexibility in pattern matching.

Here’s an example:

import re

delivery_operations = ['OP-123: Package dispatched.', 'INVALID DATA', 'OP-456: Package en route.', 'OP-!&%: Error in operation.']

def validate_operations(operations_list):
    pattern = re.compile(r'^OP-\d{3}: Package [a-z ]+\.$')
    return [bool(pattern.match(operation)) for operation in operations_list]

valid_operations = validate_operations(delivery_operations)
print(valid_operations)

The output:

[True, False, True, False]

This code snippet illustrates how to use a regular expression to check if each delivery operation conforms to a pattern that indicates a valid operation. The re.compile defines the pattern and match uses the pattern to determine the validity of each string in the list.

Method 2: Using Custom Validation Functions

Custom validation functions offer tailored and granular control over the validation logic. Method 2 focuses on writing bespoke functions that check different aspects of delivery operations such as format, content, and logical consistency, based on predefined rules.

Here’s an example:

def is_valid_operation(operation):
    parts = operation.split(': ')
    if len(parts) != 2:
        return False
    code, description = parts
    if not code.startswith('OP-') or not code[3:].isdigit():
        return False
    if description not in ['Package dispatched', 'Package en route', 'Package delivered']:
        return False
    return True

delivery_operations = ['OP-123: Package dispatched', 'INVALID', 'OP-456: Package en route', 'OP-!&%: Error']
valid_operations = [is_valid_operation(op) for op in delivery_operations]
print(valid_operations)

The output:

[True, False, True, False]

The custom function is_valid_operation deconstructs each operation into code and description and validates against predefined criteria. If an operation passes all checks, it returns True signifying a valid operation.

Method 3: Using Data Classes for Validation

Data classes in Python provide a structured way to represent data objects. Method 3 uses data classes coupled with custom validation methods to represent delivery operations and assess their validity. This structured approach is great for clarity and object-oriented programming practices.

Here’s an example:

from dataclasses import dataclass

@dataclass
class DeliveryOperation:
    operation_code: str
    description: str

    def is_valid(self):
        return self.operation_code.startswith('OP-') and self.description in ['Dispatched', 'En Route', 'Delivered']

delivery_operations = [
    DeliveryOperation('OP-123', 'Dispatched'),
    DeliveryOperation('INVALID', 'Error'),
]

valid_operations = [op.is_valid() for op in delivery_operations]
print(valid_operations)

The output:

[True, False]

In this snippet, DeliveryOperation is a data class with a built-in validation method is_valid(). Instances of this class are created for each operation, and validity is checked through this method, which makes the code organized and concise.

Method 4: Using External Validation Libraries

There are several Python libraries available that are dedicated to validation of data. Method 4 explores the use of these libraries, such as Cerberus, to define schemas and validate the delivery operations against these schemas. This method is useful for complex validation rules that might be cumbersome to implement manually.

Here’s an example:

from cerberus import Validator

schema = {'operation_code': {'type': 'string', 'regex': '^OP-\d{3}$'}, 'description': {'type': 'string', 'allowed': ['Dispatched', 'En Route', 'Delivered']}}
v = Validator(schema)

delivery_operations = [{'operation_code': 'OP-123', 'description': 'Dispatched'}, {'operation_code': 'INVALID', 'description': 'Error'}]
valid_operations = [v.validate(op) for op in delivery_operations]
print(valid_operations)

The output:

[True, False]

Using the Cerberus library, a schema for delivery operations is defined. Then, a Validator object is created to check whether each operation dictionary conforms to the schema. The boolean results of validations are collected in a list.

Bonus One-Liner Method 5: Using List Comprehensions with Conditions

List comprehensions provide a concise way to apply validation logic within a single line of code. Method 5 is a quick one-liner approach that utilizes conditions within a list comprehension to check for validity of delivery operations based on simple criteria.

Here’s an example:

delivery_operations = ['OP-123: Dispatched', 'INVALID', 'OP-456: En Route', 'OP-789: Delivered']
valid_operations = ['OP-' in op and op.split(': ')[-1] in ['Dispatched', 'En Route', 'Delivered'] for op in delivery_operations]
print(valid_operations)

The output:

[True, False, True, True]

This one-liner list comprehension checks that each string in delivery_operations contains ‘OP-‘ and ends with a valid status. This method is quick but only suitable for simple validations.

Summary/Discussion

  • Method 1: Regular Expressions. Highly efficient and flexible for pattern-based validation. May become complex with intricate patterns.
  • Method 2: Custom Validation Functions. Ideal for complex logic requiring multiple checks. Maintenance may be harder as rules change or grow in complexity.
  • Method 3: Data Classes for Validation. Object-oriented and enhances code readability. Overhead for simple validations and can be less intuitive for non-devs.
  • Method 4: External Validation Libraries. Handles complex validations conveniently and is extensible. Requires external dependencies and may be overkill for simple cases.
  • Bonus Method 5: List Comprehensions with Conditions. Quick and concise for simple checks. Not as readable and maintainable for elaborate validation rules.