pelutils 3.8.0__tar.gz → 3.8.2__tar.gz

{pelutils-3.8.0 → pelutils-3.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pelutils
-Version: 3.8.0
+Version: 3.8.2
 Summary: The Swiss army knife of Python projects.
 Home-page: https://github.com/peleiden/pelutils
 Download-URL: https://pypi.org/project/pelutils/
@@ -36,14 +36,14 @@ License-File: pelutils/_c/hashmap.c/LICENSE
 The Swiss army knife of Python projects.
 
 - A simple and powerful logger with colourful printing, stacktraces, and log file rotation.
-- Parsing for combining config files and command-line arguments - especially useful developing algorithms with many parameters.
-- A timer inspired by Matlab's `tic` and `toc`.
-- Simple, near-zero cost performance profiler.
-- An extension to the built-in `dataclass` for saving and loading data.
+- Argument parser which supports both command line arguments and config files and has baked-in auto-documentation.
+- A simple timer inspired by Matlab's `tic` and `toc`.
+- Easy-to-use, near-zero cost performance profiler.
+- An extension to `pydantic.BaseModel` with support for saving any data structure to, and loading from, a human-readable JSON file.
 - Table formatting with built-in LaTeX support.
 - Miscellaneous standalone functions - see `pelutils/__init__.py`.
 - Data-science submodule with extra utilities for statistics, plotting with `matplotlib`, and machine learning using `PyTorch`.
-- `unique` function in the style of `numpy.unique` which runs in linear time, making it significantly.
+- `unique` function in the style of `numpy.unique` which runs in linear time, making it significantly faster for large arrays.
 
 `pelutils` supports Python 3.9+.
 
@@ -121,8 +121,6 @@ based = BasedClass(
     baseder=BasederClass(based_string="Hello there")
 )
 # Save it to a file
-based.save(".")
-# Save it to a file
 based.save("directory/to/save/in")
 
 # Load it again
@@ -380,7 +378,9 @@ Examples of all the plotting utilities are shown in the `examples` directory.
 
 Precompiled wheels are provided for most common platforms.
 Notably, they are not provided for 32-bit systems.
-If no wheel is provided, `pip` should attempt a source install.
+If no wheel is provided, `pip` should attempt a source install - this requires `<Python.h>` to be available.
+On Ubuntu, this can be installed with `sudo apt install python3-dev`, and on Fedora, it is installed with `sudo dnf install python3-devel`.
+
 If all else fails, it is possible to install from source by pointing `pip` to Github directly:
 ```
 pip install git+https://github.com/peleiden/pelutils.git@release#egg=pelutils

{pelutils-3.8.0 → pelutils-3.8.2}/README.md

@@ -11,14 +11,14 @@
 The Swiss army knife of Python projects.
 
 - A simple and powerful logger with colourful printing, stacktraces, and log file rotation.
-- Parsing for combining config files and command-line arguments - especially useful developing algorithms with many parameters.
-- A timer inspired by Matlab's `tic` and `toc`.
-- Simple, near-zero cost performance profiler.
-- An extension to the built-in `dataclass` for saving and loading data.
+- Argument parser which supports both command line arguments and config files and has baked-in auto-documentation.
+- A simple timer inspired by Matlab's `tic` and `toc`.
+- Easy-to-use, near-zero cost performance profiler.
+- An extension to `pydantic.BaseModel` with support for saving any data structure to, and loading from, a human-readable JSON file.
 - Table formatting with built-in LaTeX support.
 - Miscellaneous standalone functions - see `pelutils/__init__.py`.
 - Data-science submodule with extra utilities for statistics, plotting with `matplotlib`, and machine learning using `PyTorch`.
-- `unique` function in the style of `numpy.unique` which runs in linear time, making it significantly.
+- `unique` function in the style of `numpy.unique` which runs in linear time, making it significantly faster for large arrays.
 
 `pelutils` supports Python 3.9+.
 
@@ -96,8 +96,6 @@ based = BasedClass(
     baseder=BasederClass(based_string="Hello there")
 )
 # Save it to a file
-based.save(".")
-# Save it to a file
 based.save("directory/to/save/in")
 
 # Load it again
@@ -355,7 +353,9 @@ Examples of all the plotting utilities are shown in the `examples` directory.
 
 Precompiled wheels are provided for most common platforms.
 Notably, they are not provided for 32-bit systems.
-If no wheel is provided, `pip` should attempt a source install.
+If no wheel is provided, `pip` should attempt a source install - this requires `<Python.h>` to be available.
+On Ubuntu, this can be installed with `sudo apt install python3-dev`, and on Fedora, it is installed with `sudo dnf install python3-devel`.
+
 If all else fails, it is possible to install from source by pointing `pip` to Github directly:
 ```
 pip install git+https://github.com/peleiden/pelutils.git@release#egg=pelutils

{pelutils-3.8.0 → pelutils-3.8.2}/pelutils/__version__.py

@@ -1,2 +1,2 @@
 # Do not put anything else in this file
-__version__ = "3.8.0"
+__version__ = "3.8.2"

{pelutils-3.8.0 → pelutils-3.8.2}/pelutils/datastorage2/__init__.py

@@ -6,13 +6,13 @@ from typing import TypeVar
 
 from pydantic import BaseModel, ConfigDict
 
-from pelutils.datastorage2._pretty_json import _make_json_unsafe, _pretty_json  # pyright: ignore[reportPrivateUsage]
+from pelutils.datastorage2._pretty_json import _make_json_unsafe, _pickle_encode, _pretty_json  # pyright: ignore[reportPrivateUsage]
 
 _T = TypeVar("_T", bound="DataStorage2")
 
 
 class DataStorage2(BaseModel):
-    """Better version of DataStorage based on pydantic.
+    """Better version of DataStorage based on pydantic. It makes any class fully JSON serialisable.
 
     Usage is very similar to DataStorage, but it has a few key advantages:
     - Allows saving and loading of nested objects.
@@ -38,12 +38,14 @@ class DataStorage2(BaseModel):
         If save_name is None, the path is <directory>/<class name>.json, otherwise it is <directory>/<save_name>.json.
         """
         savepath = self._resolve_save_file(directory, filename)
-        self_dict = self.model_dump()
+        self_dict = self.model_dump(mode="json", fallback=_pickle_encode)
         savepath.write_text(
             _pretty_json(
                 self_dict,
                 max_line_length=max_line_length,
                 indent=indent,
+                # Safe should not be needed here, as the fallback function in model_dump should ensure no issues
+                # However, it is kept for good measure in case there unforeseen edge cases
                 safe=True,
             ),
             encoding=encoding,

{pelutils-3.8.0 → pelutils-3.8.2}/pelutils/logging/__init__.py

@@ -4,7 +4,7 @@ import os
 import traceback as tb
 from collections.abc import Generator, Iterable
 from pathlib import Path
-from typing import Optional
+from typing import Any, Optional
 
 from pelutils import OS, UnsupportedOS, get_repo, get_timestamp
 from pelutils.format import RichString
@@ -135,7 +135,7 @@ class Logger:
 
     def _log(
         self,
-        *tolog: str,
+        *tolog: Any,  # pyright: ignore[reportExplicitAny]
         level: LogLevels = LogLevels.INFO,
         with_info: bool = True,
         sep: str | None = None,
@@ -276,34 +276,39 @@ class Logger:
             raise UnsupportedOS("Log collecting is not supported on windows")
         return _CollectLogs(self)
 
-    def section(self, *tolog: str, with_info: bool = True, sep: str | None = None, with_print: bool | None = None, newline: bool = True):
+    def section(self, *tolog: Any, with_info: bool = True, sep: str | None = None, with_print: bool | None = None, newline: bool = True):  # pyright: ignore[reportExplicitAny]
         """Log at SECTION level. See .log method for argument descriptions."""
         if newline:
             self._log("")
         self._log(*tolog, with_info=with_info, sep=sep, with_print=with_print, level=LogLevels.SECTION)
 
-    def critical(self, *tolog: str, with_info: bool = True, sep: str | None = None, with_print: bool | None = None):
+    def critical(self, *tolog: Any, with_info: bool = True, sep: str | None = None, with_print: bool | None = None):  # pyright: ignore[reportExplicitAny]
         """Log at CRITICAL level. See .log method for argument descriptions."""
         self._log(*tolog, with_info=with_info, sep=sep, with_print=with_print, level=LogLevels.CRITICAL)
 
-    def error(self, *tolog: str, with_info: bool = True, sep: str | None = None, with_print: bool | None = None):
+    def error(self, *tolog: Any, with_info: bool = True, sep: str | None = None, with_print: bool | None = None):  # pyright: ignore[reportExplicitAny]
         """Log at ERROR level. See .log method for argument descriptions."""
         self._log(*tolog, with_info=with_info, sep=sep, with_print=with_print, level=LogLevels.ERROR)
 
-    def warning(self, *tolog: str, with_info: bool = True, sep: str | None = None, with_print: bool | None = None):
+    def warning(self, *tolog: Any, with_info: bool = True, sep: str | None = None, with_print: bool | None = None):  # pyright: ignore[reportExplicitAny]
         """Log at WARNING level. See .log method for argument descriptions."""
         self._log(*tolog, with_info=with_info, sep=sep, with_print=with_print, level=LogLevels.WARNING)
 
-    def info(self, *tolog: str, with_info: bool = True, sep: str | None = None, with_print: bool | None = None):
+    def info(self, *tolog: Any, with_info: bool = True, sep: str | None = None, with_print: bool | None = None):  # pyright: ignore[reportExplicitAny]
         """Log at INFO level. See .log method for argument descriptions."""
         self._log(*tolog, with_info=with_info, sep=sep, with_print=with_print, level=LogLevels.INFO)
 
-    def debug(self, *tolog: str, with_info: bool = True, sep: str | None = None, with_print: bool | None = None):
+    def debug(self, *tolog: Any, with_info: bool = True, sep: str | None = None, with_print: bool | None = None):  # pyright: ignore[reportExplicitAny]
         """Log at DEBUG level. See .log method for argument descriptions."""
         self._log(*tolog, with_info=with_info, sep=sep, with_print=with_print, level=LogLevels.DEBUG)
 
     def __call__(
-        self, *tolog: str, level: LogLevels = LogLevels.INFO, with_info: bool = True, sep: str | None = None, with_print: bool | None = None
+        self,
+        *tolog: Any,  # pyright: ignore[reportExplicitAny]
+        level: LogLevels = LogLevels.INFO,
+        with_info: bool = True,
+        sep: str | None = None,
+        with_print: bool | None = None,
     ):
         """Shorthand for specific logging methods where level is specified as an argument."""
         self._log(*tolog, level=level, with_info=with_info, sep=sep, with_print=with_print)

{pelutils-3.8.0 → pelutils-3.8.2}/pelutils.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pelutils
-Version: 3.8.0
+Version: 3.8.2
 Summary: The Swiss army knife of Python projects.
 Home-page: https://github.com/peleiden/pelutils
 Download-URL: https://pypi.org/project/pelutils/
@@ -36,14 +36,14 @@ License-File: pelutils/_c/hashmap.c/LICENSE
 The Swiss army knife of Python projects.
 
 - A simple and powerful logger with colourful printing, stacktraces, and log file rotation.
-- Parsing for combining config files and command-line arguments - especially useful developing algorithms with many parameters.
-- A timer inspired by Matlab's `tic` and `toc`.
-- Simple, near-zero cost performance profiler.
-- An extension to the built-in `dataclass` for saving and loading data.
+- Argument parser which supports both command line arguments and config files and has baked-in auto-documentation.
+- A simple timer inspired by Matlab's `tic` and `toc`.
+- Easy-to-use, near-zero cost performance profiler.
+- An extension to `pydantic.BaseModel` with support for saving any data structure to, and loading from, a human-readable JSON file.
 - Table formatting with built-in LaTeX support.
 - Miscellaneous standalone functions - see `pelutils/__init__.py`.
 - Data-science submodule with extra utilities for statistics, plotting with `matplotlib`, and machine learning using `PyTorch`.
-- `unique` function in the style of `numpy.unique` which runs in linear time, making it significantly.
+- `unique` function in the style of `numpy.unique` which runs in linear time, making it significantly faster for large arrays.
 
 `pelutils` supports Python 3.9+.
 
@@ -121,8 +121,6 @@ based = BasedClass(
     baseder=BasederClass(based_string="Hello there")
 )
 # Save it to a file
-based.save(".")
-# Save it to a file
 based.save("directory/to/save/in")
 
 # Load it again
@@ -380,7 +378,9 @@ Examples of all the plotting utilities are shown in the `examples` directory.
 
 Precompiled wheels are provided for most common platforms.
 Notably, they are not provided for 32-bit systems.
-If no wheel is provided, `pip` should attempt a source install.
+If no wheel is provided, `pip` should attempt a source install - this requires `<Python.h>` to be available.
+On Ubuntu, this can be installed with `sudo apt install python3-dev`, and on Fedora, it is installed with `sudo dnf install python3-devel`.
+
 If all else fails, it is possible to install from source by pointing `pip` to Github directly:
 ```
 pip install git+https://github.com/peleiden/pelutils.git@release#egg=pelutils

{pelutils-3.8.0 → pelutils-3.8.2}/pelutils.egg-info/SOURCES.txt

@@ -8,6 +8,7 @@ pelutils/format.py
 pelutils/jsonl.py
 pelutils/parser.py
 pelutils/pretty_json.py
+pelutils/py.typed
 pelutils/tests.py
 pelutils/ticktock.py
 pelutils/types.py
@@ -33,7 +34,6 @@ pelutils/ds/stats.py
 pelutils/logging/__init__.py
 pelutils/logging/_rotate.py
 pelutils/logging/_utils.py
-tests/__init__.py
 tests/test_datastorage.py
 tests/test_format.py
 tests/test_init.py
@@ -42,17 +42,4 @@ tests/test_parser.py
 tests/test_pretty_json.py
 tests/test_tests.py
 tests/test_ticktock.py
-tests/test_types.py
-tests/_c/__init__.py
-tests/_c/test_c.py
-tests/datastorage2/__init__.py
-tests/datastorage2/test_init.py
-tests/datastorage2/test_pretty_json.py
-tests/ds/__init__.py
-tests/ds/test_distributions.py
-tests/ds/test_ds.py
-tests/ds/test_plots.py
-tests/ds/test_stats.py
-tests/logging/__init__.py
-tests/logging/test_logging.py
-tests/logging/test_rotate.py
+tests/test_types.py

{pelutils-3.8.0 → pelutils-3.8.2}/pelutils.egg-info/top_level.txt

@@ -1,3 +1,2 @@
 _pelutils_c
 pelutils
-tests

{pelutils-3.8.0 → pelutils-3.8.2}/setup.py

@@ -48,7 +48,9 @@ class CExtension(Extension):
     """See this thread for details: https://stackoverflow.com/a/34830639/13196863."""
 
 
-class build(build_):  # noqa: D101
+class build(build_):
+    """Extension of normal build class which handles C extensions."""
+
     def build_extension(self, ext):  # noqa: D102
         self._ctypes = isinstance(ext, CExtension)
         return super().build_extension(ext)
@@ -71,7 +73,8 @@ setup_args = dict(
     long_description_content_type="text/markdown",
     long_description=README,
     license="MIT",
-    packages=find_packages(),
+    packages=find_packages(exclude=("tests", "tests.*")),
+    package_data={"pelutils": ["py.typed"]},
     author="Asger Laurits Schultz, Søren Winkel Holm",
     author_email="asger.s@protonmail.com, swholm@protonmail.com",
     keywords=["utility", "logger", "parser", "profiling", "plotting"],

pelutils-3.8.0/tests/_c/test_c.py

@@ -1,26 +0,0 @@
-import ctypes
-
-import numpy as np
-import pytest
-import torch
-
-import pelutils._c as c_utils
-from pelutils import OS
-
-
-@pytest.mark.skipif(OS.is_windows, reason="This test does spooky shit that scares Windows")
-def test_get_c_array_args():
-    for dtype in int, float, np.float16, np.int32:
-        shape = (2, 4, 3)
-        np_arr = np.empty(shape, dtype=dtype)
-        arr_p, ndim, dims_p, strides_p = c_utils.get_array_c_args(torch.from_numpy(np_arr))
-        assert arr_p == np_arr.ctypes.data
-        assert ndim == len(shape)
-
-        itemsize = np.dtype(np.uint).itemsize
-        s = np_arr.dtype.itemsize
-        for i, d in enumerate(shape[::-1]):
-            i = len(shape) - i - 1  # noqa: PLW2901
-            assert d == ctypes.c_uint64.from_address(dims_p + i * itemsize).value
-            assert s == ctypes.c_uint64.from_address(strides_p + i * itemsize).value
-            s *= d

pelutils-3.8.0/tests/datastorage2/test_init.py

@@ -1,81 +0,0 @@
-import numpy as np
-import pandas as pd
-import pytest
-import torch
-
-from pelutils.datastorage2 import DataStorage2
-from pelutils.datastorage2._pretty_json import _PICKLE_PREFIX
-from pelutils.tests import UnitTestCollection
-from pelutils.types import FloatArray
-
-
-class DeepCollection(DataStorage2):
-    np_arr: FloatArray
-    tensor: torch.Tensor
-    df: pd.DataFrame
-
-
-class Collection(DataStorage2):
-    string: str
-    list_of_floats: list[float]
-    tuple_of_floats: tuple[float, ...]
-    tuple_of_ints: tuple[int, ...]
-    collection: DeepCollection
-
-
-class WhackStorage(DataStorage2):
-    """Whack struct with lots of nested non-native data types."""
-
-    np_arr: FloatArray
-    tensor: torch.Tensor
-    df: pd.DataFrame
-    collection: Collection
-
-
-data = WhackStorage(
-    np_arr=np.arange(5, dtype=np.float16),
-    tensor=torch.ones(5),
-    df=pd.DataFrame({"col1": [1, 2, 3], "col": np.arange(3)}),
-    collection=Collection(
-        string="Hello There",
-        list_of_floats=[1.0, 2.0, 3.0],
-        tuple_of_floats=(0.1, 0.2, 0.3),
-        tuple_of_ints=tuple(range(500)),
-        collection=DeepCollection(
-            np_arr=np.arange(10),
-            tensor=torch.zeros(0, dtype=bool),
-            df=pd.DataFrame({"col1": ["1", "2", "3"], "col": np.arange(3)}),
-        ),
-    ),
-)
-
-
-class TestDataStorage2(UnitTestCollection):
-    def test_save_load(self):
-        # Test save and load with custom file name
-        data.save(self.test_dir, filename="bollocks")
-        WhackStorage.load(self.test_dir, filename="bollocks")
-        # Set save and load with default file name
-        data.save(self.test_dir)
-        loaded = WhackStorage.load(self.test_dir)
-        assert (data.np_arr == loaded.np_arr).all()
-        assert data.np_arr.dtype == loaded.np_arr.dtype
-        assert (data.tensor == loaded.tensor).all()
-        assert data.tensor.dtype is loaded.tensor.dtype
-        assert data.df.equals(loaded.df)
-        assert data.collection.string == loaded.collection.string
-        assert data.collection.list_of_floats == data.collection.list_of_floats
-        assert data.collection.tuple_of_floats == data.collection.tuple_of_floats
-        assert data.collection.tuple_of_ints == data.collection.tuple_of_ints
-        assert (data.collection.collection.np_arr == loaded.collection.collection.np_arr).all()
-        assert data.collection.collection.np_arr.dtype == loaded.collection.collection.np_arr.dtype
-        assert (data.collection.collection.tensor == loaded.collection.collection.tensor).all()
-        assert data.collection.collection.tensor.dtype is loaded.collection.collection.tensor.dtype
-        assert data.collection.collection.df.equals(loaded.collection.collection.df)
-
-        # Check that corrupted data raises a ValueError
-        json_content = data._resolve_save_file(self.test_dir).read_text()
-        json_content = json_content.replace(_PICKLE_PREFIX, f"_{_PICKLE_PREFIX}")
-        data._resolve_save_file(self.test_dir).write_text(json_content)
-        with pytest.raises(ValueError):
-            WhackStorage.load(self.test_dir)

pelutils-3.8.0/tests/datastorage2/test_pretty_json.py

@@ -1,92 +0,0 @@
-import json
-from dataclasses import dataclass
-from datetime import datetime, timezone
-from decimal import Decimal
-from pathlib import Path
-from typing import Any
-
-import pytest
-
-from pelutils.datastorage2._pretty_json import _PICKLE_PREFIX, _decode_unpickle, _pretty_json
-
-
-def pretty_json_with_defaults(obj: Any) -> Any:
-    return _pretty_json(
-        obj,
-        max_line_length=140,
-        indent=2,
-        safe=True,
-    )
-
-
-# ─── Pickle / b64 fallback ─────────────────────────────────────────────────
-
-
-@dataclass
-class _Point:
-    x: float
-    y: float
-
-
-class TestPickleFallback:
-    def test_datetime_is_pickled(self) -> None:
-        dt = datetime(2025, 1, 1, tzinfo=timezone.utc)
-        result = pretty_json_with_defaults({"ts": dt})
-        parsed = json.loads(result)
-        assert parsed["ts"].startswith(_PICKLE_PREFIX)
-        assert _decode_unpickle(parsed["ts"]) == dt
-
-    def test_dataclass_is_pickled(self) -> None:
-        pt = _Point(1.5, 2.5)
-        result = pretty_json_with_defaults({"point": pt})
-        parsed = json.loads(result)
-        restored = _decode_unpickle(parsed["point"])
-        assert restored == pt
-
-    def test_decimal_is_pickled(self) -> None:
-        obj = {"price": Decimal("19.99")}
-        result = pretty_json_with_defaults(obj)
-        parsed = json.loads(result)
-        assert _decode_unpickle(parsed["price"]) == Decimal("19.99")
-
-    def test_path_is_pickled(self) -> None:
-        p = Path("/usr/local/bin")
-        result = pretty_json_with_defaults({"path": p})
-        parsed = json.loads(result)
-        assert _decode_unpickle(parsed["path"]) == p
-
-    def test_set_inside_list_is_pickled(self) -> None:
-        obj = [1, {2, 3, 4}, "hello"]
-        result = pretty_json_with_defaults(obj)
-        parsed = json.loads(result)
-        assert parsed[0] == 1
-        assert parsed[2] == "hello"
-        assert _decode_unpickle(parsed[1]) == {2, 3, 4}
-
-    def test_nested_non_serialisable(self) -> None:
-        obj = {"outer": {"inner": _Point(0, 0)}}
-        result = pretty_json_with_defaults(obj)
-        parsed = json.loads(result)
-        assert _decode_unpickle(parsed["outer"]["inner"]) == _Point(0, 0)
-
-    def test_unpickle_rejects_plain_string(self) -> None:
-        with pytest.raises(ValueError, match="Not a pickled value"):
-            _decode_unpickle("just a string")
-
-    def test_non_string_dict_keys_coerced(self) -> None:
-        obj = {1: "one", 2: "two"}  # type: ignore[dict-item]
-        result = pretty_json_with_defaults(obj)  # type: ignore[arg-type]
-        parsed = json.loads(result)
-        assert parsed == {"1": "one", "2": "two"}
-
-    def test_output_is_valid_json_with_mixed_types(self) -> None:
-        obj = {
-            "name": "test",
-            "when": datetime(2025, 6, 1),
-            "tags": ["a", "b"],
-            "nested": {"d": Decimal("1.1"), "n": None},
-        }
-        parsed = json.loads(pretty_json_with_defaults(obj))
-        assert parsed["name"] == "test"
-        assert parsed["tags"] == ["a", "b"]
-        assert parsed["nested"]["n"] is None

pelutils-3.8.0/tests/ds/test_distributions.py

@@ -1,147 +0,0 @@
-from itertools import product
-
-import numpy as np
-import pytest
-
-from pelutils.ds.distributions import (
-    bernoulli,
-    beta,
-    binomial,
-    chi2,
-    expon,
-    gamma,
-    geom0,
-    geom1,
-    hypergeom,
-    lognorm,
-    nbinom,
-    norm,
-    poisson,
-    rayleigh,
-)
-
-
-def test_norm():
-    mus = np.linspace(-10, 10, 5)
-    sigmas = np.linspace(0, 10, 5)[1:]
-    for mu, sigma in product(mus, sigmas):
-        dist = norm(mu, sigma**2)
-        assert np.isclose(dist.mean(), mu)
-        assert np.isclose(dist.var(), sigma**2)
-
-
-def test_lognorm():
-    mus = np.linspace(-10, 10, 5)
-    sigmas = np.linspace(0, 10, 5)[1:]
-    for mu, sigma in product(mus, sigmas):
-        dist = lognorm(mu, sigma**2)
-        assert np.isclose(dist.mean(), np.exp(mu + sigma**2 / 2))
-        assert np.isclose(dist.var(), (np.exp(sigma**2) - 1) * np.exp(2 * mu + sigma**2))
-
-
-def test_expon():
-    lambdas = np.linspace(0, 10, 5)[1:]
-    for lambda_ in lambdas:
-        dist = expon(lambda_)
-        assert np.isclose(dist.mean(), 1 / lambda_)
-        assert np.isclose(dist.var(), 1 / lambda_**2)
-
-
-def test_gamma():
-    rs = np.linspace(0, 10, 5)[1:]
-    lambdas = np.linspace(0, 10)[1:]
-    for r, lambda_ in product(rs, lambdas):
-        dist = gamma(r, lambda_)
-        assert np.isclose(dist.mean(), r / lambda_)
-        assert np.isclose(dist.var(), r / lambda_**2)
-
-
-def test_chi2():
-    dfs = np.linspace(0, 10, 31)[1:]
-    for df in dfs:
-        dist = chi2(df)
-        assert np.isclose(dist.mean(), df)
-        assert np.isclose(dist.var(), 2 * df)
-
-
-def test_rayleigh():
-    dist = rayleigh()
-    assert np.isclose(dist.mean(), np.sqrt(np.pi / 2))
-    assert np.isclose(dist.var(), (4 - np.pi) / 2)
-
-
-def test_beta():
-    rs = np.linspace(0, 10, 5)[1:]
-    ss = np.linspace(0, 10, 5)[1:]
-    for r, s in product(rs, ss):
-        dist = beta(r, s)
-        assert np.isclose(dist.mean(), r / (r + s))
-        assert np.isclose(dist.var(), r * s / ((r + s) ** 2 * (r + s + 1)))
-
-
-def test_bernoulli():
-    ps = np.linspace(0, 1, 5)
-    for p in ps:
-        dist = bernoulli(p)
-        assert np.isclose(dist.mean(), p)
-        assert np.isclose(dist.var(), p * (1 - p))
-
-
-def test_binomial():
-    ns = np.arange(0, 10)
-    ps = np.linspace(0, 1, 5)
-    for n, p in product(ns, ps):
-        dist = binomial(n, p)
-        assert np.isclose(dist.mean(), n * p)
-        assert np.isclose(dist.var(), n * p * (1 - p))
-
-
-def test_poisson():
-    mus = np.linspace(0, 10, 5)
-    for mu in mus:
-        dist = poisson(mu)
-        assert np.isclose(dist.mean(), mu)
-        assert np.isclose(dist.var(), mu)
-
-
-@pytest.mark.filterwarnings("ignore:invalid value", "ignore:divide by zero")
-def test_hypergeom():
-    ns = np.arange(0, 10)
-    Ns = np.arange(0, 10)  # noqa: N806
-    Gs = np.arange(0, 10)  # noqa: N806
-    for n, N, G in product(ns, Ns, Gs):  # noqa: N806
-        if n >= N or G > N or n == 0 or N <= 1 or G == 0:
-            with pytest.raises(AssertionError):
-                dist = hypergeom(n, N, G)
-            continue
-        dist = hypergeom(n, N, G)
-        assert np.isclose(dist.mean(), n * G / N)
-        assert np.isclose(dist.var(), n * G / N * (N - G) / N * (N - n) / (N - 1))
-
-
-@pytest.mark.filterwarnings("ignore:divide by zero")
-def test_geom0():
-    ps = np.linspace(0, 1, 5)[1:]
-    for p in ps:
-        dist = geom0(p)
-        assert np.isclose(dist.mean(), (1 - p) / p)
-        assert np.isclose(dist.var(), (1 - p) / p**2)
-
-
-@pytest.mark.filterwarnings("ignore:divide by zero")
-def test_geom1():
-    ps = np.linspace(0, 1, 5)[1:]
-    for p in ps:
-        dist = geom1(p)
-        assert np.isclose(dist.mean(), 1 / p)
-        assert np.isclose(dist.var(), (1 - p) / p**2)
-
-
-@pytest.mark.filterwarnings("ignore:divide by zero")
-def test_nbinom():
-    rs = np.arange(0, 10)[1:]
-    ps = np.linspace(0, 1, 5)[1:]
-    for r, p in product(rs, ps):
-        dist = nbinom(r, p)
-        assert np.isclose(dist.mean(), r * (1 - p) / p)
-        assert np.isclose(dist.var(), r * (1 - p) / p**2)