rddac 1.0.0__py3-none-any.whl

rddac/__init__.py

@@ -0,0 +1,66 @@
+"""RDDAC — Real Deep Drawing and Cutting Dataset.
+
+Python interface for the RDDAC dataset (experimental measurements of sheet
+metal forming; the physical counterpart to the DDACS simulations). Built on a
+Croissant 1.1 manifest: `rddac.load()` returns an `mlcroissant.Dataset` whose
+`records(view)` streams the data; `add_view`, `open_h5`, `inspect_h5` are
+convenience helpers around the same manifest.
+
+The public surface mirrors the `ddacs` package, so DDACS code ports by
+swapping the import.
+
+Examples:
+    >>> import rddac
+    >>> ds = rddac.load(data_dir="./data")
+    >>> for record in rddac.streaming.iter_view("force-curve", data_dir="./data"):
+    ...     ...
+
+    >>> with rddac.open_h5(42, data_dir="./data") as f:
+    ...     rddac.inspect_h5(f)
+
+Note: prefer ``rddac.streaming.iter_view`` (or ``RDDACDataset``) over
+``ds.records(view)`` for the h5-backed views — mlcroissant's own records()
+walks the full multi-GB zips per view and is impractically slow there.
+"""
+
+__version__ = "1.0.0"
+
+from . import streaming
+from .croissant import add_view, load
+from .h5_tools import inspect_h5, open_h5
+from .spec import RDDAC_SPEC, DatasetSpec
+from .visualization import (
+    plot_force,
+    plot_point_cloud,
+    plot_scan,
+    plot_traverse,
+    scan_to_pointcloud,
+)
+
+try:
+    from .pytorch import RDDACDataset
+except ImportError:
+    pass
+
+__all__ = [
+    "__version__",
+    # Dataset identity (consumed by the ddacs machinery via spec=)
+    "RDDAC_SPEC",
+    "DatasetSpec",
+    # Croissant entry point + helpers
+    "load",
+    "add_view",
+    # HDF5 helpers
+    "open_h5",
+    "inspect_h5",
+    # Streaming pipeline (offline iteration + numpy export)
+    "streaming",
+    # PyTorch (optional — only available if torch is installed)
+    "RDDACDataset",
+    # Visualization
+    "plot_scan",
+    "plot_point_cloud",
+    "plot_force",
+    "plot_traverse",
+    "scan_to_pointcloud",
+]

rddac/cli.py

@@ -0,0 +1,166 @@
+"""RDDAC dataset CLI — a thin front-end over the ``ddacs`` CLI machinery.
+
+Provides commands to view dataset information and download files from the RDDAC
+(Real Deep Drawing and Cutting) dataset hosted on DaRUS. Because RDDAC is the
+experimental counterpart to DDACS, the full download also fetches the matching
+DDACS simulations (skip with --no-sim).
+
+The info/download implementation is `ddacs.cli`'s, called with
+``spec=RDDAC_SPEC`` (requires ddacs >= 3.2.1). Only the parser (prog,
+--no-sim) and the simulation leg live here.
+
+Usage:
+    rddac info                         # Show dataset info and versions
+    rddac download                     # Real measurements + DDACS simulations
+    rddac download --no-sim            # Real measurements only (skip simulations)
+    rddac download --small             # Small sample bundle (quick start)
+    rddac download --files a.zip       # Download specific files
+    rddac download --extract           # Also extract zips next to the zip
+    rddac download --extract --remove-zip
+    rddac download --quiet             # No output/progress; implies --yes
+
+Zip files are kept by default so they remain readable in place via mlcroissant
+(the Croissant manifest references zip members directly).
+"""
+
+from __future__ import annotations
+
+import argparse
+import importlib.util
+import os
+import subprocess
+import sys
+
+from ddacs import cli as _ddacs_cli
+from ddacs.cli import _dataset_title  # noqa: F401  — identical helper, re-exported for tests
+from rich.panel import Panel
+
+from . import __version__
+from .spec import (
+    DDACS_DATASET_DOI,
+    DDACS_SIM_FILE,
+    RDDAC_SPEC,
+    SIM_SUBDIR,
+)
+
+DEFAULT_VERSION = RDDAC_SPEC.default_version
+DEFAULT_DATA_DIR = RDDAC_SPEC.default_data_dir
+SMALL_TEST_FILES = list(RDDAC_SPEC.small_test_files)
+
+console = _ddacs_cli.console  # shared console: ddacs's --quiet handling applies
+
+
+# ── small helpers kept for tests / tooling (dataset-agnostic) ─────────────────
+def _file_info(file_meta: dict) -> tuple[str, int]:
+    """Original filename + size from a DaRUS file metadata entry."""
+    df = file_meta["dataFile"]
+    if "originalFileName" in df:
+        return df["originalFileName"], df.get("originalFileSize", df["filesize"])
+    return df["filename"], df["filesize"]
+
+
+def _matches(file_meta: dict, names: list[str]) -> bool:
+    return _file_info(file_meta)[0] in names or file_meta["dataFile"]["filename"] in names
+
+
+# ── commands ──────────────────────────────────────────────────────────────────
+def cmd_info(args: argparse.Namespace) -> None:
+    """Display dataset information and available versions (via ddacs.cli)."""
+    _ddacs_cli.cmd_info(args, spec=RDDAC_SPEC)
+
+
+def cmd_download(args: argparse.Namespace) -> None:
+    """Download RDDAC measurements (and, by default, the DDACS simulations)."""
+    _ddacs_cli.cmd_download(args, spec=RDDAC_SPEC)
+
+    # The DDACS simulations come along only on a full download (not --small /
+    # --files), unless explicitly skipped.
+    if not args.small and not args.files and not args.no_sim:
+        _download_simulations(args)
+
+
+def _download_simulations(args: argparse.Namespace) -> int:
+    """Fetch the matching DDACS simulations by delegating to the `ddacs` CLI.
+
+    The download machinery is not duplicated here: if the `ddacs` package is
+    installed, its own CLI downloads `rddac.zip` into ``<out>/simulation``;
+    otherwise the user gets the exact command to run after installing it.
+
+    Returns the number of files fetched (0 when skipped or delegated-and-failed).
+    """
+    sim_dir = os.path.join(args.out, SIM_SUBDIR)
+    console.print()
+    console.print(Panel(
+        f"[bold]Source:[/bold] DDACS {DDACS_DATASET_DOI}\n[bold]File:[/bold] {DDACS_SIM_FILE}\n"
+        f"[bold]Destination:[/bold] {os.path.abspath(sim_dir)}\n"
+        "[dim]The matching FEM simulations. Skip with --no-sim.[/dim]",
+        title="DDACS simulation reference data", border_style="cyan"))
+
+    if importlib.util.find_spec("ddacs") is None:
+        console.print(
+            "[yellow]The `ddacs` package is not installed — skipping the simulations.[/yellow]\n"
+            "To fetch them later:\n"
+            "  [bold]pip install ddacs[/bold]\n"
+            f"  [bold]ddacs download --files {DDACS_SIM_FILE} metadata.json process_parameters.csv --out {sim_dir} -y[/bold]"
+        )
+        return 0
+
+    # Also fetch DDACS's manifest + parameter table so <out>/simulation is a
+    # self-contained DDACS data dir: ddacs.load(data_dir="<out>/simulation")
+    # resolves the DDACS manifest locally and cannot pick up RDDAC's
+    # metadata.json from the parent directory.
+    cmd = [sys.executable, "-m", "ddacs.cli", "download",
+           "--files", DDACS_SIM_FILE, "metadata.json", "process_parameters.csv",
+           "--out", sim_dir]
+    if args.yes:
+        cmd.append("-y")
+    if getattr(args, "quiet", False):
+        cmd.append("--quiet")
+    if args.extract:
+        cmd.append("--extract")
+    if args.remove_zip:
+        cmd.append("--remove-zip")
+    console.print(f"[dim]delegating to: {' '.join(cmd[2:])}[/dim]")
+    result = subprocess.run(cmd)
+    if result.returncode != 0:
+        console.print("[red]ddacs download failed.[/red]")
+        return 0
+    return 1
+
+
+def main() -> None:
+    """CLI entry point for RDDAC dataset commands."""
+    parser = argparse.ArgumentParser(
+        prog="rddac", description="RDDAC Dataset CLI - Download experimental data from DaRUS")
+    parser.add_argument("-V", "--version", action="version", version=f"%(prog)s {__version__}")
+    parser.add_argument("--token", help="DaRUS API token (for draft access)")
+    sub = parser.add_subparsers(dest="command", help="Command")
+
+    sub.add_parser("info", help="Show dataset info and versions")
+
+    dl = sub.add_parser("download", help="Download dataset files")
+    dl.add_argument("version", nargs="?", default=DEFAULT_VERSION,
+                    help=f"Dataset version (default: {DEFAULT_VERSION})")
+    dl.add_argument("--files", nargs="+", help="Specific filenames to download")
+    dl.add_argument("--small", action="store_true", help="Download the small sample bundle")
+    dl.add_argument("--no-sim", action="store_true",
+                    help="Download only the real measurements (skip the DDACS simulations)")
+    dl.add_argument("--out", default=DEFAULT_DATA_DIR,
+                    help=f"Output directory (default: {DEFAULT_DATA_DIR})")
+    dl.add_argument("-y", "--yes", action="store_true", help="Skip confirmation prompt")
+    dl.add_argument("-q", "--quiet", action="store_true",
+                    help="No output or progress bars; implies --yes")
+    dl.add_argument("--extract", action="store_true", help="Extract downloaded zips into their directory")
+    dl.add_argument("--remove-zip", action="store_true", help="Delete zips after extraction (with --extract)")
+
+    args = parser.parse_args()
+    if args.command == "info":
+        cmd_info(args)
+    elif args.command == "download":
+        cmd_download(args)
+    else:
+        parser.print_help()
+
+
+if __name__ == "__main__":
+    main()

rddac/croissant.py

@@ -0,0 +1,81 @@
+"""Croissant manifest access for RDDAC — thin wrappers over :mod:`ddacs.croissant`.
+
+The machinery lives in the ``ddacs`` package (shared with the DDACS simulation
+dataset); everything here just injects :data:`rddac.spec.RDDAC_SPEC` so the
+manifest resolution targets the RDDAC dataset. The manifest conventions
+(``field-map`` RecordSet, ``process-parameters`` join on ``index``) are
+identical between the datasets, so ``add_view`` & friends pass through as-is.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+import mlcroissant as mlc
+from ddacs import croissant as _ddacs_croissant
+from ddacs.croissant import (  # noqa: F401  — shared, dataset-agnostic API
+    FieldSpec,
+    TimestepSpec,
+    add_view,
+    dataset_name,
+    field_map,
+    process_parameters_descriptions,
+)
+from ddacs.croissant import (  # noqa: F401  — internals used by tests/tools
+    _build_mapping,
+    _load_jsonld_dict,
+    _lookup_data_type,
+    _normalize_field_spec,
+    _record_set,
+    _resolve_field_id,
+    _slicing_to_jsonpath,
+)
+
+from .spec import RDDAC_SPEC
+
+DEFAULT_DATA_DIR = RDDAC_SPEC.default_data_dir
+
+
+def metadata_url() -> str:
+    """Return the DaRUS download URL for the published RDDAC ``metadata.json``.
+
+    Resolved via the DaRUS API (numeric file id — DaRUS has no per-file
+    persistent ids) and cached for the process lifetime.
+    """
+    return _ddacs_croissant.metadata_url(RDDAC_SPEC)
+
+
+def __getattr__(name: str) -> Any:
+    # Lazy module attribute (PEP 562): METADATA_URL mirrors the ddacs API.
+    if name == "METADATA_URL":
+        return metadata_url()
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+def resolve_source(source: str | Path | None = None, data_dir: str | Path | None = None) -> str:
+    """Return the source string (path or URL) that :func:`load` would use.
+
+    Resolution order:
+        1. ``source`` if given (local path or HTTP(S) URL).
+        2. ``<data_dir>/metadata.json`` if it exists locally.
+        3. The DaRUS download URL from :func:`metadata_url`.
+    """
+    return _ddacs_croissant.resolve_source(source, data_dir, spec=RDDAC_SPEC)
+
+
+def load(
+    source: str | Path | None = None,
+    data_dir: str | Path | None = DEFAULT_DATA_DIR,
+) -> mlc.Dataset:
+    """Return an :class:`mlcroissant.Dataset` for the RDDAC manifest.
+
+    Local-first, URL-fallback resolution — see :func:`resolve_source`. When
+    ``data_dir`` points at a directory that contains files referenced by the
+    manifest (e.g. zips written by ``rddac download``), `mlcroissant` is told
+    to use those local copies instead of refetching from DaRUS.
+
+    Pass ``data_dir=None`` to opt out of local-file discovery and force
+    `mlcroissant` to download via its own cache.
+    """
+    return _ddacs_croissant.load(source, data_dir, spec=RDDAC_SPEC)

rddac/h5_tools.py

@@ -0,0 +1,50 @@
+"""HDF5 access helpers for RDDAC — thin wrappers over :mod:`ddacs.h5_tools`.
+
+`open_h5` resolves the RDDAC manifest, locates the zip member matching the
+requested experiment (zero-padded: ``42`` -> ``0042.h5``) and returns an
+`h5py.File`. `inspect_h5` pretty-prints any `h5py.File` or path.
+
+Both are re-exported as `rddac.open_h5` and `rddac.inspect_h5`.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import h5py
+from ddacs import h5_tools as _ddacs_h5_tools
+from ddacs.h5_tools import inspect_h5  # noqa: F401  — dataset-agnostic
+
+from .spec import RDDAC_SPEC
+
+DEFAULT_DATA_DIR = RDDAC_SPEC.default_data_dir
+
+
+def open_h5(
+    experiment_id: int,
+    source: str | Path | None = None,
+    data_dir: str | Path | None = DEFAULT_DATA_DIR,
+    dataset=None,
+) -> h5py.File:
+    """Return an `h5py.File` for the requested RDDAC experiment.
+
+    Looks the manifest up, walks the locally mapped zips and reads the h5
+    member matching the zero-padded ``<experiment_id>.h5`` (e.g. ``0042.h5``)
+    into a `BytesIO`. The returned object is read-only, supports the `with`
+    idiom and can be indexed like any other `h5py.File`.
+
+    Args:
+        experiment_id: The experiment index (matches the h5 filename inside
+            the zip; ``42`` -> ``0042.h5``).
+        source: Override the Croissant manifest URL / path.
+        data_dir: Directory searched for already-downloaded zips. Pass `None`
+            to skip the local lookup entirely.
+        dataset: A pre-loaded `mlcroissant.Dataset` (e.g. from `rddac.load`).
+            When given, `source` and `data_dir` are ignored.
+
+    Raises:
+        FileNotFoundError: No locally mapped zip contained the requested h5.
+    """
+    return _ddacs_h5_tools.open_h5(
+        experiment_id, source=source, data_dir=data_dir, dataset=dataset, spec=RDDAC_SPEC
+    )

rddac/pytorch.py

@@ -0,0 +1,78 @@
+"""PyTorch IterableDataset adapter for RDDAC — a thin subclass of :class:`ddacs.pytorch.DDACSDataset`.
+
+All machinery (view/field resolution, zip streaming, DataLoader-worker and DDP
+sharding, seeded shuffle, `MissingDataWarning`) is inherited; the subclass only
+injects :data:`rddac.spec.RDDAC_SPEC` so member names are zero-padded and the
+manifest resolves to the RDDAC dataset.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from pathlib import Path
+
+import pandas as pd
+
+try:
+    from ddacs.pytorch import DDACSDataset
+except ImportError as exc:
+    raise ImportError(
+        "PyTorch is required for RDDACDataset. Install with `pip install rddac[torch]` "
+        "or install a flavour from https://pytorch.org/get-started/locally/."
+    ) from exc
+
+from .spec import RDDAC_SPEC
+
+DEFAULT_DATA_DIR = RDDAC_SPEC.default_data_dir
+
+
+class RDDACDataset(DDACSDataset):
+    """Streaming PyTorch dataset for a single RDDAC Croissant view.
+
+    Yields a `dict[str, numpy.ndarray]` per experiment. Field selection is
+    derived from the Croissant view + field-map; sharding across DataLoader
+    workers and DDP ranks is decided inside `__iter__`, so the same instance
+    works under `num_workers=0`, `num_workers=N` and DDP.
+
+    Views must source `field-map` (HDF5) fields only; for views that include
+    `process-parameters` metadata columns use `rddac.streaming.iter_view`, or
+    build the view with `with_metadata=False`.
+
+    Args:
+        view: Name of the RecordSet to stream (e.g. "force-curve").
+        source: Override the manifest URL / path.
+        data_dir: Local data directory (default "./data"). Pass `None` to skip
+            local-file discovery.
+        dataset: A pre-loaded `mlcroissant.Dataset` (e.g. one mutated by
+            `rddac.add_view`) — the way to stream a custom view.
+        sim_ids: Explicit allowlist of experiment ids (name kept for drop-in
+            DDACS compatibility). Requested ids that cannot be served warn via
+            `rddac.streaming.MissingDataWarning`.
+        where: Predicate applied to each `process_parameters.csv` row before
+            any zip is opened.
+        shuffle: Per-shard seeded shuffle; call `set_epoch` between epochs.
+        seed: Base seed for the per-shard shuffle.
+    """
+
+    def __init__(
+        self,
+        view: str,
+        source: str | Path | None = None,
+        data_dir: str | Path | None = DEFAULT_DATA_DIR,
+        dataset=None,
+        sim_ids: list[int] | None = None,
+        where: Callable[[pd.Series], bool] | None = None,
+        shuffle: bool = False,
+        seed: int = 0,
+    ):
+        super().__init__(
+            view,
+            source=source,
+            data_dir=data_dir,
+            dataset=dataset,
+            sim_ids=sim_ids,
+            where=where,
+            shuffle=shuffle,
+            seed=seed,
+            spec=RDDAC_SPEC,
+        )

rddac/spec.py

@@ -0,0 +1,47 @@
+"""RDDAC dataset specification — single source of truth for the dataset identity.
+
+The identity lives in :data:`RDDAC_SPEC` (a :class:`ddacs.spec.DatasetSpec`);
+the machinery in the ``ddacs`` package consumes it via the ``spec=`` keyword —
+see the thin wrappers in :mod:`rddac.croissant`, :mod:`rddac.h5_tools`,
+:mod:`rddac.streaming` and :mod:`rddac.pytorch`. Consuming modules derive any
+module-level constants they need directly from the spec.
+"""
+
+from ddacs.spec import DatasetSpec
+
+__all__ = ["DatasetSpec", "RDDAC_SPEC"]
+
+# ── RDDAC dataset identity ────────────────────────────────────────────────────
+RDDAC_SPEC = DatasetSpec(
+    name="RDDAC",
+    prog="rddac",
+    dataset_doi="doi:10.18419/DARUS-5589",
+    default_version="1.0",
+    # Experiment ids are zero-padded in the HDF5 member names: 42 -> "0042.h5".
+    id_format="{:04d}",
+    small_test_files=(
+        "process_parameters.csv",
+        "metadata.json",
+        "sample.zip",
+    ),
+)
+
+# ── Hyperlinks (kept here so a URL change touches one file) ───────────────────
+DATASET_URL = (
+    f"{RDDAC_SPEC.darus_base_url}/dataset.xhtml?persistentId={RDDAC_SPEC.dataset_doi}"
+)
+DOI_URL = f"https://doi.org/{RDDAC_SPEC.dataset_doi.replace('doi:', '')}"
+GITHUB_URL = "https://github.com/BaumSebastian/RDDAC"
+DOCS_URL = "https://rddac.readthedocs.io"
+
+# ── DDACS simulation reference data (RDDAC-specific, not spec material) ───────
+# RDDAC is the experimental counterpart to DDACS; `rddac download` fetches the
+# matching FEM simulations alongside the measurements (skip with --no-sim) by
+# delegating to the installed `ddacs` CLI. They are the RDDAC sub-study subset
+# published in the DDACS dataset as a single zip.
+DDACS_DATASET_DOI = "doi:10.18419/DARUS-4801"
+DDACS_DATASET_URL = (
+    f"{RDDAC_SPEC.darus_base_url}/dataset.xhtml?persistentId={DDACS_DATASET_DOI}"
+)
+DDACS_SIM_FILE = "rddac.zip"
+SIM_SUBDIR = "simulation"  # local subdirectory the simulations download into

rddac/streaming.py

@@ -0,0 +1,159 @@
+"""Streaming iteration and numpy export for RDDAC — thin wrappers over :mod:`ddacs.streaming`.
+
+`iter_view` is the plain-Python counterpart to `RDDACDataset.__iter__`: it
+yields one ``dict[str, numpy.ndarray]`` per experiment with no torch
+dependency. `export_to_numpy` materializes a view as flat ``.npy`` memmaps
+(fixed shapes); `export_to_numpy_per_sim` writes one ``.npz`` per experiment
+(ragged shapes, e.g. the raw force tables); `load_export` reads an export back.
+
+The ``sim_ids=`` keyword names are kept identical to ``ddacs`` so DDACS code
+ports by swapping the import. Requested ids that cannot be served locally
+raise a suppressible :class:`MissingDataWarning`.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Iterator
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+import pandas as pd
+from ddacs import streaming as _ddacs_streaming
+from ddacs.streaming import (  # noqa: F401  — dataset-agnostic API + internals
+    MissingDataWarning,
+    _LoadedExport,
+    _apply_transforms,
+    _as_array,
+    _build_field_specs,
+    _build_unified_index,
+    _extract_record,
+    _parse_jsonpath,
+    _progress_iter,
+    _resolve_sim_ids,
+    _warn_missing,
+    load_export,
+)
+
+from .spec import RDDAC_SPEC
+
+DEFAULT_DATA_DIR = RDDAC_SPEC.default_data_dir
+
+__all__ = [
+    "iter_view",
+    "export_to_numpy",
+    "export_to_numpy_per_sim",
+    "load_export",
+    "MissingDataWarning",
+]
+
+
+def iter_view(
+    view: str,
+    *,
+    source: str | Path | None = None,
+    data_dir: str | Path | None = DEFAULT_DATA_DIR,
+    dataset=None,
+    sim_ids: list[int] | None = None,
+    where: Callable[[pd.Series], bool] | None = None,
+) -> Iterator[dict[str, np.ndarray]]:
+    """Yield one record per RDDAC experiment for a Croissant view.
+
+    Args:
+        view: Name of the RecordSet to stream (published, e.g. ``force-curve``,
+            or added via :func:`rddac.add_view`).
+        source: Override the Croissant manifest URL/path.
+        data_dir: Directory holding ``metadata.json``, ``process_parameters.csv``
+            and either loose ``h5/<id>.h5`` files or the dataset zips.
+        dataset: A pre-loaded ``mlcroissant.Dataset`` (carries ``add_view``
+            mutations).
+        sim_ids: Optional allowlist of experiment ids (name kept for drop-in
+            DDACS compatibility). Requested ids that cannot be served warn via
+            :class:`MissingDataWarning`.
+        where: Predicate applied to each ``process_parameters.csv`` row before
+            any HDF5 file is touched.
+
+    Yields:
+        A ``dict[str, np.ndarray]`` per experiment, keyed by view-field aliases
+        (plus the private ``_sim_id`` scratch key).
+    """
+    return _ddacs_streaming.iter_view(
+        view,
+        source=source,
+        data_dir=data_dir,
+        dataset=dataset,
+        sim_ids=sim_ids,
+        where=where,
+        spec=RDDAC_SPEC,
+    )
+
+
+def export_to_numpy(
+    view: str,
+    out_dir: str | Path,
+    *,
+    source: str | Path | None = None,
+    data_dir: str | Path | None = DEFAULT_DATA_DIR,
+    dataset=None,
+    sim_ids: list[int] | None = None,
+    where: Callable[[pd.Series], bool] | None = None,
+    transforms: dict[str, Callable[[Any], Any]] | None = None,
+    record_transform: Callable[[dict[str, Any]], dict[str, Any]] | None = None,
+    show_progress: bool = False,
+) -> dict[str, Path]:
+    """Materialize a Croissant view as flat ``.npy`` memmaps on disk.
+
+    Requires every record to share the same shape per field — raw RDDAC force
+    and traverse tables vary per experiment, so either slice/resample them via
+    ``record_transform`` or use :func:`export_to_numpy_per_sim`. See
+    :func:`ddacs.streaming.export_to_numpy` for the full parameter reference.
+    """
+    return _ddacs_streaming.export_to_numpy(
+        view,
+        out_dir,
+        source=source,
+        data_dir=data_dir,
+        dataset=dataset,
+        sim_ids=sim_ids,
+        where=where,
+        transforms=transforms,
+        record_transform=record_transform,
+        show_progress=show_progress,
+        spec=RDDAC_SPEC,
+    )
+
+
+def export_to_numpy_per_sim(
+    view: str,
+    out_dir: str | Path,
+    *,
+    source: str | Path | None = None,
+    data_dir: str | Path | None = DEFAULT_DATA_DIR,
+    dataset=None,
+    sim_ids: list[int] | None = None,
+    where: Callable[[pd.Series], bool] | None = None,
+    transforms: dict[str, Callable[[Any], Any]] | None = None,
+    record_transform: Callable[[dict[str, Any]], dict[str, Any]] | None = None,
+    compressed: bool = False,
+    show_progress: bool = False,
+) -> Path:
+    """Write one ``<experiment_id>.npz`` per experiment under ``out_dir``.
+
+    Same pipeline as :func:`export_to_numpy` but fields may have
+    experiment-dependent shapes (the natural fit for RDDAC's raw tables). See
+    :func:`ddacs.streaming.export_to_numpy_per_sim` for details.
+    """
+    return _ddacs_streaming.export_to_numpy_per_sim(
+        view,
+        out_dir,
+        source=source,
+        data_dir=data_dir,
+        dataset=dataset,
+        sim_ids=sim_ids,
+        where=where,
+        transforms=transforms,
+        record_transform=record_transform,
+        compressed=compressed,
+        show_progress=show_progress,
+        spec=RDDAC_SPEC,
+    )

rddac/visualization.py

@@ -0,0 +1,266 @@
+"""Visualization utilities for RDDAC experimental data.
+
+Plotting helpers operate on numpy arrays the caller already pulled out of an
+HDF5 file. Pair them with `rddac.open_h5` for end-to-end inspection:
+
+    >>> import rddac
+    >>> with rddac.open_h5(42, data_dir="./data") as f:
+    ...     z = f["pointcloud/op10/z"][:]
+    ...     lumi = f["pointcloud/op10/luminescence"][:]
+    ...     force = f["force/data"][:]
+    >>> ax, cbar = rddac.plot_scan(z)                      # heightmap image
+    >>> ax = rddac.plot_force(force)                       # force time series
+    >>> pts = rddac.scan_to_pointcloud(z, lumi)            # flat buffer -> (N, 3)
+    >>> ax, cbar = rddac.plot_point_cloud(pts, values=pts[:, 2])
+
+The raw scans are flattened row-major buffers over a ``y_shape x x_shape``
+(2000 x 3200) pixel grid — see the group attrs in the h5 file. Pixel values
+are sensor units; the calibrated mm conversion is part of the (optional)
+preprocessing step.
+"""
+
+from __future__ import annotations
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+# Default scan grid (Keyence line scanner): see pointcloud group attrs.
+SCAN_X_SHAPE = 3200
+SCAN_Y_SHAPE = 2000
+
+# Force table column layout (see the `columns` attr on the h5 `force` group).
+FORCE_COLUMNS = (
+    "time", "load_cell_1", "load_cell_2", "load_cell_3", "load_cell_4",
+    "punch_temp", "punch_pos", "total_force",
+)
+
+DEFAULT_DPI = 150
+
+
+def _scan_to_2d(buffer: np.ndarray, x_shape: int, y_shape: int) -> np.ndarray:
+    buffer = np.asarray(buffer)
+    if buffer.ndim == 1:
+        return buffer.reshape(y_shape, x_shape)
+    if buffer.ndim == 2:
+        return buffer
+    raise ValueError(f"expected a flat or 2D scan buffer, got shape {buffer.shape}")
+
+
+def plot_scan(
+    z: np.ndarray,
+    ax=None,
+    figsize: tuple[float, float] | None = None,
+    x_shape: int = SCAN_X_SHAPE,
+    y_shape: int = SCAN_Y_SHAPE,
+    cmap: str = "viridis",
+    vmin: float | None = None,
+    vmax: float | None = None,
+    mask_zero: bool = True,
+    colorbar: bool = True,
+    title: str | None = None,
+):
+    """Show a raw laser scan buffer (height or luminescence) as a 2D image.
+
+    Args:
+        z: Flat ``(x_shape*y_shape,)`` or already-reshaped ``(y_shape, x_shape)``
+            scan buffer, e.g. ``f["pointcloud/op10/z"][:]``.
+        ax: Optional existing matplotlib Axes.
+        figsize: Figure size when a new figure is created.
+        x_shape / y_shape: Grid dimensions (defaults match the group attrs).
+        cmap: Matplotlib colormap name.
+        vmin / vmax: Color range; defaults to the data range of valid pixels.
+        mask_zero: Render 0-valued pixels (no measurement) as transparent.
+        colorbar: Attach a colorbar.
+        title: Optional axes title.
+
+    Returns:
+        ``(ax, colorbar)`` — the colorbar is ``None`` when ``colorbar=False``.
+    """
+    img = _scan_to_2d(z, x_shape, y_shape).astype(float)
+    if mask_zero:
+        img = np.where(img == 0, np.nan, img)
+
+    if ax is None:
+        _, ax = plt.subplots(figsize=figsize or (12, 7.5), dpi=DEFAULT_DPI)
+    im = ax.imshow(img, origin="lower", cmap=cmap, vmin=vmin, vmax=vmax, aspect="equal")
+    ax.set_xlabel("x in px")
+    ax.set_ylabel("y in px")
+    if title:
+        ax.set_title(title)
+    cbar = ax.figure.colorbar(im, ax=ax, shrink=0.8) if colorbar else None
+    return ax, cbar
+
+
+def scan_to_pointcloud(
+    z: np.ndarray,
+    luminescence: np.ndarray | None = None,
+    x_shape: int = SCAN_X_SHAPE,
+    y_shape: int = SCAN_Y_SHAPE,
+    drop_invalid: bool = True,
+    stride: int = 1,
+) -> np.ndarray:
+    """Convert a flat scan buffer into an ``(N, 3)`` point cloud ``[x, y, z]``.
+
+    Coordinates are pixel indices and raw z units (uncalibrated); the mm
+    conversion, outlier removal and simulation alignment belong to the
+    (optional) preprocessing step.
+
+    Args:
+        z: Flat or 2D height buffer.
+        luminescence: Optional matching buffer; when given, pixels with zero
+            luminescence are treated as invalid too.
+        x_shape / y_shape: Grid dimensions.
+        drop_invalid: Drop pixels with ``z == 0`` (no measurement).
+        stride: Keep every ``stride``-th pixel in both axes (fast previews;
+            ``stride=4`` reduces 6.4M points to ~400k).
+
+    Returns:
+        ``(N, 3)`` float32 array of ``[x_px, y_px, z_raw]``.
+    """
+    z2d = _scan_to_2d(z, x_shape, y_shape)[::stride, ::stride]
+    valid = np.ones_like(z2d, dtype=bool)
+    if drop_invalid:
+        valid &= z2d != 0
+    if luminescence is not None:
+        lumi2d = _scan_to_2d(luminescence, x_shape, y_shape)[::stride, ::stride]
+        valid &= lumi2d != 0
+    yy, xx = np.nonzero(valid)
+    pts = np.column_stack([xx * stride, yy * stride, z2d[yy, xx]]).astype(np.float32)
+    return pts
+
+
+def plot_point_cloud(
+    points: np.ndarray,
+    values: np.ndarray | None = None,
+    ax=None,
+    figsize: tuple[float, float] | None = None,
+    cmap: str = "viridis",
+    vmin: float | None = None,
+    vmax: float | None = None,
+    point_size: float = 1.0,
+    max_points: int | None = 200_000,
+    colorbar: bool = True,
+    title: str | None = None,
+):
+    """Scatter an ``(N, 3)`` point cloud in 3D, optionally colored by ``values``.
+
+    Signature mirrors ``ddacs.plot_point_cloud`` so DDACS code ports by
+    swapping the import. Use :func:`scan_to_pointcloud` to build ``points``
+    from a raw scan buffer, or plot processed clouds directly.
+
+    Args:
+        points: ``(N, 3)`` array of xyz positions.
+        values: Optional per-point scalars for coloring (default: z).
+        ax: Optional existing 3D Axes.
+        figsize: Figure size when a new figure is created.
+        cmap / vmin / vmax: Color mapping.
+        point_size: Scatter marker size.
+        max_points: Random-subsample cap (``None`` = plot everything).
+        colorbar: Attach a colorbar.
+        title: Optional axes title.
+
+    Returns:
+        ``(ax, colorbar)`` — the colorbar is ``None`` when ``colorbar=False``.
+    """
+    points = np.asarray(points)
+    if points.ndim != 2 or points.shape[1] != 3:
+        raise ValueError(f"expected (N, 3) points, got {points.shape}")
+    if values is None:
+        values = points[:, 2]
+    values = np.asarray(values)
+
+    if max_points is not None and len(points) > max_points:
+        idx = np.random.default_rng(0).choice(len(points), max_points, replace=False)
+        points, values = points[idx], values[idx]
+
+    if ax is None:
+        fig = plt.figure(figsize=figsize or (10, 8), dpi=DEFAULT_DPI)
+        ax = fig.add_subplot(projection="3d")
+    sc = ax.scatter(points[:, 0], points[:, 1], points[:, 2],
+                    c=values, cmap=cmap, vmin=vmin, vmax=vmax, s=point_size)
+    ax.set_xlabel("x")
+    ax.set_ylabel("y")
+    ax.set_zlabel("z")
+    if title:
+        ax.set_title(title)
+    cbar = ax.figure.colorbar(sc, ax=ax, shrink=0.6) if colorbar else None
+    return ax, cbar
+
+
+def plot_force(
+    force: np.ndarray,
+    columns: tuple[str, ...] = FORCE_COLUMNS,
+    signals: tuple[str, ...] = ("load_cell_1", "load_cell_2", "load_cell_3", "load_cell_4", "total_force"),
+    ax=None,
+    figsize: tuple[float, float] | None = None,
+    title: str | None = None,
+):
+    """Plot press force / process signals over time from a ``force/data`` table.
+
+    Args:
+        force: ``(n, 8)`` array as stored under ``force/data``.
+        columns: Column layout (defaults to the raw layout; pass the h5 group's
+            ``columns`` attr when it differs, e.g. for preprocessed data).
+        signals: Which columns to draw against ``time``.
+        ax: Optional existing Axes.
+        figsize: Figure size when a new figure is created.
+        title: Optional axes title.
+
+    Returns:
+        The matplotlib Axes.
+    """
+    force = np.asarray(force)
+    col = {name: i for i, name in enumerate(columns)}
+    if "time" not in col:
+        raise ValueError(f"columns must contain 'time', got {columns}")
+    if ax is None:
+        _, ax = plt.subplots(figsize=figsize or (10, 5), dpi=DEFAULT_DPI)
+    t = force[:, col["time"]]
+    for name in signals:
+        if name not in col:
+            raise ValueError(f"unknown signal {name!r}; available: {sorted(col)}")
+        ax.plot(t, force[:, col[name]], label=name, linewidth=1)
+    ax.set_xlabel("time in s")
+    ax.set_ylabel("force in kN")
+    ax.legend(loc="best", fontsize="small")
+    ax.grid(True, alpha=0.3)
+    if title:
+        ax.set_title(title)
+    return ax
+
+
+def plot_traverse(
+    data: np.ndarray,
+    ax=None,
+    figsize: tuple[float, float] | None = None,
+    ylabel: str = "value",
+    label: str | None = None,
+    title: str | None = None,
+):
+    """Plot a sensor traverse table (``sheet_thickness/data`` or ``oil_thickness/data``).
+
+    Args:
+        data: ``(n, 2)`` array of ``[sensor_position, value]``.
+        ax: Optional existing Axes.
+        figsize: Figure size when a new figure is created.
+        ylabel: Y axis label (e.g. ``"sheet thickness in um"``, ``"oil in g/m^2"``).
+        label: Optional line label (for overlaying multiple traverses).
+        title: Optional axes title.
+
+    Returns:
+        The matplotlib Axes.
+    """
+    data = np.asarray(data)
+    if data.ndim != 2 or data.shape[1] != 2:
+        raise ValueError(f"expected (n, 2) traverse, got {data.shape}")
+    if ax is None:
+        _, ax = plt.subplots(figsize=figsize or (10, 4), dpi=DEFAULT_DPI)
+    ax.plot(data[:, 0], data[:, 1], linewidth=1, label=label)
+    ax.set_xlabel("sensor position in mm")
+    ax.set_ylabel(ylabel)
+    ax.grid(True, alpha=0.3)
+    if label:
+        ax.legend(loc="best", fontsize="small")
+    if title:
+        ax.set_title(title)
+    return ax

rddac-1.0.0.dist-info/METADATA

@@ -0,0 +1,155 @@
+Metadata-Version: 2.4
+Name: rddac
+Version: 1.0.0
+Summary: Python package for the Real Deep Drawing and Cutting (RDDAC) Dataset
+Author: Sebastian Baum, Pascal Heinzelmann
+License: MIT
+Project-URL: Homepage, https://github.com/BaumSebastian/RDDAC
+Project-URL: Documentation, https://rddac.readthedocs.io
+Project-URL: Repository, https://github.com/BaumSebastian/RDDAC
+Keywords: deep-drawing,sheet-metal,forming,dataset,experimental,measurement
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24.0
+Requires-Dist: pandas>=2.0.0
+Requires-Dist: h5py>=3.8.0
+Requires-Dist: matplotlib>=3.7.0
+Requires-Dist: requests>=2.28.0
+Requires-Dist: humanfriendly>=10.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: mlcroissant>=1.1.0
+Requires-Dist: ddacs<4,>=3.2.1
+Provides-Extra: torch
+Requires-Dist: torch>=2.0; extra == "torch"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: black>=24.0.0; extra == "dev"
+Requires-Dist: ruff>=0.3.0; extra == "dev"
+Requires-Dist: bumpver>=2023.1129; extra == "dev"
+Requires-Dist: pre-commit>=3.6.0; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: mkdocs>=1.5.0; extra == "docs"
+Requires-Dist: mkdocs-material>=9.5.0; extra == "docs"
+Requires-Dist: mkdocstrings[python]>=0.24.0; extra == "docs"
+Requires-Dist: mkdocs-macros-plugin>=1.0.0; extra == "docs"
+Dynamic: license-file
+
+<div align="center">
+  <img src="https://raw.githubusercontent.com/BaumSebastian/RDDAC/main/docs/images/icon/icon.png" width="150"/>
+  <h1>Real Deep Drawing and Cutting (RDDAC) Dataset</h1>
+</div>
+
+[![Code License: MIT](https://img.shields.io/badge/Code-MIT-yellow.svg)](LICENSE)
+[![Dataset License: CC BY 4.0](https://img.shields.io/badge/Dataset-CC_BY_4.0-lightgrey.svg)](https://creativecommons.org/licenses/by/4.0/)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
+[![Documentation](https://readthedocs.org/projects/rddac/badge/?version=latest)](https://rddac.readthedocs.io)
+[![DaRUS Repository](https://img.shields.io/badge/repository-DaRUS-green.svg)](https://darus.uni-stuttgart.de/dataset.xhtml?persistentId=doi:10.18419/DARUS-5589)
+[![DOI](https://img.shields.io/badge/DOI-10.18419%2FDARUS--5589-blue.svg)](https://doi.org/10.18419/DARUS-5589)
+
+<div align="center">
+
+![Measured point clouds after OP10 and OP20, colored by deviation from the matching DDACS simulation](https://raw.githubusercontent.com/BaumSebastian/RDDAC/main/docs/images/sim2real_sweep.gif)
+
+*Measured point clouds of one experiment after deep drawing (OP10, left) and cutting (OP20, right), colored by the deviation from the matching DDACS simulation.*
+
+</div>
+
+**A large-scale experimental dataset of 9,000 physical deep-drawing and cutting experiments — the real-world counterpart to the [DDACS](https://ddacs.readthedocs.io) FEM simulations.** Each experiment forms a modified quadratic cup from DP600 dual-phase steel (deep drawing in OP10, cutting in OP20) and records press force signals, sheet-thickness and oil-film traverses, and high-resolution 3D laser scans of the part after each operation. Use it to quantify the simulation-to-reality gap, train models on real process data, or validate DDACS-trained surrogates against physical measurements.
+
+|  |  |
+|---|---|
+| **Experiments** | 9,000 |
+| **Total size** | ~87 GB (HDF5, lossless) |
+| **Process steps per experiment** | 2 (OP10 deep drawing, OP20 cutting) |
+| **Parameter space** | 2 geometries x 3 blankholder forces x 3 oil types (18 categories) |
+| **Repetitions** | up to 500 per category |
+| **Train / val / test** | 7,200 / 900 / 900 (predefined, seed 42) |
+| **Matching simulations** | DDACS `rddac.zip` (~9 GB), fetched by `rddac download` |
+
+**[Documentation](https://rddac.readthedocs.io)** · **[Dataset DOI](https://doi.org/10.18419/DARUS-5589)** · **[Paper](https://doi.org/10.1007/s12666-026-03870-5)**
+
+The `rddac` package ships with the dataset and provides a Croissant native interface: one CLI for the download, one Python module for access, and an optional PyTorch `IterableDataset` for training.
+
+## Installation
+
+```bash
+pip install rddac
+```
+
+The PyTorch adapter is an optional extra. For hardware specific PyTorch builds (CUDA, ROCm, MPS), install PyTorch first from [pytorch.org](https://pytorch.org/get-started/locally/), then install the extra:
+
+```bash
+pip install 'rddac[torch]'
+```
+
+## Download the dataset
+
+```bash
+# Small sample bundle (~174 MB): manifest, CSV, and one experiment per category.
+rddac download --small -y
+
+# Full release (~87 GB), including the matching DDACS simulations (~9 GB).
+rddac download
+
+# Real measurements only (skip the simulations).
+rddac download --no-sim
+```
+
+## Basic usage
+
+```python
+import rddac
+
+with rddac.open_h5(0) as f:                    # one experiment by id
+    force = f["force/data"][:]                 # (n, 8): time, load cells, temp, position, total force
+    sheet = f["sheet_thickness/data"][:]       # (n, 2): sensor position, thickness
+    z10   = f["pointcloud/op10/z"][:]          # (6400000,) flat scan buffer
+```
+
+The public surface mirrors the [`ddacs`](https://ddacs.readthedocs.io) package one to one — `load`, `add_view`, `open_h5`, `inspect_h5`, `streaming.iter_view` / `export_to_numpy` / `load_export`, and the PyTorch `IterableDataset` share names, signatures, and semantics. Code written against DDACS ports by swapping the import:
+
+```python
+# import ddacs as dataset_pkg                  # simulations
+import rddac as dataset_pkg                    # real experiments
+
+ds = dataset_pkg.load(data_dir="./data")
+for record in dataset_pkg.streaming.iter_view("force-curve", data_dir="./data", dataset=ds):
+    ...
+```
+
+See the [documentation](https://rddac.readthedocs.io) for the dataset reference (parameter space, HDF5 structure, Croissant manifest) and step-by-step tutorials from a first plot to PyTorch training.
+
+## Citation
+
+```bibtex
+@dataset{baum2026rddac,
+  title={Real Deep Drawing and Cutting Dataset},
+  author={Baum, Sebastian and Heinzelmann, Pascal},
+  year={2026},
+  publisher={DaRUS},
+  doi={10.18419/DARUS-5589}
+}
+
+@article{baum2026deviation,
+  title={Statistical Analysis of Simulation to Reality Deviation in Deep Drawing with a Benchmark Dataset},
+  author={Baum, Sebastian and Heinzelmann, Pascal and Clau{\ss}, P. and others},
+  journal={Transactions of the Indian Institute of Metals},
+  volume={79},
+  pages={176},
+  year={2026},
+  doi={10.1007/s12666-026-03870-5}
+}
+```
+
+## License
+
+The dataset on DaRUS is licensed under [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/). The `rddac` software is licensed under the MIT License — see [LICENSE](LICENSE).

rddac-1.0.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+rddac/__init__.py,sha256=69uu0Bc2Gh9EhZ7Xt69q4J_bBFPGN1-OQtyYcMXUmHs,1898
+rddac/cli.py,sha256=CqKPmy1y2NHAnqarH7OBbpuzb81TW3B0rMhcDu4MWG0,7244
+rddac/croissant.py,sha256=LxQsuFrsQKJSfzYuNUZMxdPRrvEjqj97fdVfA5cbM0E,2845
+rddac/h5_tools.py,sha256=mUrMo72lAeKuz8gMPC1d1CHgC_zT6OqfBUySjggyZCM,1835
+rddac/pytorch.py,sha256=t8MHThEObdzhlH7MZv3c0XbP_mKP82AfrrJMn7cPjN8,2900
+rddac/spec.py,sha256=pNwRuwWr1duHo16807MjdAX7CjxvCKTSDfHagYX92kE,2115
+rddac/streaming.py,sha256=HjmGL1xFttEex1POu5nvnZIW9gdUcWq_2aRd-SIX0zM,5269
+rddac/visualization.py,sha256=y6XXOWZJ6ZQPo_y5eEOzX70UFhfy0DsdFCuTvHzkr7c,9653
+rddac-1.0.0.dist-info/licenses/LICENSE,sha256=htWii6DUxgmJYXwJcRQJvrOrQVQah0dysFFpSE8litg,1071
+rddac-1.0.0.dist-info/METADATA,sha256=CD8-2YflQii72BZqkTLHBLgNE6t0DO7-0Ql73lctiDU,7078
+rddac-1.0.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+rddac-1.0.0.dist-info/entry_points.txt,sha256=uAwbYPNp8KxNg8vfIn6K6cxqORiwzW8kkbwHu-L2AkE,41
+rddac-1.0.0.dist-info/top_level.txt,sha256=a82Qw357Rc8hZLYLMFZ-e6OQ2SQtoV5iRM34c7Ffif8,6
+rddac-1.0.0.dist-info/RECORD,,

rddac-1.0.0.dist-info/WHEEL

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

rddac-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+rddac = rddac.cli:main

rddac-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Sebastian Baum
+
+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.

rddac-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+rddac