python-fire的使用

To install Python Fire from pypi, run:

pip install fire

Alternatively, to install Python Fire from source, clone the source and run:

python setup.py install

The easiest way to use Fire is to take any Python program, and then simply callfire.Fire() at the end of the program. This will expose the full contents ofthe program to the command line.

import fire

def hello(name):
  return 'Hello {name}!'.format(name=name)

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

Here's how we can run our program from the command line:

$ python example.py hello World
Hello World!

Let's modify our program slightly to only expose the hello function to thecommand line.

import fire

def hello(name):
  return 'Hello {name}!'.format(name=name)

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

Here's how we can run this from the command line:

$ python example.py World
Hello World!

Notice we no longer have to specify to run the hello function, because wecalled fire.Fire(hello).

We can alternatively write this program like this:

import fire

def hello(name):
  return 'Hello {name}!'.format(name=name)

def main():
  fire.Fire(hello)

if __name__ == '__main__':
  main()

The simplest way to expose multiple commands is to write multiple functions, andthen call Fire.

import fire

def add(x, y):
  return x + y

def multiply(x, y):
  return x * y

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

We can use this like so:

$ python example.py add 10 20
30
$ python example.py multiply 10 20
200

Fire also works on objects, as in this variant. This is a good way to exposemultiple commands.

import fire

class Calculator(object):

  def add(self, x, y):
    return x + y

  def multiply(self, x, y):
    return x * y

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

We can use this in the same way as before:

$ python example.py add 10 20
30
$ python example.py multiply 10 20
200

Fire also works on classes. This is another good way to expose multiplecommands.

import fire

class Calculator(object):

  def add(self, x, y):
    return x + y

  def multiply(self, x, y):
    return x * y

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

We can use this in the same way as before:

$ python example.py add 10 20
30
$ python example.py multiply 10 20
200

Why might you prefer a class over an object? One reason is that you can passarguments for constructing the class too, as in this broken calculator example.

import fire

class BrokenCalculator(object):

  def __init__(self, offset=1):
      self._offset = offset

  def add(self, x, y):
    return x + y + self._offset

  def multiply(self, x, y):
    return x * y + self._offset

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

When you use a broken calculator, you get wrong answers:

$ python example.py add 10 20
31
$ python example.py multiply 10 20
201

But you can always fix it:

$ python example.py add 10 20 --offset=0
30
$ python example.py multiply 10 20 --offset=0
200

In the examples we've looked at so far, our invocations of python example.pyhave all run some function from the example program. In this example, we simplyaccess a property.

from airports import airports

import fire

class Airport(object):

  def __init__(self, code):
    self.code = code
    self.name = dict(airports).get(self.code)
    self.city = self.name.split(',')[0] if self.name else None

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

Now we can use this program to learn about airport codes!

$ python example.py --code=JFK code
JFK
$ python example.py --code=SJC name
San Jose-Sunnyvale-Santa Clara, CA - Norman Y. Mineta San Jose International (SJC)
$ python example.py --code=ALB city
Albany-Schenectady-Troy

Yes, this program is even simpler than our original Hello World example.

import fire
english = 'Hello World'
spanish = 'Hola Mundo'
fire.Fire()

You can use it like this:

$ python example.py english
Hello World
$ python example.py spanish
Hola Mundo

Arguments to a constructor are passed by name using flag syntax --name=value.

For example, consider this simple class:

import fire

class Building(object):

  def __init__(self, name, stories=1):
    self.name = name
    self.stories = 1

  def climb_stairs(self, stairs_per_story=10):
    for story in range(self.stories):
      for stair in range(1, stairs_per_story):
        yield stair
        yield 'Phew!'
    yield 'Done!'

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

We can instantiate it as follows: python example.py --name="Sherrerd Hall"

Arguments to other functions may be passed positionally or by name using flagsyntax.

To instantiate a Building and then run the climb_stairs function, thefollowing commands are all valid:

$ python example.py --name="Sherrerd Hall" --stories=3 climb_stairs 10
$ python example.py --name="Sherrerd Hall" climb_stairs --stairs_per_story=10
$ python example.py --name="Sherrerd Hall" climb_stairs --stairs-per-story 10
$ python example.py climb-stairs --stairs-per-story 10 --name="Sherrerd Hall"

You'll notice that hyphens and underscores (- and _) are interchangeable inmember names and flag names.

You'll also notice that the constructor's arguments can come after thefunction's arguments or before the function.

You'll also notice that the equal sign between the flag name and its value isoptional.

Fire supports functions that take *varargs or **kwargs. Here's an example:

import fire

def order_by_length(*items):
  """Orders items by length, breaking ties alphabetically."""
  sorted_items = sorted(items, key=lambda item: (len(str(item)), str(item)))
  return ' '.join(sorted_items)

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

To use it, we run:

$ python example.py dog cat elephant
cat dog elephant

You can use a separator to indicate that you're done providing arguments to afunction. All arguments after the separator will be used to process the resultof the function, rather than being passed to the function itself. The defaultseparator is the hyphen -.

Here's an example where we use a separator.

$ python example.py dog cat elephant - upper
CAT DOG ELEPHANT

Without the separator, upper would have been treated as another argument.

$ python example.py dog cat elephant upper
cat dog upper elephant

You can change the separator with the --separator flag. Flags are alwaysseparated from your Fire command by an isolated --. Here's an example where wechange the separator.

$ python example.py dog cat elephant X upper -- --separator=X
CAT DOG ELEPHANT

Separators can be useful when a function accepts *varargs, **kwargs, ordefault values that you don't want to specify. It is also important to rememberto change the separator if you want to pass - as an argument.

The types of the arguments are determined by their values, rather than by thefunction signature where they're used. You can pass any Python literal from thecommand line: numbers, strings, tuples, lists, dictionaries, (sets are onlysupported in some versions of Python). You can also nest the collectionsarbitrarily as long as they only contain literals.

To demonstrate this, we'll make a small example program that tells us the typeof any argument we give it:

import fire
fire.Fire(lambda obj: type(obj).__name__)

And we'll use it like so:

$ python example.py 10
int
$ python example.py 10.0
float
$ python example.py hello
str
$ python example.py '(1,2)'
tuple
$ python example.py [1,2]
list
$ python example.py True
bool
$ python example.py {name: David}
dict

You'll notice in that last example that bare-words are automatically replacedwith strings.

Be careful with your quotes! If you want to pass the string "10", rather thanthe int 10, you'll need to either escape or quote your quotes. Otherwise Bashwill eat your quotes and pass an unquoted 10 to your Python program, whereFire will interpret it as a number.

$ python example.py 10
int
$ python example.py "10"
int
$ python example.py '"10"'
str
$ python example.py "'10'"
str
$ python example.py \"10\"
str

Be careful with your quotes! Remember that Bash processes your arguments first,and then Fire parses the result of that.If you wanted to pass the dict {"name": "David Bieber"} to your program, youmight try this:

$ python example.py '{"name": "David Bieber"}'  # Good! Do this.
dict
$ python example.py {"name":'"David Bieber"'}  # Okay.
dict
$ python example.py {"name":"David Bieber"}  # Wrong. This is parsed as a string.
str
$ python example.py {"name": "David Bieber"}  # Wrong. This isn't even treated as a single argument.
<error>
$ python example.py '{"name": "Justin Bieber"}'  # Wrong. This is not the Bieber you're looking for. (The syntax is fine though :))
dict

The tokens True and False are parsed as boolean values.

You may also specify booleans via flag syntax --name and --noname, which setname to True and False respectively.

Continuing the previous example, we could run any of the following:

$ python example.py --obj=True
bool
$ python example.py --obj=False
bool
$ python example.py --obj
bool
$ python example.py --noobj
bool

Be careful with boolean flags! If a token other than another flag immediatelyfollows a flag that's supposed to be a boolean, the flag will take on the valueof the token rather than the boolean value. You can resolve this: by putting aseparator after your last flag, by explicitly stating the value of the booleanflag (as in --obj=True), or by making sure there's another flag after anyboolean flag argument.

Fire CLIs all come with a number of flags. These flags should be separated fromthe Fire command by an isolated --. If there is at least one isolated --argument, then arguments after the final isolated -- are treated as flags,whereas all arguments before the final isolated -- are considered part of theFire command.

One useful flag is the --interactive flag. Use the --interactive flag on anyCLI to enter a Python REPL with all the modules and variables used in thecontext where Fire was called already available to you for use. Other usefulvariables, such as the result of the Fire command will also be available. Usethis feature like this: python example.py -- --interactive.

You can add the help flag to any command to see help and usage information. Fireincorporates your docstrings into the help and usage information that itgenerates. Fire will try to provide help even if you omit the isolated --separating the flags from the Fire command, but may not always be able to, sincehelp is a valid argument name. Use this feature like this:python example.py -- --help.

The complete set of flags available is shown below, in the reference section.

Note that flags are separated from the Fire command by an isolated -- arg.

Python Fire is not an official Google product.