hide wrap and apply_random functions

dask/array/random.py

@@ -37,7 +37,7 @@ class RandomState(object):
     def __init__(self, seed=None):
         self._numpy_state = np.random.RandomState(seed)
 
-    def wrap(self, func, *args, **kwargs):
+    def _wrap(self, func, *args, **kwargs):
         size = kwargs.pop('size')
         chunks = kwargs.pop('chunks')
 
@@ -55,7 +55,7 @@ def wrap(self, func, *args, **kwargs):
         # Build graph
         keys = product([name], *[range(len(bd)) for bd in chunks])
         sizes = product(*chunks)
-        vals = ((apply_random,
+        vals = ((_apply_random,
                   func.__name__,
                   self._numpy_state.randint(np.iinfo(np.uint32).max),
                   size, args, kwargs)
@@ -66,203 +66,203 @@ def wrap(self, func, *args, **kwargs):
 
     @doc_wraps(np.random.RandomState.beta)
     def beta(self, a, b, size=None, chunks=None):
-        return self.wrap(np.random.RandomState.beta, a, b,
+        return self._wrap(np.random.RandomState.beta, a, b,
                          size=size, chunks=chunks)
 
     @doc_wraps(np.random.RandomState.binomial)
     def binomial(self, n, p, size=None, chunks=None):
-        return self.wrap(np.random.RandomState.binomial, n, p,
+        return self._wrap(np.random.RandomState.binomial, n, p,
                          size=size, chunks=chunks)
 
     @doc_wraps(np.random.RandomState.chisquare)
     def chisquare(self, df, size=None, chunks=None):
-        return self.wrap(np.random.RandomState.chisquare, df,
+        return self._wrap(np.random.RandomState.chisquare, df,
                          size=size, chunks=chunks)
 
     @doc_wraps(np.random.RandomState.choice)
     def choice(self, a, size=None, replace=True, p=None, chunks=None):
-        return self.wrap(np.random.RandomState.choice, a,
+        return self._wrap(np.random.RandomState.choice, a,
                          size=size, replace=True, p=None, chunks=chunks)
 
     # @doc_wraps(np.random.RandomState.dirichlet)
     # def dirichlet(self, alpha, size=None, chunks=None):
 
     @doc_wraps(np.random.RandomState.exponential)
     def exponential(self, scale=1.0, size=None, chunks=None):
-        return self.wrap(np.random.RandomState.exponential, scale,
+        return self._wrap(np.random.RandomState.exponential, scale,
                          size=size, chunks=chunks)
 
     @doc_wraps(np.random.RandomState.f)
     def f(self, dfnum, dfden, size=None, chunks=None):
-        return self.wrap(np.random.RandomState.f, dfnum, dfden,
+        return self._wrap(np.random.RandomState.f, dfnum, dfden,
                          size=size, chunks=chunks)
 
     @doc_wraps(np.random.RandomState.gamma)
     def gamma(self, shape, scale=1.0, chunks=None):
-        return self.wrap(np.random.RandomState.gamma, scale,
+        return self._wrap(np.random.RandomState.gamma, scale,
                          size=shape, chunks=chunks)
 
     @doc_wraps(np.random.RandomState.geometric)
     def geometric(self, p, size=None, chunks=None):
-        return self.wrap(np.random.RandomState.geometric, p,
+        return self._wrap(np.random.RandomState.geometric, p,
                          size=size, chunks=chunks)
 
     @doc_wraps(np.random.RandomState.gumbel)
     def gumbel(self, loc=0.0, scale=1.0, size=None, chunks=None):
-        return self.wrap(np.random.RandomState.gumbel, loc, scale,
+        return self._wrap(np.random.RandomState.gumbel, loc, scale,
                          size=size, chunks=chunks)
 
     @doc_wraps(np.random.RandomState.hypergeometric)
     def hypergeometric(self, ngood, nbad, nsample, size=None, chunks=None):
-        return self.wrap(np.random.RandomState.hypergeometric,
+        return self._wrap(np.random.RandomState.hypergeometric,
                          ngood, nbad, nsample,
                          size=size, chunks=chunks)
 
     @doc_wraps(np.random.RandomState.laplace)
     def laplace(self, loc=0.0, scale=1.0, size=None, chunks=None):
-        return self.wrap(np.random.RandomState.laplace, loc, scale,
+        return self._wrap(np.random.RandomState.laplace, loc, scale,
                          size=size, chunks=chunks)
 
     @doc_wraps(np.random.RandomState.logistic)
     def logistic(self, loc=0.0, scale=1.0, size=None, chunks=None):
-        return self.wrap(np.random.RandomState.logistic, loc, scale,
+        return self._wrap(np.random.RandomState.logistic, loc, scale,
                          size=size, chunks=chunks)
 
     @doc_wraps(np.random.RandomState.lognormal)
     def lognormal(self, mean=0.0, sigma=1.0, size=None, chunks=None):
-        return self.wrap(np.random.RandomState.lognormal, mean, sigma,
+        return self._wrap(np.random.RandomState.lognormal, mean, sigma,
                          size=size, chunks=chunks)
 
     @doc_wraps(np.random.RandomState.logseries)
     def logseries(self, p, size=None, chunks=None):
-        return self.wrap(np.random.RandomState.logseries, p,
+        return self._wrap(np.random.RandomState.logseries, p,
                          size=size, chunks=chunks)
 
     # multinomial
 
     @doc_wraps(np.random.RandomState.negative_binomial)
     def negative_binomial(self, n, p, size=None, chunks=None):
-        return self.wrap(np.random.RandomState.negative_binomial, n, p,
+        return self._wrap(np.random.RandomState.negative_binomial, n, p,
                          size=size, chunks=chunks)
 
     @doc_wraps(np.random.RandomState.noncentral_chisquare)
     def noncentral_chisquare(self, df, nonc, size=None, chunks=None):
-        return self.wrap(np.random.RandomState.noncentral_chisquare, df, nonc,
+        return self._wrap(np.random.RandomState.noncentral_chisquare, df, nonc,
                          size=size, chunks=chunks)
 
     @doc_wraps(np.random.RandomState.noncentral_f)
     def noncentral_f(self, dfnum, dfden, nonc,  size=None, chunks=None):
-        return self.wrap(np.random.RandomState.noncentral_f,
+        return self._wrap(np.random.RandomState.noncentral_f,
                          dfnum, dfden, nonc,
                          size=size, chunks=chunks)
 
     @doc_wraps(np.random.RandomState.normal)
     def normal(self, loc=0.0, scale=1.0, size=None, chunks=None):
-        return self.wrap(np.random.RandomState.normal, loc, scale,
+        return self._wrap(np.random.RandomState.normal, loc, scale,
                          size=size, chunks=chunks)
 
     @doc_wraps(np.random.RandomState.pareto)
     def pareto(self, a, size=None, chunks=None):
-        return self.wrap(np.random.RandomState.pareto, a,
+        return self._wrap(np.random.RandomState.pareto, a,
                          size=size, chunks=chunks)
 
     @doc_wraps(np.random.RandomState.poisson)
     def poisson(self, lam=1.0, size=None, chunks=None):
-        return self.wrap(np.random.RandomState.poisson, lam,
+        return self._wrap(np.random.RandomState.poisson, lam,
                          size=size, chunks=chunks)
 
     @doc_wraps(np.random.RandomState.power)
     def power(self, a, size=None, chunks=None):
-        return self.wrap(np.random.RandomState.power, a,
+        return self._wrap(np.random.RandomState.power, a,
                          size=size, chunks=chunks)
 
     @doc_wraps(np.random.RandomState.randint)
     def randint(self, low, high=None, size=None, chunks=None):
-        return self.wrap(np.random.RandomState.randint, low, high,
+        return self._wrap(np.random.RandomState.randint, low, high,
                          size=size, chunks=chunks)
 
     @doc_wraps(np.random.RandomState.random_integers)
     def random_integers(self, low, high=None, size=None, chunks=None):
-        return self.wrap(np.random.RandomState.random_integers, low, high,
+        return self._wrap(np.random.RandomState.random_integers, low, high,
                          size=size, chunks=chunks)
 
     @doc_wraps(np.random.RandomState.random_sample)
     def random_sample(self, size=None, chunks=None):
-        return self.wrap(np.random.RandomState.random_sample,
+        return self._wrap(np.random.RandomState.random_sample,
                          size=size, chunks=chunks)
 
     random = random_sample
 
     @doc_wraps(np.random.RandomState.rayleigh)
     def rayleigh(self, scale=1.0, size=None, chunks=None):
-        return self.wrap(np.random.RandomState.rayleigh, scale,
+        return self._wrap(np.random.RandomState.rayleigh, scale,
                          size=size, chunks=chunks)
 
     @doc_wraps(np.random.RandomState.standard_cauchy)
     def standard_cauchy(self, size=None, chunks=None):
-        return self.wrap(np.random.RandomState.standard_cauchy,
+        return self._wrap(np.random.RandomState.standard_cauchy,
                          size=size, chunks=chunks)
 
     @doc_wraps(np.random.RandomState.standard_exponential)
     def standard_exponential(self, size=None, chunks=None):
-        return self.wrap(np.random.RandomState.standard_exponential,
+        return self._wrap(np.random.RandomState.standard_exponential,
                          size=size, chunks=chunks)
 
     @doc_wraps(np.random.RandomState.standard_gamma)
     def standard_gamma(self, shape, size=None, chunks=None):
-        return self.wrap(np.random.RandomState.standard_gamma, shape,
+        return self._wrap(np.random.RandomState.standard_gamma, shape,
                          size=size, chunks=chunks)
 
     @doc_wraps(np.random.RandomState.standard_normal)
     def standard_normal(self, size=None, chunks=None):
-        return self.wrap(np.random.RandomState.standard_normal,
+        return self._wrap(np.random.RandomState.standard_normal,
                          size=size, chunks=chunks)
 
     @doc_wraps(np.random.RandomState.standard_t)
     def standard_t(self, df, size=None, chunks=None):
-        return self.wrap(np.random.RandomState.standard_t, df,
+        return self._wrap(np.random.RandomState.standard_t, df,
                          size=size, chunks=chunks)
 
     @doc_wraps(np.random.RandomState.tomaxint)
     def tomaxint(self, size=None, chunks=None):
-        return self.wrap(np.random.RandomState.tomaxint,
+        return self._wrap(np.random.RandomState.tomaxint,
                          size=size, chunks=chunks)
 
     @doc_wraps(np.random.RandomState.triangular)
     def triangular(self, left, mode, right, size=None, chunks=None):
-        return self.wrap(np.random.RandomState.triangular, left, mode, right,
+        return self._wrap(np.random.RandomState.triangular, left, mode, right,
                          size=size, chunks=chunks)
 
     @doc_wraps(np.random.RandomState.uniform)
     def uniform(self, low=0.0, high=1.0, size=None, chunks=None):
-        return self.wrap(np.random.RandomState.uniform, low, high,
+        return self._wrap(np.random.RandomState.uniform, low, high,
                          size=size, chunks=chunks)
 
     @doc_wraps(np.random.RandomState.vonmises)
     def vonmises(self, mu, kappa, size=None, chunks=None):
-        return self.wrap(np.random.RandomState.vonmises, mu, kappa,
+        return self._wrap(np.random.RandomState.vonmises, mu, kappa,
                          size=size, chunks=chunks)
 
     @doc_wraps(np.random.RandomState.wald)
     def wald(self, mean, scale, size=None, chunks=None):
-        return self.wrap(np.random.RandomState.wald, mean, scale,
+        return self._wrap(np.random.RandomState.wald, mean, scale,
                          size=size, chunks=chunks)
 
     @doc_wraps(np.random.RandomState.weibull)
     def weibull(self, a, size=None, chunks=None):
-        return self.wrap(np.random.RandomState.weibull, a,
+        return self._wrap(np.random.RandomState.weibull, a,
                          size=size, chunks=chunks)
 
     @doc_wraps(np.random.RandomState.zipf)
     def zipf(self, a, size=None, chunks=None):
-        return self.wrap(np.random.RandomState.zipf, a,
+        return self._wrap(np.random.RandomState.zipf, a,
                          size=size, chunks=chunks)
 
 
-def apply_random(func, seed, size, args, kwargs):
+def _apply_random(func, seed, size, args, kwargs):
     """ Apply RandomState method with seed
 
-    >>> apply_random('normal', 123, 3, (10, 1.0), {})
+    >>> _apply_random('normal', 123, 3, (10, 1.0), {})
     array([  8.9143694 ,  10.99734545,  10.2829785 ])
     """
     state = np.random.RandomState(seed)