Cara Membuat Aplikasi CLI dengan Python Fire Part 2

Kali ini admin akan membuat artikel tentang Cara Membuat Aplikasi CLI dengan Python Fire Part 2 yang sudah dijelaskan sebelumnya.

Cara Membuat Aplikasi CLI dengan Python Fire Part 2
Cara Membuat Aplikasi CLI dengan Python Fire Part 2

Jika anda belum membaca part 1, anda bisa baca artikel sebelumnya (Command Line Interfaces CLI dengan API Python) dan anda langsung bisa melanjutkan ke part 2.

Berikut Cara Membuat Aplikasi CLI dengan Python Fire:

Mari kita membuat skrip, katakanlah kita membuat file baru bernama fire_cli.py dan kita isi dengan fungsi di dalamnya sebagai berikut:

def greet_mankind():
    """Greets you with Hello World"""
    return 'Hello World'

Saat menjalankan program ini di shell Python, hasilnya adalah sebagai berikut:

>>> from fire_cli import greet_mankind
>>> greet_mankind()
'Hello World'
>>>

Kami dapat dengan mudah mengubah skrip ini menjadi aplikasi CLI menggunakan Python Fire:

import fire

def greet_mankind():
    """
    Returns a textual message
    """
    return 'Hello World'

if __name__ == '__main__':
    fire.Fire()

The fire.Fire() pemaanggilan dari modul yaitu fire_cli.py ke dalam aplikasi Api CLI. Selain itu telah mengekspos greet_mankind() fungsinya sebagai perintah secara otomatis.

Sekarang kita dapat menyimpan dan menjalankan skrip di atas sebagai CLI berikut ini:

$ python fire_greet_mk_cli.py greet_mankind
Hello World

Disini saya akan menjelaskan uraian kode diatas satu per satu:

  • $ adalah promptnya
  • python adalah penerjemah perintah
  • fire_cli.py adalah modul yang berisi perintah CLI
  • greet_mankind adalah perintahnya

Cara Meneruskan Menjadi Perintah:

Mari kita membuat aplikasi CLI lain yang menggunakan nama sebagai parameter dan menampilkan pesan salam khusus:

import fire

def greetings(name):
    '''
    Returns a greeting message
    Parameters
    ----------
    name : string
        String that represents the addresses name 

    Returns
    -------
    string
        greeting message concatenated with name
    '''
    return 'Hello %s' % name

if __name__ == '__main__':
    fire.Fire()

Di sini, kita sekarang punya fungsi yang menerima string – name. Python Fire secara otomatis akan mengambil ini dan jika kami memberikan argumen setelah memanggil greetings, itu akan diproses melalui input ke parameter name. Kami juga telah menambahkan komentar berupa dokumentasi untuk --help pada perintah tersebut.

Inilah cara kita menjalankan perintah ini dari baris perintah:

$ python fire_greet_cli.py greetings Robin
Hello Robin

Aplikasi Fire CLI dapat menggunakan --help flag untuk memeriksa deskripsi perintah yang dibuat dari dokumen Python yang kita buat:

python fire_greet_cli.py greetings --help
NAME
    fire_greet_cli.py greetings - Returns a greeting message

SYNOPSIS
    fire_greet_cli.py greetings NAME

DESCRIPTION
    Returns a greetings message

POSITIONAL ARGUMENTS
    NAME
        String that represents the addresses name

NOTES
    You can also use flags syntax for POSITIONAL ARGUMENTS

Mengatur Fungsi sebagai Titik Masuk

Dengan sedikit modifikasi, kita dapat mengontrol greetings() fungsi ke baris perintah dan mengaturnya sebagai titik masuk default:

import fire

def greetings(name):
    '''
    Returns a greeting message 
    :param name: string argument
    :return: greeting message appended with name
    '''
    return 'Hello %s' % name

if __name__ == '__main__':
    fire.Fire(greetings)

Beginilah cara kita menjalankan perintahnya:

$ python fire_greet_cli.py Robin
Hello Robin

Jadi kali ini kita tidak perlu lagi memanggil perintah seperti yang telah kita definisikan pada greetings secara implisit sebagai titik masuk menggunakan Fire(). Satu hal yang perlu diperhatikan di sini adalah bahwa dengan versi ini, kita hanya dapat memberikan satu argumen :

$ python fire_greet_cli.py Robin Hood
ERROR: Could not consume arg: Hood
...
$ python fire_greet_cli.py Robin
Hello Robin

Argumen Parsing

Perpustakaan Api juga bekerja dengan class. Mari kita definisikan class Custom Sequence yang menghasilkan dan mengembalikan daftar angka antara start dan end:

import fire

class CustomSequence:
    '''Class that generates a sequence of numbers'''
    def __init__(self, offset=1):
        '''
         Parameters
        ----------
        offset : int, optional
            Number controlling the difference between two generated values
        '''
        self.offset = offset

    def generate(self, start, stop):
        '''
        Generates the sequence of numbers

        Parameters
        ----------
        start : int
            Number that represents the elements lower bound
        stop : int
            Number that represents the elements upper bound

        Returns
        -------
        string
            a string that represents the generated sequence
        '''
        return ' '.join(str(item) for item in range(start, stop, self.offset))

if __name__ == '__main__':
    fire.Fire(CustomSequence)

Beginilah cara kami membuat urutan menggunakan utilitas pada baris perintah ini:

$ python fire_gen_cli.py generate 1 10
1 2 3 4 5 6 7 8 9

Kami menggunakan kelas daripada fungsi karena tidak seperti fungsi jika kami ingin meneruskan argumen ke konstruktor, itu selalu harus direpresentasikan sebagai bendera baris perintah dengan tanda hubung ganda (misalnya --offset=2).

Oleh karena itu, aplikasi CLI kami mendukung argumen opsional --offset yang akan diteruskan ke konstruktor kelas. Ini mengubah output dengan mengontrol perbedaan antara dua nilai yang dihasilkan secara berurutan:

Berikut output dengan nilai offset 2:

$ python fire_gen_cli.py generate 1 10 --offset=2
1 3 5 7 9

Argumen konstruktor selalu diteruskan menggunakan sintaks flag sedangkan argumen ke metode atau fungsi lain diteruskan secara posisional atau dengan nama:

$ python fire_gen_cli.py generate --start=10 --stop=20
10 11 12 13 14 15 16 17 18 19
$ python fire_gen_cli.py generate 10 20
10 11 12 13 14 15 16 17 18 19
$ python fire_gen_cli.py generate --start=10 --stop=20 --offset=2
10 12 14 16 18

Kami dapat memeriksa penggunaan generateperintah menggunakan --helpbendera. Ini akan memberikan informasi penggunaan untuk CLI:

$ python fire_gen_cli.py generate --help
INFO: Showing help with the command 'fire_gen_cli.py generate -- --help'.

NAME
    fire_gen_cli.py generate - Generates the sequence of numbers

SYNOPSIS
    fire_gen_cli.py generate START STOP

DESCRIPTION
    Generates the sequence of numbers

POSITIONAL ARGUMENTS
    START
        Number that represents the first value for the sequence
    STOP
        Number that represents the ending value for the sequence

NOTES
    You can also use flags syntax for POSITIONAL ARGUMENTS

Menggunakan --help dengan modul memberi kita informasi penggunaannya:

$ python fire_gen_cli.py  --help
INFO: Showing help with the command 'fire_gen_cli.py -- --help'.

NAME
    fire_gen_cli.py - Class that generates a sequence of numbers

SYNOPSIS
    fire_gen_cli.py <flags>

DESCRIPTION
    Class that generates a sequence of numbers

FLAGS
    --offset=OFFSET

Flag Fire

Fire CLIs hadir dengan banyak flag built-in. Kami telah melihat --help, bagaimanapun, flag berguna lainnya adalah --interactive. Menggunakan flag ini menempatkan kita dalam mode REPL Python, dengan modul yang sudah ditentukan.

Ini cukup berguna untuk menguji perintah:

$ python fire_greet_cli.py -- --interactive
Fire is starting a Python REPL with the following objects:
Modules: fire
Objects: component, fire_greet_cli.py, greetings, result, trace

Python 3.7.8 (tags/v3.7.8:4b47a5b6ba, Jun 28 2020, 08:53:46) [MSC v.1916 64 bit (AMD64)]
Type 'copyright', 'credits' or 'license' for more information
IPython 7.16.1 -- An enhanced Interactive Python. Type '?' for help.


In [1]: greetings("Robin")
Out[1]: 'Hello Robin'

Perhatikan bahwa flag Fire harus dipisahkan dari opsi lain dengan dua tanda hubung ( --), jadi jika kita ingin menggunakan keduanya --help dan –interactive flag dalam sebuah perintah, akan terlihat seperti ini:

$ python fire_greet_cli.py -- --help --interactive