Accepting request 353375 from home:TheBlackCat:branches:devel:languages:python

Update to version 1.4.3

OBS-URL: https://build.opensuse.org/request/show/353375
OBS-URL: https://build.opensuse.org/package/show/devel:languages:python/python-astroid?expand=0&rev=18

astroid-1.3.6.tar.gz

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:1241ef961448c57b4616beb8dcc959724641dca1e22914663f79d67fec26f854
-size 153863

astroid-1.4.3.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8e9ce4e925a17442cec085a7fce05478b99e482c13819c619b7cdd793777bf6b
+size 181329

python-astroid.changes

@@ -1,3 +1,199 @@
+-------------------------------------------------------------------
+Wed Jan 13 10:03:16 UTC 2016 - toddrme2178@gmail.com
+
+- 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.
+    
 -------------------------------------------------------------------
 Mon Mar 16 12:20:32 UTC 2015 - mcihar@suse.cz
 

python-astroid.spec

@@ -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}
+%if 0%{?suse_version} <= 1110
-%py_requires
+%{!?python_sitelib: %global python_sitelib %(%{__python} -c "from distutils.sysconfig import get_python_lib; print get_python_lib()")}
-%if 0%{?suse_version} > 1110
+%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 @@ python setup.py install --prefix=%{_prefix} --root="%{buildroot}"
 
 %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