Prev: Converting a pickle to python3
Next: signed vs unsigned int
From: Michele Simionato on 2 Jun 2010 00:37
I would like to announce to the world the first public release of
plac:

http://pypi.python.org/pypi/plac

Plac is a wrapper over argparse and works in all versions of
Python starting from Python 2.3 up to Python 3.1.

With blatant immodesty, plac claims to be the easiest to use command
line arguments parser module in the Python world. Its goal is to
reduce the
learning curve of argparse from hours to minutes. It does so by
removing the need to build a command line arguments parser by hand:
actually it is smart enough to infer the parser from function
annotations.

Here is a simple example (in Python 3) to wet your appetite:

$ cat example.py
def main(arg: "required argument"):
"do something with arg"
print('Got %s' % arg)

if __name__ == '__main__':
import plac; plac.call(main) # passes sys.argv[1:] to main

$ python example.py -h
usage: example.py [-h] arg

do something with arg

positional arguments:
arg required argument

optional arguments:
-h, --help show this help message and exit


$ python example.py
usage: example.py [-h] arg
example.py: error: too few arguments

$ python example.py arg
Got arg

$ python example.py arg1 arg2
usage: example.py [-h] arg
example.py: error: unrecognized arguments: arg2

You can find in the documentation a lot of other simple and not so
simple
examples:

http://micheles.googlecode.com/hg/plac/doc/plac.html


Enjoy!

Michele Simionato

P.S. answering an unspoken question: yes, we really needed yet
another
command line arguments parser! ;)
From: Tim Golden on 2 Jun 2010 04:28
On 02/06/2010 05:37, Michele Simionato wrote:
> I would like to announce to the world the first public release of
> plac:
>
> http://pypi.python.org/pypi/plac
>
> Plac is a wrapper over argparse and works in all versions of
> Python starting from Python 2.3 up to Python 3.1.

I like it. I'm a constant user of the

def main (a, b=1, c=2):
# ...

if __name__ == '__main__':
main (*sys.argv[1:])

pattern, which provides a minimally semi-self-documenting
approach for positional args, but I've always found the existing
offerings just a little too much work to bother with.
I'll give plac a run and see how it behaves.

Thanks

TJG
From: Paul Rubin on 2 Jun 2010 04:43
Tim Golden <mail(a)timgolden.me.uk> writes:
> pattern, which provides a minimally semi-self-documenting
> approach for positional args, but I've always found the existing
> offerings just a little too much work to bother with.
> I'll give plac a run and see how it behaves.

After using optparse a couple of times I got the hang of it. Maybe its
docs could be organized a bit better, but it does the obvious things
conveniently once you've figured it out a bit.
From: Michele Simionato on 2 Jun 2010 04:49
On Jun 2, 10:43 am, Paul Rubin <no.em...(a)nospam.invalid> wrote:
> Tim Golden <m...(a)timgolden.me.uk> writes:
> > pattern, which provides a minimally semi-self-documenting
> > approach for positional args, but I've always found the existing
> > offerings just a little too much work to bother with.
> > I'll give plac a run and see how it behaves.
>
> After using optparse a couple of times I got the hang of it.  Maybe its
> docs could be organized a bit better, but it does the obvious things
> conveniently once you've figured it out a bit.

Notice that optparse is basically useless in the use case Tim is
considering (positional arguments) since it only manages options.
From: Jean-Michel Pichavant on 2 Jun 2010 04:52
Michele Simionato wrote:
> I would like to announce to the world the first public release of
> plac:
>
> http://pypi.python.org/pypi/plac
>
> Plac is a wrapper over argparse and works in all versions of
> Python starting from Python 2.3 up to Python 3.1.
>
> With blatant immodesty, plac claims to be the easiest to use command
> line arguments parser module in the Python world. Its goal is to
> reduce the
> learning curve of argparse from hours to minutes. It does so by
> removing the need to build a command line arguments parser by hand:
> actually it is smart enough to infer the parser from function
> annotations.
>
> Here is a simple example (in Python 3) to wet your appetite:
>
> $ cat example.py
> def main(arg: "required argument"):
> "do something with arg"
> print('Got %s' % arg)
>
> if __name__ == '__main__':
> import plac; plac.call(main) # passes sys.argv[1:] to main
>
> $ python example.py -h
> usage: example.py [-h] arg
>
> do something with arg
>
> positional arguments:
> arg required argument
>
> optional arguments:
> -h, --help show this help message and exit
>
>
> $ python example.py
> usage: example.py [-h] arg
> example.py: error: too few arguments
>
> $ python example.py arg
> Got arg
>
> $ python example.py arg1 arg2
> usage: example.py [-h] arg
> example.py: error: unrecognized arguments: arg2
>
> You can find in the documentation a lot of other simple and not so
> simple
> examples:
>
> http://micheles.googlecode.com/hg/plac/doc/plac.html
>
>
> Enjoy!
>
> Michele Simionato
>
> P.S. answering an unspoken question: yes, we really needed yet
> another
> command line arguments parser! ;)
>
Thanks for participating.

JM
 |  Next  |  Last
Pages: 1 2 3
Prev: Converting a pickle to python3
Next: signed vs unsigned int