randomgen 2.5.0__cp315-cp315-win_amd64.whl

randomgen/__init__.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+
+import os
+import sys
+
+from randomgen._register import BitGenerators
+from randomgen.aes import AESCounter
+from randomgen.blabla import BlaBla
+from randomgen.chacha import ChaCha
+from randomgen.dsfmt import DSFMT
+from randomgen.efiix64 import EFIIX64
+from randomgen.entropy import random_entropy
+from randomgen.generator import ExtendedGenerator
+from randomgen.hc128 import HC128
+from randomgen.jsf import JSF
+from randomgen.lxm import LXM
+from randomgen.mt64 import MT64
+from randomgen.mt19937 import MT19937
+from randomgen.mwcx import MWC64X32, MWC128X, MWC128X32, MWC192X
+from randomgen.pcg32 import PCG32
+from randomgen.pcg64 import PCG64, PCG64DXSM, LCG128Mix
+from randomgen.philox import Philox
+from randomgen.rdrand import RDRAND
+from randomgen.romu import Romu
+from randomgen.seed_sequence import SeedlessSeedSequence, SeedSequence
+from randomgen.sfc import SFC64
+from randomgen.sfmt import SFMT
+from randomgen.speck128 import SPECK128
+from randomgen.squares import Squares
+from randomgen.threefry import ThreeFry
+from randomgen.tyche import Tyche
+from randomgen.wrapper import UserBitGenerator
+from randomgen.xoroshiro128 import Xoroshiro128
+from randomgen.xorshift1024 import Xorshift1024
+from randomgen.xoshiro256 import Xoshiro256
+from randomgen.xoshiro512 import Xoshiro512
+
+from ._version import version as __version__, version_tuple as __version_info__
+
+PKG = os.path.join(os.path.dirname(__file__))
+
+
+__all__ = [
+    "DSFMT",
+    "EFIIX64",
+    "HC128",
+    "JSF",
+    "LXM",
+    "MT64",
+    "MT19937",
+    "MWC64X32",
+    "MWC128X",
+    "MWC128X32",
+    "MWC192X",
+    "PCG32",
+    "PCG64",
+    "PCG64DXSM",
+    "RDRAND",
+    "SFC64",
+    "SFMT",
+    "SPECK128",
+    "AESCounter",
+    "BitGenerators",
+    "BlaBla",
+    "ChaCha",
+    "ExtendedGenerator",
+    "LCG128Mix",
+    "Philox",
+    "Romu",
+    "SeedSequence",
+    "SeedlessSeedSequence",
+    "Squares",
+    "ThreeFry",
+    "Tyche",
+    "UserBitGenerator",
+    "Xoroshiro128",
+    "Xorshift1024",
+    "Xoshiro256",
+    "Xoshiro512",
+    "__version__",
+    "__version_info__",
+    "random_entropy",
+]
+
+
+def test(extra_args: str | list[str] | None = None, exit=True) -> None:  # noqa: PT028
+    try:
+        import pytest  # noqa: PLC0415
+    except ImportError as err:
+        raise ImportError("Need pytest>=5.0.1 to run tests") from err
+    cmd = ["--skip-slow"]
+    if extra_args:
+        if not isinstance(extra_args, list):
+            extra_args = [extra_args]
+        assert isinstance(extra_args, list)
+        cmd = extra_args
+    cmd += [PKG]
+    joined = " ".join(cmd)
+    print(f"running: pytest {joined}")
+    result = pytest.main(cmd)
+    if exit:
+        sys.exit(result)
+    return result

randomgen/_pickle.py

@@ -0,0 +1,138 @@
+from __future__ import annotations
+
+import warnings
+
+from randomgen.aes import AESCounter
+from randomgen.blabla import BlaBla
+from randomgen.chacha import ChaCha
+from randomgen.common import BitGenerator
+from randomgen.dsfmt import DSFMT
+from randomgen.efiix64 import EFIIX64
+from randomgen.generator import ExtendedGenerator
+from randomgen.hc128 import HC128
+from randomgen.jsf import JSF
+from randomgen.lxm import LXM
+from randomgen.mt64 import MT64
+from randomgen.mt19937 import MT19937
+from randomgen.mwcx import MWC64X32, MWC128X, MWC128X32, MWC192X
+from randomgen.pcg32 import PCG32
+from randomgen.pcg64 import PCG64, PCG64DXSM, LCG128Mix
+from randomgen.philox import Philox
+from randomgen.rdrand import RDRAND
+from randomgen.romu import Romu
+from randomgen.sfc import SFC64
+from randomgen.sfmt import SFMT
+from randomgen.speck128 import SPECK128
+from randomgen.squares import Squares
+from randomgen.threefry import ThreeFry
+from randomgen.tyche import Tyche
+from randomgen.xoroshiro128 import Xoroshiro128
+from randomgen.xorshift1024 import Xorshift1024
+from randomgen.xoshiro256 import Xoshiro256
+from randomgen.xoshiro512 import Xoshiro512
+
+BitGenerators: dict[str, type[BitGenerator]] = {
+    "AESCounter": AESCounter,
+    "BlaBla": BlaBla,
+    "ChaCha": ChaCha,
+    "DSFMT": DSFMT,
+    "EFIIX64": EFIIX64,
+    "HC128": HC128,
+    "JSF": JSF,
+    "LCG128Mix": LCG128Mix,
+    "LXM": LXM,
+    "MT19937": MT19937,
+    "MT64": MT64,
+    "MWC64X32": MWC64X32,
+    "MWC128X": MWC128X,
+    "MWC128X32": MWC128X32,
+    "MWC192X": MWC192X,
+    "PCG32": PCG32,
+    "PCG64": PCG64,
+    "PCG64DXSM": PCG64DXSM,
+    "Philox": Philox,
+    "RDRAND": RDRAND,
+    "Romu": Romu,
+    "SFC64": SFC64,
+    "SFMT": SFMT,
+    "SPECK128": SPECK128,
+    "Squares": Squares,
+    "ThreeFry": ThreeFry,
+    "Tyche": Tyche,
+    "Xoroshiro128": Xoroshiro128,
+    "Xorshift1024": Xorshift1024,
+    "Xoshiro256": Xoshiro256,
+    "Xoshiro512": Xoshiro512,
+}
+
+# Assign the fully qualified name for future proofness
+for value in list(BitGenerators.values()):
+    BitGenerators[f"{value.__module__}.{value.__name__}"] = value
+
+
+def _get_bitgenerator(bit_generator_name: str) -> type[BitGenerator]:
+    """
+    Bit generator look-up with user-friendly errors
+    """
+    if bit_generator_name in BitGenerators:
+        bit_generator = BitGenerators[bit_generator_name]
+    else:
+        raise ValueError(
+            str(bit_generator_name) + " is not a known BitGenerator module.",
+        )
+    return bit_generator
+
+
+def _decode(name: str | bytes) -> str:
+    if isinstance(name, str):
+        return name
+    assert isinstance(name, bytes)
+    return name.decode("ascii")
+
+
+def __extended_generator_ctor(
+    bit_generator_name: str | bytes = "MT19937",
+) -> ExtendedGenerator:
+    """
+    Pickling helper function that returns a Generator object
+
+    Parameters
+    ----------
+    bit_generator_name: str
+        String containing the core BitGenerator
+
+    Returns
+    -------
+    rg: Generator
+        Generator using the named core BitGenerator
+    """
+    bit_generator_name = _decode(bit_generator_name)
+    assert isinstance(bit_generator_name, str)
+    bit_generator = _get_bitgenerator(bit_generator_name)
+    with warnings.catch_warnings():
+        warnings.filterwarnings("ignore", category=FutureWarning)
+        bit_gen = bit_generator()
+    return ExtendedGenerator(bit_gen)
+
+
+def __bit_generator_ctor(bit_generator_name: str | bytes = "MT19937") -> BitGenerator:
+    """
+    Pickling helper function that returns a bit generator object
+
+    Parameters
+    ----------
+    bit_generator_name: str
+        String containing the name of the bit generator
+
+    Returns
+    -------
+    bit_generator: BitGenerator
+        Bit generator instance
+    """
+    bit_generator_name = _decode(bit_generator_name)
+    assert isinstance(bit_generator_name, str)
+    bit_generator = _get_bitgenerator(bit_generator_name)
+    with warnings.catch_warnings():
+        warnings.filterwarnings("ignore", category=FutureWarning)
+        bit_gen = bit_generator()
+    return bit_gen

randomgen/_register.py

@@ -0,0 +1,73 @@
+from numpy.random._pickle import BitGenerators
+
+from randomgen.aes import AESCounter
+from randomgen.blabla import BlaBla
+from randomgen.chacha import ChaCha
+from randomgen.dsfmt import DSFMT
+from randomgen.efiix64 import EFIIX64
+from randomgen.hc128 import HC128
+from randomgen.jsf import JSF
+from randomgen.lxm import LXM
+from randomgen.mt64 import MT64
+from randomgen.mt19937 import MT19937
+from randomgen.mwcx import MWC64X32, MWC128X, MWC128X32, MWC192X
+from randomgen.pcg32 import PCG32
+from randomgen.pcg64 import PCG64, PCG64DXSM, LCG128Mix
+from randomgen.philox import Philox
+from randomgen.rdrand import RDRAND
+from randomgen.romu import Romu
+from randomgen.sfc import SFC64
+from randomgen.sfmt import SFMT
+from randomgen.speck128 import SPECK128
+from randomgen.squares import Squares
+from randomgen.threefry import ThreeFry
+from randomgen.tyche import Tyche
+from randomgen.wrapper import UserBitGenerator
+from randomgen.xoroshiro128 import Xoroshiro128
+from randomgen.xorshift1024 import Xorshift1024
+from randomgen.xoshiro256 import Xoshiro256
+from randomgen.xoshiro512 import Xoshiro512
+
+bit_generators = [
+    AESCounter,
+    BlaBla,
+    ChaCha,
+    DSFMT,
+    EFIIX64,
+    HC128,
+    JSF,
+    LXM,
+    MT19937,
+    MT64,
+    MWC64X32,
+    MWC128X,
+    MWC128X32,
+    MWC192X,
+    PCG32,
+    PCG64,
+    PCG64DXSM,
+    LCG128Mix,
+    Philox,
+    RDRAND,
+    Romu,
+    SFC64,
+    SFMT,
+    SPECK128,
+    Squares,
+    ThreeFry,
+    Tyche,
+    UserBitGenerator,
+    Xoroshiro128,
+    Xorshift1024,
+    Xoshiro256,
+    Xoshiro512,
+]
+
+for bitgen in bit_generators:
+    key = f"{bitgen.__name__}"
+    if key not in BitGenerators:
+        BitGenerators[key] = bitgen
+    full_key = f"{bitgen.__module__}.{bitgen.__name__}"
+    BitGenerators[full_key] = bitgen
+
+__all__ = ["BitGenerators"]

randomgen/_version.py

@@ -0,0 +1,22 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '2.5.0'
+__version_tuple__ = version_tuple = (2, 5, 0)
+    

randomgen/aes.pyi

@@ -0,0 +1,31 @@
+from collections.abc import Sequence
+
+from numpy import ndarray
+
+from randomgen.common import BitGenerator
+from randomgen.typing import IntegerSequenceSeed
+
+class AESCounter(BitGenerator):
+    def __init__(
+        self,
+        seed: IntegerSequenceSeed | None = ...,
+        *,
+        counter: int | Sequence[int] | None = ...,
+        key: int | Sequence[int] | None = ...,
+    ) -> None: ...
+    @property
+    def use_aesni(self) -> bool: ...
+    @use_aesni.setter
+    def use_aesni(self, value: bool) -> None: ...
+    def seed(
+        self,
+        seed: IntegerSequenceSeed | None = ...,
+        counter: int | Sequence[int] | None = ...,
+        key: int | Sequence[int] | None = ...,
+    ) -> None: ...
+    @property
+    def state(self) -> dict[str, str | dict[str, int | ndarray] | int]: ...
+    @state.setter
+    def state(self, value: dict[str, str | dict[str, int | ndarray] | int]) -> None: ...
+    def jumped(self, iter: int = ...) -> AESCounter: ...
+    def advance(self, delta: int) -> AESCounter: ...

randomgen/blabla.pyi

@@ -0,0 +1,32 @@
+from collections.abc import Sequence
+
+from numpy import ndarray
+
+from randomgen.common import BitGenerator
+from randomgen.typing import IntegerSequenceSeed
+
+class BlaBla(BitGenerator):
+    def __init__(
+        self,
+        seed: IntegerSequenceSeed | None = ...,
+        *,
+        counter: int | Sequence[int] | None = ...,
+        key: int | Sequence[int] | None = ...,
+        rounds: int = ...,
+    ) -> None: ...
+    @property
+    def use_avx2(self) -> bool: ...
+    @use_avx2.setter
+    def use_avx2(self, value: bool) -> None: ...
+    def seed(
+        self,
+        seed: IntegerSequenceSeed | None = ...,
+        counter: int | Sequence[int] | None = ...,
+        key: int | Sequence[int] | None = ...,
+    ) -> None: ...
+    @property
+    def state(self) -> dict[str, str | dict[str, ndarray | int]]: ...
+    @state.setter
+    def state(self, value: dict[str, str | dict[str, ndarray | int]]) -> None: ...
+    def advance(self, delta: int) -> None: ...
+    def jumped(self, iter: int = ...) -> BlaBla: ...

randomgen/chacha.pyi

@@ -0,0 +1,30 @@
+from collections.abc import Sequence
+
+from numpy import ndarray
+
+from randomgen.common import BitGenerator
+from randomgen.typing import IntegerSequenceSeed
+
+class ChaCha(BitGenerator):
+    def __init__(
+        self,
+        seed: IntegerSequenceSeed | None = ...,
+        *,
+        counter: int | Sequence[int] | None = ...,
+        key: int | Sequence[int] | None = ...,
+        rounds: int = ...,
+    ) -> None: ...
+    @property
+    def use_simd(self) -> bool: ...
+    @use_simd.setter
+    def use_simd(self, value: bool) -> None: ...
+    def seed(
+        self,
+        seed: IntegerSequenceSeed | None = ...,
+        counter: int | Sequence[int] | None = ...,
+        key: int | Sequence[int] | None = ...,
+    ) -> None: ...
+    @property
+    def state(self) -> dict[str, str | dict[str, ndarray | int]]: ...
+    @state.setter
+    def state(self, value: dict[str, str | dict[str, ndarray | int]]) -> None: ...

randomgen/common.pyi

@@ -0,0 +1,37 @@
+from typing import Any, NamedTuple
+
+from numpy import ndarray
+
+from randomgen.seed_sequence import SeedSequence
+from randomgen.typing import IntegerSequenceSeed
+
+class Interface(NamedTuple):
+    state_address: int
+    state: int
+    next_uint64: int
+    next_uint32: int
+    next_double: int
+    bit_generator: int
+
+class BitGenerator:
+    seed_seq: SeedSequence
+    def __init__(
+        self,
+        seed: IntegerSequenceSeed | None,
+        *,
+        numpy_seed: bool = ...,
+    ) -> None: ...
+    @property
+    def state(self) -> dict[str, Any]: ...
+    @state.setter
+    def state(self, value: dict[str, Any]) -> None: ...
+    def random_raw(
+        self,
+        size: int | None = ...,
+        output: bool = ...,
+    ) -> int | ndarray | None: ...
+    def _benchmark(self, cnt: int, method: str = ...) -> None: ...
+    @property
+    def ctypes(self) -> Any: ...
+    @property
+    def cffi(self) -> Any: ...

randomgen/conftest.py

@@ -0,0 +1,23 @@
+import pytest
+
+
+def pytest_configure(config):
+    # Minimal config to simplify running tests from lm.test()
+    config.addinivalue_line("markers", "slow: mark a test as slow")
+    # Used by pytest-run-parallel, registered here for runs without it
+    config.addinivalue_line(
+        "markers", "thread_unsafe: mark a test as unsafe to run in several threads"
+    )
+
+
+def pytest_addoption(parser):
+    parser.addoption("--skip-slow", action="store_true", help="skip slow tests")
+    parser.addoption("--only-slow", action="store_true", help="run only slow tests")
+
+
+def pytest_runtest_setup(item):
+    if "slow" in item.keywords and item.config.getoption("--skip-slow"):
+        pytest.skip("skipping due to --skip-slow")
+
+    if "slow" not in item.keywords and item.config.getoption("--only-slow"):
+        pytest.skip("skipping due to --only-slow")

randomgen/dsfmt.pyi

@@ -0,0 +1,17 @@
+from typing import TypeAlias
+
+import numpy as np
+
+from randomgen.common import BitGenerator
+from randomgen.typing import IntegerSequenceSeed
+
+DSFMTState: TypeAlias = dict[str, str | int | np.ndarray | dict[str, int | np.ndarray]]
+
+class DSFMT(BitGenerator):
+    def __init__(self, seed: IntegerSequenceSeed | None = ...) -> None: ...
+    def seed(self, seed: IntegerSequenceSeed | None = ...) -> None: ...
+    def jumped(self, iter: int = ...) -> DSFMT: ...
+    @property
+    def state(self) -> DSFMTState: ...
+    @state.setter
+    def state(self, value: DSFMTState) -> None: ...

randomgen/efiix64.pyi

@@ -0,0 +1,17 @@
+import numpy as np
+
+from randomgen.common import BitGenerator
+from randomgen.typing import IntegerSequenceSeed
+
+class EFIIX64(BitGenerator):
+    def __init__(self, seed: IntegerSequenceSeed | None = ...) -> None: ...
+    def seed(self, seed: IntegerSequenceSeed | None = ...) -> None: ...
+    @property
+    def state(
+        self,
+    ) -> dict[str, str | int | dict[str, int | np.ndarray]]: ...
+    @state.setter
+    def state(
+        self,
+        value: dict[str, str | int | dict[str, int | np.ndarray]],
+    ) -> None: ...

randomgen/entropy.pyi

@@ -0,0 +1,9 @@
+from typing import Literal
+
+import numpy as np
+
+def seed_by_array(seed: int | np.ndarray, n: int) -> np.ndarray: ...
+def random_entropy(
+    size: int | tuple[int, ...] | None = ...,
+    source: Literal["system", "fallback", "auto"] = ...,
+) -> int | np.ndarray: ...

randomgen/generator.pyi

@@ -0,0 +1,98 @@
+from typing import Any, Literal, overload
+
+from numpy import ndarray
+from numpy.typing import DTypeLike
+
+from randomgen.common import BitGenerator
+from randomgen.typing import RequiredSize, Size
+
+class ExtendedGenerator:
+    _bit_generator: BitGenerator
+    def __init__(self, bit_generator: BitGenerator | None = ...) -> None: ...
+    @property
+    def bit_generator(self) -> BitGenerator: ...
+    @property
+    def state(self) -> dict[str, Any]: ...
+    @state.setter
+    def state(self, value: dict[str, Any]) -> None: ...
+    @overload
+    def uintegers(self, size: None = ..., bits: Literal[32, 64] = ...) -> int: ...
+    @overload
+    def uintegers(self, size: RequiredSize, bits: Literal[32, 64] = ...) -> ndarray: ...
+    @overload
+    def random(
+        self,
+        size: None = ...,
+        dtype: DTypeLike = ...,
+        out: None = ...,
+    ) -> float: ...
+    @overload
+    def random(
+        self,
+        size: RequiredSize,
+        dtype: DTypeLike = ...,
+        out: ndarray | None = ...,
+    ) -> ndarray: ...
+    @overload
+    def random(
+        self,
+        size: None = ...,
+        dtype: DTypeLike = ...,
+        *,
+        out: ndarray,
+    ) -> ndarray: ...
+    def multivariate_normal(
+        self,
+        mean: ndarray,
+        cov: ndarray,
+        size: Size = ...,
+        check_valid: Literal["raise", "ignore", "warn"] = ...,
+        tol: float = ...,
+        *,
+        method: Literal["svd", "eigh", "cholesky", "factor"] = ...,
+    ) -> ndarray: ...
+    @overload
+    def complex_normal(
+        self,
+        loc: complex = ...,
+        gamma: complex = ...,
+        relation: complex = ...,
+        size: None = ...,
+    ) -> complex: ...
+    @overload
+    def complex_normal(
+        self,
+        loc: complex | ndarray = ...,
+        gamma: complex | ndarray = ...,
+        relation: complex | ndarray = ...,
+        size: Size = ...,
+    ) -> ndarray: ...
+    def standard_wishart(
+        self,
+        df: int,
+        dim: int,
+        size: Size = ...,
+        rescale: bool = ...,
+    ) -> ndarray: ...
+    def wishart(
+        self,
+        df: int | ndarray,
+        scale: ndarray | None = ...,
+        size: Size = ...,
+        *,
+        check_valid: Literal["raise", "ignore", "warn"] = ...,
+        tol: float = ...,
+        rank: int | None = ...,
+        method: Literal["svd", "eigh", "cholesky", "factor"] = ...,
+    ) -> ndarray: ...
+    def multivariate_complex_normal(
+        self,
+        loc: ndarray,
+        gamma: ndarray | None = ...,
+        relation: ndarray | None = ...,
+        size: Size = ...,
+        *,
+        check_valid: Literal["raise", "ignore", "warn"] = ...,
+        tol: float = ...,
+        method: Literal["svd", "eigh", "cholesky", "factor"] = ...,
+    ) -> ndarray: ...