"""
This module provides convenient functions to transform sympy expressions to
lambda functions which can be used to calculate numerical values very fast.
"""

from typing import Any, Dict, Iterable

import builtins
import inspect
import keyword
import textwrap
import linecache

from sympy.core.basic import Basic
from sympy.utilities.exceptions import SymPyDeprecationWarning
from sympy.core.compatibility import (is_sequence, iterable,
    NotIterable)
from sympy.utilities.misc import filldedent
from sympy.utilities.decorator import doctest_depends_on

__doctest_requires__ = {('lambdify',): ['numpy', 'tensorflow']}

# Default namespaces, letting us define translations that can't be defined
# by simple variable maps, like I => 1j
MATH_DEFAULT = {}  # type: Dict[str, Any]
MPMATH_DEFAULT = {}  # type: Dict[str, Any]
NUMPY_DEFAULT = {"I": 1j}  # type: Dict[str, Any]
SCIPY_DEFAULT = {"I": 1j}  # type: Dict[str, Any]
CUPY_DEFAULT = {"I": 1j}  # type: Dict[str, Any]
TENSORFLOW_DEFAULT = {}  # type: Dict[str, Any]
SYMPY_DEFAULT = {}  # type: Dict[str, Any]
NUMEXPR_DEFAULT = {}  # type: Dict[str, Any]

# These are the namespaces the lambda functions will use.
# These are separate from the names above because they are modified
# throughout this file, whereas the defaults should remain unmodified.

MATH = MATH_DEFAULT.copy()
MPMATH = MPMATH_DEFAULT.copy()
NUMPY = NUMPY_DEFAULT.copy()
SCIPY = SCIPY_DEFAULT.copy()
CUPY = CUPY_DEFAULT.copy()
TENSORFLOW = TENSORFLOW_DEFAULT.copy()
SYMPY = SYMPY_DEFAULT.copy()
NUMEXPR = NUMEXPR_DEFAULT.copy()

# Mappings between sympy and other modules function names.
MATH_TRANSLATIONS = {
    "ceiling": "ceil",
    "E": "e",
    "ln": "log",
}

# NOTE: This dictionary is reused in Function._eval_evalf to allow subclasses
# of Function to automatically evalf.
MPMATH_TRANSLATIONS = {
    "Abs": "fabs",
    "elliptic_k": "ellipk",
    "elliptic_f": "ellipf",
    "elliptic_e": "ellipe",
    "elliptic_pi": "ellippi",
    "ceiling": "ceil",
    "chebyshevt": "chebyt",
    "chebyshevu": "chebyu",
    "E": "e",
    "I": "j",
    "ln": "log",
    #"lowergamma":"lower_gamma",
    "oo": "inf",
    #"uppergamma":"upper_gamma",
    "LambertW": "lambertw",
    "MutableDenseMatrix": "matrix",
    "ImmutableDenseMatrix": "matrix",
    "conjugate": "conj",
    "dirichlet_eta": "altzeta",
    "Ei": "ei",
    "Shi": "shi",
    "Chi": "chi",
    "Si": "si",
    "Ci": "ci",
    "RisingFactorial": "rf",
    "FallingFactorial": "ff",
    "betainc_regularized": "betainc",
}

NUMPY_TRANSLATIONS = {
    "Heaviside": "heaviside",
    }  # type: Dict[str, str]
SCIPY_TRANSLATIONS = {}  # type: Dict[str, str]
CUPY_TRANSLATIONS = {}  # type: Dict[str, str]

TENSORFLOW_TRANSLATIONS = {}  # type: Dict[str, str]

NUMEXPR_TRANSLATIONS = {}  # type: Dict[str, str]

# Available modules:
MODULES = {
    "math": (MATH, MATH_DEFAULT, MATH_TRANSLATIONS, ("from math import *",)),
    "mpmath": (MPMATH, MPMATH_DEFAULT, MPMATH_TRANSLATIONS, ("from mpmath import *",)),
    "numpy": (NUMPY, NUMPY_DEFAULT, NUMPY_TRANSLATIONS, ("import numpy; from numpy import *; from numpy.linalg import *",)),
    "scipy": (SCIPY, SCIPY_DEFAULT, SCIPY_TRANSLATIONS, ("import numpy; import scipy; from scipy import *; from scipy.special import *",)),
    "cupy": (CUPY, CUPY_DEFAULT, CUPY_TRANSLATIONS, ("import cupy",)),
    "tensorflow": (TENSORFLOW, TENSORFLOW_DEFAULT, TENSORFLOW_TRANSLATIONS, ("import tensorflow",)),
    "sympy": (SYMPY, SYMPY_DEFAULT, {}, (
        "from sympy.functions import *",
        "from sympy.matrices import *",
        "from sympy import Integral, pi, oo, nan, zoo, E, I",)),
    "numexpr" : (NUMEXPR, NUMEXPR_DEFAULT, NUMEXPR_TRANSLATIONS,
                 ("import_module('numexpr')", )),
}

def _import(module, reload=False):
    """
    Creates a global translation dictionary for module.

    The argument module has to be one of the following strings: "math",
    "mpmath", "numpy", "sympy", "tensorflow".
    These dictionaries map names of python functions to their equivalent in
    other modules.
    """
    # Required despite static analysis claiming it is not used
    from sympy.external import import_module # noqa:F401
    try:
        namespace, namespace_default, translations, import_commands = MODULES[
            module]
    except KeyError:
        raise NameError(
            "'%s' module cannot be used for lambdification" % module)

    # Clear namespace or exit
    if namespace != namespace_default:
        # The namespace was already generated, don't do it again if not forced.
        if reload:
            namespace.clear()
            namespace.update(namespace_default)
        else:
            return

    for import_command in import_commands:
        if import_command.startswith('import_module'):
            module = eval(import_command)

            if module is not None:
                namespace.update(module.__dict__)
                continue
        else:
            try:
                exec(import_command, {}, namespace)
                continue
            except ImportError:
                pass

        raise ImportError(
            "Cannot import '%s' with '%s' command" % (module, import_command))

    # Add translated names to namespace
    for sympyname, translation in translations.items():
        namespace[sympyname] = namespace[translation]

    # For computing the modulus of a sympy expression we use the builtin abs
    # function, instead of the previously used fabs function for all
    # translation modules. This is because the fabs function in the math
    # module does not accept complex valued arguments. (see issue 9474). The
    # only exception, where we don't use the builtin abs function is the
    # mpmath translation module, because mpmath.fabs returns mpf objects in
    # contrast to abs().
    if 'Abs' not in namespace:
        namespace['Abs'] = abs

# Used for dynamically generated filenames that are inserted into the
# linecache.
_lambdify_generated_counter = 1

@doctest_depends_on(modules=('numpy', 'scipy', 'tensorflow',), python_version=(3,))
def lambdify(args: Iterable, expr, modules=None, printer=None, use_imps=True,
             dummify=False, cse=False):
    """Convert a SymPy expression into a function that allows for fast
    numeric evaluation.

    .. warning::
       This function uses ``exec``, and thus shouldn't be used on
       unsanitized input.

    .. versionchanged:: 1.7.0
       Passing a set for the *args* parameter is deprecated as sets are
       unordered. Use an ordered iterable such as a list or tuple.

    Explanation
    ===========

    For example, to convert the SymPy expression ``sin(x) + cos(x)`` to an
    equivalent NumPy function that numerically evaluates it:

    >>> from sympy import sin, cos, symbols, lambdify
    >>> import numpy as np
    >>> x = symbols('x')
    >>> expr = sin(x) + cos(x)
    >>> expr
    sin(x) + cos(x)
    >>> f = lambdify(x, expr, 'numpy')
    >>> a = np.array([1, 2])
    >>> f(a)
    [1.38177329 0.49315059]

    The primary purpose of this function is to provide a bridge from SymPy
    expressions to numerical libraries such as NumPy, SciPy, NumExpr, mpmath,
    and tensorflow. In general, SymPy functions do not work with objects from
    other libraries, such as NumPy arrays, and functions from numeric
    libraries like NumPy or mpmath do not work on SymPy expressions.
    ``lambdify`` bridges the two by converting a SymPy expression to an
    equivalent numeric function.

    The basic workflow with ``lambdify`` is to first create a SymPy expression
    representing whatever mathematical function you wish to evaluate. This
    should be done using only SymPy functions and expressions. Then, use
    ``lambdify`` to convert this to an equivalent function for numerical
    evaluation. For instance, above we created ``expr`` using the SymPy symbol
    ``x`` and SymPy functions ``sin`` and ``cos``, then converted it to an
    equivalent NumPy function ``f``, and called it on a NumPy array ``a``.

    Parameters
    ==========

    args : List[Symbol]
        A variable or a list of variables whose nesting represents the
        nesting of the arguments that will be passed to the function.

        Variables can be symbols, undefined functions, or matrix symbols.

        >>> from sympy import Eq
        >>> from sympy.abc import x, y, z

        The list of variables should match the structure of how the
        arguments will be passed to the function. Simply enclose the
        parameters as they will be passed in a list.

        To call a function like ``f(x)`` then ``[x]``
        should be the first argument to ``lambdify``; for this
        case a single ``x`` can also be used:

        >>> f = lambdify(x, x + 1)
        >>> f(1)
        2
        >>> f = lambdify([x], x + 1)
        >>> f(1)
        2

        To call a function like ``f(x, y)`` then ``[x, y]`` will
        be the first argument of the ``lambdify``:

        >>> f = lambdify([x, y], x + y)
        >>> f(1, 1)
        2

        To call a function with a single 3-element tuple like
        ``f((x, y, z))`` then ``[(x, y, z)]`` will be the first
        argument of the ``lambdify``:

        >>> f = lambdify([(x, y, z)], Eq(z**2, x**2 + y**2))
        >>> f((3, 4, 5))
        True

        If two args will be passed and the first is a scalar but
        the second is a tuple with two arguments then the items
        in the list should match that structure:

        >>> f = lambdify([x, (y, z)], x + y + z)
        >>> f(1, (2, 3))
        6

    expr : Expr
        An expression, list of expressions, or matrix to be evaluated.

        Lists may be nested.
        If the expression is a list, the output will also be a list.

        >>> f = lambdify(x, [x, [x + 1, x + 2]])
        >>> f(1)
        [1, [2, 3]]

        If it is a matrix, an array will be returned (for the NumPy module).

        >>> from sympy import Matrix
        >>> f = lambdify(x, Matrix([x, x + 1]))
        >>> f(1)
        [[1]
        [2]]

        Note that the argument order here (variables then expression) is used
        to emulate the Python ``lambda`` keyword. ``lambdify(x, expr)`` works
        (roughly) like ``lambda x: expr``
        (see :ref:`lambdify-how-it-works` below).

    modules : str, optional
        Specifies the numeric library to use.

        If not specified, *modules* defaults to:

        - ``["scipy", "numpy"]`` if SciPy is installed
        - ``["numpy"]`` if only NumPy is installed
        - ``["math", "mpmath", "sympy"]`` if neither is installed.

        That is, SymPy functions are replaced as far as possible by
        either ``scipy`` or ``numpy`` functions if available, and Python's
        standard library ``math``, or ``mpmath`` functions otherwise.

        *modules* can be one of the following types:

        - The strings ``"math"``, ``"mpmath"``, ``"numpy"``, ``"numexpr"``,
          ``"scipy"``, ``"sympy"``, or ``"tensorflow"``. This uses the
          corresponding printer and namespace mapping for that module.
        - A module (e.g., ``math``). This uses the global namespace of the
          module. If the module is one of the above known modules, it will
          also use the corresponding printer and namespace mapping
          (i.e., ``modules=numpy`` is equivalent to ``modules="numpy"``).
        - A dictionary that maps names of SymPy functions to arbitrary
          functions
          (e.g., ``{'sin': custom_sin}``).
        - A list that contains a mix of the arguments above, with higher
          priority given to entries appearing first
          (e.g., to use the NumPy module but override the ``sin`` function
          with a custom version, you can use
          ``[{'sin': custom_sin}, 'numpy']``).

    dummify : bool, optional
        Whether or not the variables in the provided expression that are not
        valid Python identifiers are substituted with dummy symbols.

        This allows for undefined functions like ``Function('f')(t)`` to be
        supplied as arguments. By default, the variables are only dummified
        if they are not valid Python identifiers.

        Set ``dummify=True`` to replace all arguments with dummy symbols
        (if ``args`` is not a string) - for example, to ensure that the
        arguments do not redefine any built-in names.

    cse : bool, or callable, optional
        Large expressions can be computed more efficiently when
        common subexpressions are identified and precomputed before
        being used multiple time. Finding the subexpressions will make
        creation of the 'lambdify' function slower, however.

        When ``True``, ``sympy.simplify.cse`` is used, otherwise (the default)
        the user may pass a function matching the ``cse`` signature.

    Examples
    ========

    >>> from sympy.utilities.lambdify import implemented_function
    >>> from sympy import sqrt, sin, Matrix
    >>> from sympy import Function
    >>> from sympy.abc import w, x, y, z

    >>> f = lambdify(x, x**2)
    >>> f(2)
    4
    >>> f = lambdify((x, y, z), [z, y, x])
    >>> f(1,2,3)
    [3, 2, 1]
    >>> f = lambdify(x, sqrt(x))
    >>> f(4)
    2.0
    >>> f = lambdify((x, y), sin(x*y)**2)
    >>> f(0, 5)
    0.0
    >>> row = lambdify((x, y), Matrix((x, x + y)).T, modules='sympy')
    >>> row(1, 2)
    Matrix([[1, 3]])

    ``lambdify`` can be used to translate SymPy expressions into mpmath
    functions. This may be preferable to using ``evalf`` (which uses mpmath on
    the backend) in some cases.

    >>> f = lambdify(x, sin(x), 'mpmath')
    >>> f(1)
    0.8414709848078965

    Tuple arguments are handled and the lambdified function should
    be called with the same type of arguments as were used to create
    the function:

    >>> f = lambdify((x, (y, z)), x + y)
    >>> f(1, (2, 4))
    3

    The ``flatten`` function can be used to always work with flattened
    arguments:

    >>> from sympy.utilities.iterables import flatten
    >>> args = w, (x, (y, z))
    >>> vals = 1, (2, (3, 4))
    >>> f = lambdify(flatten(args), w + x + y + z)
    >>> f(*flatten(vals))
    10

    Functions present in ``expr`` can also carry their own numerical
    implementations, in a callable attached to the ``_imp_`` attribute. This
    can be used with undefined functions using the ``implemented_function``
    factory:

    >>> f = implemented_function(Function('f'), lambda x: x+1)
    >>> func = lambdify(x, f(x))
    >>> func(4)
    5

    ``lambdify`` always prefers ``_imp_`` implementations to implementations
    in other namespaces, unless the ``use_imps`` input parameter is False.

    Usage with Tensorflow:

    >>> import tensorflow as tf
    >>> from sympy import Max, sin, lambdify
    >>> from sympy.abc import x

    >>> f = Max(x, sin(x))
    >>> func = lambdify(x, f, 'tensorflow')

    After tensorflow v2, eager execution is enabled by default.
    If you want to get the compatible result across tensorflow v1 and v2
    as same as this tutorial, run this line.

    >>> tf.compat.v1.enable_eager_execution()

    If you have eager execution enabled, you can get the result out
    immediately as you can use numpy.

    If you pass tensorflow objects, you may get an ``EagerTensor``
    object instead of value.

    >>> result = func(tf.constant(1.0))
    >>> print(result)
    tf.Tensor(1.0, shape=(), dtype=float32)
    >>> print(result.__class__)
    <class 'tensorflow.python.framework.ops.EagerTensor'>

    You can use ``.numpy()`` to get the numpy value of the tensor.

    >>> result.numpy()
    1.0

    >>> var = tf.Variable(2.0)
    >>> result = func(var) # also works for tf.Variable and tf.Placeholder
    >>> result.numpy()
    2.0

    And it works with any shape array.

    >>> tensor = tf.constant([[1.0, 2.0], [3.0, 4.0]])
    >>> result = func(tensor)
    >>> result.numpy()
    [[1. 2.]
     [3. 4.]]

    Notes
    =====

    - For functions involving large array calculations, numexpr can provide a
      significant speedup over numpy. Please note that the available functions
      for numexpr are more limited than numpy but can be expanded with
      ``implemented_function`` and user defined subclasses of Function. If
      specified, numexpr may be the only option in modules. The official list
      of numexpr functions can be found at:
      https://numexpr.readthedocs.io/en/latest/user_guide.html#supported-functions

    - In previous versions of SymPy, ``lambdify`` replaced ``Matrix`` with
      ``numpy.matrix`` by default. As of SymPy 1.0 ``numpy.array`` is the
      default. To get the old default behavior you must pass in
      ``[{'ImmutableDenseMatrix':  numpy.matrix}, 'numpy']`` to the
      ``modules`` kwarg.

      >>> from sympy import lambdify, Matrix
      >>> from sympy.abc import x, y
      >>> import numpy
      >>> array2mat = [{'ImmutableDenseMatrix': numpy.matrix}, 'numpy']
      >>> f = lambdify((x, y), Matrix([x, y]), modules=array2mat)
      >>> f(1, 2)
      [[1]
       [2]]

    - In the above examples, the generated functions can accept scalar
      values or numpy arrays as arguments.  However, in some cases
      the generated function relies on the input being a numpy array:

      >>> from sympy import Piecewise
      >>> from sympy.testing.pytest import ignore_warnings
      >>> f = lambdify(x, Piecewise((x, x <= 1), (1/x, x > 1)), "numpy")

      >>> with ignore_warnings(RuntimeWarning):
      ...     f(numpy.array([-1, 0, 1, 2]))
      [-1.   0.   1.   0.5]

      >>> f(0)
      Traceback (most recent call last):
          ...
      ZeroDivisionError: division by zero

      In such cases, the input should be wrapped in a numpy array:

      >>> with ignore_warnings(RuntimeWarning):
      ...     float(f(numpy.array([0])))
      0.0

      Or if numpy functionality is not required another module can be used:

      >>> f = lambdify(x, Piecewise((x, x <= 1), (1/x, x > 1)), "math")
      >>> f(0)
      0

    .. _lambdify-how-it-works:

    How it works
    ============

    When using this function, it helps a great deal to have an idea of what it
    is doing. At its core, lambdify is nothing more than a namespace
    translation, on top of a special printer that makes some corner cases work
    properly.

    To understand lambdify, first we must properly understand how Python
    namespaces work. Say we had two files. One called ``sin_cos_sympy.py``,
    with

    .. code:: python

        # sin_cos_sympy.py

        from sympy import sin, cos

        def sin_cos(x):
            return sin(x) + cos(x)

    and one called ``sin_cos_numpy.py`` with

    .. code:: python

        # sin_cos_numpy.py

        from numpy import sin, cos

        def sin_cos(x):
            return sin(x) + cos(x)

    The two files define an identical function ``sin_cos``. However, in the
    first file, ``sin`` and ``cos`` are defined as the SymPy ``sin`` and
    ``cos``. In the second, they are defined as the NumPy versions.

    If we were to import the first file and use the ``sin_cos`` function, we
    would get something like

    >>> from sin_cos_sympy import sin_cos # doctest: +SKIP
    >>> sin_cos(1) # doctest: +SKIP
    cos(1) + sin(1)

    On the other hand, if we imported ``sin_cos`` from the second file, we
    would get

    >>> from sin_cos_numpy import sin_cos # doctest: +SKIP
    >>> sin_cos(1) # doctest: +SKIP
    1.38177329068

    In the first case we got a symbolic output, because it used the symbolic
    ``sin`` and ``cos`` functions from SymPy. In the second, we got a numeric
    result, because ``sin_cos`` used the numeric ``sin`` and ``cos`` functions
    from NumPy. But notice that the versions of ``sin`` and ``cos`` that were
    used was not inherent to the ``sin_cos`` function definition. Both
    ``sin_cos`` definitions are exactly the same. Rather, it was based on the
    names defined at the module where the ``sin_cos`` function was defined.

    The key point here is that when function in Python references a name that
    is not defined in the function, that name is looked up in the "global"
    namespace of the module where that function is defined.

    Now, in Python, we can emulate this behavior without actually writing a
    file to disk using the ``exec`` function. ``exec`` takes a string
    containing a block of Python code, and a dictionary that should contain
    the global variables of the module. It then executes the code "in" that
    dictionary, as if it were the module globals. The following is equivalent
    to the ``sin_cos`` defined in ``sin_cos_sympy.py``:

    >>> import sympy
    >>> module_dictionary = {'sin': sympy.sin, 'cos': sympy.cos}
    >>> exec('''
    ... def sin_cos(x):
    ...     return sin(x) + cos(x)
    ... ''', module_dictionary)
    >>> sin_cos = module_dictionary['sin_cos']
    >>> sin_cos(1)
    cos(1) + sin(1)

    and similarly with ``sin_cos_numpy``:

    >>> import numpy
    >>> module_dictionary = {'sin': numpy.sin, 'cos': numpy.cos}
    >>> exec('''
    ... def sin_cos(x):
    ...     return sin(x) + cos(x)
    ... ''', module_dictionary)
    >>> sin_cos = module_dictionary['sin_cos']
    >>> sin_cos(1)
    1.38177329068

    So now we can get an idea of how ``lambdify`` works. The name "lambdify"
    comes from the fact that we can think of something like ``lambdify(x,
    sin(x) + cos(x), 'numpy')`` as ``lambda x: sin(x) + cos(x)``, where
    ``sin`` and ``cos`` come from the ``numpy`` namespace. This is also why
    the symbols argument is first in ``lambdify``, as opposed to most SymPy
    functions where it comes after the expression: to better mimic the
    ``lambda`` keyword.

    ``lambdify`` takes the input expression (like ``sin(x) + cos(x)``) and

    1. Converts it to a string
    2. Creates a module globals dictionary based on the modules that are
       passed in (by default, it uses the NumPy module)
    3. Creates the string ``"def func({vars}): return {expr}"``, where ``{vars}`` is the
       list of variables separated by commas, and ``{expr}`` is the string
       created in step 1., then ``exec``s that string with the module globals
       namespace and returns ``func``.

    In fact, functions returned by ``lambdify`` support inspection. So you can
    see exactly how they are defined by using ``inspect.getsource``, or ``??`` if you
    are using IPython or the Jupyter notebook.

    >>> f = lambdify(x, sin(x) + cos(x))
    >>> import inspect
    >>> print(inspect.getsource(f))
    def _lambdifygenerated(x):
        return sin(x) + cos(x)

    This shows us the source code of the function, but not the namespace it
    was defined in. We can inspect that by looking at the ``__globals__``
    attribute of ``f``:

    >>> f.__globals__['sin']
    <ufunc 'sin'>
    >>> f.__globals__['cos']
    <ufunc 'cos'>
    >>> f.__globals__['sin'] is numpy.sin
    True

    This shows us that ``sin`` and ``cos`` in the namespace of ``f`` will be
    ``numpy.sin`` and ``numpy.cos``.

    Note that there are some convenience layers in each of these steps, but at
    the core, this is how ``lambdify`` works. Step 1 is done using the
    ``LambdaPrinter`` printers defined in the printing module (see
    :mod:`sympy.printing.lambdarepr`). This allows different SymPy expressions
    to define how they should be converted to a string for different modules.
    You can change which printer ``lambdify`` uses by passing a custom printer
    in to the ``printer`` argument.

    Step 2 is augmented by certain translations. There are default
    translations for each module, but you can provide your own by passing a
    list to the ``modules`` argument. For instance,

    >>> def mysin(x):
    ...     print('taking the sin of', x)
    ...     return numpy.sin(x)
    ...
    >>> f = lambdify(x, sin(x), [{'sin': mysin}, 'numpy'])
    >>> f(1)
    taking the sin of 1
    0.8414709848078965

    The globals dictionary is generated from the list by merging the
    dictionary ``{'sin': mysin}`` and the module dictionary for NumPy. The
    merging is done so that earlier items take precedence, which is why
    ``mysin`` is used above instead of ``numpy.sin``.

    If you want to modify the way ``lambdify`` works for a given function, it
    is usually easiest to do so by modifying the globals dictionary as such.
    In more complicated cases, it may be necessary to create and pass in a
    custom printer.

    Finally, step 3 is augmented with certain convenience operations, such as
    the addition of a docstring.

    Understanding how ``lambdify`` works can make it easier to avoid certain
    gotchas when using it. For instance, a common mistake is to create a
    lambdified function for one module (say, NumPy), and pass it objects from
    another (say, a SymPy expression).

    For instance, say we create

    >>> from sympy.abc import x
    >>> f = lambdify(x, x + 1, 'numpy')

    Now if we pass in a NumPy array, we get that array plus 1

    >>> import numpy
    >>> a = numpy.array([1, 2])
    >>> f(a)
    [2 3]

    But what happens if you make the mistake of passing in a SymPy expression
    instead of a NumPy array:

    >>> f(x + 1)
    x + 2

    This worked, but it was only by accident. Now take a different lambdified
    function:

    >>> from sympy import sin
    >>> g = lambdify(x, x + sin(x), 'numpy')

    This works as expected on NumPy arrays:

    >>> g(a)
    [1.84147098 2.90929743]

    But if we try to pass in a SymPy expression, it fails

    >>> try:
    ...     g(x + 1)
    ... # NumPy release after 1.17 raises TypeError instead of
    ... # AttributeError
    ... except (AttributeError, TypeError):
    ...     raise AttributeError() # doctest: +IGNORE_EXCEPTION_DETAIL
    Traceback (most recent call last):
    ...
    AttributeError:

    Now, let's look at what happened. The reason this fails is that ``g``
    calls ``numpy.sin`` on the input expression, and ``numpy.sin`` does not
    know how to operate on a SymPy object. **As a general rule, NumPy
    functions do not know how to operate on SymPy expressions, and SymPy
    functions do not know how to operate on NumPy arrays. This is why lambdify
    exists: to provide a bridge between SymPy and NumPy.**

    However, why is it that ``f`` did work? That's because ``f`` doesn't call
    any functions, it only adds 1. So the resulting function that is created,
    ``def _lambdifygenerated(x): return x + 1`` does not depend on the globals
    namespace it is defined in. Thus it works, but only by accident. A future
    version of ``lambdify`` may remove this behavior.

    Be aware that certain implementation details described here may change in
    future versions of SymPy. The API of passing in custom modules and
    printers will not change, but the details of how a lambda function is
    created may change. However, the basic idea will remain the same, and
    understanding it will be helpful to understanding the behavior of
    lambdify.

    **In general: you should create lambdified functions for one module (say,
    NumPy), and only pass it input types that are compatible with that module
    (say, NumPy arrays).** Remember that by default, if the ``module``
    argument is not provided, ``lambdify`` creates functions using the NumPy
    and SciPy namespaces.
    """
    from sympy.core.symbol import Symbol

    # If the user hasn't specified any modules, use what is available.
    if modules is None:
        try:
            _import("scipy")
        except ImportError:
            try:
                _import("numpy")
            except ImportError:
                # Use either numpy (if available) or python.math where possible.
                # XXX: This leads to different behaviour on different systems and
                #      might be the reason for irreproducible errors.
                modules = ["math", "mpmath", "sympy"]
            else:
                modules = ["numpy"]
        else:
            modules = ["numpy", "scipy"]

    # Get the needed namespaces.
    namespaces = []
    # First find any function implementations
    if use_imps:
        namespaces.append(_imp_namespace(expr))
    # Check for dict before iterating
    if isinstance(modules, (dict, str)) or not hasattr(modules, '__iter__'):
        namespaces.append(modules)
    else:
        # consistency check
        if _module_present('numexpr', modules) and len(modules) > 1:
            raise TypeError("numexpr must be the only item in 'modules'")
        namespaces += list(modules)
    # fill namespace with first having highest priority
    namespace = {} # type: Dict[str, Any]
    for m in namespaces[::-1]:
        buf = _get_namespace(m)
        namespace.update(buf)

    if hasattr(expr, "atoms"):
        #Try if you can extract symbols from the expression.
        #Move on if expr.atoms in not implemented.
        syms = expr.atoms(Symbol)
        for term in syms:
            namespace.update({str(term): term})

    if printer is None:
        if _module_present('mpmath', namespaces):
            from sympy.printing.pycode import MpmathPrinter as Printer # type: ignore
        elif _module_present('scipy', namespaces):
            from sympy.printing.numpy import SciPyPrinter as Printer # type: ignore
        elif _module_present('numpy', namespaces):
            from sympy.printing.numpy import NumPyPrinter as Printer # type: ignore
        elif _module_present('cupy', namespaces):
            from sympy.printing.numpy import CuPyPrinter as Printer # type: ignore
        elif _module_present('numexpr', namespaces):
            from sympy.printing.lambdarepr import NumExprPrinter as Printer # type: ignore
        elif _module_present('tensorflow', namespaces):
            from sympy.printing.tensorflow import TensorflowPrinter as Printer # type: ignore
        elif _module_present('sympy', namespaces):
            from sympy.printing.pycode import SymPyPrinter as Printer # type: ignore
        else:
            from sympy.printing.pycode import PythonCodePrinter as Printer # type: ignore
        user_functions = {}
        for m in namespaces[::-1]:
            if isinstance(m, dict):
                for k in m:
                    user_functions[k] = k
        printer = Printer({'fully_qualified_modules': False, 'inline': True,
                           'allow_unknown_functions': True,
                           'user_functions': user_functions})

    if isinstance(args, set):
        SymPyDeprecationWarning(
                    feature="The list of arguments is a `set`. This leads to unpredictable results",
                    useinstead=": Convert set into list or tuple",
                    issue=20013,
                    deprecated_since_version="1.6.3"
                ).warn()

    # Get the names of the args, for creating a docstring
    if not iterable(args):
        args = (args,)
    names = []

    # Grab the callers frame, for getting the names by inspection (if needed)
    callers_local_vars = inspect.currentframe().f_back.f_locals.items() # type: ignore
    for n, var in enumerate(args):
        if hasattr(var, 'name'):
            names.append(var.name)
        else:
            # It's an iterable. Try to get name by inspection of calling frame.
            name_list = [var_name for var_name, var_val in callers_local_vars
                    if var_val is var]
            if len(name_list) == 1:
                names.append(name_list[0])
            else:
                # Cannot infer name with certainty. arg_# will have to do.
                names.append('arg_' + str(n))

    # Create the function definition code and execute it
    funcname = '_lambdifygenerated'
    if _module_present('tensorflow', namespaces):
        funcprinter = _TensorflowEvaluatorPrinter(printer, dummify) # type: _EvaluatorPrinter
    else:
        funcprinter = _EvaluatorPrinter(printer, dummify)

    if cse == True:
        from sympy.simplify.cse_main import cse
        cses, _expr = cse(expr, list=False)
    elif callable(cse):
        cses, _expr = cse(expr)
    else:
        cses, _expr = (), expr
    funcstr = funcprinter.doprint(funcname, args, _expr, cses=cses)

    # Collect the module imports from the code printers.
    imp_mod_lines = []
    for mod, keys in (getattr(printer, 'module_imports', None) or {}).items():
        for k in keys:
            if k not in namespace:
                ln = "from %s import %s" % (mod, k)
                try:
                    exec(ln, {}, namespace)
                except ImportError:
                    # Tensorflow 2.0 has issues with importing a specific
                    # function from its submodule.
                    # https://github.com/tensorflow/tensorflow/issues/33022
                    ln = "%s = %s.%s" % (k, mod, k)
                    exec(ln, {}, namespace)
                imp_mod_lines.append(ln)

    # Provide lambda expression with builtins, and compatible implementation of range
    namespace.update({'builtins':builtins, 'range':range})

    funclocals = {} # type: Dict[str, Any]
    global _lambdify_generated_counter
    filename = '<lambdifygenerated-%s>' % _lambdify_generated_counter
    _lambdify_generated_counter += 1
    c = compile(funcstr, filename, 'exec')
    exec(c, namespace, funclocals)
    # mtime has to be None or else linecache.checkcache will remove it
    linecache.cache[filename] = (len(funcstr), None, funcstr.splitlines(True), filename) # type: ignore

    func = funclocals[funcname]

    # Apply the docstring
    sig = "func({})".format(", ".join(str(i) for i in names))
    sig = textwrap.fill(sig, subsequent_indent=' '*8)
    expr_str = str(expr)
    if len(expr_str) > 78:
        expr_str = textwrap.wrap(expr_str, 75)[0] + '...'
    func.__doc__ = (
        "Created with lambdify. Signature:\n\n"
        "{sig}\n\n"
        "Expression:\n\n"
        "{expr}\n\n"
        "Source code:\n\n"
        "{src}\n\n"
        "Imported modules:\n\n"
        "{imp_mods}"
        ).format(sig=sig, expr=expr_str, src=funcstr, imp_mods='\n'.join(imp_mod_lines))
    return func

def _module_present(modname, modlist):
    if modname in modlist:
        return True
    for m in modlist:
        if hasattr(m, '__name__') and m.__name__ == modname:
            return True
    return False

def _get_namespace(m):
    """
    This is used by _lambdify to parse its arguments.
    """
    if isinstance(m, str):
        _import(m)
        return MODULES[m][0]
    elif isinstance(m, dict):
        return m
    elif hasattr(m, "__dict__"):
        return m.__dict__
    else:
        raise TypeError("Argument must be either a string, dict or module but it is: %s" % m)

def _recursive_to_string(doprint, arg):
    """Functions in lambdify accept both sympy types and non-sympy types such as python
    lists and tuples. This method ensures that we only call the doprint method of the
    printer with SymPy types (so that the printer safely can use SymPy-methods)."""
    from sympy.matrices.common import MatrixOperations

    if isinstance(arg, (Basic, MatrixOperations)):
        return doprint(arg)
    elif iterable(arg):
        if isinstance(arg, list):
            left, right = "[]"
        elif isinstance(arg, tuple):
            left, right = "()"
        else:
            raise NotImplementedError("unhandled type: %s, %s" % (type(arg), arg))
        return left +', '.join(_recursive_to_string(doprint, e) for e in arg) + right
    elif isinstance(arg, str):
        return arg
    else:
        return doprint(arg)

def lambdastr(args, expr, printer=None, dummify=None):
    """
    Returns a string that can be evaluated to a lambda function.

    Examples
    ========

    >>> from sympy.abc import x, y, z
    >>> from sympy.utilities.lambdify import lambdastr
    >>> lambdastr(x, x**2)
    'lambda x: (x**2)'
    >>> lambdastr((x,y,z), [z,y,x])
    'lambda x,y,z: ([z, y, x])'

    Although tuples may not appear as arguments to lambda in Python 3,
    lambdastr will create a lambda function that will unpack the original
    arguments so that nested arguments can be handled:

    >>> lambdastr((x, (y, z)), x + y)
    'lambda _0,_1: (lambda x,y,z: (x + y))(_0,_1[0],_1[1])'
    """
    # Transforming everything to strings.
    from sympy.matrices import DeferredVector
    from sympy import Dummy, sympify, Symbol, Function, flatten, Derivative

    if printer is not None:
        if inspect.isfunction(printer):
            lambdarepr = printer
        else:
            if inspect.isclass(printer):
                lambdarepr = lambda expr: printer().doprint(expr)
            else:
                lambdarepr = lambda expr: printer.doprint(expr)
    else:
        #XXX: This has to be done here because of circular imports
        from sympy.printing.lambdarepr import lambdarepr

    def sub_args(args, dummies_dict):
        if isinstance(args, str):
            return args
        elif isinstance(args, DeferredVector):
            return str(args)
        elif iterable(args):
            dummies = flatten([sub_args(a, dummies_dict) for a in args])
            return ",".join(str(a) for a in dummies)
        else:
            # replace these with Dummy symbols
            if isinstance(args, (Function, Symbol, Derivative)):
                dummies = Dummy()
                dummies_dict.update({args : dummies})
                return str(dummies)
            else:
                return str(args)

    def sub_expr(expr, dummies_dict):
        expr = sympify(expr)
        # dict/tuple are sympified to Basic
        if isinstance(expr, Basic):
            expr = expr.xreplace(dummies_dict)
        # list is not sympified to Basic
        elif isinstance(expr, list):
            expr = [sub_expr(a, dummies_dict) for a in expr]
        return expr

    # Transform args
    def isiter(l):
        return iterable(l, exclude=(str, DeferredVector, NotIterable))

    def flat_indexes(iterable):
        n = 0

        for el in iterable:
            if isiter(el):
                for ndeep in flat_indexes(el):
                    yield (n,) + ndeep
            else:
                yield (n,)

            n += 1

    if dummify is None:
        dummify = any(isinstance(a, Basic) and
            a.atoms(Function, Derivative) for a in (
            args if isiter(args) else [args]))

    if isiter(args) and any(isiter(i) for i in args):
        dum_args = [str(Dummy(str(i))) for i in range(len(args))]

        indexed_args = ','.join([
            dum_args[ind[0]] + ''.join(["[%s]" % k for k in ind[1:]])
                    for ind in flat_indexes(args)])

        lstr = lambdastr(flatten(args), expr, printer=printer, dummify=dummify)

        return 'lambda %s: (%s)(%s)' % (','.join(dum_args), lstr, indexed_args)

    dummies_dict = {}
    if dummify:
        args = sub_args(args, dummies_dict)
    else:
        if isinstance(args, str):
            pass
        elif iterable(args, exclude=DeferredVector):
            args = ",".join(str(a) for a in args)

    # Transform expr
    if dummify:
        if isinstance(expr, str):
            pass
        else:
            expr = sub_expr(expr, dummies_dict)
    expr = _recursive_to_string(lambdarepr, expr)
    return "lambda %s: (%s)" % (args, expr)

class _EvaluatorPrinter:
    def __init__(self, printer=None, dummify=False):
        self._dummify = dummify

        #XXX: This has to be done here because of circular imports
        from sympy.printing.lambdarepr import LambdaPrinter

        if printer is None:
            printer = LambdaPrinter()

        if inspect.isfunction(printer):
            self._exprrepr = printer
        else:
            if inspect.isclass(printer):
                printer = printer()

            self._exprrepr = printer.doprint

            #if hasattr(printer, '_print_Symbol'):
            #    symbolrepr = printer._print_Symbol

            #if hasattr(printer, '_print_Dummy'):
            #    dummyrepr = printer._print_Dummy

        # Used to print the generated function arguments in a standard way
        self._argrepr = LambdaPrinter().doprint

    def doprint(self, funcname, args, expr, *, cses=()):
        """
        Returns the function definition code as a string.
        """
        from sympy import Dummy

        funcbody = []

        if not iterable(args):
            args = [args]

        argstrs, expr = self._preprocess(args, expr)

        # Generate argument unpacking and final argument list
        funcargs = []
        unpackings = []

        for argstr in argstrs:
            if iterable(argstr):
                funcargs.append(self._argrepr(Dummy()))
                unpackings.extend(self._print_unpacking(argstr, funcargs[-1]))
            else:
                funcargs.append(argstr)

        funcsig = 'def {}({}):'.format(funcname, ', '.join(funcargs))

        # Wrap input arguments before unpacking
        funcbody.extend(self._print_funcargwrapping(funcargs))

        funcbody.extend(unpackings)

        for s, e in cses:
            if e is None:
                funcbody.append('del {}'.format(s))
            else:
                funcbody.append('{} = {}'.format(s, self._exprrepr(e)))

        str_expr = _recursive_to_string(self._exprrepr, expr)

        if '\n' in str_expr:
            str_expr = '({})'.format(str_expr)
        funcbody.append('return {}'.format(str_expr))

        funclines = [funcsig]
        funclines.extend(['    ' + line for line in funcbody])

        return '\n'.join(funclines) + '\n'

    @classmethod
    def _is_safe_ident(cls, ident):
        return isinstance(ident, str) and ident.isidentifier() \
                and not keyword.iskeyword(ident)

    def _preprocess(self, args, expr):
        """Preprocess args, expr to replace arguments that do not map
        to valid Python identifiers.

        Returns string form of args, and updated expr.
        """
        from sympy import Dummy, Function, flatten, Derivative, ordered, Basic
        from sympy.matrices import DeferredVector
        from sympy.core.symbol import uniquely_named_symbol
        from sympy.core.expr import Expr

        # Args of type Dummy can cause name collisions with args
        # of type Symbol.  Force dummify of everything in this
        # situation.
        dummify = self._dummify or any(
            isinstance(arg, Dummy) for arg in flatten(args))

        argstrs = [None]*len(args)
        for arg, i in reversed(list(ordered(zip(args, range(len(args)))))):
            if iterable(arg):
                s, expr = self._preprocess(arg, expr)
            elif isinstance(arg, DeferredVector):
                s = str(arg)
            elif isinstance(arg, Basic) and arg.is_symbol:
                s = self._argrepr(arg)
                if dummify or not self._is_safe_ident(s):
                    dummy = Dummy()
                    if isinstance(expr, Expr):
                        dummy = uniquely_named_symbol(
                            dummy.name, expr, modify=lambda s: '_' + s)
                    s = self._argrepr(dummy)
                    expr = self._subexpr(expr, {arg: dummy})
            elif dummify or isinstance(arg, (Function, Derivative)):
                dummy = Dummy()
                s = self._argrepr(dummy)
                expr = self._subexpr(expr, {arg: dummy})
            else:
                s = str(arg)
            argstrs[i] = s
        return argstrs, expr

    def _subexpr(self, expr, dummies_dict):
        from sympy.matrices import DeferredVector
        from sympy import sympify

        expr = sympify(expr)
        xreplace = getattr(expr, 'xreplace', None)
        if xreplace is not None:
            expr = xreplace(dummies_dict)
        else:
            if isinstance(expr, DeferredVector):
                pass
            elif isinstance(expr, dict):
                k = [self._subexpr(sympify(a), dummies_dict) for a in expr.keys()]
                v = [self._subexpr(sympify(a), dummies_dict) for a in expr.values()]
                expr = dict(zip(k, v))
            elif isinstance(expr, tuple):
                expr = tuple(self._subexpr(sympify(a), dummies_dict) for a in expr)
            elif isinstance(expr, list):
                expr = [self._subexpr(sympify(a), dummies_dict) for a in expr]
        return expr

    def _print_funcargwrapping(self, args):
        """Generate argument wrapping code.

        args is the argument list of the generated function (strings).

        Return value is a list of lines of code that will be inserted  at
        the beginning of the function definition.
        """
        return []

    def _print_unpacking(self, unpackto, arg):
        """Generate argument unpacking code.

        arg is the function argument to be unpacked (a string), and
        unpackto is a list or nested lists of the variable names (strings) to
        unpack to.
        """
        def unpack_lhs(lvalues):
            return '[{}]'.format(', '.join(
                unpack_lhs(val) if iterable(val) else val for val in lvalues))

        return ['{} = {}'.format(unpack_lhs(unpackto), arg)]

class _TensorflowEvaluatorPrinter(_EvaluatorPrinter):
    def _print_unpacking(self, lvalues, rvalue):
        """Generate argument unpacking code.

        This method is used when the input value is not interable,
        but can be indexed (see issue #14655).
        """
        from sympy import flatten

        def flat_indexes(elems):
            n = 0

            for el in elems:
                if iterable(el):
                    for ndeep in flat_indexes(el):
                        yield (n,) + ndeep
                else:
                    yield (n,)

                n += 1

        indexed = ', '.join('{}[{}]'.format(rvalue, ']['.join(map(str, ind)))
                                for ind in flat_indexes(lvalues))

        return ['[{}] = [{}]'.format(', '.join(flatten(lvalues)), indexed)]

def _imp_namespace(expr, namespace=None):
    """ Return namespace dict with function implementations

    We need to search for functions in anything that can be thrown at
    us - that is - anything that could be passed as ``expr``.  Examples
    include sympy expressions, as well as tuples, lists and dicts that may
    contain sympy expressions.

    Parameters
    ----------
    expr : object
       Something passed to lambdify, that will generate valid code from
       ``str(expr)``.
    namespace : None or mapping
       Namespace to fill.  None results in new empty dict

    Returns
    -------
    namespace : dict
       dict with keys of implemented function names within ``expr`` and
       corresponding values being the numerical implementation of
       function

    Examples
    ========

    >>> from sympy.abc import x
    >>> from sympy.utilities.lambdify import implemented_function, _imp_namespace
    >>> from sympy import Function
    >>> f = implemented_function(Function('f'), lambda x: x+1)
    >>> g = implemented_function(Function('g'), lambda x: x*10)
    >>> namespace = _imp_namespace(f(g(x)))
    >>> sorted(namespace.keys())
    ['f', 'g']
    """
    # Delayed import to avoid circular imports
    from sympy.core.function import FunctionClass
    if namespace is None:
        namespace = {}
    # tuples, lists, dicts are valid expressions
    if is_sequence(expr):
        for arg in expr:
            _imp_namespace(arg, namespace)
        return namespace
    elif isinstance(expr, dict):
        for key, val in expr.items():
            # functions can be in dictionary keys
            _imp_namespace(key, namespace)
            _imp_namespace(val, namespace)
        return namespace
    # sympy expressions may be Functions themselves
    func = getattr(expr, 'func', None)
    if isinstance(func, FunctionClass):
        imp = getattr(func, '_imp_', None)
        if imp is not None:
            name = expr.func.__name__
            if name in namespace and namespace[name] != imp:
                raise ValueError('We found more than one '
                                 'implementation with name '
                                 '"%s"' % name)
            namespace[name] = imp
    # and / or they may take Functions as arguments
    if hasattr(expr, 'args'):
        for arg in expr.args:
            _imp_namespace(arg, namespace)
    return namespace

def implemented_function(symfunc, implementation):
    """ Add numerical ``implementation`` to function ``symfunc``.

    ``symfunc`` can be an ``UndefinedFunction`` instance, or a name string.
    In the latter case we create an ``UndefinedFunction`` instance with that
    name.

    Be aware that this is a quick workaround, not a general method to create
    special symbolic functions. If you want to create a symbolic function to be
    used by all the machinery of SymPy you should subclass the ``Function``
    class.

    Parameters
    ----------
    symfunc : ``str`` or ``UndefinedFunction`` instance
       If ``str``, then create new ``UndefinedFunction`` with this as
       name.  If ``symfunc`` is an Undefined function, create a new function
       with the same name and the implemented function attached.
    implementation : callable
       numerical implementation to be called by ``evalf()`` or ``lambdify``

    Returns
    -------
    afunc : sympy.FunctionClass instance
       function with attached implementation

    Examples
    ========

    >>> from sympy.abc import x
    >>> from sympy.utilities.lambdify import lambdify, implemented_function
    >>> f = implemented_function('f', lambda x: x+1)
    >>> lam_f = lambdify(x, f(x))
    >>> lam_f(4)
    5
    """
    # Delayed import to avoid circular imports
    from sympy.core.function import UndefinedFunction
    # if name, create function to hold implementation
    kwargs = {}
    if isinstance(symfunc, UndefinedFunction):
        kwargs = symfunc._kwargs
        symfunc = symfunc.__name__
    if isinstance(symfunc, str):
        # Keyword arguments to UndefinedFunction are added as attributes to
        # the created class.
        symfunc = UndefinedFunction(
            symfunc, _imp_=staticmethod(implementation), **kwargs)
    elif not isinstance(symfunc, UndefinedFunction):
        raise ValueError(filldedent('''
            symfunc should be either a string or
            an UndefinedFunction instance.'''))
    return symfunc

import numpy,from numpy,import scipy,from scipy,import sympy,from sympy,from mpmath,import cupy


#importando pacotes
import pandas as pd
import numpy as np

#Criando um dicionario com os dados
dados = {'canal_venda' : ['Facebook', 'Twitter', 'Instagram', 'Linkedin', 'Facebook'],
         'acessos': [100,200,300,400,500],
         'site': ['site1','site1', 'site2', 'site2', 'site3' ],
         'vendas': [1000.52, 1052.34, 2002, 5000, 300]}

#Printa os dados do dicionario na tela
print(dados)

#Verificando o tipo de dicionario
print(type(dados))

#Acessando as chaves do meu dicionario
print(dados.keys())

#Acessando chave especifica
print(dados['canal_venda'])

#Acessando posicao especifica de um dicionario
print(dados['canal_venda'][2])

#Acessando posicoes especificas de um dicionario com intervalo
print(dados['canal_venda'][:2])

#Listas

#Verificando se é uma lista
print(type([1,2,3]))

#Criando uma lista
lista = [200, 200 , 300 ,800, 200]

#Printando a lista
print(lista)

#Vendo valores especificos
print(lista[1])

#Fatia de lista
print(lista[:2])

#Adicionando a lista ao dicionario
dados['lista'] = lista

print(dados)

#Data Frames

#Criando um data frame a partir de um dicionario
dataframe = pd.DataFrame(dados)

#printando o data frame
print(dataframe)

#Printando os 2 primeiros casos do data frame
print(dataframe.head(2))

#Verificando o formato do data frame
print(dataframe.shape)

#Verificando o indice do dataframe
print(dataframe.index)

#Verificando os tipos dos dados do dataframe
print(dataframe.dtypes)
print(dataframe.dtypes.value_counts())

#Verificando se existem valores faltantes, mostrando a tabela
print(dataframe.isna())

#Mostra o numero de acordo com a varival
print(dataframe.isna().sum())

#printando os nomes das colunas
print(dataframe.columns)

#Acessando uma coluna especifica
print(dataframe['canal_venda'])

# Criando uma nova coluna
dataframe['nova_coluna'] = [1, 2, 3, 4, 5]

#Mostrando novamente as colunas
print(dataframe.columns)

# Removendo colunas
dataframe.drop(columns = ['acessos','site', 'canal_venda'])
#Ele so elemina no data frame originial se usar o parametro inplace = true

#Acessando valores especificos
print(dataframe['acessos'][1])

#Acessando fatia de coluna especifica
print(dataframe['canal_venda'][:2])

#Fatiando dados com iloc: Linhas/Colunas
print(dataframe.iloc[1:2, 1:3])

#Fatiar os dados usando o loc (indice), que so pega o indice
print(dataframe.loc[:3])

#Selecionando colunas especificas
print(dataframe[['canal_venda', 'vendas']])

#Podemos passar os valores da coluna atraves de uma lista
filtro = ['canal_venda', 'acessos']
print(dataframe[filtro])

#Metodo info diz as caracteristicas do dataframe
print(dataframe.info())

#Pivotando os dados (coluna), funciona como uma juncao de colunas
aux = dataframe.pivot(index = 'canal_venda', columns='site', values='acessos')
print(aux)

#Completando os valores faltantes usando fillna, dizendo que os faltantes vao ser igualados a 0
#Pivotando os dados (coluna)
aux = dataframe.pivot(index = 'canal_venda', columns='site', values='acessos').fillna(0)
print(dataframe.pivot(index = 'canal_venda', columns='site', values='acessos').fillna(0))

# Mudando as colunas usando o comando melt
print(dataframe.melt(id_vars='site', value_vars=['canal_venda']))

#Resetando o indice do dataframe, voltando ao original
print(aux.columns)
aux = dataframe.reset_index()
print(aux.columns)

aux.reset_index()

#Exemplo do comando melt
#print(aux.melt(id_vars='canal_venda', value_vars=['site1', 'site2', 'site3']))

#Somando as colunas do dataframe
print(dataframe.sum())
print(dataframe.sum(axis = 1))

#Calculando a mediana das colunas numericas
print('Por linha: ',dataframe.median(axis= 1) )
print('Por coluna: ', dataframe.median())

#So pega os valores de numeros, nao pega as strings
#Calculando a media das colunas númericas
print(dataframe.mean())

#Calculando o desvio padrão das colunas numericas
print(dataframe.std())

#Usando o comando describe que calcula estatisticas descritivas para colunas numericas
print(dataframe.describe())

#Calculando a moda
print(dataframe.mode())

#Mostrando os valores max e min
print(dataframe.max() , dataframe.min())

#Printando o numero de unicos
print(dataframe.nunique())

#Contando valores unicos de uma coluna
print(dataframe['canal_venda'].value_counts())

#String com o nome dos valores unicos de uma coluna
print(dataframe['canal_venda'].unique())

# Usando o groupby com valores numericos
print(dataframe.groupby('site')['acessos'].sum())

# Usando o groupby com valores numericos
print(dataframe.groupby('canal_venda')['acessos'].median())

# Usando o groupby com categoricos
print(dataframe.groupby('site')['canal_venda'].first())

#Usando o groupby com a função agg
print(dataframe.groupby('canal_venda').agg({'site': 'unique',
                                     'acessos': 'sum'}))

#Correlações entre variaveis
print(dataframe.corr(method = 'spearman'))

#Criando variaveis categoricas por fatia de variavel numerica
dataframe['categoria_vendas'] = pd.cut(dataframe['vendas'],
                                       bins= (0, 1500, 2000, 8000),
                                       labels = ('0 a 1500', '1500 a 2000', '2000 a 8000'))

#Criando variavel categorica usando compressao de lista
dataframe['categoria_acessos'] = ['maior_que_300' if x > 300 else 'menor_que_300' for x in dataframe['acessos']]

#Criando o dataframe_2
dataframe_2 = pd.DataFrame({'site': ['site1', 'site1', 'site2', 'site2', 'site3'],
               'suporte': ['Carlos', 'Carlos', 'Maria', 'Maria', 'Ezequiel']})

#Realizando o merge para juntar os dois data frames
print(dataframe.merge(dataframe_2, on = 'site', how = 'left'))

#Salvando o dataframe como csv
dataframe.to_csv('dataframe.csv', sep = ';', decimal = ',', index = False)

#Lendo dados no formato csv
dataframe_lido = pd.read_csv('dataframe.csv', sep = ';', decimal = ',')


"""
Tests array tools.
"""
# Author: Kacper Sokol <k.sokol@bristol.ac.uk>
# License: new BSD

import numpy as np

import pytest

import fatf.utils.array.tools as fuat
import fatf.utils.array.validation as fuav

from fatf.exceptions import IncorrectShapeError
from fatf.utils.testing.arrays import (
    BASE_NP_ARRAY, NOT_BASE_NP_ARRAY, NOT_BASE_STRUCTURED_ARRAY,
    NOT_NUMERICAL_NP_ARRAY, NOT_NUMERICAL_STRUCTURED_ARRAY, NUMERICAL_NP_ARRAY,
    NUMERICAL_STRUCTURED_ARRAY, WIDE_NP_ARRAY, WIDE_STRUCTURED_ARRAY)

NUMERICAL_UNSTRUCTURED_ARRAY = np.array([
    [1.0, 1.0 + 1j],
    [1, 1 + 1j],
    [np.nan, -1 + 1j],
    [np.inf, -1 + 1j],
    [-np.inf, -1 + 1j],
    [-1, -1 + 1j]])  # yapf: disable
NOT_NUMERICAL_UNSTRUCTURED_ARRAY = np.array([
    [1 + 0.j, 'a'],
    [1 + 0.j, 'b'],
    [-1 + 0.j, 'c'],
    [1 + 0.j, 'd'],
    [1 + 1j, 'e'],
    [0j, 'f'],
    [np.nan + 0j, 'g'],
    [np.inf + 0j, 'h'],
    [-np.inf + 0j, 'i']])  # yapf: disable
WIDE_UNSTRUCTURED_ARRAY = np.array([
    [1.0, 1.0 + 1j, np.nan],
    [np.inf, 1 + 1j, 6],
    [-1, -1 + 1j, -np.inf]])  # yapf: disable

NP_VER = [int(i) for i in np.version.version.split('.')]

def _compare_nan_arrays(array1, array2):
    """
    Compares 2 numpy arrays and returns True if they are element-wise the same.
    """
    assert not fuav.is_structured_array(array1), 'array1 cannot be structured.'
    assert not fuav.is_structured_array(array2), 'array2 cannot be structured.'
    assert array1.shape == array2.shape, 'Inputs must be of the same shape.'
    # pylint: disable=len-as-condition
    assert len(array1.shape) > 0 and len(array1.shape) < 3, 'Only 1D or 2D.'
    are_equal = True
    if len(array1.shape) == 1:
        for i in range(array1.shape[0]):
            if np.isnan(array1[i]) and np.isnan(array2[i]):
                continue
            elif array1[i] != array2[i]:
                are_equal = False
                break
    elif len(array1.shape) == 2:
        for i in range(array1.shape[0]):
            for j in range(array1.shape[1]):
                if np.isnan(array1[i, j]) and np.isnan(array2[i, j]):
                    continue
                elif array1[i, j] != array2[i, j]:
                    are_equal = False
                    break
            if not are_equal:
                break
    return are_equal

def test_compare_nan_arrays():
    """
    Tests numpy arrays element-wise array comparison.
    """
    assertion_error_1 = 'array1 cannot be structured.'
    assertion_error_2 = 'array2 cannot be structured.'
    assertion_error_3 = 'Inputs must be of the same shape.'
    assertion_error_4 = 'Only 1D or 2D.'

    array_3d_a = np.ones((2, 2, 2), dtype=float)
    array_struct = np.array([(1, 1.)], dtype=[('a', int), ('b', float)])
    array_1d_a = np.array([1, np.nan, 3])
    array_1d_b = np.array([-np.inf, 5, np.inf])
    array_2d_a = np.array([[1, np.nan, 3], [-np.inf, 5, np.inf]])
    array_2d_b = np.array([[-np.inf, 5, np.inf], [1, np.nan, 3]])

    # Assertion error 1 -- structured array 1
    with pytest.raises(AssertionError) as exin:
        _compare_nan_arrays(array_struct, array_struct)
    assert str(exin.value).startswith(assertion_error_1)

    # Assertion error 2 -- structured array 2
    with pytest.raises(AssertionError) as exin:
        _compare_nan_arrays(array_1d_a, array_struct)
    assert str(exin.value).startswith(assertion_error_2)

    # Assertion error 3 -- different shapes
    with pytest.raises(AssertionError) as exin:
        _compare_nan_arrays(array_1d_a, array_2d_a)
    assert str(exin.value).startswith(assertion_error_3)

    # Assertion error 4 -- 3D array
    with pytest.raises(AssertionError) as exin:
        _compare_nan_arrays(array_3d_a, array_3d_a)
    assert str(exin.value).startswith(assertion_error_4)

    # 1D
    assert not _compare_nan_arrays(array_1d_a, array_1d_b)
    assert _compare_nan_arrays(array_1d_a, array_2d_a[0, :])
    assert not _compare_nan_arrays(array_1d_a, array_2d_a[1, :])
    assert not _compare_nan_arrays(array_1d_b, array_2d_a[0, :])
    assert _compare_nan_arrays(array_1d_b, array_2d_a[1, :])

    # 2D
    assert not _compare_nan_arrays(array_2d_a, array_2d_b)
    assert not _compare_nan_arrays(array_2d_a[[0], :], array_2d_b[[0], :])
    assert _compare_nan_arrays(array_2d_a, array_2d_b[[1, 0], :])
    assert _compare_nan_arrays(array_2d_a[[0], :], array_2d_b[[1], :])
    assert _compare_nan_arrays(array_2d_a[[1], :], array_2d_b[[0], :])

def test_indices_by_type():
    """
    Tests :func:`fatf.utils.array.tools.indices_by_type` function.
    """
    # pylint: disable=too-many-locals,too-many-statements
    # Test any object and shape
    type_error = 'The input should be a numpy array-like.'
    incorrect_shape_error = 'The input array should be 2-dimensional.'
    value_error = ('indices_by_type only supports input arrays that hold base '
                   'numpy types, i.e. numerical and string-like -- numpy void '
                   'and object-like types are not allowed.')
    with pytest.raises(TypeError) as exin:
        fuat.indices_by_type(None)
    assert str(exin.value) == type_error
    with pytest.raises(IncorrectShapeError) as exin:
        fuat.indices_by_type(np.empty((0, )))
    assert str(exin.value) == incorrect_shape_error
    with pytest.raises(ValueError) as exin:
        fuat.indices_by_type(NOT_NUMERICAL_NP_ARRAY)
    assert str(exin.value) == value_error

    # Empty array
    i_n, i_c = fuat.indices_by_type(np.empty((22, 0)))
    assert np.array_equal([], i_n)
    assert np.array_equal([], i_c)

    # All numerical array
    array_all_numerical = np.ones((22, 4))
    array_all_numerical_indices_numerical = np.array([0, 1, 2, 3])
    array_all_numerical_indices_categorical = np.array([], dtype=int)
    i_n, i_c = fuat.indices_by_type(array_all_numerical)
    assert np.array_equal(array_all_numerical_indices_numerical, i_n)
    assert np.array_equal(array_all_numerical_indices_categorical, i_c)

    # All categorical -- single type -- array
    array_all_categorical = np.ones((22, 4), dtype='U4')
    array_all_categorical_indices_numerical = np.array([])
    array_all_categorical_indices_categorical = np.array([0, 1, 2, 3])
    i_n, i_c = fuat.indices_by_type(array_all_categorical)
    assert np.array_equal(array_all_categorical_indices_numerical, i_n)
    assert np.array_equal(array_all_categorical_indices_categorical, i_c)

    # Mixture array
    array_mixture_1 = np.ones((22, ), dtype=[('a', 'U4'),
                                             ('b', 'U4'),
                                             ('c', 'U4'),
                                             ('d', 'U4')])  # yapf: disable
    array_mixture_1_indices_numerical = np.array([])
    array_mixture_1_indices_categorical = np.array(['a', 'b', 'c', 'd'],
                                                   dtype='U1')
    ####
    i_n, i_c = fuat.indices_by_type(array_mixture_1)
    assert np.array_equal(array_mixture_1_indices_numerical, i_n)
    assert np.array_equal(array_mixture_1_indices_categorical, i_c)

    array_mixture_2 = np.ones((22, ), dtype=[('a', 'U4'),
                                             ('b', 'f'),
                                             ('c', 'U4'),
                                             ('d', int)])  # yapf: disable
    array_mixture_2_indices_numerical = np.array(['b', 'd'], dtype='U1')
    array_mixture_2_indices_categorical = np.array(['a', 'c'], dtype='U1')
    i_n, i_c = fuat.indices_by_type(array_mixture_2)
    assert np.array_equal(array_mixture_2_indices_numerical, i_n)
    assert np.array_equal(array_mixture_2_indices_categorical, i_c)

    glob_indices_numerical = np.array([0, 1])
    glob_indices_categorical = np.array([])
    i_n, i_c = fuat.indices_by_type(NUMERICAL_NP_ARRAY)
    assert np.array_equal(glob_indices_numerical, i_n)
    assert np.array_equal(glob_indices_categorical, i_c)
    #
    glob_indices_numerical = np.array([0, 1, 2])
    glob_indices_categorical = np.array([])
    i_n, i_c = fuat.indices_by_type(WIDE_NP_ARRAY)
    assert np.array_equal(glob_indices_numerical, i_n)
    assert np.array_equal(glob_indices_categorical, i_c)
    #
    glob_indices_numerical = np.array(['numbers', 'complex'])
    glob_indices_categorical = np.array([])
    i_n, i_c = fuat.indices_by_type(NUMERICAL_STRUCTURED_ARRAY)
    assert np.array_equal(glob_indices_numerical, i_n)
    assert np.array_equal(glob_indices_categorical, i_c)
    #
    glob_indices_numerical = np.array(['numerical'])
    glob_indices_categorical = np.array(['categorical'])
    i_n, i_c = fuat.indices_by_type(NOT_NUMERICAL_STRUCTURED_ARRAY)
    assert np.array_equal(glob_indices_numerical, i_n)
    assert np.array_equal(glob_indices_categorical, i_c)
    #
    glob_indices_numerical = np.array(['numbers', 'complex', 'anybody'])
    glob_indices_categorical = np.array([])
    i_n, i_c = fuat.indices_by_type(WIDE_STRUCTURED_ARRAY)
    assert np.array_equal(glob_indices_numerical, i_n)
    assert np.array_equal(glob_indices_categorical, i_c)

def test_get_invalid_indices():
    """
    Tests :func:`fatf.utils.array.tools.get_invalid_indices` function.
    """
    type_error = 'Input arrays should be numpy array-like objects.'
    incorrect_shape_array = 'The input array should be 2-dimensional.'
    incorrect_shape_indices = 'The indices array should be 1-dimensional.'
    with pytest.raises(TypeError) as exin:
        fuat.get_invalid_indices(None, np.ones((4, )))
    assert str(exin.value) == type_error
    with pytest.raises(TypeError) as exin:
        fuat.get_invalid_indices(None, np.ones((4, 4)))
    assert str(exin.value) == type_error
    with pytest.raises(TypeError) as exin:
        fuat.get_invalid_indices(np.ones((4, )), None)
    assert str(exin.value) == type_error
    with pytest.raises(TypeError) as exin:
        fuat.get_invalid_indices(None, np.ones((4, 4)))
    assert str(exin.value) == type_error
    # Incorrect shape array
    with pytest.raises(IncorrectShapeError) as exin:
        fuat.get_invalid_indices(np.ones((5, )), np.ones((4, 4)))
    assert str(exin.value) == incorrect_shape_array
    with pytest.raises(IncorrectShapeError) as exin:
        fuat.get_invalid_indices(np.ones((5, )), np.ones((4, )))
    assert str(exin.value) == incorrect_shape_array
    with pytest.raises(IncorrectShapeError) as exin:
        fuat.get_invalid_indices(np.ones((5, 3)), np.ones((4, 4)))
    assert str(exin.value) == incorrect_shape_indices

    gind = fuat.get_invalid_indices(NUMERICAL_NP_ARRAY, np.array([0, 2]))
    assert np.array_equal(gind, np.array([2]))
    gind = fuat.get_invalid_indices(NUMERICAL_NP_ARRAY, np.array(['a', 1]))
    assert np.array_equal(gind, np.array(['1', 'a']))
    gind = fuat.get_invalid_indices(NUMERICAL_NP_ARRAY, np.array([1, 0]))
    assert np.array_equal(gind, np.array([]))
    assert np.array_equal(gind, np.empty((0, )))
    #
    gind = fuat.get_invalid_indices(NOT_NUMERICAL_NP_ARRAY, np.array([0, 2]))
    assert np.array_equal(gind, np.array([2]))
    gind = fuat.get_invalid_indices(NOT_NUMERICAL_NP_ARRAY, np.array(['a', 1]))
    assert np.array_equal(gind, np.array(['1', 'a']))
    #
    gind = fuat.get_invalid_indices(NUMERICAL_STRUCTURED_ARRAY,
                                    np.array([0, 'numbers']))
    assert np.array_equal(gind, np.array(['0']))
    gind = fuat.get_invalid_indices(NUMERICAL_STRUCTURED_ARRAY, np.array([0]))
    assert np.array_equal(gind, np.array([0]))
    gind = fuat.get_invalid_indices(NUMERICAL_STRUCTURED_ARRAY,
                                    np.array(['complex', 'numbers']))
    assert np.array_equal(gind, np.array([]))
    #
    gind = fuat.get_invalid_indices(WIDE_STRUCTURED_ARRAY,
                                    np.array(['complex', 'numbers']))
    assert np.array_equal(gind, np.array([]))

def test_are_indices_valid():
    """
    Tests :func:`fatf.utils.array.tools.are_indices_valid` function.
    """
    type_error = 'Input arrays should be numpy array-like objects.'
    incorrect_shape_array = 'The input array should be 2-dimensional.'
    incorrect_shape_indices = 'The indices array should be 1-dimensional.'
    with pytest.raises(TypeError) as exin:
        fuat.are_indices_valid(None, np.ones((4, )))
    assert str(exin.value) == type_error
    with pytest.raises(TypeError) as exin:
        fuat.are_indices_valid(None, np.ones((4, 4)))
    assert str(exin.value) == type_error
    with pytest.raises(TypeError) as exin:
        fuat.are_indices_valid(np.ones((4, )), None)
    assert str(exin.value) == type_error
    with pytest.raises(TypeError) as exin:
        fuat.are_indices_valid(None, np.ones((4, 4)))
    assert str(exin.value) == type_error
    # Incorrect shape array
    with pytest.raises(IncorrectShapeError) as exin:
        fuat.are_indices_valid(np.ones((5, )), np.ones((4, 4)))
    assert str(exin.value) == incorrect_shape_array
    with pytest.raises(IncorrectShapeError) as exin:
        fuat.are_indices_valid(np.ones((5, )), np.ones((4, )))
    assert str(exin.value) == incorrect_shape_array
    with pytest.raises(IncorrectShapeError) as exin:
        fuat.are_indices_valid(np.ones((5, 3)), np.ones((4, 4)))
    assert str(exin.value) == incorrect_shape_indices

    assert not fuat.are_indices_valid(NUMERICAL_NP_ARRAY, np.array([0, 2]))
    assert not fuat.are_indices_valid(NUMERICAL_NP_ARRAY, np.array(['a', 1]))
    assert fuat.are_indices_valid(NUMERICAL_NP_ARRAY, np.array([1, 0]))
    #
    assert not fuat.are_indices_valid(NOT_NUMERICAL_NP_ARRAY, np.array([0, 2]))
    assert not fuat.are_indices_valid(NOT_NUMERICAL_NP_ARRAY,
                                      np.array(['a', 1]))  # yapf: disable
    assert fuat.are_indices_valid(NOT_NUMERICAL_NP_ARRAY, np.array([0, 1]))
    #
    assert not fuat.are_indices_valid(NUMERICAL_STRUCTURED_ARRAY,
                                      np.array([0, 'numbers']))
    assert not fuat.are_indices_valid(NUMERICAL_STRUCTURED_ARRAY,
                                      np.array([0]))  # yapf: disable
    assert fuat.are_indices_valid(NUMERICAL_STRUCTURED_ARRAY,
                                  np.array(['complex', 'numbers']))
    #
    assert fuat.are_indices_valid(WIDE_STRUCTURED_ARRAY,
                                  np.array(['complex', 'numbers']))

def test_generalise_dtype():
    """
    Tests :func:`fatf.utils.array.tools.generalise_dtype`.
    """
    error_msg = 'The {} dtype is not one of the base types (strings/numbers).'
    with pytest.raises(ValueError) as exin:
        fuat.generalise_dtype(np.dtype(np.datetime64), np.dtype(np.datetime64))
    assert str(exin.value) == error_msg.format('first')

    with pytest.raises(ValueError) as exin:
        fuat.generalise_dtype(np.dtype(np.float64), np.dtype(np.datetime64))
    assert str(exin.value) == error_msg.format('second')

    dtype_int = np.dtype(int)
    dtype_int32 = np.dtype(np.int32)
    dtype_int64 = np.dtype(np.int64)
    dtype_float = np.dtype(float)
    dtype_float16 = np.dtype(np.float16)
    dtype_float32 = np.dtype(np.float32)
    dtype_float64 = np.dtype(np.float64)
    dtype_str = np.dtype(str)
    dtype_str4 = np.dtype('U4')
    dtype_str11 = np.dtype('U11')
    dtype_str16 = np.dtype('U16')
    dtype_str21 = np.dtype('U21')
    dtype_str32 = np.dtype('U32')

    assert dtype_int64 is fuat.generalise_dtype(dtype_int, dtype_int32)
    assert dtype_int64 is fuat.generalise_dtype(dtype_int, dtype_int64)
    assert dtype_int64 is fuat.generalise_dtype(dtype_int32, dtype_int64)
    assert dtype_int64 is fuat.generalise_dtype(dtype_int, dtype_int)

    assert dtype_float64 is fuat.generalise_dtype(dtype_float, dtype_float)
    assert dtype_float64 is fuat.generalise_dtype(dtype_float64, dtype_float)
    assert dtype_float64 is fuat.generalise_dtype(dtype_int, dtype_float32)
    assert dtype_float64 is fuat.generalise_dtype(dtype_int32, dtype_float32)
    assert dtype_float32 is fuat.generalise_dtype(dtype_float32, dtype_float16)

    assert dtype_str4 is fuat.generalise_dtype(dtype_str, dtype_str4)
    assert dtype_str21 is fuat.generalise_dtype(dtype_str21, dtype_str4)

    assert dtype_str16 == fuat.generalise_dtype(dtype_str11, dtype_str16)
    assert dtype_str11 == fuat.generalise_dtype(dtype_int32, dtype_str4)
    assert dtype_str21 == fuat.generalise_dtype(dtype_int64, dtype_str4)
    assert dtype_str32 == fuat.generalise_dtype(dtype_float32, dtype_str4)
    assert dtype_str32 == fuat.generalise_dtype(dtype_float64, dtype_str16)

def test_fatf_structured_to_unstructured_row():
    """
    Tests :func:`fatf.utils.array.tools.fatf_structured_to_unstructured_row`.
    """
    type_error = 'The input should be a row of a structured array.'
    with pytest.raises(TypeError) as exin:
        fuat.fatf_structured_to_unstructured_row(
            np.array([b'123'], np.void)[0])
    assert str(exin.value) == type_error
    value_arror = ('structured_to_unstructured_row only supports conversion '
                   'of structured rows that hold base numpy types, i.e. '
                   'numerical and string-like -- numpy void and object-like '
                   'types are not allowed.')
    with pytest.raises(ValueError) as exin:
        fuat.fatf_structured_to_unstructured_row(NOT_BASE_STRUCTURED_ARRAY[0])
    assert str(exin.value) == value_arror

    simple = fuat.fatf_structured_to_unstructured_row(
        NUMERICAL_STRUCTURED_ARRAY[0])
    assert _compare_nan_arrays(simple, NUMERICAL_UNSTRUCTURED_ARRAY[0])
    simple = fuat.fatf_structured_to_unstructured_row(
        NUMERICAL_STRUCTURED_ARRAY[2])
    assert _compare_nan_arrays(simple, NUMERICAL_UNSTRUCTURED_ARRAY[2])
    simple = fuat.fatf_structured_to_unstructured_row(
        NUMERICAL_STRUCTURED_ARRAY[3])
    assert _compare_nan_arrays(simple, NUMERICAL_UNSTRUCTURED_ARRAY[3])
    #
    simple = fuat.fatf_structured_to_unstructured_row(
        NOT_NUMERICAL_STRUCTURED_ARRAY[0])
    assert np.array_equal(simple, NOT_NUMERICAL_UNSTRUCTURED_ARRAY[0])
    simple = fuat.fatf_structured_to_unstructured_row(
        NOT_NUMERICAL_STRUCTURED_ARRAY[6])
    assert np.array_equal(simple, NOT_NUMERICAL_UNSTRUCTURED_ARRAY[6])
    simple = fuat.fatf_structured_to_unstructured_row(
        NOT_NUMERICAL_STRUCTURED_ARRAY[7])
    assert np.array_equal(simple, NOT_NUMERICAL_UNSTRUCTURED_ARRAY[7])
    #
    simple = fuat.fatf_structured_to_unstructured_row(WIDE_STRUCTURED_ARRAY[0])
    assert _compare_nan_arrays(simple, WIDE_UNSTRUCTURED_ARRAY[0])
    simple = fuat.fatf_structured_to_unstructured_row(WIDE_STRUCTURED_ARRAY[2])
    assert _compare_nan_arrays(simple, WIDE_UNSTRUCTURED_ARRAY[2])

    assert fuat.fatf_structured_to_unstructured_row(
        np.array([(7, )], dtype=[('f', float)])[0]) == 7

def test_structured_to_unstructured_row():
    """
    Tests :func:`fatf.utils.array.tools.structured_to_unstructured_row`.
    """
    simple = fuat.fatf_structured_to_unstructured_row(
        NUMERICAL_STRUCTURED_ARRAY[2])
    assert _compare_nan_arrays(simple, NUMERICAL_UNSTRUCTURED_ARRAY[2])
    assert fuat.fatf_structured_to_unstructured_row(
        np.array([(7, )], dtype=[('f', float)])[0]) == 7
    assert ('This function need not be tested as test_choose_structured_to_'
            'unstructured and test_fatf_structured_to_unstructured_row tests '
            'are sufficient and there is no straight forward way of testing '
            'it.')

def test_choose_structured_to_unstructured(caplog):
    """
    Tests :func:`fatf.utils.array.tools._choose_structured_to_unstructured`.
    """
    # pylint: disable=protected-access
    # Memorise current numpy version
    installed_numpy_version = np.version.version
    # Fake version lower than 1.16.0
    np.version.version = '1.15.999'
    log_message = ("Using fatf's fatf.utils.array.tools."
                   'fatf_structured_to_unstructured as fatf.utils.'
                   'array.tools.structured_to_unstructured and fatf.utils.'
                   'array.tools.fatf_structured_to_unstructured_row as '
                   'fatf.utils.array.tools.structured_to_unstructured_row.')
    assert fuat._choose_structured_to_unstructured()
    assert len(caplog.records) == 1
    assert caplog.records[0].levelname == 'INFO'
    assert caplog.records[0].getMessage() == log_message
    # Fake at least 1.16.0 version
    np.version.version = '1.16.000'
    log_message = ("Using numpy's numpy.lib.recfunctions."
                   'structured_to_unstructured as fatf.utils.array.tools.'
                   'structured_to_unstructured and fatf.utils.array.tools.'
                   'structured_to_unstructured_row.')
    assert not fuat._choose_structured_to_unstructured()
    assert len(caplog.records) == 2
    assert caplog.records[1].levelname == 'INFO'
    assert caplog.records[1].getMessage() == log_message
    # Restore numpy version
    assert len(caplog.records) == 2
    np.version.version = installed_numpy_version

def test_fatf_structured_to_unstructured():
    """
    Tests :func:`fatf.utils.array.tools.fatf_structured_to_unstructured`.
    """
    # Wrong array types
    type_error = 'structured_array should be a structured numpy array.'
    with pytest.raises(TypeError) as exin:
        fuat.fatf_structured_to_unstructured(NUMERICAL_NP_ARRAY)
    assert str(exin.value) == type_error
    with pytest.raises(TypeError) as exin:
        fuat.fatf_structured_to_unstructured(NOT_NUMERICAL_NP_ARRAY)
    assert str(exin.value) == type_error
    with pytest.raises(TypeError) as exin:
        fuat.fatf_structured_to_unstructured(WIDE_NP_ARRAY)
    assert str(exin.value) == type_error

    # Arrays of complex-types
    value_error = ('fatf_structured_to_unstructured only supports conversion '
                   'of arrays that hold base numpy types, i.e. numerical and '
                   'string-like -- numpy void and object-like types are not '
                   'allowed.')
    complex_array = np.array([(None, object())],
                             dtype=[('n', 'O'), ('o', 'O')])
    with pytest.raises(ValueError) as exin:
        fuat.fatf_structured_to_unstructured(complex_array)
    assert str(exin.value) == value_error

    # Right type
    simple = fuat.fatf_structured_to_unstructured(NUMERICAL_STRUCTURED_ARRAY)
    assert _compare_nan_arrays(simple, NUMERICAL_UNSTRUCTURED_ARRAY)
    simple = fuat.fatf_structured_to_unstructured(
        NOT_NUMERICAL_STRUCTURED_ARRAY)
    assert np.array_equal(simple, NOT_NUMERICAL_UNSTRUCTURED_ARRAY)
    simple = fuat.fatf_structured_to_unstructured(WIDE_STRUCTURED_ARRAY)
    assert _compare_nan_arrays(simple, WIDE_UNSTRUCTURED_ARRAY)

    simple = fuat.fatf_structured_to_unstructured(
        np.array([(7, )], dtype=[('f', float)]))
    assert np.array_equal(simple, np.array([[7]]))
    simple = fuat.fatf_structured_to_unstructured(
        np.array([(4, ), (2, )], dtype=[('f', float)]))
    assert np.array_equal(simple, np.array([[4], [2]]))

def test_structured_to_unstructured():
    """
    Tests :func:`fatf.utils.array.tools.structured_to_unstructured`.
    """
    simple = fuat.structured_to_unstructured(NOT_NUMERICAL_STRUCTURED_ARRAY)
    assert np.array_equal(simple, NOT_NUMERICAL_UNSTRUCTURED_ARRAY)
    simple = fuat.structured_to_unstructured(
        np.array([(7, )], dtype=[('f', float)]))
    assert _compare_nan_arrays(simple, np.array([[7]]))
    assert ('This function need not be tested as test_choose_structured_to_'
            'unstructured and test_fatf_structured_to_unstructured tests are '
            'sufficient and there is no straight forward way of testing it.')

def test_as_unstructured():
    """
    Tests :func:`fatf.utils.array.tools.as_unstructured`.
    """
    type_error = ('The input should either be a numpy (structured or '
                  'unstructured) array-like object (numpy.ndarray) or a row '
                  'of a structured numpy array (numpy.void).')
    value_error = ('as_unstructured only supports conversion of arrays that '
                   'hold base numpy types, i.e. numerical and string-like -- '
                   'numpy void and object-like types are not allowed.')
    # Test incompatible -- None -- type
    with pytest.raises(TypeError) as exin:
        fuat.as_unstructured(None)
    assert str(exin.value) == type_error

    # Test np.void -- a structured array's row
    simple = fuat.as_unstructured(NUMERICAL_STRUCTURED_ARRAY[0])
    assert _compare_nan_arrays(simple, NUMERICAL_UNSTRUCTURED_ARRAY[0])

    # Test structured array
    simple = fuat.as_unstructured(NOT_NUMERICAL_STRUCTURED_ARRAY)
    assert np.array_equal(simple, NOT_NUMERICAL_UNSTRUCTURED_ARRAY)
    # Test unstructured -- base type
    simple = fuat.as_unstructured(BASE_NP_ARRAY)
    assert np.array_equal(simple, BASE_NP_ARRAY)
    # Test unstructured -- not base type
    with pytest.raises(ValueError) as exin:
        fuat.as_unstructured(NOT_BASE_NP_ARRAY)
    assert str(exin.value) == value_error