यदि आप कभी भी अपने सीएलआई को अधिक इंटरैक्टिव और गतिशील बनाना चाहते हैं, तो रीयल-टाइम कमांड इंटरेक्शन सिस्टम बनाना इसका उत्तर हो सकता है। पायथन की आत्मनिरीक्षण क्षमताओं, कमांड को प्रबंधित करने के लिए क्लिक और आउटपुट को फ़ॉर्मेट करने के लिए रिच का लाभ उठाकर, आप एक शक्तिशाली, लचीला सीएलआई बना सकते हैं जो उपयोगकर्ता इनपुट पर समझदारी से प्रतिक्रिया करता है। प्रत्येक कमांड को मैन्युअल रूप से हार्डकोड करने के बजाय, आपका सीएलआई स्वचालित रूप से कमांड को खोज और निष्पादित कर सकता है, जिससे उपयोगकर्ता का अनुभव सहज और अधिक आकर्षक हो जाता है।

रंगीन कंसोल अराजकता: जहां क्लिक कमांड रिच आउटपुट से मिलते हैं-क्योंकि टर्मिनल भी स्टाइल में दिखाना पसंद करता है!

क्लिक और मार्कडाउन का उपयोग क्यों करें?

क्लिक कमांड के प्रबंधन, तर्क पार्सिंग और सहायता सृजन को सरल बनाता है। यह आसान कमांड संरचना और विकल्प प्रबंधन की भी अनुमति देता है।

रिच आपको खूबसूरती से स्वरूपित मार्कडाउन को सीधे टर्मिनल में आउटपुट करने में सक्षम बनाता है, जिससे परिणाम न केवल कार्यात्मक होते हैं बल्कि दृष्टि से आकर्षक भी होते हैं।

इन दो पुस्तकालयों को पायथन आत्मनिरीक्षण के साथ जोड़कर, आप एक इंटरैक्टिव चैट सुविधा का निर्माण कर सकते हैं जो एक समृद्ध, पठनीय प्रारूप में आउटपुट प्रदर्शित करते हुए गतिशील रूप से कमांड की खोज और निष्पादन करता है। एक व्यावहारिक उदाहरण के लिए, देखें कि कैसे StoryCraftr AI-संचालित लेखन वर्कफ़्लो को सुव्यवस्थित करने के लिए एक समान दृष्टिकोण का उपयोग करता है: https://storycraftr.app.

इंटरएक्टिव चैट सिस्टम का निर्माण

1. बेसिक चैट कमांड सेट करना

चैट कमांड सत्र को आरंभ करता है, जिससे उपयोगकर्ता सीएलआई के साथ बातचीत कर सकते हैं। यहां, हम उपयोगकर्ता इनपुट कैप्चर करते हैं, जिसे गतिशील रूप से उचित क्लिक कमांड पर मैप किया जाएगा।

import os
import click
import shlex
from rich.console import Console
from rich.markdown import Markdown

console = Console()

@click.command()
@click.option("--project-path", type=click.Path(), help="Path to the project directory")
def chat(project_path=None):
    """
    Start a chat session with the assistant for the given project.
    """
    if not project_path:
        project_path = os.getcwd()

    console.print(
        f"Starting chat for [bold]{project_path}[/bold]. Type [bold green]exit()[/bold green] to quit."
    )

    # Start the interactive session
    while True:
        user_input = console.input("[bold blue]You:[/bold blue] ")

        # Handle exit
        if user_input.lower() == "exit()":
            console.print("[bold red]Exiting chat...[/bold red]")
            break

        # Call the function to handle command execution
        execute_cli_command(user_input)

2. आदेशों की खोज और निष्पादन के लिए आत्मनिरीक्षण

पायथन आत्मनिरीक्षण का उपयोग करके, हम गतिशील रूप से उपलब्ध कमांड की खोज करते हैं और उन्हें निष्पादित करते हैं। यहां एक महत्वपूर्ण हिस्सा यह है कि क्लिक कमांड सजाए गए फ़ंक्शन हैं। वास्तविक तर्क को निष्पादित करने के लिए, हमें अनडेकोरेटेड फ़ंक्शन (यानी, कॉलबैक) को कॉल करने की आवश्यकता है।

यहां बताया गया है कि आप आत्मनिरीक्षण का उपयोग करके कमांड को गतिशील रूप से कैसे निष्पादित कर सकते हैं और क्लिक के डेकोरेटर को संभाल सकते हैं:

import inspect
import your_project_cmd  # Replace with your actual module containing commands

command_modules = {"project": your_project_cmd}  # List your command modules here

def execute_cli_command(user_input):
    """
    Function to execute CLI commands dynamically based on the available modules,
    calling the undecorated function directly.
    """
    try:
        # Use shlex.split to handle quotes and separate arguments correctly
        parts = shlex.split(user_input)
        module_name = parts[0]
        command_name = parts[1].replace("-", "_")  # Replace hyphens with underscores
        command_args = parts[2:]  # Keep the rest of the arguments as a list

        # Check if the module exists in command_modules
        if module_name in command_modules:
            module = command_modules[module_name]

            # Introspection: Get the function by name
            if hasattr(module, command_name):
                cmd_func = getattr(module, command_name)

                # Check if it's a Click command and strip the decorator
                if hasattr(cmd_func, "callback"):
                    # Call the underlying undecorated function
                    cmd_func = cmd_func.callback

                # Check if it's a callable (function)
                if callable(cmd_func):
                    console.print(
                        f"Executing command from module: [bold]{module_name}[/bold]"
                    )

                    # Directly call the function with the argument list
                    cmd_func(*command_args)
                else:
                    console.print(
                        f"[bold red]'{command_name}' is not a valid command[/bold red]"
                    )
            else:
                console.print(
                    f"[bold red]Command '{command_name}' not found in {module_name}[/bold red]"
                )
        else:
            console.print(f"[bold red]Module {module_name} not found[/bold red]")
    except Exception as e:
        console.print(f"[bold red]Error executing command: {str(e)}[/bold red]")

कैसे यह काम करता है?

• इनपुट पार्सिंग: हम कमांड-लाइन तर्क जैसे इनपुट को संभालने के लिए shlex.split का उपयोग करते हैं। यह सुनिश्चित करता है कि उद्धृत स्ट्रिंग और विशेष वर्ण सही ढंग से संसाधित किए गए हैं।
• मॉड्यूल और कमांड लुकअप: इनपुट को मॉड्यूल_नाम और कमांड_नाम में विभाजित किया गया है। कमांड नाम को पायथन फ़ंक्शन नामों से मेल खाने के लिए अंडरस्कोर के साथ हाइफ़न को बदलने के लिए संसाधित किया जाता है।
• आत्मनिरीक्षण: हम मॉड्यूल से कमांड फ़ंक्शन को गतिशील रूप से लाने के लिए getattr() का उपयोग करते हैं। यदि यह एक क्लिक कमांड है (यानी, इसमें कॉलबैक विशेषता है), तो हम क्लिक डेकोरेटर को हटाकर वास्तविक फ़ंक्शन लॉजिक तक पहुंचते हैं।
• कमांड निष्पादन: एक बार जब हम अनडेकोरेटेड फ़ंक्शन को पुनः प्राप्त कर लेते हैं, तो हम तर्क पास करते हैं और इसे कॉल करते हैं, जैसे कि हम सीधे पायथन फ़ंक्शन को लागू कर रहे थे।

3. उदाहरण सीएलआई कमांड

आइए प्रोजेक्ट मॉड्यूल के भीतर कुछ नमूना आदेशों पर विचार करें जिन्हें उपयोगकर्ता चैट के माध्यम से इंटरैक्टिव रूप से कॉल कर सकते हैं:

@click.group()
def project():
    """Project management CLI."""
    pass

@project.command()
def init():
    """Initialize a new project."""
    console.print("[bold green]Project initialized![/bold green]")

@project.command()
@click.argument("name")
def create(name):
    """Create a new component in the project."""
    console.print(f"[bold cyan]Component {name} created.[/bold cyan]")

@project.command()
def status():
    """Check the project status."""
    console.print("[bold yellow]All systems operational.[/bold yellow]")

चैट इंटरफ़ेस निष्पादित करना

इंटरैक्टिव चैट सिस्टम चलाने के लिए:

1. सुनिश्चित करें कि आपके मॉड्यूल (प्रोजेक्ट की तरह) कमांड_मॉड्यूल में सूचीबद्ध हैं।
2. आदेश चलाएँ:

python your_cli.py chat --project-path /path/to/project

एक बार सत्र शुरू होने पर, उपयोगकर्ता कमांड इनपुट कर सकते हैं जैसे:

You: project init You: project create "Homepage"

रिच मार्कडाउन का उपयोग करके आउटपुट को अच्छी तरह से स्वरूपित तरीके से प्रदर्शित किया जाएगा:

[bold green]Project initialized![/bold green] [bold cyan]Component Homepage created.[/bold cyan]

निष्कर्ष

कमांड प्रबंधन के लिए क्लिक, मार्कडाउन फ़ॉर्मेटिंग के लिए रिच और पायथन आत्मनिरीक्षण के संयोजन से, हम सीएलआई के लिए एक शक्तिशाली और इंटरैक्टिव चैट सिस्टम बना सकते हैं। यह दृष्टिकोण आपको एक सुंदर, पठनीय प्रारूप में आउटपुट प्रस्तुत करते हुए गतिशील रूप से कमांड खोजने और निष्पादित करने की अनुमति देता है।

मुख्य विशेषताएं:

• डायनामिक कमांड निष्पादन: आत्मनिरीक्षण आपको कमांड को हार्डकोड किए बिना खोजने और चलाने में सक्षम बनाता है।
• रिच आउटपुट: रिच मार्कडाउन का उपयोग यह सुनिश्चित करता है कि आउटपुट पढ़ने में आसान और देखने में आकर्षक हो।
• लचीलापन: यह सेटअप कमांड संरचना और निष्पादन में लचीलेपन की अनुमति देता है।