Hello community, here is the log from the commit of package python-astroid for openSUSE:Factory checked in at 2016-01-13 22:46:12 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/python-astroid (Old) and /work/SRC/openSUSE:Factory/.python-astroid.new (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "python-astroid" Changes: -------- --- /work/SRC/openSUSE:Factory/python-astroid/python-astroid.changes 2015-03-18 13:05:39.000000000 +0100 +++ /work/SRC/openSUSE:Factory/.python-astroid.new/python-astroid.changes 2016-01-13 22:46:15.000000000 +0100 @@ -1,0 +2,196 @@ +Wed Jan 13 10:03:16 UTC 2016 - [email protected] + +- Update to version 1.4.3 + * pkg_resources brain tips are a bit more specific, + by specifiying proper returns. + * Standard library modules are properly detected by is_standard_module. + This should fix issues such as https://github.com/PyCQA/pylint/issues/725. +- Update to version 1.4.2 + * The slots() method conflates all the slots from the ancestors + into a list of current and parent slots. + We're doing this because this is the right semantics of slots, + they get inherited, as long as each parent defines a __slots__ + entry. + * Revert to using printf-style formatting in as_string, in order + to avoid a potential problem with encodings when using .format. + Closes issue #273. + * assigned_stmts methods have the same signature from now on. + They used to have different signatures and each one made + assumptions about what could be passed to other implementations, + leading to various possible crashes when one or more arguments + weren't given. Closes issue #277. +- update to version 1.4.1: + * Add support for handling Uninferable nodes when calling as_string + + Some object, for instance List or Tuple can have, after inference, + Uninferable as their elements, happening when their components + weren't couldn't be inferred properly. This means that as_string + needs to cope with expecting Uninferable nodes part of the other + nodes coming for a string transformation. The patch adds a visit + method in AsString and "accept" on Yes / Uninferable nodes. + Closes issue #270. +- update to version 1.4.0: + * Class.getattr('__mro__') returns the actual MRO. Closes issue #128. + * The logilab-common dependency is not needed anymore as the needed code + was integrated into astroid. + * Add 'assert_equals' method in nose.tools's brain plugin. + * Generated enum member stubs now support IntEnum and multiple + base classes. + * Add brain tips for multiprocessing.Manager and + multiprocessing.managers.SyncManager. + * Add brain tips for multiprocessing post Python 3.4+, + where the module level functions are retrieved with getattr + from a context object, leading to many no-member errors + in Pylint. + * The Generator objects inferred with `infer_call_result` + from functions have as parent the function from which they + are returned. + * Understand partially the 3-argument form of `type`. + The only change is that astroid understands members + passed in as dictionaries as the third argument. + * Improve the inference of Getattr nodes when dealing with + abstract properties from the abc module. + + In astroid.bases.Instance._wrap_attr we had a detection + code for properties, which basically inferred whatever + a property returned, passing the results up the stack, + to the igetattr() method. It handled only the builtin property + but the new patch also handles a couple of other properties, + such as abc.abstractproperty. + * UnboundMethod.getattr calls the getattr of its _proxied object + and doesn't call super(...) anymore. + + It previously crashed, since the first ancestor in its mro was + bases.Proxy and bases.Proxy doesn't implement the .getattr method. + Closes issue #91. + * Don't hard fail when calling .mro() on a class which has + combined both newstyle and old style classes. The class + in question is actually newstyle (and the __mro__ can be + retrieved using Python). + + .mro() fallbacks to using .ancestors() in that case. + * Class.local_attr and Class.local_attr_ancestors uses internally + a mro lookup, using .mro() method, if they can. + + That means for newstyle classes, when trying to lookup a member + using one of these functions, the first one according to the + mro will be returned. This reflects nicely the reality, + but it can have as a drawback the fact that it is a behaviour + change (the previous behaviour was incorrect though). Also, + having bases which can return multiple values when inferred + will not work with the new approach, because .mro() only + retrieves the first value inferred from a base. + * Expose a implicit_metaclass() method in Class. This will return + a builtins.type instance for newstyle classes. + * Add two new exceptions for handling MRO error cases. DuplicateBasesError + is emitted when duplicate bases are found in a class, + InconsistentMroError is raised when the method resolution is determined + to be inconsistent. They share a common class, MroError, which + is a subclass of ResolveError, meaning that this change is backwards + compatible. + * Classes aren't marked as interfaces anymore, in the `type` attribute. + * Class.has_dynamic_getattr doesn't return True for special methods + which aren't implemented in pure Python, as it is the case for extension modules. + + Since most likely the methods were coming from a live object, this implies + that all of them will have __getattr__ and __getattribute__ present and it + is wrong to consider that those methods were actually implemented. + * Add `igetattr` method to scoped_nodes.Function. + * Add support for Python 3.5's MatMul operation: see PEP 465 for more + details. + * NotImplemented is detected properly now as being part of the + builtins module. Previously trying to infer the Name(NotImplemented) + returned an YES object. + * Add proper grammatical names for `infered` and `ass_type` methods, + namely `inferred` and `assign_type`. + + The old methods will raise PendingDeprecationWarning, being slated + for removal in astroid 2.0. + * Add new AST names in order to be similar to the ones + from the builtin ast module. + + With this change, Getattr becomes Attributes, Backquote becomes + Repr, Class is ClassDef, Function is FunctionDef, Discard is Expr, + CallFunc is Call, From is ImportFrom, AssName is AssignName + and AssAttr is AssignAttr. The old names are maintained for backwards + compatibility and they are interchangeable, in the sense that using + Discard will use Expr under the hood and the implemented visit_discard + in checkers will be called with Expr nodes instead. The AST does not + contain the old nodes, only the interoperability between them hides this + fact. Recommandations to move to the new nodes are emitted accordingly, + the old names will be removed in astroid 2.0. + * Star unpacking in assignments returns properly a list, + not the individual components. Closes issue #138. + * Lambdas found at class level, which have a `self` argument, are considered + * Add annotation support for function.as_string(). Closes issue #37. + * Add support for indexing bytes on Python 3. + BoundMethods when accessing them from instances of their class. + * Add support for inferring subscript on instances, which will + use __getitem__. Closes issue #124. + * Understand metaclasses added with six.add_metaclass decorator. Closes issue #129. + * Add a new convenience API, `astroid.parse`, which can be used to retrieve + an astroid AST from a source code string, similar to how ast.parse can be + used to obtain a Python AST from a source string. This is the test_utils.build_module + promoted to a public API. + * do_import_module passes the proper relative_only flag if the level is higher + than 1. This has the side effect that using `from .something import something` + in a non-package will finally result in an import-error on Pylint's side. + Until now relative_only was ignored, leading to the import of `something`, + if it was globally available. + * There's a new separate step for transforms. + + Until now, the transforms were applied at the same time the tree was + being built. This was problematic if the transform functions were + using inference, since the inference was executed on a partially + constructed tree, which led to failures when post-building + information was needed (such as setting the _from_names + for the From imports). + Now there's a separate step for transforms, which are applied + using transform.TransformVisitor. + There's a couple of other related changes: + + astroid.parse and AstroidBuilder gained a new parameter + `apply_transforms`, which is a boolean flag, which will + control if the transforms are applied. We do this because + there are uses when the vanilla tree is wanted, without + any implicit modification. + + the transforms are also applied for builtin modules, + as a side effect of the fact that transform visiting + was moved in AstroidBuilder._post_build from + AstroidBuilder._data_build. + Closes issue #116. + * Add a new node, DictUnpack, which is used to represent the unpacking + of a dictionary into another dictionary, using PEP 448 specific syntax + ({1:2, **{2:3}) + + This is a different approach than what the builtin ast module does, + since it just uses None to represent this kind of operation, + which seems conceptually wrong, due to the fact the AST contains + non-AST nodes. Closes issue #206. + * Add a new type of node, called *inference objects*. Inference objects are similar with + AST nodes, but they can be obtained only after inference, so they can't be found + inside the AST tree. Their purpose is to handle at astroid level + some operations which can't be handled when using brain transforms. + For instance, the first object added is FrozenSet, which can be manipulated + at astroid's level (inferred, itered etc). Code such as this 'frozenset((1,2))' + will not return an Instance of frozenset, without having access to its + content, but a new objects.FrozenSet, which can be used just as a nodes.Set. + * Add a new *inference object* called Super, which also adds support for understanding + super calls. astroid understands the zero-argument form of super, specific to + Python 3, where the interpreter fills itself the arguments of the call. Also, we + are understanding the 2-argument form of super, both for bounded lookups + (super(X, instance)) as well as for unbounded lookups (super(X, Y)), + having as well support for validating that the object-or-type is a subtype + of the first argument. The unbounded form of super (one argument) is not + understood, since it's useless in practice and should be removed from + Python's specification. Closes issue #89. + * astroid.utils.ASTWalker and astroid.utils.LocalsVisitor + were moved to pylint.pyreverse.utils. +- update to version 1.3.8: + * Backport of 40e3176, which fixes issue #84. +- update to version 1.3.7: + * Improve the inference of six.moves, especially when using `from + ... import ...` syntax. Also, we added a new fail import hook for + six.moves, which fixes the import-error false positive from + pylint. Closes issue #107. + +------------------------------------------------------------------- Old: ---- astroid-1.3.6.tar.gz New: ---- astroid-1.4.3.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ python-astroid.spec ++++++ --- /var/tmp/diff_new_pack.yg4d9T/_old 2016-01-13 22:46:16.000000000 +0100 +++ /var/tmp/diff_new_pack.yg4d9T/_new 2016-01-13 22:46:16.000000000 +0100 @@ -1,7 +1,7 @@ # # spec file for package python-astroid # -# Copyright (c) 2015 SUSE LINUX GmbH, Nuernberg, Germany. +# Copyright (c) 2016 SUSE LINUX GmbH, Nuernberg, Germany. # # All modifications and additions to the file contributed by third parties # remain the property of their copyright owners, unless otherwise agreed @@ -17,28 +17,23 @@ Name: python-astroid -Version: 1.3.6 +Version: 1.4.3 Release: 0 -Url: http://bitbucket.org/logilab/astroid +Url: https://github.com/pycqa/astroid Summary: Rebuild a new abstract syntax tree from Python's ast License: LGPL-2.1+ Group: Development/Libraries/Python Source: https://pypi.python.org/packages/source/a/astroid/astroid-%{version}.tar.gz BuildRoot: %{_tmppath}/%{name}-%{version}-build BuildRequires: python-devel -BuildRequires: python-logilab-common BuildRequires: python-setuptools BuildRequires: python-six -BuildRequires: unzip -Requires: python-logilab-common Requires: python-six -%if 0%{?suse_version} -%py_requires -%if 0%{?suse_version} > 1110 +%if 0%{?suse_version} <= 1110 +%{!?python_sitelib: %global python_sitelib %(%{__python} -c "from distutils.sysconfig import get_python_lib; print get_python_lib()")} +%else BuildArch: noarch %endif -%endif -%{!?python_sitelib: %global python_sitelib %(%{__python} -c "from distutils.sysconfig import get_python_lib; print get_python_lib()")} %description The aim of this module is to provide a common base representation of @@ -66,7 +61,7 @@ %files %defattr(-,root,root,-) -%doc COPYING COPYING.LESSER ChangeLog README +%doc COPYING COPYING.LESSER ChangeLog README.rst %{python_sitelib}/astroid/ %{python_sitelib}/astroid-%{version}-py*.egg-info ++++++ astroid-1.3.6.tar.gz -> astroid-1.4.3.tar.gz ++++++ ++++ 18979 lines of diff (skipped)
