Python Argparse Geavanceerd: Subopdrachten en Aangepaste Actieklassen Meesteren

Python's argparse module is een krachtig hulpmiddel voor het creëren van command-line interfaces (CLIs). Hoewel basisgebruik relatief eenvoudig is, biedt argparse geavanceerde functies waarmee geavanceerde en gebruiksvriendelijke CLIs kunnen worden gemaakt. Deze blogpost duikt in twee van dergelijke geavanceerde functies: subopdrachten en aangepaste actieklassen.

Waarom Geavanceerde Argparse?

Voor eenvoudige scripts met slechts een paar opties kan de basisfunctionaliteit van argparse volstaan. Naarmate uw scripts echter complexer worden en meer functionaliteit krijgen, wordt een meer gestructureerde en georganiseerde CLI essentieel. Geavanceerde argparse-functies helpen bij:

• Verbetering van de Gebruikerservaring: Bied een duidelijke en intuïtieve interface voor gebruikers.
• Verbetering van de Code Onderhoudbaarheid: Organiseer uw code in logische modules, waardoor deze gemakkelijker te begrijpen en te onderhouden is.
• Vergroting van de Functionaliteit: Ondersteuning van complexe workflows en meerdere bewerkingen binnen een enkel script.
• Bevordering van Herbruikbaarheid: Creëer herbruikbare componenten die kunnen worden toegepast op verschillende delen van uw applicatie.

Subopdrachten: Complexe CLIs Organiseren

Subopdrachten zijn een manier om gerelateerde opdrachten te groeperen onder één enkele hoofdopdracht. Dit is met name handig voor applicaties die een verscheidenheid aan afzonderlijke taken uitvoeren. Denk bijvoorbeeld aan Git. Het gebruikt uitgebreid subopdrachten: git commit, git push, git pull, enzovoort. Elke subopdracht heeft zijn eigen set argumenten en opties.

Subopdrachten Implementeren met argparse

Om subopdrachten te implementeren met argparse, gebruikt u de methode add_subparsers(). Hier is een eenvoudig voorbeeld:

            
import argparse

# Creëer de hoofdparser
parser = argparse.ArgumentParser(description='Een eenvoudig voorbeeld met subopdrachten')

# Creëer de subparser
subparsers = parser.add_subparsers(dest='command', help='Beschikbare opdrachten')

# Creëer de 'add' subopdracht
add_parser = subparsers.add_parser('add', help='Tel twee getallen op')
add_parser.add_argument('x', type=int, help='Eerste getal')
add_parser.add_argument('y', type=int, help='Tweede getal')

# Creëer de 'subtract' subopdracht
subtract_parser = subparsers.add_parser('subtract', help='Trek twee getallen af')
subtract_parser.add_argument('x', type=int, help='Eerste getal')
subtract_parser.add_argument('y', type=int, help='Tweede getal')

# Parseer de argumenten
args = parser.parse_args()

# Voer de actie uit op basis van de subopdracht
if args.command == 'add':
    result = args.x + args.y
    print(f'De som is: {result}')
elif args.command == 'subtract':
    result = args.x - args.y
    print(f'Het verschil is: {result}')
else:
    parser.print_help()

            

              
                Copy
              
            
          

In dit voorbeeld:

• We creëren een hoofdparser met behulp van argparse.ArgumentParser().
• We voegen een subparser toe met behulp van parser.add_subparsers(dest='command', help='Beschikbare opdrachten'). Het argument dest specificeert het attribuut dat de naam van de gekozen subopdracht zal opslaan.
• We creëren twee subopdrachten, 'add' en 'subtract', met behulp van subparsers.add_parser().
• Elke subopdracht heeft zijn eigen set argumenten (x en y).
• We parseren de argumenten met behulp van parser.parse_args().
• We controleren de waarde van args.command om te bepalen welke subopdracht is gekozen en voeren vervolgens de bijbehorende actie uit.

Om dit script uit te voeren, zou u opdrachten gebruiken zoals:

python your_script.py add 5 3
python your_script.py subtract 10 2

Geavanceerde Subopdrachttechnieken

1. Functies Gebruiken om Subopdrachten Af te Handelen

Een meer georganiseerde aanpak is om afzonderlijke functies te definiëren om elke subopdracht af te handelen. Dit verbetert de leesbaarheid en onderhoudbaarheid van de code.

            
import argparse

def add(args):
    result = args.x + args.y
    print(f'De som is: {result}')

def subtract(args):
    result = args.x - args.y
    print(f'Het verschil is: {result}')

# Creëer de hoofdparser
parser = argparse.ArgumentParser(description='Een eenvoudig voorbeeld met subopdrachten')

# Creëer de subparser
subparsers = parser.add_subparsers(dest='command', help='Beschikbare opdrachten')

# Creëer de 'add' subopdracht
add_parser = subparsers.add_parser('add', help='Tel twee getallen op')
add_parser.add_argument('x', type=int, help='Eerste getal')
add_parser.add_argument('y', type=int, help='Tweede getal')
add_parser.set_defaults(func=add)

# Creëer de 'subtract' subopdracht
subtract_parser = subparsers.add_parser('subtract', help='Trek twee getallen af')
subtract_parser.add_argument('x', type=int, help='Eerste getal')
subtract_parser.add_argument('y', type=int, help='Tweede getal')
subtract_parser.set_defaults(func=subtract)

# Parseer de argumenten
args = parser.parse_args()

# Roep de functie aan die is gekoppeld aan de subopdracht
if hasattr(args, 'func'):
    args.func(args)
else:
    parser.print_help()

            

              
                Copy
              
            
          

Hier gebruiken we set_defaults(func=...) om een functie te associëren met elke subopdracht. Vervolgens, na het parseren, roepen we de juiste functie aan als deze bestaat.

2. Subopdrachten Nesten

U kunt subopdrachten nesten om nog complexere en hiërarchische CLIs te creëren. Overweeg bijvoorbeeld een CLI voor het beheren van cloudbronnen:

cloud compute instance create --name my-instance --region us-east-1
cloud storage bucket list --project my-project

In dit voorbeeld is cloud de hoofdopdracht, compute en storage zijn subopdrachten, en instance en bucket zijn sub-subopdrachten.

3. Praktijkvoorbeeld: Internationalisatietool

Stel u een tool voor om vertalingen in een meertalige applicatie te beheren. U kunt subopdrachten gebruiken om de verschillende bewerkingen te organiseren:

translation tool add-language --code fr_FR --name "Frans (Frankrijk)"
translation tool extract-strings --source-dir src
translation tool translate --target-language es_ES --source-file strings.pot

Deze aanpak maakt een duidelijke scheiding van concerns mogelijk en maakt de tool gemakkelijker te gebruiken en te onderhouden, vooral bij het omgaan met talrijke talen en vertaalworkflows die in verschillende landen van toepassing zijn.

Aangepaste Actieklassen: Argument Parsing Op Maat Maken

argparse stelt u in staat om aangepaste actieklassen te definiëren om aan te passen hoe argumenten worden verwerkt. Dit is handig voor scenario's waarin het standaardargumentverwerkingsgedrag niet voldoende is. Een actieklasse is een klasse die overerft van argparse.Action en de methode __call__ overschrijft.

Een Aangepaste Actieklasse Creëren

Hier is een voorbeeld van een aangepaste actieklasse die een argument in hoofdletters converteert:

            
import argparse

class ToUpper(argparse.Action):
    def __call__(self, parser, namespace, values, option_string=None):
        if isinstance(values, list):
            setattr(namespace, self.dest, [v.upper() for v in values])
        else:
            setattr(namespace, self.dest, values.upper())

# Creëer de parser
parser = argparse.ArgumentParser(description='Voorbeeld met aangepaste actie')

# Voeg een argument toe met de aangepaste actie
parser.add_argument('--name', action=ToUpper, help='Naam om te converteren naar hoofdletters')
parser.add_argument('--cities', action=ToUpper, nargs='+', help='Lijst met steden om te converteren naar hoofdletters')

# Parseer de argumenten
args = parser.parse_args()

# Print het resultaat
if args.name:
    print(f'Naam: {args.name}')
if args.cities:
    print(f'Steden: {args.cities}')

            

              
                Copy
              
            
          

In dit voorbeeld:

• We definiëren een klasse ToUpper die overerft van argparse.Action.
• De methode __call__ wordt aangeroepen wanneer het argument wordt aangetroffen. Het neemt de volgende argumenten:
  • parser: Het ArgumentParser-object.
  • namespace: Het namespace-object waar de geparste argumenten worden opgeslagen.
  • values: De waarde(n) van het argument.
  • option_string: De optiestring die werd gebruikt om deze actie aan te roepen (bijvoorbeeld --name).
• Binnen de methode __call__ converteren we de waarde naar hoofdletters met behulp van values.upper() en slaan we deze op in de namespace met behulp van setattr(namespace, self.dest, values.upper()).
• We voegen een argument toe aan de parser met behulp van parser.add_argument('--name', action=ToUpper, help='Naam om te converteren naar hoofdletters'). We specificeren het argument action als onze aangepaste actieklasse.

Om dit script uit te voeren, zou u opdrachten gebruiken zoals:

python your_script.py --name john
python your_script.py --cities london paris tokyo

Gebruiksscenario's voor Aangepaste Actieklassen

1. Invoer Valideren

U kunt aangepaste actieklassen gebruiken om invoer te valideren en een fout te genereren als de invoer ongeldig is. U kunt bijvoorbeeld een actieklasse maken die controleert of een bestand bestaat of dat een getal binnen een specifiek bereik valt.

            
import argparse
import os

class FileMustExist(argparse.Action):
    def __call__(self, parser, namespace, values, option_string=None):
        if not os.path.exists(values):
            raise argparse.ArgumentTypeError(f'Bestand niet gevonden: {values}')
        setattr(namespace, self.dest, values)

parser = argparse.ArgumentParser(description='Voorbeeld van het valideren van het bestaan van een bestand.')
parser.add_argument('--input-file', action=FileMustExist, help='Pad naar het invoerbestand.')

args = parser.parse_args()

print(f'Invoerbestand: {args.input_file}')

            

              
                Copy
              
            
          

2. Eenheden Converteren

U kunt aangepaste actieklassen gebruiken om eenheden te converteren. U kunt bijvoorbeeld een actieklasse maken die temperaturen van Celsius naar Fahrenheit converteert.

3. Complexe Gegevensstructuren Afhandelen

Als u argumenten in complexe gegevensstructuren moet parseren (bijvoorbeeld woordenboeken, lijsten met objecten), kunt u aangepaste actieklassen gebruiken om de parserlogica af te handelen.

4. Voorbeeld: Tijdzones Afhandelen

Overweeg een applicatie die datums en tijden in verschillende tijdzones moet afhandelen. Een aangepaste actieklasse kan worden gebruikt om een datumstring te parseren en deze om te zetten naar een specifieke tijdzone met behulp van bibliotheken zoals pytz.

            
import argparse
import datetime
import pytz

class TimeZoneConverter(argparse.Action):
    def __init__(self, option_strings, dest, timezone=None, **kwargs):
        super().__init__(option_strings, dest, **kwargs)
        self.timezone = timezone

    def __call__(self, parser, namespace, values, option_string=None):
        try:
            dt = datetime.datetime.fromisoformat(values)
            if self.timezone:
                tz = pytz.timezone(self.timezone)
                dt = tz.localize(dt)
            setattr(namespace, self.dest, dt)
        except ValueError:
            raise argparse.ArgumentTypeError(f"Ongeldig datum/tijd formaat. Gebruik ISO formaat (JJJJ-MM-DDTHH:MM:SS): {values}")
        except pytz.exceptions.UnknownTimeZoneError:
            raise argparse.ArgumentTypeError(f"Ongeldige tijdzone: {self.timezone}")

parser = argparse.ArgumentParser(description='Voorbeeld met tijdzone conversie.')
parser.add_argument('--event-time', action=TimeZoneConverter, timezone='America/Los_Angeles', help='Evenementtijd in ISO formaat (JJJJ-MM-DDTHH:MM:SS). Converteert naar de tijdzone America/Los_Angeles.')

args = parser.parse_args(['--event-time', '2024-10-27T10:00:00'])

print(f'Evenementtijd (Los Angeles): {args.event_time}')

            

              
                Copy
              
            
          

Dit voorbeeld laat zien hoe aangepaste acties tijdzoneconversies kunnen afhandelen met behulp van de pytz-bibliotheek, wat een meer geavanceerd gebruik demonstreert dat wereldwijd relevant is.

Beste Praktijken voor het Gebruiken van Geavanceerde Argparse

• Houd het Eenvoudig: Maak uw CLI niet te ingewikkeld. Gebruik subopdrachten en aangepaste acties alleen wanneer dat nodig is.
• Zorg voor Duidelijke Helpberichten: Schrijf duidelijke en beknopte helpberichten voor elke opdracht en elk argument. Gebruik het argument help in add_argument() uitgebreid.
• Valideer Invoer: Valideer altijd de invoer van de gebruiker om fouten en beveiligingslekken te voorkomen.
• Gebruik Consistente Naamsconventies: Volg consistente naamsconventies voor opdrachten, argumenten en opties. Overweeg het gebruik van kebab-case (--my-option) voor lange optienamen.
• Test Grondig: Test uw CLI grondig met verschillende invoer en scenario's.
• Documenteer Uw CLI: Zorg voor uitgebreide documentatie voor uw CLI, inclusief voorbeelden van het gebruik van elke opdracht en elk argument. Hulpprogramma's zoals Sphinx kunnen documentatie genereren op basis van uw code.
• Overweeg Lokalisatie: Als uw CLI bedoeld is voor een wereldwijd publiek, overweeg dan om uw helpberichten en andere gebruikersgerichte tekst te lokaliseren.

Conclusie

Subopdrachten en aangepaste actieklassen zijn krachtige hulpmiddelen voor het creëren van geavanceerde en gebruiksvriendelijke CLIs met argparse. Door deze geavanceerde functies onder de knie te krijgen, kunt u robuuste, onderhoudbare en schaalbare command-line applicaties bouwen die voldoen aan de behoeften van een diverse gebruikersbasis. Van het beheren van meertalige applicaties tot het afhandelen van tijdzones over de hele wereld, de mogelijkheden zijn enorm. Omarm deze technieken om uw Python scripting en command-line tool ontwikkeling naar een hoger niveau te tillen.