Attachment 1709077 Details for Bug 1865302 – build.log

build.log

build.log (text/plain), 32.00 KB, created by Fedora Release Engineering on 2020-08-03 20:52:47 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Fedora Release Engineering

Created: 2020-08-03 20:52:47 UTC

Size: 32.00 KB

patch

obsolete

>)
>            _test(node)
>    
>            # case 2: output_dim set explicitly
>            node = klass(*args)
>            node.output_dim = output_dim
>            _test(node)
>        else:
>            if issubclass(klass, PreserveDimNode):
>                # check that constructor allows to set output_dim
>                assert 'output_dim' in getargs(klass.__init__)[0]
>                # check that setting the input dim, then incompatible output dims
>                # raises an appropriate error
>                # case 1: both in the constructor
>>               pytest.raises(InconsistentDimException,
>                              'klass(input_dim=inp.shape[1], output_dim=output_dim, *args)')
>E               TypeError: 'klass(input_dim=inp.shape[1], output_dim=output_dim, *args)' object (type: <class 'str'>) must be callable
>mdp/test/test_nodes_generic.py:264: TypeError
>__________________ test_outputdim_consistency[HistogramNode] ___________________
>klass = <class 'mdp.nodes.HistogramNode'>, init_args = ()
>inp_arg_gen = <function generic_test_factory.<locals>.<lambda> at 0x7fff5a123f70>
>sup_arg_gen = None, execute_arg_gen = None
>    def test_outputdim_consistency(klass, init_args, inp_arg_gen,
>                                   sup_arg_gen, execute_arg_gen):
>        args = call_init_args(init_args)
>        inp = inp_arg_gen()
>        # See https://github.com/mdp-toolkit/mdp-toolkit/pull/47
>        # and https://github.com/mdp-toolkit/mdp-toolkit/issues/62.
>        if klass.__name__ in ABSINPUT_NODES:
>            inp = numx.absolute(inp)
>        # support generators
>        if isinstance(inp, Iter):
>            for x in inp:
>                pass
>            output_dim = x.shape[1] // 2
>        else:
>            output_dim = inp.shape[1] // 2
>        extra = [execute_arg_gen(inp)] if execute_arg_gen else []
>    
>        def _test(node):
>            _train_if_necessary(inp, node, sup_arg_gen)
>            # support generators
>            if isinstance(inp, Iter):
>                for x in inp:
>                    out = node.execute(x)
>            else:
>                out = node.execute(inp, *extra)
>            assert out.shape[1] == output_dim
>            assert node._output_dim == output_dim
>    
>        # check if the node output dimension can be set or must be determined
>        # by the node
>        if (not issubclass(klass, PreserveDimNode) and
>                'output_dim' in getargs(klass.__init__)[0]):
>            # case 1: output dim set in the constructor
>            node = klass(output_dim=output_dim, *args)
>            _test(node)
>    
>            # case 2: output_dim set explicitly
>            node = klass(*args)
>            node.output_dim = output_dim
>            _test(node)
>        else:
>            if issubclass(klass, PreserveDimNode):
>                # check that constructor allows to set output_dim
>                assert 'output_dim' in getargs(klass.__init__)[0]
>                # check that setting the input dim, then incompatible output dims
>                # raises an appropriate error
>                # case 1: both in the constructor
>>               pytest.raises(InconsistentDimException,
>                              'klass(input_dim=inp.shape[1], output_dim=output_dim, *args)')
>E               TypeError: 'klass(input_dim=inp.shape[1], output_dim=output_dim, *args)' object (type: <class 'str'>) must be callable
>mdp/test/test_nodes_generic.py:264: TypeError
>___________________ test_outputdim_consistency[IdentityNode] ___________________
>klass = <class 'mdp.nodes.IdentityNode'>, init_args = ()
>inp_arg_gen = <function generic_test_factory.<locals>.<lambda> at 0x7fff5a1250d0>
>sup_arg_gen = None, execute_arg_gen = None
>    def test_outputdim_consistency(klass, init_args, inp_arg_gen,
>                                   sup_arg_gen, execute_arg_gen):
>        args = call_init_args(init_args)
>        inp = inp_arg_gen()
>        # See https://github.com/mdp-toolkit/mdp-toolkit/pull/47
>        # and https://github.com/mdp-toolkit/mdp-toolkit/issues/62.
>        if klass.__name__ in ABSINPUT_NODES:
>            inp = numx.absolute(inp)
>        # support generators
>        if isinstance(inp, Iter):
>            for x in inp:
>                pass
>            output_dim = x.shape[1] // 2
>        else:
>            output_dim = inp.shape[1] // 2
>        extra = [execute_arg_gen(inp)] if execute_arg_gen else []
>    
>        def _test(node):
>            _train_if_necessary(inp, node, sup_arg_gen)
>            # support generators
>            if isinstance(inp, Iter):
>                for x in inp:
>                    out = node.execute(x)
>            else:
>                out = node.execute(inp, *extra)
>            assert out.shape[1] == output_dim
>            assert node._output_dim == output_dim
>    
>        # check if the node output dimension can be set or must be determined
>        # by the node
>        if (not issubclass(klass, PreserveDimNode) and
>                'output_dim' in getargs(klass.__init__)[0]):
>            # case 1: output dim set in the constructor
>            node = klass(output_dim=output_dim, *args)
>            _test(node)
>    
>            # case 2: output_dim set explicitly
>            node = klass(*args)
>            node.output_dim = output_dim
>            _test(node)
>        else:
>            if issubclass(klass, PreserveDimNode):
>                # check that constructor allows to set output_dim
>                assert 'output_dim' in getargs(klass.__init__)[0]
>                # check that setting the input dim, then incompatible output dims
>                # raises an appropriate error
>                # case 1: both in the constructor
>>               pytest.raises(InconsistentDimException,
>                              'klass(input_dim=inp.shape[1], output_dim=output_dim, *args)')
>E               TypeError: 'klass(input_dim=inp.shape[1], output_dim=output_dim, *args)' object (type: <class 'str'>) must be callable
>mdp/test/test_nodes_generic.py:264: TypeError
>____________________ test_outputdim_consistency[NoiseNode] _____________________
>klass = <class 'mdp.nodes.NoiseNode'>, init_args = ()
>inp_arg_gen = <function generic_test_factory.<locals>.<lambda> at 0x7fff5a125160>
>sup_arg_gen = None, execute_arg_gen = None
>    def test_outputdim_consistency(klass, init_args, inp_arg_gen,
>                                   sup_arg_gen, execute_arg_gen):
>        args = call_init_args(init_args)
>        inp = inp_arg_gen()
>        # See https://github.com/mdp-toolkit/mdp-toolkit/pull/47
>        # and https://github.com/mdp-toolkit/mdp-toolkit/issues/62.
>        if klass.__name__ in ABSINPUT_NODES:
>            inp = numx.absolute(inp)
>        # support generators
>        if isinstance(inp, Iter):
>            for x in inp:
>                pass
>            output_dim = x.shape[1] // 2
>        else:
>            output_dim = inp.shape[1] // 2
>        extra = [execute_arg_gen(inp)] if execute_arg_gen else []
>    
>        def _test(node):
>            _train_if_necessary(inp, node, sup_arg_gen)
>            # support generators
>            if isinstance(inp, Iter):
>                for x in inp:
>                    out = node.execute(x)
>            else:
>                out = node.execute(inp, *extra)
>            assert out.shape[1] == output_dim
>            assert node._output_dim == output_dim
>    
>        # check if the node output dimension can be set or must be determined
>        # by the node
>        if (not issubclass(klass, PreserveDimNode) and
>                'output_dim' in getargs(klass.__init__)[0]):
>            # case 1: output dim set in the constructor
>            node = klass(output_dim=output_dim, *args)
>            _test(node)
>    
>            # case 2: output_dim set explicitly
>            node = klass(*args)
>            node.output_dim = output_dim
>            _test(node)
>        else:
>            if issubclass(klass, PreserveDimNode):
>                # check that constructor allows to set output_dim
>                assert 'output_dim' in getargs(klass.__init__)[0]
>                # check that setting the input dim, then incompatible output dims
>                # raises an appropriate error
>                # case 1: both in the constructor
>>               pytest.raises(InconsistentDimException,
>                              'klass(input_dim=inp.shape[1], output_dim=output_dim, *args)')
>E               TypeError: 'klass(input_dim=inp.shape[1], output_dim=output_dim, *args)' object (type: <class 'str'>) must be callable
>mdp/test/test_nodes_generic.py:264: TypeError
>_________________ test_outputdim_consistency[NormalNoiseNode] __________________
>klass = <class 'mdp.nodes.NormalNoiseNode'>, init_args = ()
>inp_arg_gen = <function generic_test_factory.<locals>.<lambda> at 0x7fff5a1251f0>
>sup_arg_gen = None, execute_arg_gen = None
>    def test_outputdim_consistency(klass, init_args, inp_arg_gen,
>                                   sup_arg_gen, execute_arg_gen):
>        args = call_init_args(init_args)
>        inp = inp_arg_gen()
>        # See https://github.com/mdp-toolkit/mdp-toolkit/pull/47
>        # and https://github.com/mdp-toolkit/mdp-toolkit/issues/62.
>        if klass.__name__ in ABSINPUT_NODES:
>            inp = numx.absolute(inp)
>        # support generators
>        if isinstance(inp, Iter):
>            for x in inp:
>                pass
>            output_dim = x.shape[1] // 2
>        else:
>            output_dim = inp.shape[1] // 2
>        extra = [execute_arg_gen(inp)] if execute_arg_gen else []
>    
>        def _test(node):
>            _train_if_necessary(inp, node, sup_arg_gen)
>            # support generators
>            if isinstance(inp, Iter):
>                for x in inp:
>                    out = node.execute(x)
>            else:
>                out = node.execute(inp, *extra)
>            assert out.shape[1] == output_dim
>            assert node._output_dim == output_dim
>    
>        # check if the node output dimension can be set or must be determined
>        # by the node
>        if (not issubclass(klass, PreserveDimNode) and
>                'output_dim' in getargs(klass.__init__)[0]):
>            # case 1: output dim set in the constructor
>            node = klass(output_dim=output_dim, *args)
>            _test(node)
>    
>            # case 2: output_dim set explicitly
>            node = klass(*args)
>            node.output_dim = output_dim
>            _test(node)
>        else:
>            if issubclass(klass, PreserveDimNode):
>                # check that constructor allows to set output_dim
>                assert 'output_dim' in getargs(klass.__init__)[0]
>                # check that setting the input dim, then incompatible output dims
>                # raises an appropriate error
>                # case 1: both in the constructor
>>               pytest.raises(InconsistentDimException,
>                              'klass(input_dim=inp.shape[1], output_dim=output_dim, *args)')
>E               TypeError: 'klass(input_dim=inp.shape[1], output_dim=output_dim, *args)' object (type: <class 'str'>) must be callable
>mdp/test/test_nodes_generic.py:264: TypeError
>__________________ test_outputdim_consistency[NormalizeNode] ___________________
>klass = <class 'mdp.nodes.NormalizeNode'>, init_args = ()
>inp_arg_gen = <function generic_test_factory.<locals>.<lambda> at 0x7fff5a125280>
>sup_arg_gen = None, execute_arg_gen = None
>    def test_outputdim_consistency(klass, init_args, inp_arg_gen,
>                                   sup_arg_gen, execute_arg_gen):
>        args = call_init_args(init_args)
>        inp = inp_arg_gen()
>        # See https://github.com/mdp-toolkit/mdp-toolkit/pull/47
>        # and https://github.com/mdp-toolkit/mdp-toolkit/issues/62.
>        if klass.__name__ in ABSINPUT_NODES:
>            inp = numx.absolute(inp)
>        # support generators
>        if isinstance(inp, Iter):
>            for x in inp:
>                pass
>            output_dim = x.shape[1] // 2
>        else:
>            output_dim = inp.shape[1] // 2
>        extra = [execute_arg_gen(inp)] if execute_arg_gen else []
>    
>        def _test(node):
>            _train_if_necessary(inp, node, sup_arg_gen)
>            # support generators
>            if isinstance(inp, Iter):
>                for x in inp:
>                    out = node.execute(x)
>            else:
>                out = node.execute(inp, *extra)
>            assert out.shape[1] == output_dim
>            assert node._output_dim == output_dim
>    
>        # check if the node output dimension can be set or must be determined
>        # by the node
>        if (not issubclass(klass, PreserveDimNode) and
>                'output_dim' in getargs(klass.__init__)[0]):
>            # case 1: output dim set in the constructor
>            node = klass(output_dim=output_dim, *args)
>            _test(node)
>    
>            # case 2: output_dim set explicitly
>            node = klass(*args)
>            node.output_dim = output_dim
>            _test(node)
>        else:
>            if issubclass(klass, PreserveDimNode):
>                # check that constructor allows to set output_dim
>                assert 'output_dim' in getargs(klass.__init__)[0]
>                # check that setting the input dim, then incompatible output dims
>                # raises an appropriate error
>                # case 1: both in the constructor
>>               pytest.raises(InconsistentDimException,
>                              'klass(input_dim=inp.shape[1], output_dim=output_dim, *args)')
>E               TypeError: 'klass(input_dim=inp.shape[1], output_dim=output_dim, *args)' object (type: <class 'str'>) must be callable
>mdp/test/test_nodes_generic.py:264: TypeError
>_______________ test_outputdim_consistency[OnlineCenteringNode] ________________
>klass = <class 'mdp.nodes.OnlineCenteringNode'>, init_args = ()
>inp_arg_gen = <function generic_test_factory.<locals>.<lambda> at 0x7fff5a1253a0>
>sup_arg_gen = None, execute_arg_gen = None
>    def test_outputdim_consistency(klass, init_args, inp_arg_gen,
>                                   sup_arg_gen, execute_arg_gen):
>        args = call_init_args(init_args)
>        inp = inp_arg_gen()
>        # See https://github.com/mdp-toolkit/mdp-toolkit/pull/47
>        # and https://github.com/mdp-toolkit/mdp-toolkit/issues/62.
>        if klass.__name__ in ABSINPUT_NODES:
>            inp = numx.absolute(inp)
>        # support generators
>        if isinstance(inp, Iter):
>            for x in inp:
>                pass
>            output_dim = x.shape[1] // 2
>        else:
>            output_dim = inp.shape[1] // 2
>        extra = [execute_arg_gen(inp)] if execute_arg_gen else []
>    
>        def _test(node):
>            _train_if_necessary(inp, node, sup_arg_gen)
>            # support generators
>            if isinstance(inp, Iter):
>                for x in inp:
>                    out = node.execute(x)
>            else:
>                out = node.execute(inp, *extra)
>            assert out.shape[1] == output_dim
>            assert node._output_dim == output_dim
>    
>        # check if the node output dimension can be set or must be determined
>        # by the node
>        if (not issubclass(klass, PreserveDimNode) and
>                'output_dim' in getargs(klass.__init__)[0]):
>            # case 1: output dim set in the constructor
>            node = klass(output_dim=output_dim, *args)
>            _test(node)
>    
>            # case 2: output_dim set explicitly
>            node = klass(*args)
>            node.output_dim = output_dim
>            _test(node)
>        else:
>            if issubclass(klass, PreserveDimNode):
>                # check that constructor allows to set output_dim
>                assert 'output_dim' in getargs(klass.__init__)[0]
>                # check that setting the input dim, then incompatible output dims
>                # raises an appropriate error
>                # case 1: both in the constructor
>>               pytest.raises(InconsistentDimException,
>                              'klass(input_dim=inp.shape[1], output_dim=output_dim, *args)')
>E               TypeError: 'klass(input_dim=inp.shape[1], output_dim=output_dim, *args)' object (type: <class 'str'>) must be callable
>mdp/test/test_nodes_generic.py:264: TypeError
>________________ test_outputdim_consistency[OnlineTimeDiffNode] ________________
>klass = <class 'mdp.nodes.OnlineTimeDiffNode'>, init_args = ()
>inp_arg_gen = <function generic_test_factory.<locals>.<lambda> at 0x7fff5a125430>
>sup_arg_gen = None, execute_arg_gen = None
>    def test_outputdim_consistency(klass, init_args, inp_arg_gen,
>                                   sup_arg_gen, execute_arg_gen):
>        args = call_init_args(init_args)
>        inp = inp_arg_gen()
>        # See https://github.com/mdp-toolkit/mdp-toolkit/pull/47
>        # and https://github.com/mdp-toolkit/mdp-toolkit/issues/62.
>        if klass.__name__ in ABSINPUT_NODES:
>            inp = numx.absolute(inp)
>        # support generators
>        if isinstance(inp, Iter):
>            for x in inp:
>                pass
>            output_dim = x.shape[1] // 2
>        else:
>            output_dim = inp.shape[1] // 2
>        extra = [execute_arg_gen(inp)] if execute_arg_gen else []
>    
>        def _test(node):
>            _train_if_necessary(inp, node, sup_arg_gen)
>            # support generators
>            if isinstance(inp, Iter):
>                for x in inp:
>                    out = node.execute(x)
>            else:
>                out = node.execute(inp, *extra)
>            assert out.shape[1] == output_dim
>            assert node._output_dim == output_dim
>    
>        # check if the node output dimension can be set or must be determined
>        # by the node
>        if (not issubclass(klass, PreserveDimNode) and
>                'output_dim' in getargs(klass.__init__)[0]):
>            # case 1: output dim set in the constructor
>            node = klass(output_dim=output_dim, *args)
>            _test(node)
>    
>            # case 2: output_dim set explicitly
>            node = klass(*args)
>            node.output_dim = output_dim
>            _test(node)
>        else:
>            if issubclass(klass, PreserveDimNode):
>                # check that constructor allows to set output_dim
>                assert 'output_dim' in getargs(klass.__init__)[0]
>                # check that setting the input dim, then incompatible output dims
>                # raises an appropriate error
>                # case 1: both in the constructor
>>               pytest.raises(InconsistentDimException,
>                              'klass(input_dim=inp.shape[1], output_dim=output_dim, *args)')
>E               TypeError: 'klass(input_dim=inp.shape[1], output_dim=output_dim, *args)' object (type: <class 'str'>) must be callable
>mdp/test/test_nodes_generic.py:264: TypeError
>_________________ test_outputdim_consistency[SignumClassifier] _________________
>klass = <class 'mdp.nodes.SignumClassifier'>, init_args = ()
>inp_arg_gen = <function generic_test_factory.<locals>.<lambda> at 0x7fff5a125700>
>sup_arg_gen = None, execute_arg_gen = None
>    def test_outputdim_consistency(klass, init_args, inp_arg_gen,
>                                   sup_arg_gen, execute_arg_gen):
>        args = call_init_args(init_args)
>        inp = inp_arg_gen()
>        # See https://github.com/mdp-toolkit/mdp-toolkit/pull/47
>        # and https://github.com/mdp-toolkit/mdp-toolkit/issues/62.
>        if klass.__name__ in ABSINPUT_NODES:
>            inp = numx.absolute(inp)
>        # support generators
>        if isinstance(inp, Iter):
>            for x in inp:
>                pass
>            output_dim = x.shape[1] // 2
>        else:
>            output_dim = inp.shape[1] // 2
>        extra = [execute_arg_gen(inp)] if execute_arg_gen else []
>    
>        def _test(node):
>            _train_if_necessary(inp, node, sup_arg_gen)
>            # support generators
>            if isinstance(inp, Iter):
>                for x in inp:
>                    out = node.execute(x)
>            else:
>                out = node.execute(inp, *extra)
>            assert out.shape[1] == output_dim
>            assert node._output_dim == output_dim
>    
>        # check if the node output dimension can be set or must be determined
>        # by the node
>        if (not issubclass(klass, PreserveDimNode) and
>                'output_dim' in getargs(klass.__init__)[0]):
>            # case 1: output dim set in the constructor
>            node = klass(output_dim=output_dim, *args)
>            _test(node)
>    
>            # case 2: output_dim set explicitly
>            node = klass(*args)
>            node.output_dim = output_dim
>            _test(node)
>        else:
>            if issubclass(klass, PreserveDimNode):
>                # check that constructor allows to set output_dim
>                assert 'output_dim' in getargs(klass.__init__)[0]
>                # check that setting the input dim, then incompatible output dims
>                # raises an appropriate error
>                # case 1: both in the constructor
>>               pytest.raises(InconsistentDimException,
>                              'klass(input_dim=inp.shape[1], output_dim=output_dim, *args)')
>E               TypeError: 'klass(input_dim=inp.shape[1], output_dim=output_dim, *args)' object (type: <class 'str'>) must be callable
>mdp/test/test_nodes_generic.py:264: TypeError
>=============================== warnings summary ===============================
>mdp/test/test_nodes_generic.py::test_dtype_consistency[LinearSVCScikitsLearnNode]
>mdp/test/test_nodes_generic.py::test_dtype_consistency[LinearSVCScikitsLearnNode]
>mdp/test/test_nodes_generic.py::test_dtype_consistency[CalibratedClassifierCVScikitsLearnNode]
>mdp/test/test_nodes_generic.py::test_dtype_consistency[CalibratedClassifierCVScikitsLearnNode]
>mdp/test/test_nodes_generic.py::test_dtype_consistency[CalibratedClassifierCVScikitsLearnNode]
>mdp/test/test_nodes_generic.py::test_dimdtypeset[LinearSVCScikitsLearnNode]
>mdp/test/test_nodes_generic.py::test_dimdtypeset[CalibratedClassifierCVScikitsLearnNode]
>mdp/test/test_nodes_generic.py::test_dimdtypeset[CalibratedClassifierCVScikitsLearnNode]
>  /usr/lib64/python3.9/site-packages/sklearn/svm/_base.py:976: ConvergenceWarning: Liblinear failed to converge, increase the number of iterations.
>    warnings.warn("Liblinear failed to converge, increase "
>mdp/test/test_nodes_generic.py::test_dtype_consistency[DummyClassifierScikitsLearnNode]
>mdp/test/test_nodes_generic.py::test_dimdtypeset[DummyClassifierScikitsLearnNode]
>  /usr/lib64/python3.9/site-packages/sklearn/dummy.py:131: FutureWarning: The default value of strategy will change from stratified to prior in 0.24.
>    warnings.warn("The default value of strategy will change from "
>mdp/test/test_nodes_generic.py::test_dtype_consistency[MLPClassifierScikitsLearnNode]
>mdp/test/test_nodes_generic.py::test_dtype_consistency[MLPClassifierScikitsLearnNode]
>mdp/test/test_nodes_generic.py::test_dimdtypeset[MLPClassifierScikitsLearnNode]
>  /usr/lib64/python3.9/site-packages/sklearn/neural_network/_multilayer_perceptron.py:582: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.
>    warnings.warn(
>-- Docs: https://docs.pytest.org/en/latest/warnings.html
>===================================== NOTE =====================================
>          python: 3.9.0.beta.5
>             mdp: 3.5
> parallel python: NOT AVAILABLE: No module named 'pp'
>          shogun: NOT AVAILABLE: No module named 'shogun'
>          libsvm: NOT AVAILABLE: No module named 'svm'
>          joblib: 0.16.0
>         sklearn: 0.23.1
>            numx: scipy 1.5.0
>          symeig: scipy.linalg.eigh
>Random Seed: 725021957
>IMPORTANT: some tests use random numbers. This could
>occasionally lead to failures due to numerical degeneracies.
>To rule this out, please run the tests more than once.
>If you get reproducible failures please report a bug!
>=========================== short test summary info ============================
>FAILED mdp/test/test_Convolution2DNode.py::testConvolution2DNode_arguments - ...
>FAILED mdp/test/test_FANode.py::test_FANode_singular_cov - TypeError: 'fanode...
>FAILED mdp/test/test_PCANode.py::test_PCANode_no_eigenvalues_left - TypeError...
>FAILED mdp/test/test_metaclass_and_extensions.py::test_signatures_same_no_arguments
>FAILED mdp/test/test_metaclass_and_extensions.py::test_signatures_more_arguments
>FAILED mdp/test/test_metaclass_and_extensions.py::test_signatures_less_arguments
>FAILED mdp/test/test_nodes_generic.py::test_outputdim_consistency[HitParadeNode]
>FAILED mdp/test/test_nodes_generic.py::test_outputdim_consistency[GaussianClassifier]
>FAILED mdp/test/test_nodes_generic.py::test_outputdim_consistency[NearestMeanClassifier]
>FAILED mdp/test/test_nodes_generic.py::test_outputdim_consistency[KNNClassifier]
>FAILED mdp/test/test_nodes_generic.py::test_outputdim_consistency[KMeansClassifier]
>FAILED mdp/test/test_nodes_generic.py::test_outputdim_consistency[PerceptronClassifier]
>FAILED mdp/test/test_nodes_generic.py::test_outputdim_consistency[SimpleMarkovClassifier]
>FAILED mdp/test/test_nodes_generic.py::test_outputdim_consistency[MultinomialNBScikitsLearnNode]
>FAILED mdp/test/test_nodes_generic.py::test_outputdim_consistency[SGDClassifierScikitsLearnNode]
>FAILED mdp/test/test_nodes_generic.py::test_outputdim_consistency[RidgeClassifierScikitsLearnNode]
>FAILED mdp/test/test_nodes_generic.py::test_outputdim_consistency[RidgeClassifierCVScikitsLearnNode]
>FAILED mdp/test/test_nodes_generic.py::test_outputdim_consistency[LogisticRegressionScikitsLearnNode]
>FAILED mdp/test/test_nodes_generic.py::test_outputdim_consistency[LogisticRegressionCVScikitsLearnNode]
>FAILED mdp/test/test_nodes_generic.py::test_outputdim_consistency[PassiveAggressiveClassifierScikitsLearnNode]
>FAILED mdp/test/test_nodes_generic.py::test_outputdim_consistency[PerceptronScikitsLearnNode]
>FAILED mdp/test/test_nodes_generic.py::test_outputdim_consistency[SVCScikitsLearnNode]
>FAILED mdp/test/test_nodes_generic.py::test_outputdim_consistency[NuSVCScikitsLearnNode]
>FAILED mdp/test/test_nodes_generic.py::test_outputdim_consistency[LinearSVCScikitsLearnNode]
>FAILED mdp/test/test_nodes_generic.py::test_outputdim_consistency[CalibratedClassifierCVScikitsLearnNode]
>FAILED mdp/test/test_nodes_generic.py::test_outputdim_consistency[KNeighborsClassifierScikitsLearnNode]
>FAILED mdp/test/test_nodes_generic.py::test_outputdim_consistency[RadiusNeighborsClassifierScikitsLearnNode]
>FAILED mdp/test/test_nodes_generic.py::test_outputdim_consistency[NearestCentroidScikitsLearnNode]
>FAILED mdp/test/test_nodes_generic.py::test_outputdim_consistency[DecisionTreeClassifierScikitsLearnNode]
>FAILED mdp/test/test_nodes_generic.py::test_outputdim_consistency[ExtraTreeClassifierScikitsLearnNode]
>FAILED mdp/test/test_nodes_generic.py::test_outputdim_consistency[LinearDiscriminantAnalysisScikitsLearnNode]
>FAILED mdp/test/test_nodes_generic.py::test_outputdim_consistency[QuadraticDiscriminantAnalysisScikitsLearnNode]
>FAILED mdp/test/test_nodes_generic.py::test_outputdim_consistency[DummyClassifierScikitsLearnNode]
>FAILED mdp/test/test_nodes_generic.py::test_outputdim_consistency[RandomForestClassifierScikitsLearnNode]
>FAILED mdp/test/test_nodes_generic.py::test_outputdim_consistency[ExtraTreesClassifierScikitsLearnNode]
>FAILED mdp/test/test_nodes_generic.py::test_outputdim_consistency[BaggingClassifierScikitsLearnNode]
>FAILED mdp/test/test_nodes_generic.py::test_outputdim_consistency[AdaBoostClassifierScikitsLearnNode]
>FAILED mdp/test/test_nodes_generic.py::test_outputdim_consistency[GradientBoostingClassifierScikitsLearnNode]
>FAILED mdp/test/test_nodes_generic.py::test_outputdim_consistency[GaussianProcessClassifierScikitsLearnNode]
>FAILED mdp/test/test_nodes_generic.py::test_outputdim_consistency[GaussianNBScikitsLearnNode]
>FAILED mdp/test/test_nodes_generic.py::test_outputdim_consistency[ComplementNBScikitsLearnNode]
>FAILED mdp/test/test_nodes_generic.py::test_outputdim_consistency[BernoulliNBScikitsLearnNode]
>FAILED mdp/test/test_nodes_generic.py::test_outputdim_consistency[CategoricalNBScikitsLearnNode]
>FAILED mdp/test/test_nodes_generic.py::test_outputdim_consistency[MLPClassifierScikitsLearnNode]
>FAILED mdp/test/test_nodes_generic.py::test_outputdim_consistency[LabelPropagationScikitsLearnNode]
>FAILED mdp/test/test_nodes_generic.py::test_outputdim_consistency[AdaptiveCutoffNode]
>FAILED mdp/test/test_nodes_generic.py::test_outputdim_consistency[CutoffNode]
>FAILED mdp/test/test_nodes_generic.py::test_outputdim_consistency[DiscreteHopfieldClassifier]
>FAILED mdp/test/test_nodes_generic.py::test_outputdim_consistency[HistogramNode]
>FAILED mdp/test/test_nodes_generic.py::test_outputdim_consistency[IdentityNode]
>FAILED mdp/test/test_nodes_generic.py::test_outputdim_consistency[NoiseNode]
>FAILED mdp/test/test_nodes_generic.py::test_outputdim_consistency[NormalNoiseNode]
>FAILED mdp/test/test_nodes_generic.py::test_outputdim_consistency[NormalizeNode]
>FAILED mdp/test/test_nodes_generic.py::test_outputdim_consistency[OnlineCenteringNode]
>FAILED mdp/test/test_nodes_generic.py::test_outputdim_consistency[OnlineTimeDiffNode]
>FAILED mdp/test/test_nodes_generic.py::test_outputdim_consistency[SignumClassifier]
>====== 56 failed, 801 passed, 7 skipped, 13 warnings in 107.40s (0:01:47) ======
>============================= test session starts ==============================
>platform linux -- Python 3.9.0b5, pytest-5.4.3, py-1.9.0, pluggy-0.13.1
>          python: 3.9.0.beta.5
>             mdp: 3.5
> parallel python: NOT AVAILABLE: No module named 'pp'
>          shogun: NOT AVAILABLE: No module named 'shogun'
>          libsvm: NOT AVAILABLE: No module named 'svm'
>          joblib: 0.16.0
>         sklearn: 0.23.1
>            numx: scipy 1.5.0
>          symeig: scipy.linalg.eigh
>Random Seed: 725021957
>rootdir: /builddir/build/BUILD/mdp-toolkit-1693b65e5cad07cc3325034e6ebae4ea8ba9ce2a, inifile: pytest.ini
>collected 64 items
>bimdp/test/test_biflow.py .............                                  [ 20%]
>bimdp/test/test_bihinet.py .........                                     [ 34%]
>bimdp/test/test_binode.py .................sssss                         [ 68%]
>bimdp/test/test_gradient.py ...........                                  [ 85%]
>bimdp/test/test_namespace_fixups.py ....                                 [ 92%]
>bimdp/test/test_parallelbiflow.py ....                                   [ 98%]
>bimdp/test/test_parallelbihinet.py .                                     [100%]
>=============================== warnings summary ===============================
>bimdp/test/test_gradient.py::TestGradientExtension::test_sfa2_gradient2
>  /builddir/build/BUILD/mdp-toolkit-1693b65e5cad07cc3325034e6ebae4ea8ba9ce2a/bimdp/test/test_gradient.py:106: FutureWarning: arrays to stack must be passed as a "sequence" type such as list or tuple. Support for non-sequence iterables such as generators is deprecated as of NumPy 1.16 and will raise an error in the future.
>    self.__gradient_Hs = numx.vstack((quad_form.H[numx.newaxis]
>bimdp/test/test_gradient.py::TestGradientExtension::test_sfa2_gradient2
>  /builddir/build/BUILD/mdp-toolkit-1693b65e5cad07cc3325034e6ebae4ea8ba9ce2a/bimdp/test/test_gradient.py:108: FutureWarning: arrays to stack must be passed as a "sequence" type such as list or tuple. Support for non-sequence iterables such as generators is deprecated as of NumPy 1.16 and will raise an error in the future.
>    self.__gradient_fs = numx.vstack((quad_form.f[numx.newaxis]
>-- Docs: https://docs.pytest.org/en/latest/warnings.html
>===================================== NOTE =====================================
>          python: 3.9.0.beta.5
>             mdp: 3.5
> parallel python: NOT AVAILABLE: No module named 'pp'
>          shogun: NOT AVAILABLE: No module named 'shogun'
>          libsvm: NOT AVAILABLE: No module named 'svm'
>          joblib: 0.16.0
>         sklearn: 0.23.1
>            numx: scipy 1.5.0
>          symeig: scipy.linalg.eigh
>Random Seed: 725021957
>================== 59 passed, 5 skipped, 2 warnings in 5.09s ===================
>error: Bad exit status from /var/tmp/rpm-tmp.1v3fG8 (%check)
>RPM build errors:
>    Bad exit status from /var/tmp/rpm-tmp.1v3fG8 (%check)
>Child return code was: 1
>EXCEPTION: [Error()]
>Traceback (most recent call last):
>  File "/usr/lib/python3.8/site-packages/mockbuild/trace_decorator.py", line 93, in trace
>    result = func(*args, **kw)
>  File "/usr/lib/python3.8/site-packages/mockbuild/util.py", line 776, in do_with_status
>    raise exception.Error("Command failed: \n # %s\n%s" % (command, output), child.returncode)
>mockbuild.exception.Error: Command failed: 
> # bash --login -c /usr/bin/rpmbuild -bb --target noarch --nodeps /builddir/build/SPECS/python-mdp.spec
>

Actions: View

Attachments on bug 1865302: 1709077 | 1709078 | 1709079