Hello community, here is the log from the commit of package python3-astroid for openSUSE:Factory checked in at 2015-12-03 13:32:18 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/python3-astroid (Old) and /work/SRC/openSUSE:Factory/.python3-astroid.new (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Package is "python3-astroid" Changes: -------- --- /work/SRC/openSUSE:Factory/python3-astroid/python3-astroid.changes 2015-11-02 12:55:51.000000000 +0100 +++ /work/SRC/openSUSE:Factory/.python3-astroid.new/python3-astroid.changes 2015-12-03 13:32:19.000000000 +0100 @@ -1,0 +2,177 @@ +Tue Dec 1 00:04:31 UTC 2015 - arun@gmx.de + +- 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. + +------------------------------------------------------------------- +Sun Nov 29 20:18:09 UTC 2015 - arun@gmx.de + +- specfile: + * removed logilab-common dependency + +- 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. + +------------------------------------------------------------------- Old: ---- astroid-1.3.8.tar.gz New: ---- astroid-1.4.1.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ python3-astroid.spec ++++++ --- /var/tmp/diff_new_pack.UwC2Sd/_old 2015-12-03 13:32:20.000000000 +0100 +++ /var/tmp/diff_new_pack.UwC2Sd/_new 2015-12-03 13:32:20.000000000 +0100 @@ -17,7 +17,7 @@ Name: python3-astroid -Version: 1.3.8 +Version: 1.4.1 Release: 0 Url: http://bitbucket.org/logilab/astroid Summary: Rebuild a new abstract syntax tree from Python's ast @@ -27,9 +27,7 @@ BuildRoot: %{_tmppath}/%{name}-%{version}-build BuildRequires: python3-2to3 BuildRequires: python3-devel -BuildRequires: python3-logilab-common BuildRequires: python3-setuptools -Requires: python3-logilab-common BuildArch: noarch %description ++++++ astroid-1.3.8.tar.gz -> astroid-1.4.1.tar.gz ++++++ ++++ 18506 lines of diff (skipped)