fl-data-generator 0.1.0__py3-none-any.whl

fl_data_generator/__init__.py

@@ -0,0 +1,16 @@
+from .dataset import FederatedDataset, NumpyDataset
+from .dirichlet import dirichlet_partition
+from .hybrid import hybrid_partition
+from .iid import iid_partition
+from .pathological import pathological_partition
+from .quantity import quantity_skew_partition
+
+__all__ = [
+    "FederatedDataset",
+    "NumpyDataset",
+    "dirichlet_partition",
+    "hybrid_partition",
+    "iid_partition",
+    "pathological_partition",
+    "quantity_skew_partition",
+]

fl_data_generator/_validation.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+from typing import Sequence
+
+import numpy as np
+
+
+def validate_labels(labels: Sequence | np.ndarray) -> np.ndarray:
+    """Validate and cast dataset labels to a 1D int64 numpy array.
+
+    Parameters
+    ----------
+    labels : Sequence or np.ndarray
+        Dataset labels as an array-like or sequence.
+
+    Returns
+    -------
+    np.ndarray
+        A 1D numpy array with dtype np.int64.
+
+    Raises
+    ------
+    ValueError
+        If labels is empty, not 1-dimensional, contains NaN or Inf, or
+        cannot be converted to integer values without loss of information.
+    TypeError
+        If labels elements cannot be converted to numeric values.
+    """
+    arr = np.asarray(labels)
+
+    if arr.ndim != 1:
+        raise ValueError("labels must be 1-dimensional; consider using labels.ravel()")
+
+    if arr.size == 0:
+        raise ValueError("labels cannot be empty")
+
+    if not np.issubdtype(arr.dtype, np.number):
+        # Could be object array with strings or other non-numeric types
+        try:
+            arr = arr.astype(np.float64)
+        except (ValueError, TypeError) as exc:
+            raise TypeError("labels must contain numeric values") from exc
+
+    # Check for NaN or Inf
+    if np.isnan(arr).any():
+        raise ValueError("labels contains NaN values")
+
+    if np.isinf(arr).any():
+        raise ValueError("labels contains infinite values")
+
+    # Check if integer-valued
+    if np.issubdtype(arr.dtype, np.floating):
+        if not np.all(np.floor(arr) == arr):
+            raise ValueError("labels must be integer-valued")
+        arr = arr.astype(np.int64)
+    elif np.issubdtype(arr.dtype, np.integer):
+        if arr.dtype != np.int64:
+            arr = arr.astype(np.int64)
+
+    return arr

fl_data_generator/dataset.py

@@ -0,0 +1,422 @@
+from typing import Any, Callable, Dict, Optional, Tuple, Union
+
+import numpy as np
+
+try:
+    import torch
+    from torch.utils.data import DataLoader, Dataset, Subset
+
+    _HAS_TORCH = True
+except ImportError:
+    _HAS_TORCH = False
+    Dataset = object  # type: ignore
+    DataLoader = None  # type: ignore
+    Subset = None  # type: ignore
+
+try:
+    import torchvision
+    import torchvision.datasets as tv_datasets
+
+    _HAS_TORCHVISION = True
+except ImportError:
+    _HAS_TORCHVISION = False
+    tv_datasets = None  # type: ignore
+
+from .dirichlet import dirichlet_partition
+from .hybrid import hybrid_partition
+from .iid import iid_partition
+from .pathological import pathological_partition
+from .quantity import quantity_skew_partition
+
+
+class NumpyDataset(Dataset):
+    """Lightweight dataset wrapper for NumPy arrays or tensor tuples.
+
+    Parameters
+    ----------
+    data : Sequence or np.ndarray or torch.Tensor
+        Feature array or tensor.
+    targets : Sequence or np.ndarray or torch.Tensor
+        Target labels array or tensor.
+    transform : callable, optional
+        Transformation applied to feature samples.
+    target_transform : callable, optional
+        Transformation applied to target labels.
+    """
+
+    def __init__(
+        self,
+        data: Any,
+        targets: Any,
+        transform: Optional[Callable] = None,
+        target_transform: Optional[Callable] = None,
+    ) -> None:
+        self.data = data
+        self.targets = targets
+        self.transform = transform
+        self.target_transform = target_transform
+
+    def __len__(self) -> int:
+        return len(self.targets)
+
+    def __getitem__(self, index: int) -> Tuple[Any, Any]:
+        x = self.data[index]
+        y = self.targets[index]
+
+        if self.transform is not None:
+            x = self.transform(x)
+        if self.target_transform is not None:
+            y = self.target_transform(y)
+
+        return x, y
+
+
+class FederatedDataset:
+    """High-level Federated Dataset manager for simulated distributed learning.
+
+    Provides automatic downloading, loading, and partitioning of datasets across
+    simulated clients according to standard Federated Learning benchmark distributions.
+
+    Supported Partitioning Regimes
+    ------------------------------
+    - **"iid"**:
+      Uniform random data splitting across all clients. Every client receives roughly
+      equal sample quantities and an identical class distribution.
+
+    - **"dirichlet"** (Label Skew):
+      Continuous non-IID label distribution based on Dirichlet sampling Dir(alpha).
+      * **alpha -> infinity** (e.g., 100.0): Approaches uniform, near-IID class distribution.
+      * **alpha ≈ 0.5**: Standard benchmark setting representing realistic heterogeneous clients.
+      * **alpha -> 0** (e.g., 0.05, 0.01): Extreme non-IID label skew where each client predominantly
+        holds samples from only 1 or 2 classes.
+
+    - **"pathological"** (Shard-based Label Skew):
+      The classic FedAvg benchmark (McMahan et al., 2017). Samples are sorted by label,
+      split into shards, and each client is assigned shards from a fixed number of classes
+      (configured via `classes_per_client`, e.g., 2 classes per client for MNIST).
+
+    - **"quantity"** (Sample Volume Skew):
+      Simulates hardware/usage heterogeneity where different clients collect vastly different
+      volumes of data. Client sample sizes follow a Dirichlet distribution parameterized by `beta`.
+      * **beta -> infinity** (e.g., 100.0): Clients receive roughly equal sample volumes.
+      * **beta -> 0** (e.g., 0.1): Extreme volume disparity (some clients receive hundreds of samples,
+        while others receive single digits).
+
+    - **"hybrid"** (Joint Label & Quantity Skew):
+      Combines volume disparity (governed by `beta`) with label preference heterogeneity
+      (governed by `alpha`).
+
+    Parameters
+    ----------
+    dataset : str or Tuple[Any, Any] or Dataset
+        Dataset identifier or instance:
+        - String name for built-in torchvision datasets: `"mnist"`, `"cifar10"`,
+          `"cifar100"`, `"fashion_mnist"`.
+        - Tuple of `(X, y)` containing features and labels (NumPy arrays or lists).
+        - Existing PyTorch `Dataset` object.
+    data_dir : str, default="./data"
+        Directory path used to cache and download standard datasets.
+    num_clients : int
+        Number of participating federated clients.
+    partition : str, default="iid"
+        Partition strategy. Choices: `"iid"`, `"dirichlet"`, `"pathological"`,
+        `"quantity"`, `"hybrid"`.
+    alpha : float, default=0.5
+        Dirichlet concentration parameter for label skew. Smaller values yield stronger
+        label heterogeneity across clients.
+    beta : float, default=0.5
+        Dirichlet concentration parameter for quantity skew. Smaller values yield higher
+        variance in client sample counts.
+    classes_per_client : int, default=2
+        Number of distinct classes assigned to each client in `"pathological"` partition.
+    seed : int, optional
+        Random seed for reproducible dataset partitioning.
+    train : bool, default=True
+        Whether to load the training or test split when downloading built-in datasets.
+    download : bool, default=True
+        Whether to automatically download built-in torchvision datasets if not present locally.
+    transform : callable, optional
+        Feature transformation applied to samples.
+    target_transform : callable, optional
+        Target transformation applied to labels.
+
+    Examples
+    --------
+    >>> # Using standard MNIST with Dirichlet label skew:
+    >>> fed_data = FederatedDataset("mnist", num_clients=10, partition="dirichlet", alpha=0.5)
+    >>> client_0_loader = fed_data.get_client_dataloader(client_id=0, batch_size=32)
+
+    >>> # Using custom NumPy arrays with quantity skew:
+    >>> import numpy as np
+    >>> X = np.random.randn(1000, 20)
+    >>> y = np.random.randint(0, 5, size=1000)
+    >>> fed_data = FederatedDataset((X, y), num_clients=5, partition="quantity", beta=0.2)
+    >>> indices = fed_data.get_client_indices(client_id=0)
+    """
+
+    SUPPORTED_DATASETS = {
+        "mnist": "MNIST",
+        "cifar10": "CIFAR10",
+        "cifar100": "CIFAR100",
+        "fashion_mnist": "FashionMNIST",
+        "fashionmnist": "FashionMNIST",
+    }
+
+    SUPPORTED_PARTITIONS = {
+        "iid",
+        "dirichlet",
+        "pathological",
+        "quantity",
+        "hybrid",
+    }
+
+    def __init__(
+        self,
+        dataset: Union[str, Tuple[Any, Any], Any],
+        data_dir: str = "./data",
+        num_clients: int = 10,
+        partition: str = "iid",
+        alpha: float = 0.5,
+        beta: float = 0.5,
+        classes_per_client: int = 2,
+        seed: Optional[int] = None,
+        train: bool = True,
+        download: bool = True,
+        transform: Optional[Callable] = None,
+        target_transform: Optional[Callable] = None,
+    ) -> None:
+        self.data_dir = data_dir
+        self.num_clients = num_clients
+        self.partition = partition.lower()
+        self.alpha = alpha
+        self.beta = beta
+        self.classes_per_client = classes_per_client
+        self.seed = seed
+        self.train = train
+        self.download = download
+        self.transform = transform
+        self.target_transform = target_transform
+
+        if self.num_clients <= 0:
+            raise ValueError(
+                f"num_clients must be positive, got {self.num_clients}"
+            )
+        if self.partition not in self.SUPPORTED_PARTITIONS:
+            raise ValueError(
+                f"Unsupported partition '{self.partition}'. "
+                f"Choose from: {sorted(self.SUPPORTED_PARTITIONS)}"
+            )
+
+        # 1. Load the underlying base dataset and extract target labels
+        self.base_dataset, self.labels = self._load_dataset(dataset)
+
+        # 2. Perform the specified partitioning
+        self.client_dict = self._partition_data()
+
+    def _load_dataset(self, dataset: Any) -> Tuple[Any, np.ndarray]:
+        """Resolve dataset input into a dataset instance and NumPy labels array."""
+        if isinstance(dataset, str):
+            ds_key = dataset.lower().strip()
+            if ds_key not in self.SUPPORTED_DATASETS:
+                raise ValueError(
+                    f"Unknown built-in dataset '{dataset}'. "
+                    f"Supported names: {sorted(self.SUPPORTED_DATASETS.keys())}"
+                )
+            if not _HAS_TORCHVISION:
+                raise ImportError(
+                    f"torchvision is required to download and load '{dataset}'. "
+                    f"Please install torchvision or provide custom (X, y) data."
+                )
+
+            ds_class_name = self.SUPPORTED_DATASETS[ds_key]
+            ds_cls = getattr(tv_datasets, ds_class_name)
+
+            ds_instance = ds_cls(
+                root=self.data_dir,
+                train=self.train,
+                download=self.download,
+                transform=self.transform,
+                target_transform=self.target_transform,
+            )
+
+            # Extract targets
+            if hasattr(ds_instance, "targets"):
+                targets = ds_instance.targets
+                if hasattr(targets, "numpy"):
+                    labels = targets.numpy()
+                else:
+                    labels = np.asarray(targets)
+            else:
+                labels = np.array([ds_instance[i][1] for i in range(len(ds_instance))])
+
+            return ds_instance, labels
+
+        if isinstance(dataset, tuple) and len(dataset) == 2:
+            data, targets = dataset
+            if len(data) != len(targets):
+                raise ValueError(
+                    f"Mismatch between features length ({len(data)}) and "
+                    f"targets length ({len(targets)})"
+                )
+            labels = np.asarray(targets)
+            ds_instance = NumpyDataset(
+                data=data,
+                targets=targets,
+                transform=self.transform,
+                target_transform=self.target_transform,
+            )
+            return ds_instance, labels
+
+        # Generic dataset object (e.g. custom PyTorch Dataset)
+        if hasattr(dataset, "__len__") and hasattr(dataset, "__getitem__"):
+            if hasattr(dataset, "targets"):
+                targets = dataset.targets
+                labels = targets.numpy() if hasattr(targets, "numpy") else np.asarray(targets)
+            elif hasattr(dataset, "labels"):
+                labels = np.asarray(dataset.labels)
+            else:
+                labels = np.array([dataset[i][1] for i in range(len(dataset))])
+            return dataset, labels
+
+        raise TypeError(
+            f"dataset must be a string name, (X, y) tuple, or Dataset instance. Got: {type(dataset)}"
+        )
+
+    def _partition_data(self) -> Dict[int, np.ndarray]:
+        """Dispatch partitioning according to configured strategy."""
+        if self.partition == "iid":
+            return iid_partition(
+                labels=self.labels,
+                num_clients=self.num_clients,
+                seed=self.seed,
+            )
+        elif self.partition == "dirichlet":
+            return dirichlet_partition(
+                labels=self.labels,
+                num_clients=self.num_clients,
+                alpha=self.alpha,
+                seed=self.seed,
+            )
+        elif self.partition == "pathological":
+            return pathological_partition(
+                labels=self.labels,
+                num_clients=self.num_clients,
+                classes_per_client=self.classes_per_client,
+                seed=self.seed,
+            )
+        elif self.partition == "quantity":
+            return quantity_skew_partition(
+                labels=self.labels,
+                num_clients=self.num_clients,
+                beta=self.beta,
+                seed=self.seed,
+            )
+        elif self.partition == "hybrid":
+            return hybrid_partition(
+                labels=self.labels,
+                num_clients=self.num_clients,
+                alpha=self.alpha,
+                beta=self.beta,
+                seed=self.seed,
+            )
+        else:
+            raise ValueError(f"Unknown partition strategy: {self.partition}")
+
+    def get_client_indices(self, client_id: int) -> np.ndarray:
+        """Get the array of sample indices allocated to a specific client.
+
+        Parameters
+        ----------
+        client_id : int
+            Index of the client (0 <= client_id < num_clients).
+
+        Returns
+        -------
+        np.ndarray
+            1D array of sample indices.
+        """
+        if client_id not in self.client_dict:
+            raise IndexError(
+                f"Client ID {client_id} out of bounds for num_clients={self.num_clients}"
+            )
+        return self.client_dict[client_id]
+
+    def get_client_dataset(self, client_id: int) -> Any:
+        """Get a Dataset instance containing only the client's assigned samples.
+
+        Parameters
+        ----------
+        client_id : int
+            Index of the client.
+
+        Returns
+        -------
+        Dataset or Subset
+            Client dataset wrapper.
+        """
+        indices = self.get_client_indices(client_id)
+        if _HAS_TORCH and Subset is not None:
+            return Subset(self.base_dataset, indices)
+
+        # Fallback subset wrapper for non-torch environments
+        class _NonTorchSubset:
+            def __init__(self, base, idxs):
+                self.base = base
+                self.indices = idxs
+
+            def __len__(self):
+                return len(self.indices)
+
+            def __getitem__(self, i):
+                return self.base[self.indices[i]]
+
+        return _NonTorchSubset(self.base_dataset, indices)
+
+    def get_client_dataloader(
+        self,
+        client_id: int,
+        batch_size: int = 32,
+        shuffle: bool = True,
+        **kwargs: Any,
+    ) -> Any:
+        """Get a PyTorch DataLoader for the specified client.
+
+        Parameters
+        ----------
+        client_id : int
+            Index of the client.
+        batch_size : int, default=32
+            Mini-batch size for client local training.
+        shuffle : bool, default=True
+            Whether to shuffle the client's data each epoch.
+        **kwargs : Any
+            Additional keyword arguments passed to `torch.utils.data.DataLoader`.
+
+        Returns
+        -------
+        torch.utils.data.DataLoader
+            Configured DataLoader for local client training.
+        """
+        if not _HAS_TORCH or DataLoader is None:
+            raise ImportError(
+                "PyTorch is required to create a DataLoader. "
+                "Install torch (`pip install torch`) or use get_client_dataset() / get_client_indices()."
+            )
+
+        client_ds = self.get_client_dataset(client_id)
+        return DataLoader(client_ds, batch_size=batch_size, shuffle=shuffle, **kwargs)
+
+    @property
+    def client_sizes(self) -> Dict[int, int]:
+        """Dictionary mapping client IDs to assigned sample counts."""
+        return {cid: len(indices) for cid, indices in self.client_dict.items()}
+
+    def __len__(self) -> int:
+        """Total number of samples in the partitioned dataset."""
+        return len(self.labels)
+
+    def __repr__(self) -> str:
+        return (
+            f"FederatedDataset(num_clients={self.num_clients}, "
+            f"partition='{self.partition}', total_samples={len(self)})"
+        )

fl_data_generator/dirichlet.py

@@ -0,0 +1,123 @@
+from typing import Dict, Optional, Sequence, Union
+
+import numpy as np
+
+from ._validation import validate_labels
+
+
+def dirichlet_partition(
+    labels: Union[Sequence, np.ndarray],
+    num_clients: int,
+    alpha: Union[float, Sequence[float]] = 0.5,
+    seed: Optional[int] = None,
+    min_size: int = 1,
+    max_retries: int = 100,
+) -> Dict[int, np.ndarray]:
+    """Partition dataset indices among clients using a Dirichlet distribution over classes.
+
+    Simulates non-IID label skew across clients in Federated Learning. Smaller alpha values
+    result in higher distribution skew (more non-IID), while larger alpha values approach
+    an IID distribution.
+
+    Parameters
+    ----------
+    labels : Sequence or np.ndarray
+        Dataset class labels or targets.
+    num_clients : int
+        Number of clients to partition data among.
+    alpha : float or Sequence[float], default=0.5
+        Concentration parameter for the Dirichlet distribution.
+    seed : int, optional
+        Random seed for reproducibility.
+    min_size : int, default=1
+        Minimum number of samples required per client.
+    max_retries : int, default=100
+        Maximum number of Dirichlet resampling attempts to satisfy min_size.
+
+    Returns
+    -------
+    dict of int to np.ndarray
+        Mapping from client ID to array of assigned sample indices.
+
+    Raises
+    ------
+    ValueError
+        If labels is invalid (empty, not 1D, non-integer, or contains NaN/Inf).
+        If num_clients <= 0 or alpha <= 0.
+        If num_clients exceeds num_samples.
+        If alpha is a sequence and its length does not match num_clients.
+        If min_size < 0, not an integer, or min_size * num_clients > num_samples.
+    RuntimeError
+        If unable to partition data such that all clients receive at least min_size samples
+        within max_retries attempts.
+    """
+    labels_arr = validate_labels(labels)
+    num_samples = len(labels_arr)
+
+    if num_clients <= 0:
+        raise ValueError(f"num_clients must be positive, got {num_clients}")
+    if num_clients > num_samples:
+        raise ValueError(
+            f"num_clients ({num_clients}) cannot exceed number of samples ({num_samples})"
+        )
+
+    if not isinstance(min_size, int) or isinstance(min_size, bool):
+        raise ValueError(f"min_size must be an integer, got {type(min_size).__name__}")  # noqa: TRY004
+    if min_size < 0:
+        raise ValueError(f"min_size must be non-negative, got {min_size}")
+    if min_size * num_clients > num_samples:
+        raise ValueError(
+            f"min_size * num_clients ({min_size * num_clients}) cannot exceed number of samples ({num_samples})"
+        )
+    if not isinstance(max_retries, int) or isinstance(max_retries, bool) or max_retries <= 0:
+        raise ValueError(f"max_retries must be a positive integer, got {max_retries}")
+
+    if isinstance(alpha, (int, float)):
+        if alpha <= 0:
+            raise ValueError(f"alpha must be positive, got {alpha}")
+        alpha_vec = np.repeat(float(alpha), num_clients)
+    else:
+        alpha_vec = np.asarray(alpha, dtype=float)
+        if alpha_vec.shape != (num_clients,):
+            raise ValueError(
+                f"alpha length must match num_clients ({num_clients}), got {len(alpha_vec)}"
+            )
+        if (alpha_vec <= 0).any():
+            raise ValueError("All alpha values must be positive")
+
+    rng = np.random.default_rng(seed)
+    unique_classes = np.unique(labels_arr)
+
+    for _ in range(max_retries):
+        client_indices: Dict[int, list] = {cid: [] for cid in range(num_clients)}
+
+        for cls in unique_classes:
+            cls_idx = np.where(labels_arr == cls)[0]
+            rng.shuffle(cls_idx)
+
+            proportions = rng.dirichlet(alpha_vec)
+            split_points = (np.cumsum(proportions)[:-1] * len(cls_idx)).astype(int)
+            splits = np.split(cls_idx, split_points)
+
+            for cid, split in enumerate(splits):
+                if len(split) > 0:
+                    client_indices[cid].append(split)
+
+        if all(sum(len(s) for s in client_indices[cid]) >= min_size for cid in range(num_clients)):
+            break
+    else:
+        raise RuntimeError(
+            f"Could not partition data such that all clients receive at least min_size={min_size} samples "
+            f"after {max_retries} retries. Try using a larger alpha or a smaller min_size."
+        )
+
+    result = {}
+    for cid in range(num_clients):
+        if client_indices[cid]:
+            merged = np.concatenate(client_indices[cid])
+            rng.shuffle(merged)
+            result[cid] = merged
+        else:
+            result[cid] = np.array([], dtype=int)
+
+    return result

fl_data_generator/hybrid.py

@@ -0,0 +1,138 @@
+from typing import Dict, Optional, Sequence, Union
+
+import numpy as np
+
+from ._validation import validate_labels
+
+
+def hybrid_partition(
+    labels: Union[Sequence, np.ndarray],
+    num_clients: int,
+    alpha: float = 0.5,
+    beta: float = 0.5,
+    seed: Optional[int] = None,
+) -> Dict[int, np.ndarray]:
+    """Partition dataset indices combining label skew and quantity skew (experimental).
+
+    .. warning::
+        This method is experimental and not a standard published partitioning method.
+        It uses sequential allocation: client sample capacities are first determined
+        via Dirichlet distribution with parameter beta (quantity skew). Samples are then
+        allocated sequentially to clients in a randomly permuted client order based on class
+        preference distributions drawn from a Dirichlet distribution with parameter alpha
+        (label skew). Because samples are drawn without replacement from a shared finite pool,
+        there is a client-order effect: earlier clients in the sequence have access to the
+        full class distribution, while later clients may receive residual classes that deviate
+        from their drawn preferences.
+
+    Parameters
+    ----------
+    labels : Sequence or np.ndarray
+        Dataset class labels or targets.
+    num_clients : int
+        Number of clients to partition data among.
+    alpha : float, default=0.5
+        Concentration parameter for the Dirichlet distribution governing label skew.
+        Must be a positive scalar. Smaller values induce stronger class preference heterogeneity.
+    beta : float, default=0.5
+        Concentration parameter for the Dirichlet distribution governing quantity skew.
+        Must be a positive scalar. Smaller values induce greater disparity in sample volume across clients.
+    seed : int, optional
+        Random seed for reproducibility.
+
+    Returns
+    -------
+    dict of int to np.ndarray
+        Mapping from client ID to array of assigned sample indices.
+
+    Raises
+    ------
+    ValueError
+        If labels is invalid (empty, not 1D, non-integer, or contains NaN/Inf).
+        If num_clients <= 0, alpha <= 0, or beta <= 0.
+        If num_clients exceeds num_samples.
+        If alpha or beta is a sequence rather than a scalar.
+    """
+    labels_arr = validate_labels(labels)
+    num_samples = len(labels_arr)
+
+    if num_clients <= 0:
+        raise ValueError(f"num_clients must be positive, got {num_clients}")
+    if num_clients > num_samples:
+        raise ValueError(
+            f"num_clients ({num_clients}) cannot exceed number of samples ({num_samples})"
+        )
+
+    if isinstance(alpha, (Sequence, np.ndarray)) or np.ndim(alpha) > 0 or not isinstance(alpha, (int, float, np.number)) or isinstance(alpha, bool):
+        raise ValueError(f"alpha must be a scalar positive number, got {alpha}")
+    if alpha <= 0:
+        raise ValueError(f"alpha must be positive, got {alpha}")
+
+    if isinstance(beta, (Sequence, np.ndarray)) or np.ndim(beta) > 0 or not isinstance(beta, (int, float, np.number)) or isinstance(beta, bool):
+        raise ValueError(f"beta must be a scalar positive number, got {beta}")
+    if beta <= 0:
+        raise ValueError(f"beta must be positive, got {beta}")
+
+    rng = np.random.default_rng(seed)
+    unique_classes = np.unique(labels_arr)
+    num_classes = len(unique_classes)
+    cls_to_idx = {c: i for i, c in enumerate(unique_classes)}
+
+    # 1. Determine client sample sizes via quantity skew (Dirichlet with parameter beta)
+    q_props = rng.dirichlet(np.repeat(beta, num_clients))
+    remaining = num_samples - num_clients
+    splits = (np.cumsum(q_props)[:-1] * remaining).astype(int)
+    client_sizes = np.diff(np.concatenate(([0], splits, [remaining]))) + 1
+
+    # Organize available sample indices by class
+    class_indices: Dict[object, list] = {}
+    for cls in unique_classes:
+        idx = np.where(labels_arr == cls)[0]
+        rng.shuffle(idx)
+        class_indices[cls] = list(idx)
+
+    # 2. Allocate samples to each client proportionally based on label skew (Dirichlet alpha)
+    client_partitions: Dict[int, list] = {cid: [] for cid in range(num_clients)}
+    client_order = rng.permutation(num_clients)
+
+    for cid in client_order:
+        needed = client_sizes[cid]
+        p = rng.dirichlet(np.repeat(alpha, num_classes))
+
+        while needed > 0:
+            avail_classes = [c for c in unique_classes if len(class_indices[c]) > 0]
+            if not avail_classes:
+                break
+
+            avail_p = np.array([p[cls_to_idx[c]] for c in avail_classes])
+            p_sum = avail_p.sum()
+            if p_sum == 0:
+                avail_p = np.ones(len(avail_classes))
+                p_sum = len(avail_classes)
+            avail_p = avail_p / p_sum
+
+            counts = (avail_p * needed).astype(int)
+            if counts.sum() == 0:
+                counts[np.argmax(avail_p)] = 1
+
+            allocated_this_round = 0
+            for c, cnt in zip(avail_classes, counts):
+                take = min(cnt, len(class_indices[c]), needed)
+                if take > 0:
+                    for _ in range(take):
+                        client_partitions[cid].append(class_indices[c].pop())
+                    needed -= take
+                    allocated_this_round += take
+
+            if allocated_this_round == 0:
+                c = avail_classes[0]
+                client_partitions[cid].append(class_indices[c].pop())
+                needed -= 1
+
+    result: Dict[int, np.ndarray] = {}
+    for cid in range(num_clients):
+        arr = np.array(client_partitions[cid], dtype=int)
+        rng.shuffle(arr)
+        result[cid] = arr
+
+    return result

fl_data_generator/iid.py

@@ -0,0 +1,49 @@
+from typing import Dict, Optional, Sequence, Union
+
+import numpy as np
+
+from ._validation import validate_labels
+
+
+def iid_partition(
+    labels: Union[Sequence, np.ndarray],
+    num_clients: int,
+    seed: Optional[int] = None,
+) -> Dict[int, np.ndarray]:
+    """Partition dataset indices in an IID fashion across clients.
+
+    Parameters
+    ----------
+    labels : Sequence or np.ndarray
+        Dataset labels or target sequence.
+    num_clients : int
+        Number of clients to partition data among.
+    seed : int, optional
+        Random seed for reproducibility.
+
+    Returns
+    -------
+    dict of int to np.ndarray
+        Mapping from client ID to array of assigned sample indices.
+
+    Raises
+    ------
+    ValueError
+        If labels is invalid (empty, not 1D, non-integer, or contains NaN/Inf).
+        If num_clients <= 0 or num_clients > num_samples.
+    """
+    labels_arr = validate_labels(labels)
+    num_samples = len(labels_arr)
+
+    if num_clients <= 0:
+        raise ValueError(f"num_clients must be positive, got {num_clients}")
+    if num_clients > num_samples:
+        raise ValueError(
+            f"num_clients ({num_clients}) cannot exceed number of samples ({num_samples})"
+        )
+
+    rng = np.random.default_rng(seed)
+    indices = rng.permutation(num_samples)
+    client_splits = np.array_split(indices, num_clients)
+
+    return {cid: split for cid, split in enumerate(client_splits)}

fl_data_generator/pathological.py

@@ -0,0 +1,137 @@
+from typing import Dict, Optional, Sequence, Union
+
+import numpy as np
+
+from ._validation import validate_labels
+
+
+def pathological_partition(
+    labels: Union[Sequence, np.ndarray],
+    num_clients: int,
+    classes_per_client: int = 2,
+    seed: Optional[int] = None,
+) -> Dict[int, np.ndarray]:
+    """Partition dataset indices among clients with pathological non-IID label skew.
+
+    Assigns k distinct classes per client (NIID-Bench #C=k, Li et al. 2021),
+    NOT the McMahan et al. 2017 sort-and-shard scheme. Each class's samples are
+    split into shards, and clients receive shards corresponding to their assigned
+    classes.
+
+    Parameters
+    ----------
+    labels : Sequence or np.ndarray
+        Dataset class labels or targets.
+    num_clients : int
+        Number of clients to partition data among.
+    classes_per_client : int, default=2
+        Number of distinct classes assigned to each client.
+    seed : int, optional
+        Random seed for reproducibility.
+
+    Returns
+    -------
+    dict of int to np.ndarray
+        Mapping from client ID to array of assigned sample indices.
+
+    Raises
+    ------
+    ValueError
+        If labels is invalid (empty, not 1D, non-integer, or contains NaN/Inf).
+        If num_clients <= 0 or classes_per_client <= 0.
+        If classes_per_client exceeds the number of unique classes.
+        If total client slots is less than the number of unique classes.
+        If total samples is less than total class shards.
+        If any class has fewer samples than the number of shards assigned to it.
+    """
+    labels_arr = validate_labels(labels)
+    num_samples = len(labels_arr)
+
+    if num_clients <= 0:
+        raise ValueError(f"num_clients must be positive, got {num_clients}")
+    if classes_per_client <= 0:
+        raise ValueError(
+            f"classes_per_client must be positive, got {classes_per_client}"
+        )
+
+
+    unique_classes = np.unique(labels_arr)
+    num_classes = len(unique_classes)
+
+    if classes_per_client > num_classes:
+        raise ValueError(
+            f"classes_per_client ({classes_per_client}) cannot exceed number of unique classes ({num_classes})"
+        )
+
+    total_slots = num_clients * classes_per_client
+    if total_slots < num_classes:
+        raise ValueError(
+            f"Total client class slots ({num_clients} * {classes_per_client} = {total_slots}) "
+            f"must be at least the number of unique classes ({num_classes}) to allocate all samples."
+        )
+
+    if num_samples < total_slots:
+        raise ValueError(
+            f"Total samples ({num_samples}) must be at least total class shards ({total_slots})"
+        )
+
+    rng = np.random.default_rng(seed)
+
+    # Distribute class slots across clients
+    counts = np.ones(num_classes, dtype=int)
+    remaining = total_slots - num_classes
+    base = remaining // num_classes
+    rem = remaining % num_classes
+    counts += base
+    counts[:rem] += 1
+    rng.shuffle(counts)
+
+    # Validate that every class has at least as many samples as assigned shards
+    for c_idx, cls_val in enumerate(unique_classes):
+        class_sample_count = int(np.count_nonzero(labels_arr == cls_val))
+        needed_shards = int(counts[c_idx])
+        if class_sample_count < needed_shards:
+            raise ValueError(
+                f"Class '{cls_val}' has {class_sample_count} sample(s), which is fewer than "
+                f"the assigned {needed_shards} shard(s). Cannot partition without producing empty shards."
+            )
+
+
+    client_classes = [set() for _ in range(num_clients)]
+    sorted_class_indices = np.argsort(-counts)
+
+    for c_idx in sorted_class_indices:
+        cls_val = unique_classes[c_idx]
+        needed = counts[c_idx]
+
+        candidates = [
+            cid
+            for cid in range(num_clients)
+            if cls_val not in client_classes[cid]
+            and len(client_classes[cid]) < classes_per_client
+        ]
+        candidates.sort(key=lambda cid: (len(client_classes[cid]), rng.random()))
+
+        for cid in candidates[:needed]:
+            client_classes[cid].add(cls_val)
+
+    # Split each class's samples into the assigned number of shards
+    class_shards: Dict[object, list] = {}
+    for c_idx, cls_val in enumerate(unique_classes):
+        cls_indices = np.where(labels_arr == cls_val)[0]
+        rng.shuffle(cls_indices)
+        num_shards = counts[c_idx]
+        class_shards[cls_val] = list(np.array_split(cls_indices, num_shards))
+
+    # Assign shards to clients
+    result: Dict[int, np.ndarray] = {}
+    for cid in range(num_clients):
+        cid_shards = []
+        for cls_val in client_classes[cid]:
+            cid_shards.append(class_shards[cls_val].pop())
+
+        merged = np.concatenate(cid_shards)
+        rng.shuffle(merged)
+        result[cid] = merged
+
+    return result

fl_data_generator/quantity.py

@@ -0,0 +1,83 @@
+from typing import Dict, Optional, Sequence, Union
+
+import numpy as np
+
+from ._validation import validate_labels
+
+
+def quantity_skew_partition(
+    labels: Union[Sequence, np.ndarray],
+    num_clients: int,
+    beta: Union[float, Sequence[float]] = 0.5,
+    seed: Optional[int] = None,
+) -> Dict[int, np.ndarray]:
+    """Partition dataset indices among clients with quantity skew (varying sample sizes).
+
+    Simulates realistic volume heterogeneity across clients in Federated Learning.
+    The proportion of total samples assigned to each client is drawn from a Dirichlet
+    distribution parameterized by beta. Smaller beta values produce severe volume
+    disparities, while larger beta values approach uniform sample sizes.
+
+    Parameters
+    ----------
+    labels : Sequence or np.ndarray
+        Dataset labels or target sequence.
+    num_clients : int
+        Number of clients to partition data among.
+    beta : float or Sequence[float], default=0.5
+        Concentration parameter for the Dirichlet distribution governing client sample sizes.
+    seed : int, optional
+        Random seed for reproducibility.
+
+    Returns
+    -------
+    dict of int to np.ndarray
+        Mapping from client ID to array of assigned sample indices.
+
+    Raises
+    ------
+    ValueError
+        If labels is invalid (empty, not 1D, non-integer, or contains NaN/Inf).
+        If num_clients <= 0 or beta <= 0.
+        If num_clients exceeds num_samples.
+        If beta is a sequence and its length does not match num_clients.
+    """
+    labels_arr = validate_labels(labels)
+    num_samples = len(labels_arr)
+
+    if num_clients <= 0:
+        raise ValueError(f"num_clients must be positive, got {num_clients}")
+    if num_clients > num_samples:
+
+        raise ValueError(
+            f"num_clients ({num_clients}) cannot exceed number of samples ({num_samples})"
+        )
+
+    if isinstance(beta, (int, float)):
+        if beta <= 0:
+            raise ValueError(f"beta must be positive, got {beta}")
+        beta_vec = np.repeat(float(beta), num_clients)
+    else:
+        beta_vec = np.asarray(beta, dtype=float)
+        if beta_vec.shape != (num_clients,):
+            raise ValueError(
+                f"beta length must match num_clients ({num_clients}), got {len(beta_vec)}"
+            )
+        if (beta_vec <= 0).any():
+            raise ValueError("All beta values must be positive")
+
+    rng = np.random.default_rng(seed)
+    shuffled_indices = rng.permutation(num_samples)
+
+    # Sample client proportions from Dirichlet distribution
+    proportions = rng.dirichlet(beta_vec)
+
+    # Allocate at least 1 sample to each client, distribute remainder according to proportions
+    remaining = num_samples - num_clients
+    split_points = (np.cumsum(proportions)[:-1] * remaining).astype(int)
+    counts = np.diff(np.concatenate(([0], split_points, [remaining]))) + 1
+
+    # Split shuffled indices by cumulative sample counts
+    index_splits = np.split(shuffled_indices, np.cumsum(counts)[:-1])
+
+    return {cid: split for cid, split in enumerate(index_splits)}

fl_data_generator-0.1.0.dist-info/METADATA

@@ -0,0 +1,233 @@
+Metadata-Version: 2.4
+Name: fl-data-generator
+Version: 0.1.0
+Summary: A lightweight, framework-agnostic library for IID and non-IID data partitioning in Federated Learning.
+Author-email: Mostafa Khastkhodaei <dev.khastkhodaei@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/khastkhodaei/fl-data-generator
+Project-URL: Bug Tracker, https://github.com/khastkhodaei/fl-data-generator/issues
+Project-URL: Source Code, https://github.com/khastkhodaei/fl-data-generator
+Keywords: federated-learning,data-partitioning,non-iid,dirichlet,label-skew,quantity-skew,machine-learning
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.20.0
+Provides-Extra: dev
+Requires-Dist: hypothesis>=6.0.0; extra == "dev"
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: ruff~=0.17.0; extra == "dev"
+Provides-Extra: viz
+Requires-Dist: matplotlib>=3.5.0; extra == "viz"
+Dynamic: license-file
+
+# fl-data-generator
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python 3.9+](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/downloads/)
+
+A lightweight, framework-agnostic Python library for **IID** and **Non-IID** data partitioning in **Federated Learning (FL)**.
+
+---
+
+## Overview
+
+In Federated Learning research and benchmarks, simulating realistic data heterogeneity across distributed clients is essential. **fl-data-generator** simplifies partitioning arbitrary datasets into realistic client distributions without tying you to any specific deep learning framework.
+
+Whether you are using PyTorch, TensorFlow, JAX, or federated frameworks like Flower, FedML, or PySyft, `fl-data-generator` provides clean sample indices and dataset wrappers for your clients.
+
+---
+
+## Features
+
+- **IID Partitioning**: Uniform random sample allocation across all clients.
+- **Dirichlet Partitioning**: Continuous label distribution skew ($\text{Dir}(\alpha)$) over class proportions, with client minimum size constraints (`min_size`).
+- **Pathological Non-IID Partitioning**: Allocation of a fixed number of classes ($k$ classes per client, following the NIID-Bench benchmark scheme).
+- **Quantity Skew Partitioning**: Volume heterogeneity where client dataset sizes vary according to a Dirichlet distribution ($\text{Dir}(\beta)$).
+- **Hybrid Partitioning (Experimental)**: Sequential joint label skew and quantity skew allocation combining Dirichlet $\alpha$ and $\beta$.
+- **FederatedDataset Wrapper**: High-level wrapper supporting built-in computer vision datasets (`mnist`, `cifar10`, `cifar100`, `fashion_mnist`) as well as custom `(X, y)` tuples and PyTorch `Dataset` instances.
+
+---
+
+## Installation
+
+### From Source
+
+```bash
+git clone https://github.com/khastkhodaei/fl-data-generator.git
+cd fl-data-generator
+pip install -e .
+```
+
+### With Optional Extras
+
+```bash
+# Development dependencies (pytest, hypothesis, ruff, etc.)
+pip install -e ".[dev]"
+
+# Visualization support (matplotlib)
+pip install -e ".[viz]"
+```
+
+---
+
+## Runnable Examples
+
+### 1. IID Partitioning
+
+Uniformly partitions sample indices across clients.
+
+```python
+import numpy as np
+from fl_data_generator import iid_partition
+
+labels = np.array([0, 1] * 50)  # 100 samples
+client_dict = iid_partition(labels, num_clients=4, seed=42)
+
+print("Client sample counts:", [len(indices) for indices in client_dict.values()])
+# Real Output: Client sample counts: [25, 25, 25, 25]
+```
+
+### 2. Dirichlet Label Skew Partitioning
+
+Simulates non-IID label skew parameterized by concentration parameter `alpha`. Smaller $\alpha$ generates severe distribution skew, while larger $\alpha$ approaches uniform class distributions.
+
+```python
+import numpy as np
+from fl_data_generator import dirichlet_partition
+
+labels = np.repeat(np.arange(4), 50)  # 200 samples across 4 classes
+client_dict = dirichlet_partition(labels, num_clients=3, alpha=0.5, seed=42)
+
+print("Client sample counts:", [len(indices) for indices in client_dict.values()])
+# Real Output: Client sample counts: [114, 42, 44]
+```
+
+### 3. Pathological Non-IID Partitioning ($k$ Classes per Client)
+
+Partitions data such that each client receives samples from exactly $k$ distinct classes (NIID-Bench #C=k scheme).
+
+```python
+import numpy as np
+from fl_data_generator import pathological_partition
+
+labels = np.repeat(np.arange(4), 50)  # 200 samples across 4 classes
+client_dict = pathological_partition(labels, num_clients=4, classes_per_client=2, seed=42)
+
+client_0_labels = labels[client_dict[0]]
+print("Client 0 distinct classes:", np.unique(client_0_labels).tolist())
+# Real Output: Client 0 distinct classes: [1, 2]
+```
+
+### 4. Quantity Skew Partitioning (Volume Heterogeneity)
+
+Allocates varying numbers of samples to clients according to a Dirichlet distribution parameterized by concentration parameter `beta`.
+
+```python
+import numpy as np
+from fl_data_generator import quantity_skew_partition
+
+labels = np.arange(200)  # 200 samples
+client_dict = quantity_skew_partition(labels, num_clients=4, beta=0.5, seed=42)
+
+print("Client sample counts:", [len(indices) for indices in client_dict.values()])
+# Real Output: Client sample counts: [52, 72, 16, 60]
+```
+
+### 5. Hybrid Partitioning (Experimental)
+
+Combines quantity skew ($\beta$) and label skew ($\alpha$) via sequential allocation.
+
+```python
+import numpy as np
+from fl_data_generator import hybrid_partition
+
+labels = np.repeat(np.arange(4), 50)  # 200 samples across 4 classes
+client_dict = hybrid_partition(labels, num_clients=4, alpha=0.5, beta=0.5, seed=42)
+
+print("Client sample counts:", [len(indices) for indices in client_dict.values()])
+# Real Output: Client sample counts: [56, 89, 2, 53]
+```
+
+### 6. FederatedDataset Interface
+
+High-level interface for creating client-specific datasets and PyTorch DataLoaders.
+
+```python
+import numpy as np
+from fl_data_generator import FederatedDataset
+
+X = np.random.default_rng(42).standard_normal((100, 5))
+y = np.array([0, 1] * 50)
+
+fed_data = FederatedDataset((X, y), num_clients=4, partition="iid", seed=42)
+client_0_ds = fed_data.get_client_dataset(0)
+
+print(f"Client 0 sample count: {len(client_0_ds)}")
+features, label = client_0_ds[0]
+print(f"Feature shape: {features.shape}, Label: {label}")
+# Real Output:
+# Client 0 sample count: 25
+# Feature shape: (5,), Label: 1
+```
+
+---
+
+## Roadmap
+
+The following experimental features and partition strategies are planned for future releases:
+- **Feature Skew (Covariate Shift)**: Partitioning based on continuous feature space clusters or synthetic domain perturbations.
+- **Power-Law Quantity Skew**: Heavy-tailed sample volume distribution across clients.
+- **Asymmetric Class Topologies**: Custom directed class sharing graphs.
+
+---
+
+## Project Structure
+
+```text
+fl-data-generator/
+├── .github/
+│   └── workflows/
+│       └── ci.yml               # GitHub Actions CI matrix workflow
+├── src/
+│   └── fl_data_generator/       # Core library package
+│       ├── __init__.py          # Public API exports
+│       ├── _validation.py       # Input validation utilities
+│       ├── dataset.py           # FederatedDataset interface & torchvision loaders
+│       ├── dirichlet.py         # Dirichlet label skew partitioner
+│       ├── hybrid.py            # Hybrid label & quantity skew partitioner
+│       ├── iid.py               # Uniform IID partitioner
+│       ├── pathological.py      # Pathological k-class partitioner
+│       └── quantity.py          # Quantity skew partitioner
+├── tests/                       # Unit, integration, and property test suite
+│   ├── test_dataset.py
+│   ├── test_dirichlet.py
+│   ├── test_hybrid.py
+│   ├── test_iid.py
+│   ├── test_pathological.py
+│   ├── test_properties.py
+│   ├── test_quantity.py
+│   ├── test_readme.py
+│   └── test_validation.py
+├── pyproject.toml               # Package build configuration & Ruff settings
+├── LICENSE                      # MIT License
+└── README.md                    # Project documentation
+```
+
+---
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

fl_data_generator-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+fl_data_generator/__init__.py,sha256=m0oFZhpYf6MWug0dqfnTv3EmMCrtHm2ge3t-LxjVr3g,466
+fl_data_generator/_validation.py,sha256=5hkJELUbBskEjHOkz1PN1zodntp3M4eYaGmo7mDavXw,1823
+fl_data_generator/dataset.py,sha256=4jUobhkOoewO_6LW491yH3o1me2C28mevQtjsInBkpg,15910
+fl_data_generator/dirichlet.py,sha256=2dHX2FGQQgtuK03GHOAznPflIwp4Uwg_QubVeQKAQeA,4803
+fl_data_generator/hybrid.py,sha256=Ol3v85V8mOWmL0WbIvk-RCnov2uxTfyns0SJrn_vfGE,5800
+fl_data_generator/iid.py,sha256=f2GFubs8hq_w_CU8it1qI9XXHq4C_af0nReZBx2Jqrk,1475
+fl_data_generator/pathological.py,sha256=rdh5-6SUIKl3Ij_P2c8Ud7aPpvk96onE-QSVPkuCApw,4949
+fl_data_generator/quantity.py,sha256=_VEo9-GnPUHdvBLxB3GwpvO9aE_-f46sMteyBrFV0UY,3149
+fl_data_generator-0.1.0.dist-info/licenses/LICENSE,sha256=hkYdGffXw9mXezr-rwHQYwTTqM1r5rvJfa5esQyyLkA,1077
+fl_data_generator-0.1.0.dist-info/METADATA,sha256=lyy8zTz-KEpJpOMmHVDXRIjyiPm0KcWSLlHyR_24pMw,9225
+fl_data_generator-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+fl_data_generator-0.1.0.dist-info/top_level.txt,sha256=sHZKMdxbAhWu3-VClvEPI1AaLhPsD9SPjt14IlOGByc,18
+fl_data_generator-0.1.0.dist-info/RECORD,,

fl_data_generator-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

fl_data_generator-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mostafa Khastkhodaei
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

fl_data_generator-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+fl_data_generator