是否存在类似Symfony Console组件的Python CLI开发包？

Hey there! If you want a Python CLI setup that mirrors Symfony Console's powerful, object-oriented, and flexible approach, Cliff (Command Line Interface Framework) is exactly what you need. It meets all your core requirements without being overly complex. Let's break down how to implement it:

First, Does It Check All Your Boxes? #

Absolutely:

• ✅ Commands as the first argument (e.g., python myapp.py command1)
• ✅ Nested commands like foo:bar (callable via python myapp.py foo or python myapp.py foo:bar)
• ✅ Each command maps to a dedicated object (just like Symfony's Command classes)
• ✅ Strict separation of arguments and options (parses into distinct structures)
• ✅ Options can come before positional arguments
• ✅ Support for array-type options (multiple values for the same flag)

Step-by-Step Implementation #

1. Install Cliff #

First, grab the package via pip:

pip install cliff

2. Define Your Command Classes #

Each command is a class extending cliff.command.Command—just like how you'd create a Command subclass in Symfony.

Example: Top-Level foo Command

from cliff.command import Command

class FooCommand(Command):
    """Run the top-level foo command"""

    def get_parser(self, prog_name):
        # Get the base parser, then add your arguments and options
        parser = super().get_parser(prog_name)
        
        # Add positional arguments (these are your "arguments" in the requirement)
        parser.add_argument('arg1', help='First positional argument')
        parser.add_argument('arg2', help='Second positional argument')
        
        # Add options (flags with/without values)
        parser.add_argument('--opt1', action='store_true', help='Boolean flag (no value needed)')
        parser.add_argument('--opt2-w-value', help='Option that requires a value')
        parser.add_argument('--opt5', action='append', help='Array-type option (use multiple times)')
        
        return parser

    def take_action(self, parsed_args):
        # This is where your command logic lives (like Symfony's execute method)
        # Separate arguments and options as requested
        arguments = [parsed_args.arg1, parsed_args.arg2]
        options = {
            'opt1': parsed_args.opt1,
            'opt2-w-value': parsed_args.opt2_w_value,
            'opt5': parsed_args.opt5 or []  # Default to empty list if not set
        }
        
        # Output the parsed results to verify
        self.app.stdout.write(f"Arguments: {arguments}\n")
        self.app.stdout.write(f"Options: {options}\n")

Example: Nested foo:bar Subcommand

Use a colon-separated name to define nested commands:

class FooBarCommand(Command):
    """Run the foo:bar subcommand"""

    def get_parser(self, prog_name):
        parser = super().get_parser(prog_name)
        
        parser.add_argument('arg1', help='Positional argument for foo:bar')
        parser.add_argument('--opt1', action='store_true', help='Boolean flag for foo:bar')
        parser.add_argument('--opt5', action='append', help='Array option for foo:bar')
        
        return parser

    def take_action(self, parsed_args):
        arguments = [parsed_args.arg1]
        options = {
            'opt1': parsed_args.opt1,
            'opt5': parsed_args.opt5 or []
        }
        
        self.app.stdout.write(f"[foo:bar] Arguments: {arguments}\n")
        self.app.stdout.write(f"[foo:bar] Options: {options}\n")

3. Build Your CLI Application #

Create the main app and register your commands—just like Symfony's Application class:

from cliff.app import App
from cliff.commandmanager import CommandManager

class MyCLI(App):
    def __init__(self):
        super().__init__(
            description='Symfony-style Python CLI App',
            version='1.0',
            command_manager=CommandManager('myapp.commands'),
        )

if __name__ == '__main__':
    # Register commands with their names (including nested colon format)
    cmd_manager = CommandManager('myapp.commands')
    cmd_manager.add_command('foo', FooCommand)
    cmd_manager.add_command('foo:bar', FooBarCommand)

    # Run the app
    app = MyCLI()
    app.command_manager = cmd_manager
    app.run()

4. Test It Out #

Let's verify all your requirements work as expected:

Test 1: Full Command with Arguments, Options, and Array Flag

Run:

python myapp.py foo arg1 arg2 --opt1 --opt2-w-value myvalue --opt5 val1 --opt5 val2

Output:

Arguments: ['arg1', 'arg2']
Options: {'opt1': True, 'opt2-w-value': 'myvalue', 'opt5': ['val1', 'val2']}

Test 2: Options Before Arguments

Run:

python myapp.py foo --opt1 arg1 arg2

Output:

Arguments: ['arg1', 'arg2']
Options: {'opt1': True, 'opt2-w-value': None, 'opt5': []}

Test 3: Nested Subcommand

Run:

python myapp.py foo:bar test_arg --opt5 valA --opt5 valB

Output:

[foo:bar] Arguments: ['test_arg']
[foo:bar] Options: {'opt1': False, 'opt5': ['valA', 'valB']}

Extra Notes #

• Cliff is built on top of Python's standard argparse, so any existing knowledge you have about argument parsing will transfer directly.
• If you ever need to extend functionality (like adding custom help formatting or global options), Cliff has hooks to do that easily.
• Each command's take_action method is where you'll put your business logic—just like Symfony's execute method.

内容的提问来源于stack exchange，提问作者Kirby