copulas 0.10.1.dev0__py3-none-any.whl → 0.12.1.dev0__py3-none-any.whl

copulas/multivariate/tree.py

@@ -6,9 +6,9 @@ from enum import Enum
 import numpy as np
 import scipy
 
-from copulas import EPSILON, get_qualified_name
 from copulas.bivariate.base import Bivariate
 from copulas.multivariate.base import Multivariate
+from copulas.utils import EPSILON, get_qualified_name
 
 LOGGER = logging.getLogger(__name__)
 
@@ -98,7 +98,7 @@ class Tree(Multivariate):
         """
         # first column is the variable of interest
         tau_y = self.tau_matrix[:, y]
-        tau_y[y] = np.NaN
+        tau_y[y] = np.nan
 
         temp = np.empty([self.n_nodes, 3])
         temp[:, 0] = np.arange(self.n_nodes)
@@ -131,7 +131,7 @@ class Tree(Multivariate):
                     left_parent, right_parent = edge.parents
                     left_u, right_u = Edge.get_conditional_uni(left_parent, right_parent)
 
-                tau[i, j], pvalue = scipy.stats.kendalltau(left_u, right_u)
+                tau[i, j], _pvalue = scipy.stats.kendalltau(left_u, right_u)
 
         return tau
 
@@ -212,8 +212,7 @@ class Tree(Multivariate):
         """Produce printable representation of the class."""
         template = 'L:{} R:{} D:{} Copula:{} Theta:{}'
         return '\n'.join([
-            template.format(edge.L, edge.R, edge.D, edge.name, edge.theta)
-            for edge in self.edges
+            template.format(edge.L, edge.R, edge.D, edge.name, edge.theta) for edge in self.edges
         ])
 
     def _serialize_previous_tree(self):
@@ -237,11 +236,7 @@ class Tree(Multivariate):
                 Parameters of this Tree.
         """
         fitted = self.fitted
-        result = {
-            'tree_type': self.tree_type,
-            'type': get_qualified_name(self),
-            'fitted': fitted
-        }
+        result = {'tree_type': self.tree_type, 'type': get_qualified_name(self), 'fitted': fitted}
 
         if not fitted:
             return result
@@ -451,7 +446,7 @@ def get_tree(tree_type):
             Instance of a Tree of the specified type.
     """
     if not isinstance(tree_type, TreeTypes):
-        if (isinstance(tree_type, str) and tree_type.upper() in TreeTypes.__members__):
+        if isinstance(tree_type, str) and tree_type.upper() in TreeTypes.__members__:
             tree_type = TreeTypes[tree_type.upper()]
         else:
             raise ValueError(f'Invalid tree type {tree_type}')
@@ -657,7 +652,7 @@ class Edge(object):
             'theta': self.theta,
             'tau': self.tau,
             'U': U,
-            'likelihood': self.likelihood
+            'likelihood': self.likelihood,
         }
 
     @classmethod
@@ -674,8 +669,11 @@ class Edge(object):
                 Instance of the edge defined on the parameters.
         """
         instance = cls(
-            edge_dict['index'], edge_dict['L'], edge_dict['R'],
-            edge_dict['name'], edge_dict['theta']
+            edge_dict['index'],
+            edge_dict['L'],
+            edge_dict['R'],
+            edge_dict['name'],
+            edge_dict['theta'],
         )
         instance.U = np.array(edge_dict['U'])
         parents = edge_dict['parents']

copulas/multivariate/vine.py

@@ -7,13 +7,18 @@ import warnings
 import numpy as np
 import pandas as pd
 
-from copulas import (
-    EPSILON, check_valid_values, get_qualified_name, random_state, store_args,
-    validate_random_state)
 from copulas.bivariate.base import Bivariate, CopulaTypes
 from copulas.multivariate.base import Multivariate
 from copulas.multivariate.tree import Tree, get_tree
 from copulas.univariate.gaussian_kde import GaussianKDE
+from copulas.utils import (
+    EPSILON,
+    check_valid_values,
+    get_qualified_name,
+    random_state,
+    store_args,
+    validate_random_state,
+)
 
 LOGGER = logging.getLogger(__name__)
 
@@ -71,8 +76,7 @@ class VineCopula(Multivariate):
     def __init__(self, vine_type, random_state=None):
         if sys.version_info > (3, 8):
             warnings.warn(
-                'Vines have not been fully tested on Python >= 3.8 and might '
-                'produce wrong results.'
+                'Vines have not been fully tested on Python >= 3.8 and might produce wrong results.'
             )
 
         self.random_state = validate_random_state(random_state)
@@ -103,7 +107,7 @@ class VineCopula(Multivariate):
         result = {
             'type': get_qualified_name(self),
             'vine_type': self.vine_type,
-            'fitted': self.fitted
+            'fitted': self.fitted,
         }
 
         if not self.fitted:
@@ -118,7 +122,7 @@ class VineCopula(Multivariate):
             'tau_mat': self.tau_mat.tolist(),
             'u_matrix': self.u_matrix.tolist(),
             'unis': [distribution.to_dict() for distribution in self.unis],
-            'columns': self.columns
+            'columns': self.columns,
         })
         return result
 
@@ -293,8 +297,9 @@ class VineCopula(Multivariate):
                     # get index of edge to retrieve
                     for edge in current_tree:
                         if i == 0:
-                            if (edge.L == current and edge.R == visited[0]) or\
-                               (edge.R == current and edge.L == visited[0]):
+                            if (edge.L == current and edge.R == visited[0]) or (
+                                edge.R == current and edge.L == visited[0]
+                            ):
                                 current_ind = edge.index
                                 break
                         else:

copulas/optimize/__init__.py

@@ -127,7 +127,7 @@ def chandrupatla(f, xmin, xmax, eps_m=None, eps_a=None, maxiter=50):
         # to determine which method we should use next
         xi = (a - b) / (c - b)
         phi = (fa - fb) / (fc - fb)
-        iqi = np.logical_and(phi**2 < xi, (1 - phi)**2 < 1 - xi)
+        iqi = np.logical_and(phi**2 < xi, (1 - phi) ** 2 < 1 - xi)
 
         if not shape:
             # scalar case
@@ -143,8 +143,9 @@ def chandrupatla(f, xmin, xmax, eps_m=None, eps_a=None, maxiter=50):
             # array case
             t = np.full(shape, 0.5)
             a2, b2, c2, fa2, fb2, fc2 = a[iqi], b[iqi], c[iqi], fa[iqi], fb[iqi], fc[iqi]
-            t[iqi] = fa2 / (fb2 - fa2) * fc2 / (fb2 - fc2) + (c2 - a2) / \
-                (b2 - a2) * fa2 / (fc2 - fa2) * fb2 / (fc2 - fb2)
+            t[iqi] = fa2 / (fb2 - fa2) * fc2 / (fb2 - fc2) + (c2 - a2) / (b2 - a2) * fa2 / (
+                fc2 - fa2
+            ) * fb2 / (fc2 - fb2)
 
         # limit to the range (tlim, 1-tlim)
         t = np.minimum(1 - tlim, np.maximum(tlim, t))

copulas/univariate/__init__.py

@@ -21,5 +21,5 @@ __all__ = (
     'ParametricType',
     'BoundedType',
     'UniformUnivariate',
-    'LogLaplace'
+    'LogLaplace',
 )

copulas/univariate/base.py

@@ -6,10 +6,15 @@ from enum import Enum
 
 import numpy as np
 
-from copulas import (
-    NotFittedError, get_instance, get_qualified_name, random_state, store_args,
-    validate_random_state)
+from copulas.errors import NotFittedError
 from copulas.univariate.selection import select_univariate
+from copulas.utils import (
+    get_instance,
+    get_qualified_name,
+    random_state,
+    store_args,
+    validate_random_state,
+)
 
 
 class ParametricType(Enum):
@@ -84,8 +89,14 @@ class Univariate(object):
         return candidates
 
     @store_args
-    def __init__(self, candidates=None, parametric=None, bounded=None, random_state=None,
-                 selection_sample_size=None):
+    def __init__(
+        self,
+        candidates=None,
+        parametric=None,
+        bounded=None,
+        random_state=None,
+        selection_sample_size=None,
+    ):
         self.candidates = candidates or self._select_candidates(parametric, bounded)
         self.random_state = validate_random_state(random_state)
         self.selection_sample_size = selection_sample_size

copulas/univariate/beta.py

@@ -28,12 +28,7 @@ class BetaUnivariate(ScipyModel):
         loc = np.min(X)
         scale = np.max(X) - loc
         a, b, loc, scale = beta.fit(X, loc=loc, scale=scale)
-        self._params = {
-            'loc': loc,
-            'scale': scale,
-            'a': a,
-            'b': b
-        }
+        self._params = {'loc': loc, 'scale': scale, 'a': a, 'b': b}
 
     def _is_constant(self):
         return self._params['scale'] == 0

copulas/univariate/gaussian.py

@@ -15,16 +15,10 @@ class GaussianUnivariate(ScipyModel):
     MODEL_CLASS = norm
 
     def _fit_constant(self, X):
-        self._params = {
-            'loc': np.unique(X)[0],
-            'scale': 0
-        }
+        self._params = {'loc': np.unique(X)[0], 'scale': 0}
 
     def _fit(self, X):
-        self._params = {
-            'loc': np.mean(X),
-            'scale': np.std(X)
-        }
+        self._params = {'loc': np.mean(X), 'scale': np.std(X)}
 
     def _is_constant(self):
         return self._params['scale'] == 0

copulas/univariate/gaussian_kde.py

@@ -4,9 +4,9 @@ import numpy as np
 from scipy.special import ndtr
 from scipy.stats import gaussian_kde
 
-from copulas import EPSILON, random_state, store_args, validate_random_state
 from copulas.optimize import bisect, chandrupatla
 from copulas.univariate.base import BoundedType, ParametricType, ScipyModel
+from copulas.utils import EPSILON, random_state, store_args, validate_random_state
 
 
 class GaussianKDE(ScipyModel):
@@ -129,7 +129,7 @@ class GaussianKDE(ScipyModel):
         self.check_fit()
 
         if len(U.shape) > 1:
-            raise ValueError(f'Expected 1d array, got {(U, )}.')
+            raise ValueError(f'Expected 1d array, got {(U,)}.')
 
         if np.any(U > 1.0) or np.any(U < 0.0):
             raise ValueError('Expected values in range [0.0, 1.0].')
@@ -165,11 +165,10 @@ class GaussianKDE(ScipyModel):
 
     def _fit(self, X):
         if self._sample_size:
-            X = gaussian_kde(X, bw_method=self.bw_method,
-                             weights=self.weights).resample(self._sample_size)
-        self._params = {
-            'dataset': X.tolist()
-        }
+            X = gaussian_kde(X, bw_method=self.bw_method, weights=self.weights).resample(
+                self._sample_size
+            )
+        self._params = {'dataset': X.tolist()}
         self._model = self._get_model()
 
     def _is_constant(self):

copulas/univariate/selection.py

@@ -3,7 +3,7 @@
 import numpy as np
 from scipy.stats import kstest
 
-from copulas import get_instance
+from copulas.utils import get_instance
 
 
 def select_univariate(X, candidates):

copulas/univariate/student_t.py

@@ -22,11 +22,7 @@ class StudentTUnivariate(ScipyModel):
 
     def _fit(self, X):
         dataframe, loc, scale = t.fit(X)
-        self._params = {
-            'df': dataframe,
-            'loc': loc,
-            'scale': scale
-        }
+        self._params = {'df': dataframe, 'loc': loc, 'scale': scale}
 
     def _is_constant(self):
         return self._params['scale'] == 0

copulas/univariate/truncated_gaussian.py

@@ -6,8 +6,8 @@ import numpy as np
 from scipy.optimize import fmin_slsqp
 from scipy.stats import truncnorm
 
-from copulas import EPSILON, store_args, validate_random_state
 from copulas.univariate.base import BoundedType, ParametricType, ScipyModel
+from copulas.utils import EPSILON, store_args, validate_random_state
 
 
 class TruncatedGaussian(ScipyModel):
@@ -28,12 +28,7 @@ class TruncatedGaussian(ScipyModel):
 
     def _fit_constant(self, X):
         constant = np.unique(X)[0]
-        self._params = {
-            'a': constant,
-            'b': constant,
-            'loc': constant,
-            'scale': 0.0
-        }
+        self._params = {'a': constant, 'b': constant, 'loc': constant, 'scale': 0.0}
 
     def _fit(self, X):
         if self.min is None:
@@ -51,21 +46,18 @@ class TruncatedGaussian(ScipyModel):
         initial_params = X.mean(), X.std()
         with warnings.catch_warnings():
             warnings.simplefilter('ignore', category=RuntimeWarning)
-            optimal = fmin_slsqp(nnlf, initial_params, iprint=False, bounds=[
-                (self.min, self.max),
-                (0.0, (self.max - self.min)**2)
-            ])
+            optimal = fmin_slsqp(
+                nnlf,
+                initial_params,
+                iprint=False,
+                bounds=[(self.min, self.max), (0.0, (self.max - self.min) ** 2)],
+            )
 
         loc, scale = optimal
         a = (self.min - loc) / scale
         b = (self.max - loc) / scale
 
-        self._params = {
-            'a': a,
-            'b': b,
-            'loc': loc,
-            'scale': scale
-        }
+        self._params = {'a': a, 'b': b, 'loc': loc, 'scale': scale}
 
     def _is_constant(self):
         return self._params['a'] == self._params['b']

copulas/univariate/uniform.py

@@ -15,16 +15,10 @@ class UniformUnivariate(ScipyModel):
     MODEL_CLASS = uniform
 
     def _fit_constant(self, X):
-        self._params = {
-            'loc': np.min(X),
-            'scale': np.max(X) - np.min(X)
-        }
+        self._params = {'loc': np.min(X), 'scale': np.max(X) - np.min(X)}
 
     def _fit(self, X):
-        self._params = {
-            'loc': np.min(X),
-            'scale': np.max(X) - np.min(X)
-        }
+        self._params = {'loc': np.min(X), 'scale': np.max(X) - np.min(X)}
 
     def _is_constant(self):
         return self._params['scale'] == 0

copulas/utils.py

@@ -0,0 +1,248 @@
+"""Utils module."""
+
+import contextlib
+import importlib
+from copy import deepcopy
+from functools import wraps
+
+import numpy as np
+import pandas as pd
+
+EPSILON = np.finfo(np.float32).eps
+
+
+@contextlib.contextmanager
+def set_random_state(random_state, set_model_random_state):
+    """Context manager for managing the random state.
+
+    Args:
+        random_state (int or np.random.RandomState):
+            The random seed or RandomState.
+        set_model_random_state (function):
+            Function to set the random state on the model.
+    """
+    original_state = np.random.get_state()
+    np.random.set_state(random_state.get_state())
+
+    try:
+        yield
+    finally:
+        current_random_state = np.random.RandomState()
+        current_random_state.set_state(np.random.get_state())
+        set_model_random_state(current_random_state)
+        np.random.set_state(original_state)
+
+
+def random_state(function):
+    """Set the random state before calling the function.
+
+    Args:
+        function (Callable):
+            The function to wrap around.
+    """
+
+    @wraps(function)
+    def wrapper(self, *args, **kwargs):
+        if self.random_state is None:
+            return function(self, *args, **kwargs)
+        else:
+            with set_random_state(self.random_state, self.set_random_state):
+                return function(self, *args, **kwargs)
+
+    return wrapper
+
+
+def validate_random_state(random_state):
+    """Validate random state argument.
+
+    Args:
+        random_state (int, numpy.random.RandomState, tuple, or None):
+            Seed or RandomState for the random generator.
+
+    Output:
+        numpy.random.RandomState
+    """
+    if random_state is None:
+        return None
+
+    if isinstance(random_state, int):
+        return np.random.RandomState(seed=random_state)
+    elif isinstance(random_state, np.random.RandomState):
+        return random_state
+    else:
+        raise TypeError(
+            f'`random_state` {random_state} expected to be an int '
+            'or `np.random.RandomState` object.'
+        )
+
+
+def get_instance(obj, **kwargs):
+    """Create new instance of the ``obj`` argument.
+
+    Args:
+        obj (str, type, instance):
+    """
+    instance = None
+    if isinstance(obj, str):
+        package, name = obj.rsplit('.', 1)
+        instance = getattr(importlib.import_module(package), name)(**kwargs)
+    elif isinstance(obj, type):
+        instance = obj(**kwargs)
+    else:
+        if kwargs:
+            instance = obj.__class__(**kwargs)
+        else:
+            args = getattr(obj, '__args__', ())
+            kwargs = getattr(obj, '__kwargs__', {})
+            instance = obj.__class__(*args, **kwargs)
+
+    return instance
+
+
+def store_args(__init__):
+    """Save ``*args`` and ``**kwargs`` used in the ``__init__`` of a copula.
+
+    Args:
+        __init__(callable): ``__init__`` function to store their arguments.
+
+    Returns:
+        callable: Decorated ``__init__`` function.
+    """
+
+    @wraps(__init__)
+    def new__init__(self, *args, **kwargs):
+        args_copy = deepcopy(args)
+        kwargs_copy = deepcopy(kwargs)
+        __init__(self, *args, **kwargs)
+        self.__args__ = args_copy
+        self.__kwargs__ = kwargs_copy
+
+    return new__init__
+
+
+def get_qualified_name(_object):
+    """Return the Fully Qualified Name from an instance or class."""
+    module = _object.__module__
+    if hasattr(_object, '__name__'):
+        _class = _object.__name__
+    else:
+        _class = _object.__class__.__name__
+
+    return module + '.' + _class
+
+
+def vectorize(function):
+    """Allow a method that only accepts scalars to accept vectors too.
+
+    This decorator has two different behaviors depending on the dimensionality of the
+    array passed as an argument:
+
+    **1-d array**
+
+    It will work under the assumption that the `function` argument is a callable
+    with signature::
+
+        function(self, X, *args, **kwargs)
+
+    where X is an scalar magnitude.
+
+    In this case the arguments of the input array will be given one at a time, and
+    both the input and output of the decorated function will have shape (n,).
+
+    **2-d array**
+
+    It will work under the assumption that the `function` argument is a callable with signature::
+
+        function(self, X0, ..., Xj, *args, **kwargs)
+
+    where `Xi` are scalar magnitudes.
+
+    It will pass the contents of each row unpacked on each call. The input is espected to have
+    shape (n, j), the output a shape of (n,)
+
+    It will return a function that is guaranteed to return a `numpy.array`.
+
+    Args:
+        function(callable): Function that only accept and return scalars.
+
+    Returns:
+        callable: Decorated function that can accept and return :attr:`numpy.array`.
+
+    """
+
+    @wraps(function)
+    def decorated(self, X, *args, **kwargs):
+        if not isinstance(X, np.ndarray):
+            return function(self, X, *args, **kwargs)
+
+        if len(X.shape) == 1:
+            X = X.reshape([-1, 1])
+
+        if len(X.shape) == 2:
+            return np.fromiter(
+                (function(self, *x, *args, **kwargs) for x in X), np.dtype('float64')
+            )
+        else:
+            raise ValueError('Arrays of dimensionality higher than 2 are not supported.')
+
+    return decorated
+
+
+def scalarize(function):
+    """Allow methods that only accepts 1-d vectors to work with scalars.
+
+    Args:
+        function(callable): Function that accepts and returns vectors.
+
+    Returns:
+        callable: Decorated function that accepts and returns scalars.
+    """
+
+    @wraps(function)
+    def decorated(self, X, *args, **kwargs):
+        scalar = not isinstance(X, np.ndarray)
+
+        if scalar:
+            X = np.array([X])
+
+        result = function(self, X, *args, **kwargs)
+        if scalar:
+            result = result[0]
+
+        return result
+
+    return decorated
+
+
+def check_valid_values(function):
+    """Raise an exception if the given values are not supported.
+
+    Args:
+        function(callable): Method whose unique argument is a numpy.array-like object.
+
+    Returns:
+        callable: Decorated function
+
+    Raises:
+        ValueError: If there are missing or invalid values or if the dataset is empty.
+    """
+
+    @wraps(function)
+    def decorated(self, X, *args, **kwargs):
+        if isinstance(X, pd.DataFrame):
+            W = X.to_numpy()
+        else:
+            W = X
+
+        if not len(W):
+            raise ValueError('Your dataset is empty.')
+
+        if not (np.issubdtype(W.dtype, np.floating) or np.issubdtype(W.dtype, np.integer)):
+            raise ValueError('There are non-numerical values in your data.')
+
+        if np.isnan(W).any().any():
+            raise ValueError('There are nan values in your data.')
+
+        return function(self, X, *args, **kwargs)
+
+    return decorated