Hello community, here is the log from the commit of package python-argh for openSUSE:Factory checked in at 2012-06-10 20:18:56 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/python-argh (Old) and /work/SRC/openSUSE:Factory/.python-argh.new (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "python-argh", Maintainer is "" Changes: -------- --- /work/SRC/openSUSE:Factory/python-argh/python-argh.changes 2012-02-01 09:59:36.000000000 +0100 +++ /work/SRC/openSUSE:Factory/.python-argh.new/python-argh.changes 2012-06-10 21:52:12.000000000 +0200 @@ -1,0 +2,5 @@ +Wed Jun 6 23:41:39 UTC 2012 - [email protected] + +- Update to 0.15.1 + +------------------------------------------------------------------- Old: ---- argh-0.14.2.tar.gz New: ---- argh-0.15.1.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ python-argh.spec ++++++ --- /var/tmp/diff_new_pack.QwBcDG/_old 2012-06-10 21:52:14.000000000 +0200 +++ /var/tmp/diff_new_pack.QwBcDG/_new 2012-06-10 21:52:14.000000000 +0200 @@ -11,12 +11,13 @@ # case the license is the MIT License). An "Open Source License" is a # license that conforms to the Open Source Definition (Version 1.9) # published by the Open Source Initiative. -# + # Please submit bugfixes or comments via http://bugs.opensuse.org/ # + Name: python-argh -Version: 0.14.2 +Version: 0.15.1 Release: 0 Url: http://bitbucket.org/neithere/argh/ Summary: A simple argparse wrapper @@ -24,8 +25,8 @@ Group: Development/Languages/Python Source: http://pypi.python.org/packages/source/a/argh/argh-%{version}.tar.gz BuildRoot: %{_tmppath}/%{name}-%{version}-build -BuildRequires: python-devel BuildRequires: python-argparse >= 1.1 +BuildRequires: python-devel BuildRequires: python-distribute Requires: python-argparse >= 1.1 %if 0%{?suse_version} && 0%{?suse_version} <= 1110 ++++++ argh-0.14.2.tar.gz -> argh-0.15.1.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/argh-0.14.2/PKG-INFO new/argh-0.15.1/PKG-INFO --- old/argh-0.14.2/PKG-INFO 2011-09-19 20:20:48.000000000 +0200 +++ new/argh-0.15.1/PKG-INFO 2012-03-10 16:33:20.000000000 +0100 @@ -1,6 +1,6 @@ Metadata-Version: 1.1 Name: argh -Version: 0.14.2 +Version: 0.15.1 Summary: A simple argparse wrapper. Home-page: http://bitbucket.org/neithere/argh/ Author: Andrey Mikhaylenko @@ -22,7 +22,7 @@ * mark a function as a CLI command and specify its arguments before the parser is instantiated; - * nesed commands made easy: no messing with subparsers (though they are of + * nested commands made easy: no messing with subparsers (though they are of course used under the hood); * infer agrument type from the default value; * infer command name from function name; @@ -47,7 +47,7 @@ @command def echo(text='hello'): print text - + parser = ArghParser() parser.add_commands([echo]) @@ -62,6 +62,11 @@ The approaches can be safely combined. + Dependencies + ------------ + + `Argh` runs on Python 2.x (since 2.6, incl. PyPy) and 3.x. See documentation. + Documentation ------------- diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/argh-0.14.2/README new/argh-0.15.1/README --- old/argh-0.14.2/README 2011-09-19 20:18:31.000000000 +0200 +++ new/argh-0.15.1/README 2012-02-14 02:24:35.000000000 +0100 @@ -13,7 +13,7 @@ * mark a function as a CLI command and specify its arguments before the parser is instantiated; -* nesed commands made easy: no messing with subparsers (though they are of +* nested commands made easy: no messing with subparsers (though they are of course used under the hood); * infer agrument type from the default value; * infer command name from function name; @@ -38,7 +38,7 @@ @command def echo(text='hello'): print text - + parser = ArghParser() parser.add_commands([echo]) @@ -53,6 +53,11 @@ The approaches can be safely combined. +Dependencies +------------ + +`Argh` runs on Python 2.x (since 2.6, incl. PyPy) and 3.x. See documentation. + Documentation ------------- diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/argh-0.14.2/_version.py new/argh-0.15.1/_version.py --- old/argh-0.14.2/_version.py 2011-09-19 20:19:42.000000000 +0200 +++ new/argh-0.15.1/_version.py 2012-03-10 16:29:53.000000000 +0100 @@ -1 +1 @@ -version = '0.14.2' +version = '0.15.1' diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/argh-0.14.2/argh/__init__.py new/argh-0.15.1/argh/__init__.py --- old/argh-0.14.2/argh/__init__.py 2011-09-19 20:18:31.000000000 +0200 +++ new/argh-0.15.1/argh/__init__.py 2012-02-13 04:24:43.000000000 +0100 @@ -1,6 +1,6 @@ # -*- coding: utf-8 -*- # -# Copyright (c) 2010 Andrey Mikhailenko and contributors +# Copyright (c) 2010—2012 Andrey Mikhailenko and contributors # # This file is part of Argh. # @@ -22,6 +22,6 @@ :members: """ -from exceptions import * -from helpers import * -from decorators import * +from .exceptions import * +from .helpers import * +from .decorators import * diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/argh-0.14.2/argh/completion.py new/argh-0.15.1/argh/completion.py --- old/argh-0.14.2/argh/completion.py 2011-09-19 20:18:31.000000000 +0200 +++ new/argh-0.15.1/argh/completion.py 2012-02-14 01:12:15.000000000 +0100 @@ -1,6 +1,6 @@ # -*- coding: utf-8 -*- # -# Copyright (c) 2010 Andrey Mikhailenko and contributors +# Copyright (c) 2010—2012 Andrey Mikhailenko and contributors # # This file is part of Argh. # @@ -38,7 +38,7 @@ choices = _autocomplete(root_parser, cwords, cword) - print ' '.join(choices) + print(' '.join(choices)) sys.exit(1) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/argh-0.14.2/argh/constants.py new/argh-0.15.1/argh/constants.py --- old/argh-0.14.2/argh/constants.py 2011-09-19 20:18:31.000000000 +0200 +++ new/argh-0.15.1/argh/constants.py 2012-02-14 01:13:14.000000000 +0100 @@ -1,6 +1,6 @@ # -*- coding: utf-8 -*- # -# Copyright (c) 2010 Andrey Mikhailenko and contributors +# Copyright (c) 2010—2012 Andrey Mikhailenko and contributors # # This file is part of Argh. # diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/argh-0.14.2/argh/decorators.py new/argh-0.15.1/argh/decorators.py --- old/argh-0.14.2/argh/decorators.py 2011-09-19 20:19:13.000000000 +0200 +++ new/argh-0.15.1/argh/decorators.py 2012-02-14 01:13:36.000000000 +0100 @@ -1,9 +1,17 @@ # -*- coding: utf-8 -*- +# +# Copyright (c) 2010—2012 Andrey Mikhailenko and contributors +# +# This file is part of Argh. +# +# Argh is free software under terms of the GNU Lesser +# General Public License version 3 (LGPLv3) as published by the Free +# Software Foundation. See the file README for copying conditions. +# """ Command decorators ================== """ -from functools import wraps import inspect from argh.constants import ATTR_ALIAS, ATTR_ARGS, ATTR_NO_NAMESPACE diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/argh-0.14.2/argh/exceptions.py new/argh-0.15.1/argh/exceptions.py --- old/argh-0.14.2/argh/exceptions.py 2011-09-19 20:18:31.000000000 +0200 +++ new/argh-0.15.1/argh/exceptions.py 2012-02-14 01:13:43.000000000 +0100 @@ -1,3 +1,13 @@ +# -*- coding: utf-8 -*- +# +# Copyright (c) 2010—2012 Andrey Mikhailenko and contributors +# +# This file is part of Argh. +# +# Argh is free software under terms of the GNU Lesser +# General Public License version 3 (LGPLv3) as published by the Free +# Software Foundation. See the file README for copying conditions. +# """ Exceptions ========== diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/argh-0.14.2/argh/helpers.py new/argh-0.15.1/argh/helpers.py --- old/argh-0.14.2/argh/helpers.py 2011-09-19 20:18:31.000000000 +0200 +++ new/argh-0.15.1/argh/helpers.py 2012-03-10 16:27:05.000000000 +0100 @@ -1,6 +1,6 @@ # -*- coding: utf-8 -*- # -# Copyright (c) 2010 Andrey Mikhailenko and contributors +# Copyright (c) 2010—2012 Andrey Mikhailenko and contributors # # This file is part of Argh. # @@ -13,12 +13,11 @@ ======= """ import argparse -from functools import wraps import locale -from StringIO import StringIO import sys from types import GeneratorType +from argh.six import b, u, string_types, text_type, BytesIO, PY3 from argh.exceptions import CommandError from argh.utils import get_subparsers from argh.completion import autocomplete @@ -26,6 +25,9 @@ ATTR_ALIAS, ATTR_ARGS, ATTR_NO_NAMESPACE, ATTR_WRAPPED_EXCEPTIONS ) +if PY3: + def raw_input(text): + return input(text.decode()) __all__ = [ 'ArghParser', 'add_commands', 'autocomplete', 'dispatch', 'confirm', @@ -96,7 +98,7 @@ if namespace: # make a namespace placeholder and register the commands within it - assert isinstance(namespace, str) + assert isinstance(namespace, string_types) subsubparser = subparsers.add_parser(namespace, help=title) subparsers = subsubparser.add_subparsers(title=title, description=description, @@ -192,7 +194,7 @@ if output_file is None: # user wants a string; we create an internal temporary file-like object # and will return its contents as a string - f = StringIO() + f = BytesIO() else: # normally this is stdout; can be any file f = output_file @@ -206,7 +208,7 @@ f.write(output) if not raw_output: # in most cases user wants on message per line - f.write('\n') + f.write(b('\n')) if output_file is None: # user wanted a string; return contents of our temporary file-like obj @@ -218,11 +220,11 @@ is determined from terminal settings or, if none, from system settings. """ # Convert string to Unicode - if not isinstance(line, unicode): + if not isinstance(line, text_type): try: - line = unicode(line) + line = text_type(line) except UnicodeDecodeError: - line = str(line).decode('utf-8') + line = b(line).decode('utf-8') # Choose output encoding if not encoding: @@ -251,7 +253,12 @@ # filter the namespace variables so that only those expected by the # actual function will pass f = args.function - expected_args = f.func_code.co_varnames[:f.func_code.co_argcount] + if hasattr(f, 'func_code'): + # Python 2 + expected_args = f.func_code.co_varnames[:f.func_code.co_argcount] + else: + # Python 3 + expected_args = f.__code__.co_varnames[:f.__code__.co_argcount] ok_args = [x for x in args._get_args() if x in expected_args] ok_kwargs = dict((k,v) for k,v in args._get_kwargs() if k in expected_args) @@ -276,8 +283,8 @@ result = _call() for line in result: yield line - except tuple(wrappable_exceptions), e: - yield str(e) + except tuple(wrappable_exceptions) as e: + yield text_type(e) class ArghParser(argparse.ArgumentParser): @@ -345,7 +352,7 @@ False: ('y','N'), } y, n = defaults[default] - prompt = (u'%(action)s? (%(y)s/%(n)s)' % locals()).encode('utf-8') + prompt = u('{action}? ({y}/{n})').format(**locals()).encode('utf-8') choice = None try: if default is None: diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/argh-0.14.2/argh/six.py new/argh-0.15.1/argh/six.py --- old/argh-0.14.2/argh/six.py 1970-01-01 01:00:00.000000000 +0100 +++ new/argh-0.15.1/argh/six.py 2012-02-13 04:41:26.000000000 +0100 @@ -0,0 +1,382 @@ +# +# Copyright (c) 2010-2011 Benjamin Peterson +# +# Permission is hereby granted, free of charge, to any person obtaining a copy of +# this software and associated documentation files (the "Software"), to deal in +# the Software without restriction, including without limitation the rights to +# use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +# the Software, and to permit persons to whom the Software is furnished to do so, +# subject to the following conditions: + +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. + +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS +# FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +# COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +# IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +# +"""Utilities for writing code that runs on Python 2 and 3""" + +import operator +import sys +import types + +__author__ = "Benjamin Peterson <[email protected]>" +__version__ = "1.1.0" + + +# True if we are running on Python 3. +PY3 = sys.version_info[0] == 3 + +if PY3: + string_types = str, + integer_types = int, + class_types = type, + text_type = str + binary_type = bytes + + MAXSIZE = sys.maxsize +else: + string_types = basestring, + integer_types = (int, long) + class_types = (type, types.ClassType) + text_type = unicode + binary_type = str + + # It's possible to have sizeof(long) != sizeof(Py_ssize_t). + class X(object): + def __len__(self): + return 1 << 31 + try: + len(X()) + except OverflowError: + # 32-bit + MAXSIZE = int((1 << 31) - 1) + else: + # 64-bit + MAXSIZE = int((1 << 63) - 1) + del X + + +def _add_doc(func, doc): + """Add documentation to a function.""" + func.__doc__ = doc + + +def _import_module(name): + """Import module, returning the module after the last dot.""" + __import__(name) + return sys.modules[name] + + +class _LazyDescr(object): + + def __init__(self, name): + self.name = name + + def __get__(self, obj, tp): + result = self._resolve() + setattr(obj, self.name, result) + # This is a bit ugly, but it avoids running this again. + delattr(tp, self.name) + return result + + +class MovedModule(_LazyDescr): + + def __init__(self, name, old, new=None): + super(MovedModule, self).__init__(name) + if PY3: + if new is None: + new = name + self.mod = new + else: + self.mod = old + + def _resolve(self): + return _import_module(self.mod) + + +class MovedAttribute(_LazyDescr): + + def __init__(self, name, old_mod, new_mod, old_attr=None, new_attr=None): + super(MovedAttribute, self).__init__(name) + if PY3: + if new_mod is None: + new_mod = name + self.mod = new_mod + if new_attr is None: + if old_attr is None: + new_attr = name + else: + new_attr = old_attr + self.attr = new_attr + else: + self.mod = old_mod + if old_attr is None: + old_attr = name + self.attr = old_attr + + def _resolve(self): + module = _import_module(self.mod) + return getattr(module, self.attr) + + + +class _MovedItems(types.ModuleType): + """Lazy loading of moved objects""" + + +_moved_attributes = [ + MovedAttribute("cStringIO", "cStringIO", "io", "StringIO"), + MovedAttribute("filter", "itertools", "builtins", "ifilter", "filter"), + MovedAttribute("map", "itertools", "builtins", "imap", "map"), + MovedAttribute("reload_module", "__builtin__", "imp", "reload"), + MovedAttribute("reduce", "__builtin__", "functools"), + MovedAttribute("StringIO", "StringIO", "io"), + MovedAttribute("xrange", "__builtin__", "builtins", "xrange", "range"), + MovedAttribute("zip", "itertools", "builtins", "izip", "zip"), + + MovedModule("builtins", "__builtin__"), + MovedModule("configparser", "ConfigParser"), + MovedModule("copyreg", "copy_reg"), + MovedModule("http_cookiejar", "cookielib", "http.cookiejar"), + MovedModule("http_cookies", "Cookie", "http.cookies"), + MovedModule("html_entities", "htmlentitydefs", "html.entities"), + MovedModule("html_parser", "HTMLParser", "html.parser"), + MovedModule("http_client", "httplib", "http.client"), + MovedModule("BaseHTTPServer", "BaseHTTPServer", "http.server"), + MovedModule("CGIHTTPServer", "CGIHTTPServer", "http.server"), + MovedModule("SimpleHTTPServer", "SimpleHTTPServer", "http.server"), + MovedModule("cPickle", "cPickle", "pickle"), + MovedModule("queue", "Queue"), + MovedModule("reprlib", "repr"), + MovedModule("socketserver", "SocketServer"), + MovedModule("tkinter", "Tkinter"), + MovedModule("tkinter_dialog", "Dialog", "tkinter.dialog"), + MovedModule("tkinter_filedialog", "FileDialog", "tkinter.filedialog"), + MovedModule("tkinter_scrolledtext", "ScrolledText", "tkinter.scrolledtext"), + MovedModule("tkinter_simpledialog", "SimpleDialog", "tkinter.simpledialog"), + MovedModule("tkinter_tix", "Tix", "tkinter.tix"), + MovedModule("tkinter_constants", "Tkconstants", "tkinter.constants"), + MovedModule("tkinter_dnd", "Tkdnd", "tkinter.dnd"), + MovedModule("tkinter_colorchooser", "tkColorChooser", + "tkinter.colorchooser"), + MovedModule("tkinter_commondialog", "tkCommonDialog", + "tkinter.commondialog"), + MovedModule("tkinter_tkfiledialog", "tkFileDialog", "tkinter.filedialog"), + MovedModule("tkinter_font", "tkFont", "tkinter.font"), + MovedModule("tkinter_messagebox", "tkMessageBox", "tkinter.messagebox"), + MovedModule("tkinter_tksimpledialog", "tkSimpleDialog", + "tkinter.simpledialog"), + MovedModule("urllib_robotparser", "robotparser", "urllib.robotparser"), + MovedModule("winreg", "_winreg"), +] +for attr in _moved_attributes: + setattr(_MovedItems, attr.name, attr) +del attr + +moves = sys.modules["six.moves"] = _MovedItems("moves") + + +def add_move(move): + """Add an item to six.moves.""" + setattr(_MovedItems, move.name, move) + + +def remove_move(name): + """Remove item from six.moves.""" + try: + delattr(_MovedItems, name) + except AttributeError: + try: + del moves.__dict__[name] + except KeyError: + raise AttributeError("no such move, %r" % (name,)) + + +if PY3: + _meth_func = "__func__" + _meth_self = "__self__" + + _func_code = "__code__" + _func_defaults = "__defaults__" + + _iterkeys = "keys" + _itervalues = "values" + _iteritems = "items" +else: + _meth_func = "im_func" + _meth_self = "im_self" + + _func_code = "func_code" + _func_defaults = "func_defaults" + + _iterkeys = "iterkeys" + _itervalues = "itervalues" + _iteritems = "iteritems" + + +try: + advance_iterator = next +except NameError: + def advance_iterator(it): + return it.next() +next = advance_iterator + + +if PY3: + def get_unbound_function(unbound): + return unbound + + Iterator = object + + def callable(obj): + return any("__call__" in klass.__dict__ for klass in type(obj).__mro__) +else: + def get_unbound_function(unbound): + return unbound.im_func + + class Iterator(object): + + def next(self): + return type(self).__next__(self) + + callable = callable +_add_doc(get_unbound_function, + """Get the function out of a possibly unbound function""") + + +get_method_function = operator.attrgetter(_meth_func) +get_method_self = operator.attrgetter(_meth_self) +get_function_code = operator.attrgetter(_func_code) +get_function_defaults = operator.attrgetter(_func_defaults) + + +def iterkeys(d): + """Return an iterator over the keys of a dictionary.""" + return getattr(d, _iterkeys)() + +def itervalues(d): + """Return an iterator over the values of a dictionary.""" + return getattr(d, _itervalues)() + +def iteritems(d): + """Return an iterator over the (key, value) pairs of a dictionary.""" + return getattr(d, _iteritems)() + + +if PY3: + def b(s): + return s.encode("latin-1") + def u(s): + return s + if sys.version_info[1] <= 1: + def int2byte(i): + return bytes((i,)) + else: + # This is about 2x faster than the implementation above on 3.2+ + int2byte = operator.methodcaller("to_bytes", 1, "big") + import io + StringIO = io.StringIO + BytesIO = io.BytesIO +else: + def b(s): + return s + def u(s): + return unicode(s, "unicode_escape") + int2byte = chr + import StringIO + StringIO = BytesIO = StringIO.StringIO +_add_doc(b, """Byte literal""") +_add_doc(u, """Text literal""") + + +if PY3: + import builtins + exec_ = getattr(builtins, "exec") + + + def reraise(tp, value, tb=None): + if value.__traceback__ is not tb: + raise value.with_traceback(tb) + raise value + + + print_ = getattr(builtins, "print") + del builtins + +else: + def exec_(code, globs=None, locs=None): + """Execute code in a namespace.""" + if globs is None: + frame = sys._getframe(1) + globs = frame.f_globals + if locs is None: + locs = frame.f_locals + del frame + elif locs is None: + locs = globs + exec("""exec code in globs, locs""") + + + exec_("""def reraise(tp, value, tb=None): + raise tp, value, tb +""") + + + def print_(*args, **kwargs): + """The new-style print function.""" + fp = kwargs.pop("file", sys.stdout) + if fp is None: + return + def write(data): + if not isinstance(data, basestring): + data = str(data) + fp.write(data) + want_unicode = False + sep = kwargs.pop("sep", None) + if sep is not None: + if isinstance(sep, unicode): + want_unicode = True + elif not isinstance(sep, str): + raise TypeError("sep must be None or a string") + end = kwargs.pop("end", None) + if end is not None: + if isinstance(end, unicode): + want_unicode = True + elif not isinstance(end, str): + raise TypeError("end must be None or a string") + if kwargs: + raise TypeError("invalid keyword arguments to print()") + if not want_unicode: + for arg in args: + if isinstance(arg, unicode): + want_unicode = True + break + if want_unicode: + newline = unicode("\n") + space = unicode(" ") + else: + newline = "\n" + space = " " + if sep is None: + sep = space + if end is None: + end = newline + for i, arg in enumerate(args): + if i: + write(sep) + write(arg) + write(end) + +_add_doc(reraise, """Reraise an exception.""") + + +def with_metaclass(meta, base=object): + """Create a base class with a metaclass.""" + return meta("NewBase", (base,), {}) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/argh-0.14.2/argh/utils.py new/argh-0.15.1/argh/utils.py --- old/argh-0.14.2/argh/utils.py 2011-09-19 20:18:31.000000000 +0200 +++ new/argh-0.15.1/argh/utils.py 2012-02-14 01:13:07.000000000 +0100 @@ -1,6 +1,6 @@ # -*- coding: utf-8 -*- # -# Copyright (c) 2010 Andrey Mikhailenko and contributors +# Copyright (c) 2010—2012 Andrey Mikhailenko and contributors # # This file is part of Argh. # diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/argh-0.14.2/argh.egg-info/PKG-INFO new/argh-0.15.1/argh.egg-info/PKG-INFO --- old/argh-0.14.2/argh.egg-info/PKG-INFO 2011-09-19 20:20:47.000000000 +0200 +++ new/argh-0.15.1/argh.egg-info/PKG-INFO 2012-03-10 16:33:20.000000000 +0100 @@ -1,6 +1,6 @@ Metadata-Version: 1.1 Name: argh -Version: 0.14.2 +Version: 0.15.1 Summary: A simple argparse wrapper. Home-page: http://bitbucket.org/neithere/argh/ Author: Andrey Mikhaylenko @@ -22,7 +22,7 @@ * mark a function as a CLI command and specify its arguments before the parser is instantiated; - * nesed commands made easy: no messing with subparsers (though they are of + * nested commands made easy: no messing with subparsers (though they are of course used under the hood); * infer agrument type from the default value; * infer command name from function name; @@ -47,7 +47,7 @@ @command def echo(text='hello'): print text - + parser = ArghParser() parser.add_commands([echo]) @@ -62,6 +62,11 @@ The approaches can be safely combined. + Dependencies + ------------ + + `Argh` runs on Python 2.x (since 2.6, incl. PyPy) and 3.x. See documentation. + Documentation ------------- diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/argh-0.14.2/argh.egg-info/SOURCES.txt new/argh-0.15.1/argh.egg-info/SOURCES.txt --- old/argh-0.14.2/argh.egg-info/SOURCES.txt 2011-09-19 20:20:47.000000000 +0200 +++ new/argh-0.15.1/argh.egg-info/SOURCES.txt 2012-03-10 16:33:20.000000000 +0100 @@ -9,6 +9,7 @@ argh/decorators.py argh/exceptions.py argh/helpers.py +argh/six.py argh/utils.py argh.egg-info/PKG-INFO argh.egg-info/SOURCES.txt -- To unsubscribe, e-mail: [email protected] For additional commands, e-mail: [email protected]
