Rutherfurd.net

#!/usr/bin/env python
import sys

class Command(object):
    """Base class for commands.
    """
    # optional command-specific args
    args = []
    def execute(self, args):
        raise NotImplementedError()

def arg(*args, **kw):
    # sugar for arg declaration
    return (args, kw)

def commands():
    """Return list of Command sub classes from current module.
    """
    mod = sys.modules[__name__]
    classes = []
    for attr in [getattr(mod, name) for name in dir(mod)]:
        if Command in getattr(attr, '__bases__', []):
            classes.append(attr)
    return classes

def register_commands(arg_parser):
    """Register all subclasses of Command.
    """
    cmd_parsers = arg_parser.add_subparsers()
    for cmd in commands():
        # use first line of docstring as help
        help = (cmd.__doc__ or 'no help').strip().splitlines()[0]
        cmd_parser = cmd_parsers.add_parser(cmd.__name__, help=help)
        # add optional command-specific arguments
        for (args, kw) in cmd.args:
            cmd_parser.add_argument(*args, **kw)
        # This is really, really important!
        # Without it we won't know which command to execute.
        cmd_parser.set_defaults(command_class=cmd)

class Date(Command):
    """show current date
    """
    args = [
        arg('format', default=['%Y-%m-%d'], nargs='*',
            help='strftime-compatiable format'),
    ]
    def execute(self, args):
        import datetime
        print datetime.date.today().strftime(' '.join(args.format))


class Echo(Command):
    """echo input to stdout
    """
    args = [
        arg('-n', dest='newline', default=True,
            action='store_false',
            help='do not output the trailing newline'),
        arg('strings', metavar='string', nargs='*'),
    ]
    def execute(self, args):
        sys.stdout.write(' '.join(args.strings))
        if args.newline:
            sys.stdout.write('\n')

if __name__ == '__main__':
    import argparse
    arg_parser = argparse.ArgumentParser()
    # really just to demonstrate a global option
    arg_parser.add_argument('-v', '--verbose',
        action='store_true', help='example global option')
    # register commands
    register_commands(arg_parser)
    # parse args including which command to run
    args = arg_parser.parse_args(sys.argv[1:])
    # create instance of command
    command = args.command_class()
    if args.verbose:
        print 'running', command
    # run it
    command.execute(args)

orutherfurd@laptop:~/tmp$ ./argparse_commands.py --help
usage: argparse_commands.py [-h] {Date,Echo} ...

positional arguments:
  {Date,Echo}
    Date       show current date
    Echo       echo input to stdout

optional arguments:
  -h, --help     show this help message and exit
  -v, --verbose  example global option

orutherfurd@laptop:~/tmp$ ./argparse_commands.py Echo --help
usage: argparse_commands.py Echo [-h] [-n] [string [string ...]]

positional arguments:
  string

optional arguments:
  -h, --help  show this help message and exit
  -n          do not output the trailing newline

orutherfurd@laptop:~/tmp$ ./argparse_commands.py Date
2010-04-29

orutherfurd@laptop:~/tmp$ ./argparse_commands.py Date %b %d, %Y
Apr 29, 2010

# standard
urlpatterns += patterns('django.views.generic.date_based',
    url(r'^(?P<year>\d{4})/(?P<month>[a-z]{3})/(?P<day>\w{1,2})/(?P<slug>[-\w]+)/$',
        'object_detail', info_dict),
    url(r'^(?P<year>\d{4})/(?P<month>[a-z]{3})/(?P<day>\d{1,2})/$',
        'archive_day',   info_dict),
    url(r'^(?P<year>\d{4})/(?P<month>[a-z]{3})/$', 'archive_month', info_dict),
    url(r'^(?P<year>\d{4})/$', 'archive_year',  info_dict),
)

# use easyurls, and let it generate the regex for you
from easyurls import regex as p
urlpatterns += patterns('django.views.generic.date_based',
    url(p('<year>/<month:mon>/<day>/<slug>'), 'object_detail', info_dict),
    url(p('<year>/<month:mon>/<day>'),        'archive_day',   info_dict),
    url(p('<year>/<month:mon>'),              'archive_month', info_dict),
    url(p('<year>'),                          'archive_year',  info_dict),
)

>>> from easyurls import regex as p
>>> for name in sorted(p.patterns):
...     print '%5s: %s' % (name,p.patterns[name])
  day: \d{1,2}
   id: \d+
  mon: [a-z]{3}
month: \d{1,2}
    n: \d+
 slug: [\w-]+
  tag: \w+
 year: \d{4}

# default for month is \d{1,2}
>>> print p('<month>')
^(?P<month>\d{1,2})/$

# using [a-z]{3} for month
>>> print p('<month:mon>')
^(?P<month>[a-z]{3})/$

# using [a-z]{3} for mmm
>>> print p('<mmm:mon>')
^(?P<mmm>[a-z]{3})/$

>>> p['yy'] = r'\d{2}'
>>> p['mm'] = r'\d{2}'
>>> p['dd'] = r'\d{2}'

>>> print p('<year:yy>/<month:mm>/<day:dd>')
^(?P<year>\d{2})/(?P<month>\d{2})/(?P<day>\d{2})/$

>>> print p('releases/<project_id>')
^releases/(?P<project_id>\d+)/$

# regex for unknown "zip_code"
>>> print p('zip/<zip_code:\d{5}>')
^zip/(?P<zip_code>\d{5})/$

# override slug, allowing "."
>>> print p('<slug:[\w-.]+>')
^(?P<slug>[\w-.]+)/$

>>> print p('')
^$
>>> print p('foo$')
^foo$
>>> print p('foo/')
^foo/$
>>> print p('/')
^/$

>>> p('foo', anchor=False, terminate=False, append_slash=False)
'foo'