o &j@s6dZddlmZmZmZddlZddlZddl m Z dZ dZ eeeejdddZeddks9eddkrOd Z ejjZ eddkrKejjjZnejjZdadZd ZGd d d eZd dZddZddZ ddZ!ddZ"ddZ#ddZ$ddZ%ddZ&dd Z'd!d"Z(d#d$Z)d%d&Z*d'd(Z+d)d*Z,d+d,Z-d-d.Z.d/d0Z/d1d2Z0d3d4Z1d5d6Z2d7d8Z3d9d:Z4d;d<Z5d=d>Z6d?d@Z7dAdBZ8dCdDZ9dEdFZ:dGdHZ;dIdJZdOdPZ?dQdRZ@dSdTZAdUdVZBdWdXZCdYdZZDd[d\ZEd]d^ZFd_d`ZG a didbdcZHdjdedfZIGdgdhdheZJdS)kaClasses and functions related to pseudo-random number generation. This module deals with the generation of pseudo-random numbers. It provides the :class:`~imgaug.random.RNG` class, which is the primary random number generator in ``imgaug``. It also provides various utility functions related random number generation, such as copying random number generators or setting their state. The main benefit of this module is to hide the actually used random number generation classes and methods behin imgaug-specific classes and methods. This allows to deal with numpy using two different interfaces (one old interface in numpy <=1.16 and a new one in numpy 1.17+). It also allows to potentially switch to a different framework/library in the future. Definitions ----------- - *numpy generator* or *numpy random number generator*: Usually an instance of :class:`numpy.random.Generator`. Can often also denote an instance of :class:`numpy.random.RandomState` as both have almost the same interface. - *RandomState*: An instance of `numpy.random.RandomState`. Note that outside of this module, the term "random state" often roughly translates to "any random number generator with numpy-like interface in a given state", i.e. it can then include instances of :class:`numpy.random.Generator` or :class:`~imgaug.random.RNG`. - *RNG*: An instance of :class:`~imgaug.random.RNG`. Examples -------- >>> import imgaug.random as iarandom >>> rng = iarandom.RNG(1234) >>> rng.integers(0, 1000) Initialize a random number generator with seed ``1234``, then sample a single integer from the discrete interval ``[0, 1000)``. This will use a :class:`numpy.random.Generator` in numpy 1.17+ and automatically fall back to :class:`numpy.random.RandomState` in numpy <=1.16. )print_functiondivisionabsolute_importNF.Tic@seZdZdZddZeddZejddZddZd d Z d d Z d dZ ddZ ddZ ddZddZddZddZddZddZdd Zd!d"Zed#d$Zed%d&Z ( )dd*d+Zdd-d.Zdd0d1Zd2d3Zd4d5Zd6d7Zdd8d9Zdd:d;Z ddd?Z"ddAdBZ#ddCdDZ$ddEdFZ%ddGdHZ&ddJdKZ'ddLdMZ(ddNdOZ)ddPdQZ*ddRdSZ+ddTdUZ,ddVdWZ- X YddZd[Z.dd\d]Z/dd^d_Z0dd`daZ1ddbdcZ2ddddeZ3ddfdgZ4ddhdiZ5ddjdkZ6ddldmZ7 n 'ddodpZ8ddqdrZ9ddsdtZ:ddudvZ;ddwdxZdd}d~Z?dddZ@dddZAddZBdddZCddZDdddZEddZFdddZGd'S)RNGa Random number generator for imgaug. This class is a wrapper around ``numpy.random.Generator`` and automatically falls back to ``numpy.random.RandomState`` in case of numpy version 1.16 or lower. It allows to use numpy 1.17's sampling functions in 1.16 too and supports a variety of useful functions on the wrapped sampler, e.g. gettings its state or copying it. Not supported sampling functions of numpy <=1.16: * :func:`numpy.random.RandomState.rand` * :func:`numpy.random.RandomState.randn` * :func:`numpy.random.RandomState.randint` * :func:`numpy.random.RandomState.random_integers` * :func:`numpy.random.RandomState.random_sample` * :func:`numpy.random.RandomState.ranf` * :func:`numpy.random.RandomState.sample` * :func:`numpy.random.RandomState.seed` * :func:`numpy.random.RandomState.get_state` * :func:`numpy.random.RandomState.set_state` In :func:`~imgaug.random.RNG.choice`, the `axis` argument is not yet supported. Parameters ---------- generator : None or int or RNG or numpy.random.Generator or numpy.random.BitGenerator or numpy.random.SeedSequence or numpy.random.RandomState The numpy random number generator to use. In case of numpy version 1.17 or later, this shouldn't be a ``RandomState`` as that class is outdated. Behaviour for different datatypes: * If ``None``: The global RNG is wrapped by this RNG (they are then effectively identical, any sampling on this RNG will affect the global RNG). * If ``int``: In numpy 1.17+, the value is used as a seed for a ``Generator`` wrapped by this RNG. I.e. it will be provided as the entropy to a ``SeedSequence``, which will then be used for an ``SFC64`` bit generator and wrapped by a ``Generator``. In numpy <=1.16, the value is used as a seed for a ``RandomState``, which is then wrapped by this RNG. * If :class:`RNG`: That RNG's ``generator`` attribute will be used as the generator for this RNG, i.e. the same as ``RNG(other_rng.generator)``. * If :class:`numpy.random.Generator`: That generator will be wrapped. * If :class:`numpy.random.BitGenerator`: A numpy generator will be created (and wrapped by this RNG) that contains the bit generator. * If :class:`numpy.random.SeedSequence`: A numpy generator will be created (and wrapped by this RNG) that contains an ``SFC64`` bit generator initialized with the given ``SeedSequence``. * If :class:`numpy.random.RandomState`: In numpy <=1.16, this ``RandomState`` will be wrapped and used to sample random values. In numpy 1.17+, a seed will be derived from this ``RandomState`` and a new ``numpy.generator.Generator`` based on an ``SFC64`` bit generator will be created and wrapped by this RNG. cCs6t|tr |j|_nt||_t|jtjj |_dSN) isinstancer generatornormalize_generator_nprandom RandomState_is_new_rng_style)selfr rN/var/www/html/Deteccion_Ine/venv/lib/python3.10/site-packages/imgaug/random.py__init__s   z RNG.__init__cC t|jS)aqGet the state of this RNG. Returns ------- tuple or dict The state of the RNG. In numpy 1.17+, the bit generator's state will be returned. In numpy <=1.16, the ``RandomState`` 's state is returned. In both cases the state is a copy. In-place changes will not affect the RNG. )get_generator_stater rrrrstate z RNG.statecCs||dS)zSet the state if the RNG in-place. Parameters ---------- value : tuple or dict The new state of the RNG. Should correspond to the output of the ``state`` property. N) set_state_rvaluerrrr cCst|j||S)a'Set the state if the RNG in-place. Parameters ---------- value : tuple or dict The new state of the RNG. Should correspond to the output of the ``state`` property. Returns ------- RNG The RNG itself. )set_generator_state_r rrrrrs zRNG.set_state_cCs ||jS)aCopy and use (in-place) the state of another RNG. .. note:: It is often sensible to first verify that neither this RNG nor `other` are identical to the global RNG. Parameters ---------- other : RNG The other RNG, which's state will be copied. Returns ------- RNG The RNG itself. )rrrotherrrr use_state_of_ zRNG.use_state_of_cCstj|juS)acEstimate whether this RNG is identical to the global RNG. Returns ------- bool ``True`` is this RNG's underlying generator is identical to the global RNG's underlying generator. The RNGs themselves may be different, only the wrapped generator matters. ``False`` otherwise. )get_global_rngr rrrr is_global_rngszRNG.is_global_rngcCs t|S)aEstimate whether this RNG has the same state as the global RNG. Returns ------- bool ``True`` is this RNG has the same state as the global RNG, i.e. it will lead to the same sampled values given the same sampling method calls. The RNGs *don't* have to be identical object instances, which protects against e.g. copy effects. ``False`` otherwise. )r$equalsrrrrequals_global_rngs zRNG.equals_global_rngcCr)zSample a random seed. This advances the underlying generator's state. See ``SEED_MIN_VALUE`` and ``SEED_MAX_VALUE`` for the seed's value range. Returns ------- int The sampled seed. )generate_seed_r rrrrr(rzRNG.generate_seed_cCs t|j|S)avGenerate `n` random seed values. This advances the underlying generator's state. See ``SEED_MIN_VALUE`` and ``SEED_MAX_VALUE`` for the seed's value range. Parameters ---------- n : int Number of seeds to sample. Returns ------- ndarray 1D-array of ``int32`` seeds. )generate_seeds_r rnrrrr)r#zRNG.generate_seeds_cCt|j|S)zoReset all cache of this RNG. Returns ------- RNG The RNG itself. )reset_generator_cache_r rrrr reset_cache_'s zRNG.reset_cache_cCs|ddS)zCreate a child RNG. This advances the underlying generator's state. Returns ------- RNG A child RNG. rr) derive_rngs_rrrr derive_rng_3rzRNG.derive_rng_cCsddt|j|DS)a Create `n` child RNGs. This advances the underlying generator's state. Parameters ---------- n : int Number of child RNGs to derive. Returns ------- list of RNG Child RNGs. cSg|]}t|qSr)r ).0genrrr Psz$RNG.derive_rngs_..)derive_generators_r r*rrrr/@szRNG.derive_rngs_cCs*t|tsJdt|ft|j|jS)zEstimate whether this RNG and `other` have the same state. Returns ------- bool ``True`` if this RNG's generator and the generator of `other` have equal internal states. ``False`` otherwise. zExpected 'other' to be an RNG, got type %s. Use imgaug.random.is_generator_equal_to() to compare numpy generators or RandomStates.)r r typeis_generator_equal_tor r rrrr&Rs z RNG.equalscCr,)aAdvance the RNG's internal state in-place by one step. This advances the underlying generator's state. .. note:: This simply samples one or more random values. This means that a call of this method will not completely change the outputs of the next called sampling method. To achieve more drastic output changes, call :func:`~imgaug.random.RNG.derive_rng_`. Returns ------- RNG The RNG itself. )advance_generator_r rrrradvance_bs z RNG.advance_cCstt|jS)zCreate a copy of this RNG. Returns ------- RNG Copy of this RNG. The copy will produce the same random samples. )r copy_generatorr rrrrcopyws zRNG.copycCs|r|S|S)aCreate a copy of this RNG unless it is the global RNG. Returns ------- RNG Copy of this RNG unless it is the global RNG. In the latter case the RNG instance itself will be returned without any changes. )r%r;rrrrcopy_unless_global_rngs zRNG.copy_unless_global_rngcsfddt|DS)aCreate a list containing `n` times this RNG. This method was mainly introduced as a replacement for previous calls of :func:`~imgaug.random.RNG.derive_rngs_`. These calls turned out to be very slow in numpy 1.17+ and were hence replaced by simple duplication (except for the cases where child RNGs absolutely *had* to be created). This RNG duplication method doesn't help very much against code repetition, but it does *mark* the points where it would be desirable to create child RNGs for various reasons. Once deriving child RNGs is somehow sped up in the future, these calls can again be easily found and replaced. Parameters ---------- n : int Length of the output list. Returns ------- list of RNG List containing `n` times this RNG (same instances, no copies). csg|]}qSrr)r2_rrrr4sz!RNG.duplicate..)smxranger*rrr duplicatesz RNG.duplicatecCs ttS)aCreate a new RNG, based on entropy provided from the OS. Returns ------- RNG A new RNG. It is not derived from any other previously created RNG, nor does it depend on the seeding of imgaug or numpy. )r create_fully_random_generatorclsrrrcreate_fully_randoms zRNG.create_fully_randomcCs tS)a4Create a new RNG in pseudo-random fashion. A seed will be sampled from the current global RNG and used to initialize the new RNG. This advandes the global RNG's state. Returns ------- RNG A new RNG, derived from the current global RNG. )r$r0rBrrrcreate_pseudo_random_s zRNG.create_pseudo_random_Nint32FcCst|j|||||dS)zCall numpy's ``integers()`` or ``randint()``. .. note:: Changed `dtype` argument default value from numpy's ``int64`` to ``int32``. lowhighsizedtypeendpoint)polyfill_integersr )rrHrIrJrKrLrrrintegerss z RNG.integersfloat32cCst|j|||dS)zCall numpy's ``random()`` or ``random_sample()``. .. note:: Changed `dtype` argument default value from numpy's ``d`` to ``float32``. rJrKout)polyfill_randomr )rrJrKrQrrrrs z RNG.randomTcC|jj||||dS)z+Call :func:`numpy.random.Generator.choice`.)arJreplacep)r choice)rrTrJrUrVrrrrWsz RNG.choicecC|jj|dS)z*Call :func:`numpy.random.Generator.bytes`.)length)r bytes)rrYrrrrZz RNG.bytescCs|j|dS)z,Call :func:`numpy.random.Generator.shuffle`.N)r shufflerxrrrr\sz RNG.shufflecCs |j|S)z0Call :func:`numpy.random.Generator.permutation`.)r permutationr]rrrr_s zRNG.permutationcC|jj|||dS)z)Call :func:`numpy.random.Generator.beta`.)rTbrJ)r beta)rrTrarJrrrrbzRNG.betacCr`)z-Call :func:`numpy.random.Generator.binomial`.r+rVrJ)r binomialrr+rVrJrrrrez RNG.binomialcC|jj||dS)z.Call :func:`numpy.random.Generator.chisquare`.dfrJ)r chisquarerrjrJrrrrk z RNG.chisquarecCrh)z.Call :func:`numpy.random.Generator.dirichlet`.)alpharJ)r dirichlet)rrnrJrrrroz RNG.dirichlet?cCrh)z0Call :func:`numpy.random.Generator.exponential`.scalerJ)r exponentialrrsrJrrrrtrpzRNG.exponentialcCr`)z&Call :func:`numpy.random.Generator.f`.)dfnumdfdenrJ)r f)rrvrwrJrrrrxrgzRNG.fcCr`)z*Call :func:`numpy.random.Generator.gamma`.)shapersrJ)r gamma)rryrsrJrrrrzrgz RNG.gammacCrh)z.Call :func:`numpy.random.Generator.geometric`.rVrJ)r geometricrrVrJrrrr| rpz RNG.geometriccCr`)z+Call :func:`numpy.random.Generator.gumbel`.locrsrJ)r gumbelrrrsrJrrrr$rgz RNG.gumbelcCrS)z3Call :func:`numpy.random.Generator.hypergeometric`.)ngoodnbadnsamplerJ)r hypergeometric)rrrrrJrrrr(zRNG.hypergeometriccCr`)z,Call :func:`numpy.random.Generator.laplace`.r)r laplacerrrrr-rgz RNG.laplacecCr`)z-Call :func:`numpy.random.Generator.logistic`.r)r logisticrrrrr1rgz RNG.logisticcCr`)z.Call :func:`numpy.random.Generator.lognormal`.)meansigmarJ)r lognormal)rrrrJrrrr5rgz RNG.lognormalcCrh)z.Call :func:`numpy.random.Generator.logseries`.r{)r logseriesr}rrrr9rpz RNG.logseriescCr`)z0Call :func:`numpy.random.Generator.multinomial`.)r+pvalsrJ)r multinomial)rr+rrJrrrr=rgzRNG.multinomialwarn:0yE>cCs|jj|||||dS)z8Call :func:`numpy.random.Generator.multivariate_normal`.)rcovrJ check_validtol)r multivariate_normal)rrrrJrrrrrrAs zRNG.multivariate_normalcCr`)z6Call :func:`numpy.random.Generator.negative_binomial`.rd)r negative_binomialrfrrrrGrgzRNG.negative_binomialcCr`)z9Call :func:`numpy.random.Generator.noncentral_chisquare`.)rjnoncrJ)r noncentral_chisquare)rrjrrJrrrrKrczRNG.noncentral_chisquarecCrS)z1Call :func:`numpy.random.Generator.noncentral_f`.)rvrwrrJ)r noncentral_f)rrvrwrrJrrrrPrzRNG.noncentral_fcCr`)z+Call :func:`numpy.random.Generator.normal`.r)r normalrrrrrUrgz RNG.normalcCrh)z+Call :func:`numpy.random.Generator.pareto`.rTrJ)r paretorrTrJrrrrYrmz RNG.paretocCrh)z,Call :func:`numpy.random.Generator.poisson`.)lamrJ)r poisson)rrrJrrrr^rpz RNG.poissoncCrh)z*Call :func:`numpy.random.Generator.power`.r)r powerrrrrrbrmz RNG.powercCrh)z-Call :func:`numpy.random.Generator.rayleigh`.rr)r rayleighrurrrrgrpz RNG.rayleighcCrX)z4Call :func:`numpy.random.Generator.standard_cauchy`.rJ)r standard_cauchyrrJrrrrkr[zRNG.standard_cauchyzigcCsj|jr |jj||||dS|jj|d|}|dur3|jj|jjks/Jd|jj|jjf||d<|S)zCall :func:`numpy.random.Generator.standard_exponential`. .. note:: Changed `dtype` argument default value from numpy's ``d`` to ``float32``. )rJrKmethodrQrNzyExpected out array to have the same dtype as standard_exponential()'s result array. Got %s (out) and %s (result) instead..)rr standard_exponentialastyperKname)rrJrKrrQresultrrrros zRNG.standard_exponentialcCsl|jr |jj||||dS|jj||d|}|dur4|jj|jjks0Jd|jj|jjf||d<|S)zCall :func:`numpy.random.Generator.standard_gamma`. .. note:: Changed `dtype` argument default value from numpy's ``d`` to ``float32``. )ryrJrKrQ)ryrJNzsExpected out array to have the same dtype as standard_gamma()'s result array. Got %s (out) and %s (result) instead..)rr standard_gammarrKr)rryrJrKrQrrrrrs" zRNG.standard_gammacCsh|jr |jj|||dS|jj|d|}|dur2|jj|jjks.Jd|jj|jjf||d<|S)zCall :func:`numpy.random.Generator.standard_normal`. .. note:: Changed `dtype` argument default value from numpy's ``d`` to ``float32``. rPrNztExpected out array to have the same dtype as standard_normal()'s result array. Got %s (out) and %s (result) instead..)rr standard_normalrrKr)rrJrKrQrrrrrs zRNG.standard_normalcCrh)z/Call :func:`numpy.random.Generator.standard_t`.ri)r standard_trlrrrrrmzRNG.standard_tcCrS)z/Call :func:`numpy.random.Generator.triangular`.)leftmoderightrJ)r triangular)rrrrrJrrrrrzRNG.triangularcCr`)z,Call :func:`numpy.random.Generator.uniform`.)rHrIrJ)r uniformrrHrIrJrrrrrgz RNG.uniformcCr`)z-Call :func:`numpy.random.Generator.vonmises`.)mukapparJ)r vonmises)rrrrJrrrrrcz RNG.vonmisescCr`)z)Call :func:`numpy.random.Generator.wald`.)rrsrJ)r wald)rrrsrJrrrrrgzRNG.waldcCrh)z,Call :func:`numpy.random.Generator.weibull`.r)r weibullrrrrrrmz RNG.weibullcCrh)z)Call :func:`numpy.random.Generator.zipf`.r)r zipfrrrrrrmzRNG.zipfcG |j|dS)zCall :func:`numpy.random.RandomState.rand`. .. warning:: This method is outdated in numpy. Use :func:`RNG.random` instead. Added in 0.4.0. r)rrargsrrrrands zRNG.randcCs|j||||ddS)a8Call :func:`numpy.random.RandomState.randint`. .. note:: Changed `dtype` argument default value from numpy's ``I`` to ``int32``. .. warning:: This method is outdated in numpy. Use :func:`RNG.integers` instead. Added in 0.4.0. FrGrN)rrHrIrJrKrrrrandints z RNG.randintcGr)zCall :func:`numpy.random.RandomState.randn`. .. warning:: This method is outdated in numpy. Use :func:`RNG.standard_normal` instead. Added in 0.4.0. r)rrrrrrandns z RNG.randncCs,|dur |jd||ddS|j|||ddS)zCall :func:`numpy.random.RandomState.random_integers`. .. warning:: This method is outdated in numpy. Use :func:`RNG.integers` instead. Added in 0.4.0. NrT)rHrIrJrLrrrrrrandom_integerss zRNG.random_integerscCs|jdd|dS)zCall :func:`numpy.random.RandomState.random_sample`. .. warning:: This method is outdated in numpy. Use :func:`RNG.uniform` instead. Added in 0.4.0. r~rqr)rrrrr random_samples zRNG.random_samplecCs4ddl}|j}ttjj}|jdt|||ddS)zCall :func:`numpy.random.RandomState.tomaxint`. .. warning:: This method is outdated in numpy. Use :func:`RNG.integers` instead. Added in 0.4.0. rNT)rJrL)sysmaxsizerZiinforFmaxrNmin)rrJrZmaxintZint32maxrrrtomaxint s  z RNG.tomaxintNNrFFrON)NTNr )rqN)r~rqN)Nrr)NrOrN)NrON)NNrF)NN)H__name__ __module__ __qualname____doc__rpropertyrsetterrr"r%r'r(r)r.r0r/r&r9r;r<r@ classmethodrDrErNrrWrZr\r_rbrerkrortrxrzr|rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr Vs?                                              r cCstS)ap Determine whether numpy supports the new ``random`` interface (v1.17+). Returns ------- bool ``True`` if the new ``random`` interface is supported by numpy, i.e. if numpy has version 1.17 or later. Otherwise ``False``, i.e. numpy has version 1.16 or older and ``numpy.random.RandomState`` should be used instead. )SUPPORTS_NEW_NP_RNG_STYLErrrrsupports_new_numpy_rng_style2s rcCs"tdurttj}tt|atS)z Get or create the current global RNG of imgaug. Note that the first call to this function will create a global RNG. Returns ------- RNG The global RNG to use. N) GLOBAL_RNGr(rrr convert_seed_to_generator)seedrrrr$Bs  r$cCstrt|dSt|dS)a Set the seed of imgaug's global RNG (in-place). The global RNG controls most of the "randomness" in imgaug. The global RNG is the default one used by all augmenters. Under special circumstances (e.g. when an augmenter is switched to deterministic mode), the global RNG is replaced with a local one. The state of that replacement may be dependent on the global RNG's state at the time of creating the child RNG. Parameters ---------- entropy : int The seed value to use. N)r _seed_np117_ _seed_np116_entropyrrrr_s  rcCst|jt_dSr ) BIT_GENERATORrr$rrrrrvsrcCstj|dSr )r$r rrrrrr~srcCstt|S)aNormalize various inputs to a numpy (random number) generator. This function will first copy the provided argument, i.e. it never returns a provided instance itself. Parameters ---------- generator : None or int or numpy.random.Generator or numpy.random.BitGenerator or numpy.random.SeedSequence or numpy.random.RandomState The numpy random number generator to normalize. In case of numpy version 1.17 or later, this shouldn't be a ``RandomState`` as that class is outdated. Behaviour for different datatypes: * If ``None``: The global RNG's generator is returned. * If ``int``: In numpy 1.17+, the value is used as a seed for a ``Generator``, i.e. it will be provided as the entropy to a ``SeedSequence``, which will then be used for an ``SFC64`` bit generator and wrapped by a ``Generator``, which is then returned. In numpy <=1.16, the value is used as a seed for a ``RandomState``, which will then be returned. * If :class:`numpy.random.Generator`: That generator will be returned. * If :class:`numpy.random.BitGenerator`: A numpy generator will be created and returned that contains the bit generator. * If :class:`numpy.random.SeedSequence`: A numpy generator will be created and returned that contains an ``SFC64`` bit generator initialized with the given ``SeedSequence``. * If :class:`numpy.random.RandomState`: In numpy <=1.16, this ``RandomState`` will be returned. In numpy 1.17+, a seed will be derived from this ``RandomState`` and a new ``numpy.generator.Generator`` based on an ``SFC64`` bit generator will be created and returned. Returns ------- numpy.random.Generator or numpy.random.RandomState In numpy <=1.16 a ``RandomState``, in 1.17+ a ``Generator`` (even if the input was a ``RandomState``). )r copylibdeepcopyr rrrnormalize_generators*rcCtst|St|S)a;Normalize in-place various inputs to a numpy (random number) generator. This function will try to return the provided instance itself. Parameters ---------- generator : None or int or numpy.random.Generator or numpy.random.BitGenerator or numpy.random.SeedSequence or numpy.random.RandomState See :func:`~imgaug.random.normalize_generator`. Returns ------- numpy.random.Generator or numpy.random.RandomState In numpy <=1.16 a ``RandomState``, in 1.17+ a ``Generator`` (even if the input was a ``RandomState``). )r_normalize_generator_np116__normalize_generator_np117_rrrrr sr cCs|durtjSt|tjjrtjt|St|tr(tj|}t ||St|tjjr5t ||St|tjj rBt t |S|}t |Sr ) r$r r rr SeedSequence Generatorr_BIT_GENERATOR_INTERFACEr-rrr()r seed_rrrrs"   rcCs.|durtjSt|tjjr|S|}t|Sr )r$r r rrrr) random_staterrrrrs rcCr)aZConvert a seed value to a numpy (random number) generator. Parameters ---------- entropy : int The seed value to use. Returns ------- numpy.random.Generator or numpy.random.RandomState In numpy <=1.16 a ``RandomState``, in 1.17+ a ``Generator``. Both are initialized with the provided seed. )r _convert_seed_to_generator_np116 _convert_seed_to_generator_np117rrrrrsrcCstj|}t|Sr )rrr"convert_seed_sequence_to_generator)r seed_sequencerrrrs rcCs tj|Sr rrrrrrrr rcCstjt|S)a"Convert a seed sequence to a numpy (random number) generator. Parameters ---------- seed_sequence : numpy.random.SeedSequence The seed value to use. Returns ------- numpy.random.Generator Generator initialized with the provided seed sequence. )rrrr)rrrrr srcCsttj}t|S)aXCreate a new numpy (random) generator, derived from the global RNG. This function advances the global RNG's state. Returns ------- numpy.random.Generator or numpy.random.RandomState In numpy <=1.16 a ``RandomState``, in 1.17+ a ``Generator``. Both are initialized with a seed sampled from the global RNG. )r(r$r r)Z random_seedrrrcreate_pseudo_random_generator_s rcCststStS)anCreate a new numpy (random) generator, derived from OS's entropy. Returns ------- numpy.random.Generator or numpy.random.RandomState In numpy <=1.16 a ``RandomState``, in 1.17+ a ``Generator``. Both are initialized with entropy requested from the OS. They are hence independent of entered seeds or the library's global RNG. )r$_create_fully_random_generator_np116$_create_fully_random_generator_np117rrrrrA-s rAcCstjtjSr )rrrSFC64rrrrr=rgrcCs tjSr rrrrrrBs rcCst|ddS)aSample a seed from the provided generator. This function advances the generator's state. See ``SEED_MIN_VALUE`` and ``SEED_MAX_VALUE`` for the seed's value range. Parameters ---------- generator : numpy.random.Generator or numpy.random.RandomState The generator from which to sample the seed. Returns ------- int The sampled seed. rr)r)rrrrr(Fsr(cCst|tt|fdS)awSample `n` seeds from the provided generator. This function advances the generator's state. Parameters ---------- generator : numpy.random.Generator or numpy.random.RandomState The generator from which to sample the seed. n : int Number of seeds to sample. Returns ------- ndarray 1D-array of ``int32`` seeds. r)rMSEED_MIN_VALUESEED_MAX_VALUEr r+rrrr)\sr)cCt|tjjr t|St|S)a|Copy an existing numpy (random number) generator. Parameters ---------- generator : numpy.random.Generator or numpy.random.RandomState The generator to copy. Returns ------- numpy.random.Generator or numpy.random.RandomState In numpy <=1.16 a ``RandomState``, in 1.17+ a ``Generator``. Both are copies of the input argument. )r rrr_copy_generator_np116_copy_generator_np117rrrrr:ssr:cCs*|j}|d}t|j|_tj|SNr) bit_generator __class__rrrrrr)r Z old_bit_genZ new_bit_genrrrrs  rcCs"tjd}|}|||Sr)rrr get_state set_state)rZrs_copyrrrrrs  rcCs|tjur|St|S)aCopy a numpy generator unless it is the current global generator. "global generator" here denotes the generator contained in the global RNG's ``.generator`` attribute. Parameters ---------- generator : numpy.random.Generator or numpy.random.RandomState The generator to copy. Returns ------- numpy.random.Generator or numpy.random.RandomState In numpy <=1.16 a ``RandomState``, in 1.17+ a ``Generator``. Both are copies of the input argument, unless that input is identical to the global generator. If it is identical, the instance itself will be returned without copying it. )r$r r:rrrr©_generator_unless_global_generators rcCr)aReset a numpy (random number) generator's internal cache. This function modifies the generator's state in-place. Parameters ---------- generator : numpy.random.Generator or numpy.random.RandomState The generator of which to reset the cache. Returns ------- numpy.random.Generator or numpy.random.RandomState In numpy <=1.16 a ``RandomState``, in 1.17+ a ``Generator``. In both cases the input argument itself. )r rrr_reset_generator_cache_np116__reset_generator_cache_np117_rrrrr-sr-cCst|}d|d<t|||S)Nr has_uint32)_get_generator_state_np117_set_generator_state_np117_r rrrrrs rcCs&t|}d|d<|t||S)Nr)listrrtuplerrrrrrs rcCst|dddS)aCreate a child numpy (random number) generator from an existing one. This advances the generator's state. Parameters ---------- generator : numpy.random.Generator or numpy.random.RandomState The generator from which to derive a new child generator. Returns ------- numpy.random.Generator or numpy.random.RandomState In numpy <=1.16 a ``RandomState``, in 1.17+ a ``Generator``. In both cases a derived child generator. rr+r)r5rrrrderive_generator_srcCs&t|tjjr t||dSt||dS)a"Create child numpy (random number) generators from an existing one. Parameters ---------- generator : numpy.random.Generator or numpy.random.RandomState The generator from which to derive new child generators. n : int Number of child generators to derive. Returns ------- list of numpy.random.Generator or list of numpy.random.RandomState In numpy <=1.16 a list of ``RandomState`` s, in 1.17+ a list of ``Generator`` s. In both cases lists of derived child generators. r)r rrr_derive_generators_np116__derive_generators_np117_rrrrr5s  r5cCs:|jttdddd}tj|}||}dd|DS)aL advance_rng_(rng) rng = copylib.deepcopy(rng) reset_rng_cache_(rng) state = rng.bit_generator.state rngs = [] for i in sm.xrange(n): state["state"]["state"] += (i * 100003 + 17) rng.bit_generator.state = state rngs.append(rng) rng = copylib.deepcopy(rng) return rngs rF)r)rKrJcSr1r)r)r2seed_seqrrrr4's z-_derive_generators_np117_..)rNrrrrrZspawn)r r+rr Z seed_seqsrrrr  s   r cs$|ttfddt|DS)Ncsg|]}t|qSr)r)r2irrrr4-sz-_derive_generators_np116_..)rrrr>r?)rr+rrrr +s r cCr)aGet the state of this provided generator. Parameters ---------- generator : numpy.random.Generator or numpy.random.RandomState The generator, which's state is supposed to be extracted. Returns ------- tuple or dict The state of the generator. In numpy 1.17+, the bit generator's state will be returned. In numpy <=1.16, the ``RandomState`` 's state is returned. In both cases the state is a copy. In-place changes will not affect the RNG. )r rrr_get_generator_state_np116rrrrrr0srcCs|jjSr rrrrrrrGrcCs|Sr )r)rrrrrKrrcCs*t|tjjrt||dSt||dS)aSet the state of a numpy (random number) generator in-place. Parameters ---------- generator : numpy.random.Generator or numpy.random.RandomState The generator, which's state is supposed to be modified. state : tuple or dict The new state of the generator. Should correspond to the output of :func:`~imgaug.random.get_generator_state`. N)r rrr_set_generator_state_np116_rrrrrrOsrcCs ||j_dSr rrrrrrcrrcCs||dSr )rrrrrrgsrcCs"t|tjjr t||St||S)aEstimate whether two generator have the same class and state. Parameters ---------- generator : numpy.random.Generator or numpy.random.RandomState First generator used in the comparison. other_generator : numpy.random.Generator or numpy.random.RandomState Second generator used in the comparison. Returns ------- bool ``True`` if `generator` 's class and state are the same as the class and state of `other_generator`. ``False`` otherwise. )r rrr_is_generator_equal_to_np116_is_generator_equal_to_np117)r other_generatorrrrr7ks  r7cCs|j|jusJdt|t|ft|}t|}|ddks)Jd|df|ddks8Jd|df|d|dkrBdS|d|dkrPdkr\nn |d|dkr\dSt|d d |d d S) NzCExpected both rngs to have the same class, got types '%s' and '%s'.rrzSCan currently only compare the states of numpy.random.SFC64 bit generators, got %s.rFrZuintegerr)rr6rr array_equal)r rstate1state2rrrrs. rcCs@t|}t|}tddD]}t||||sdSqdS)NrFT)rr>r?rr)rZother_random_staterrr rrrrsrcCs&t|tjjr t|dSt|dS)a:Advance a numpy random generator's internal state in-place by one step. This advances the generator's state. .. note:: This simply samples one or more random values. This means that a call of this method will not completely change the outputs of the next called sampling method. To achieve more drastic output changes, call :func:`~imgaug.random.derive_generator_`. Parameters ---------- generator : numpy.random.Generator or numpy.random.RandomState Generator of which to advance the internal state. N)r rrr_advance_generator_np116__advance_generator_np117_rrrrr8s  r8cCt||dSr )rrrrrrr rcCrr )rrrrrrrrrrFcCsRt|dr|r|dur|d}d}n|d}|j||||dS|j|||||dS)aSample integers from a generator in different numpy versions. Parameters ---------- generator : numpy.random.Generator or numpy.random.RandomState The generator to sample from. If it is a ``RandomState``, :func:`numpy.random.RandomState.randint` will be called, otherwise :func:`numpy.random.Generator.integers`. low : int or array-like of ints See :func:`numpy.random.Generator.integers`. high : int or array-like of ints, optional See :func:`numpy.random.Generator.integers`. size : int or tuple of ints, optional See :func:`numpy.random.Generator.integers`. dtype : {str, dtype}, optional See :func:`numpy.random.Generator.integers`. endpoint : bool, optional See :func:`numpy.random.Generator.integers`. Returns ------- int or ndarray of ints See :func:`numpy.random.Generator.integers`. rNrr)rHrIrJrKrG)hasattrrrN)r rHrIrJrKrLrrrrMs  rMrOcCsht|dr,|j|d|}|dur*|jj|jjks&Jd|jj|jjf||d<|S|j|||dS)aSample random floats from a generator in different numpy versions. Parameters ---------- generator : numpy.random.Generator or numpy.random.RandomState The generator to sample from. Both ``RandomState`` and ``Generator`` support ``random()``, but with different interfaces. size : int or tuple of ints, optional See :func:`numpy.random.Generator.random`. dtype : {str, dtype}, optional See :func:`numpy.random.Generator.random`. out : ndarray, optional See :func:`numpy.random.Generator.random`. Returns ------- float or ndarray of floats See :func:`numpy.random.Generator.random`. rrNzrExpected out array to have the same dtype as random_sample()'s result array. Got %s (out) and %s (result) instead..rP)rrrrKrr)r rJrKrQrrrrrRs rRc@s*eZdZdZd ddZddZddZdS) temporary_numpy_seedaContext to temporarily alter the random state of ``numpy.random``. The random state's internal state will be set back to the original one once the context finishes. Added in 0.4.0. Parameters ---------- entropy : None or int The seed value to use. If `None` then the seed will not be altered and the internal state of ``numpy.random`` will not be reset back upon context exit (i.e. this context will do nothing). NcCsd|_||_dSr ) old_stater)rrrrrr1s ztemporary_numpy_seed.__init__cCs,|jdurtj|_tj|jdSdSr )rrrrr rrrrr __enter__5s  ztemporary_numpy_seed.__enter__cCs |jdurtj|jdSdSr )rrrrr )rexc_typeexc_valexc_tbrrr__exit__:s ztemporary_numpy_seed.__exit__r )rrrrrr!r%rrrrrs   rrr)Kr __future__rrrr;rnumpyrZ six.movesZmovesr>rrrmapint __version__splitZ _NP_VERSIONrrrZ BitGeneratorrrrrobjectr rr$rrrrr rrrrrrrrArrr(r)r:rrrr-rrrr5r r rrrrrrr7rrr8rrrMrRrrrrrs(   a-    "  ,(