d3plot-compress 0.1.0__tar.gz

d3plot_compress-0.1.0/LICENSE

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

d3plot_compress-0.1.0/PKG-INFO

@@ -0,0 +1,97 @@
+Metadata-Version: 2.4
+Name: d3plot-compress
+Version: 0.1.0
+Summary: Lossless gzip compression for LS-DYNA d3plot binary result files
+License: MIT
+Keywords: ls-dyna,d3plot,fea,compression,cae
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering
+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
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# d3plot-compress
+
+Lossless gzip compression for **LS-DYNA d3plot** binary result files.
+
+Compressed files are read **directly** by BETA CAE META post-processor — no manual decompression needed before viewing animations.
+
+## Install
+
+```bash
+pip install d3plot-compress
+```
+
+## Usage
+
+### Command line
+
+```bash
+# Compress all d3plot files in a folder (replaces originals with .gz)
+d3plot-compress compress /path/to/results
+
+# Compress but keep originals
+d3plot-compress compress /path/to/results --keep-original
+
+# Use maximum compression (slower but smallest size)
+d3plot-compress compress /path/to/results --level 9
+
+# Decompress (if you need raw files for a tool that doesn't support .gz)
+d3plot-compress decompress /path/to/results
+```
+
+### Python API
+
+```python
+from d3plot_compress import compress_folder, decompress_folder
+
+# Compress
+compress_folder("/path/to/results")
+
+# Decompress
+decompress_folder("/path/to/results")
+```
+
+## How it works
+
+LS-DYNA writes results as a sequence of binary files:
+
+```
+d3plot        ← header + first state
+d3plot01      ← subsequent time steps
+d3plot02
+...
+```
+
+This tool compresses each file individually using gzip (lossless), producing:
+
+```
+d3plot.gz
+d3plot01.gz
+d3plot02.gz
+...
+```
+
+BETA CAE META post-processor recognises the `.gz` extension and decompresses on-the-fly, so animations play exactly as with the original files.
+
+## Options
+
+| Flag | Description |
+|------|-------------|
+| `--level 1-9` | Compression level (1=fastest, 9=smallest, default=6) |
+| `--keep-original` | Keep uncompressed files alongside `.gz` |
+| `--keep-compressed` | (decompress) Keep `.gz` alongside restored files |
+| `--quiet` | Suppress progress output |
+
+## Requirements
+
+- Python 3.10+
+- No external dependencies (uses Python's built-in `gzip` module)

d3plot_compress-0.1.0/README.md

@@ -0,0 +1,77 @@
+# d3plot-compress
+
+Lossless gzip compression for **LS-DYNA d3plot** binary result files.
+
+Compressed files are read **directly** by BETA CAE META post-processor — no manual decompression needed before viewing animations.
+
+## Install
+
+```bash
+pip install d3plot-compress
+```
+
+## Usage
+
+### Command line
+
+```bash
+# Compress all d3plot files in a folder (replaces originals with .gz)
+d3plot-compress compress /path/to/results
+
+# Compress but keep originals
+d3plot-compress compress /path/to/results --keep-original
+
+# Use maximum compression (slower but smallest size)
+d3plot-compress compress /path/to/results --level 9
+
+# Decompress (if you need raw files for a tool that doesn't support .gz)
+d3plot-compress decompress /path/to/results
+```
+
+### Python API
+
+```python
+from d3plot_compress import compress_folder, decompress_folder
+
+# Compress
+compress_folder("/path/to/results")
+
+# Decompress
+decompress_folder("/path/to/results")
+```
+
+## How it works
+
+LS-DYNA writes results as a sequence of binary files:
+
+```
+d3plot        ← header + first state
+d3plot01      ← subsequent time steps
+d3plot02
+...
+```
+
+This tool compresses each file individually using gzip (lossless), producing:
+
+```
+d3plot.gz
+d3plot01.gz
+d3plot02.gz
+...
+```
+
+BETA CAE META post-processor recognises the `.gz` extension and decompresses on-the-fly, so animations play exactly as with the original files.
+
+## Options
+
+| Flag | Description |
+|------|-------------|
+| `--level 1-9` | Compression level (1=fastest, 9=smallest, default=6) |
+| `--keep-original` | Keep uncompressed files alongside `.gz` |
+| `--keep-compressed` | (decompress) Keep `.gz` alongside restored files |
+| `--quiet` | Suppress progress output |
+
+## Requirements
+
+- Python 3.10+
+- No external dependencies (uses Python's built-in `gzip` module)

d3plot_compress-0.1.0/d3plot_compress/__init__.py

@@ -0,0 +1,3 @@
+"""d3plot_compress — lossless gzip compression for LS-DYNA d3plot files."""
+
+__version__ = "0.1.0"

d3plot_compress-0.1.0/d3plot_compress/cli.py

@@ -0,0 +1,89 @@
+"""Command-line interface for d3plot_compress."""
+
+import argparse
+import sys
+from pathlib import Path
+
+from .core import compress_folder, decompress_folder
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="d3plot-compress",
+        description=(
+            "Lossless gzip compression for LS-DYNA d3plot files.\n"
+            "Compressed files are readable directly by BETA CAE META post-processor."
+        ),
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  d3plot-compress compress ./results
+  d3plot-compress compress ./results --keep-original --level 9
+  d3plot-compress decompress ./results
+  d3plot-compress decompress ./results --keep-compressed
+""",
+    )
+
+    parser.add_argument(
+        "action",
+        choices=["compress", "decompress"],
+        help="compress: d3plot → d3plot.gz  |  decompress: d3plot.gz → d3plot",
+    )
+    parser.add_argument(
+        "folder",
+        type=Path,
+        help="Folder containing d3plot files",
+    )
+    parser.add_argument(
+        "--keep-original",
+        action="store_true",
+        help="(compress) Keep uncompressed originals alongside .gz files",
+    )
+    parser.add_argument(
+        "--keep-compressed",
+        action="store_true",
+        help="(decompress) Keep .gz files alongside restored originals",
+    )
+    parser.add_argument(
+        "--level",
+        type=int,
+        default=6,
+        choices=range(1, 10),
+        metavar="1-9",
+        help="Gzip compression level: 1=fastest, 9=smallest (default: 6)",
+    )
+    parser.add_argument(
+        "--quiet",
+        action="store_true",
+        help="Suppress progress output",
+    )
+
+    args = parser.parse_args()
+
+    if not args.folder.is_dir():
+        print(f"Error: folder not found: {args.folder}", file=sys.stderr)
+        sys.exit(1)
+
+    verbose = not args.quiet
+
+    if args.action == "compress":
+        results = compress_folder(
+            args.folder,
+            keep_original=args.keep_original,
+            level=args.level,
+            verbose=verbose,
+        )
+        if verbose and results:
+            print(f"\nDone. {len(results)} file(s) compressed.")
+    else:
+        results = decompress_folder(
+            args.folder,
+            keep_compressed=args.keep_compressed,
+            verbose=verbose,
+        )
+        if verbose and results:
+            print(f"\nDone. {len(results)} file(s) decompressed.")
+
+
+if __name__ == "__main__":
+    main()

d3plot_compress-0.1.0/d3plot_compress/core.py

@@ -0,0 +1,138 @@
+"""Core compress/decompress logic for LS-DYNA d3plot files."""
+
+from __future__ import annotations
+
+import gzip
+import os
+import re
+import shutil
+from pathlib import Path
+
+# Matches: d3plot, d3plot01, d3plot02, ..., d3plot99, d3plot100, etc.
+_D3PLOT_PATTERN = re.compile(r"^d3plot(\d*)$", re.IGNORECASE)
+_D3PLOT_GZ_PATTERN = re.compile(r"^d3plot(\d*)\.gz$", re.IGNORECASE)
+
+
+def find_d3plot_files(folder: Path) -> list[Path]:
+    """Return uncompressed d3plot files in folder, sorted by sequence number."""
+    files = [
+        f for f in folder.iterdir()
+        if f.is_file() and _D3PLOT_PATTERN.match(f.name)
+    ]
+    return sorted(files, key=lambda f: _sort_key(f.name))
+
+
+def find_compressed_files(folder: Path) -> list[Path]:
+    """Return compressed d3plot.gz files in folder, sorted by sequence number."""
+    files = [
+        f for f in folder.iterdir()
+        if f.is_file() and _D3PLOT_GZ_PATTERN.match(f.name)
+    ]
+    return sorted(files, key=lambda f: _sort_key(f.name))
+
+
+def _sort_key(name: str) -> tuple:
+    m = _D3PLOT_PATTERN.match(name) or _D3PLOT_GZ_PATTERN.match(name)
+    suffix = m.group(1) if m else ""
+    return (int(suffix),) if suffix else (0,)
+
+
+def compress_file(src: Path, keep_original: bool = False, level: int = 6) -> Path:
+    """
+    Compress a single d3plot file to <name>.gz in the same folder.
+    Returns path to the compressed file.
+    """
+    dst = src.with_name(src.name + ".gz")
+    with src.open("rb") as f_in, gzip.open(dst, "wb", compresslevel=level) as f_out:
+        shutil.copyfileobj(f_in, f_out)
+    if not keep_original:
+        src.unlink()
+    return dst
+
+
+def decompress_file(src: Path, keep_compressed: bool = False) -> Path:
+    """
+    Decompress a single d3plot.gz file, restoring original name.
+    Returns path to the decompressed file.
+    """
+    # d3plot01.gz  →  d3plot01
+    dst = src.with_suffix("")  # strips .gz
+    with gzip.open(src, "rb") as f_in, dst.open("wb") as f_out:
+        shutil.copyfileobj(f_in, f_out)
+    if not keep_compressed:
+        src.unlink()
+    return dst
+
+
+def compress_folder(
+    folder: str | os.PathLike,
+    keep_original: bool = False,
+    level: int = 6,
+    verbose: bool = True,
+) -> list[Path]:
+    """
+    Compress all d3plot files in *folder*.
+
+    Parameters
+    ----------
+    folder       : path containing d3plot, d3plot01, d3plot02, ...
+    keep_original: keep uncompressed originals alongside .gz files
+    level        : gzip compression level 1 (fastest) – 9 (smallest), default 6
+    verbose      : print progress
+
+    Returns list of compressed file paths.
+    """
+    folder = Path(folder)
+    files = find_d3plot_files(folder)
+    if not files:
+        if verbose:
+            print(f"No uncompressed d3plot files found in: {folder}")
+        return []
+
+    results = []
+    for f in files:
+        if verbose:
+            size_mb = f.stat().st_size / 1_048_576
+            print(f"  Compressing {f.name} ({size_mb:.1f} MB) ...", end=" ", flush=True)
+        out = compress_file(f, keep_original=keep_original, level=level)
+        if verbose:
+            out_mb = out.stat().st_size / 1_048_576
+            print(f"→ {out.name} ({out_mb:.1f} MB)")
+        results.append(out)
+    return results
+
+
+def decompress_folder(
+    folder: str | os.PathLike,
+    keep_compressed: bool = False,
+    verbose: bool = True,
+) -> list[Path]:
+    """
+    Decompress all d3plot.gz files in *folder*.
+
+    Parameters
+    ----------
+    folder         : path containing d3plot.gz, d3plot01.gz, ...
+    keep_compressed: keep .gz files alongside restored originals
+    verbose        : print progress
+
+    Returns list of decompressed file paths.
+    """
+    folder = Path(folder)
+    files = find_compressed_files(folder)
+    if not files:
+        if verbose:
+            print(f"No compressed d3plot.gz files found in: {folder}")
+        return []
+
+    results = []
+    for f in files:
+        if verbose:
+            size_mb = f.stat().st_size / 1_048_576
+            print(f"  Decompressing {f.name} ({size_mb:.1f} MB) ...", end=" ", flush=True)
+        out = decompress_file(f, keep_compressed=keep_compressed)
+        if verbose:
+            out_mb = out.stat().st_size / 1_048_576
+            print(f"→ {out.name} ({out_mb:.1f} MB)")
+        results.append(out)
+    return results

d3plot_compress-0.1.0/d3plot_compress.egg-info/PKG-INFO

@@ -0,0 +1,97 @@
+Metadata-Version: 2.4
+Name: d3plot-compress
+Version: 0.1.0
+Summary: Lossless gzip compression for LS-DYNA d3plot binary result files
+License: MIT
+Keywords: ls-dyna,d3plot,fea,compression,cae
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering
+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
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# d3plot-compress
+
+Lossless gzip compression for **LS-DYNA d3plot** binary result files.
+
+Compressed files are read **directly** by BETA CAE META post-processor — no manual decompression needed before viewing animations.
+
+## Install
+
+```bash
+pip install d3plot-compress
+```
+
+## Usage
+
+### Command line
+
+```bash
+# Compress all d3plot files in a folder (replaces originals with .gz)
+d3plot-compress compress /path/to/results
+
+# Compress but keep originals
+d3plot-compress compress /path/to/results --keep-original
+
+# Use maximum compression (slower but smallest size)
+d3plot-compress compress /path/to/results --level 9
+
+# Decompress (if you need raw files for a tool that doesn't support .gz)
+d3plot-compress decompress /path/to/results
+```
+
+### Python API
+
+```python
+from d3plot_compress import compress_folder, decompress_folder
+
+# Compress
+compress_folder("/path/to/results")
+
+# Decompress
+decompress_folder("/path/to/results")
+```
+
+## How it works
+
+LS-DYNA writes results as a sequence of binary files:
+
+```
+d3plot        ← header + first state
+d3plot01      ← subsequent time steps
+d3plot02
+...
+```
+
+This tool compresses each file individually using gzip (lossless), producing:
+
+```
+d3plot.gz
+d3plot01.gz
+d3plot02.gz
+...
+```
+
+BETA CAE META post-processor recognises the `.gz` extension and decompresses on-the-fly, so animations play exactly as with the original files.
+
+## Options
+
+| Flag | Description |
+|------|-------------|
+| `--level 1-9` | Compression level (1=fastest, 9=smallest, default=6) |
+| `--keep-original` | Keep uncompressed files alongside `.gz` |
+| `--keep-compressed` | (decompress) Keep `.gz` alongside restored files |
+| `--quiet` | Suppress progress output |
+
+## Requirements
+
+- Python 3.10+
+- No external dependencies (uses Python's built-in `gzip` module)

d3plot_compress-0.1.0/d3plot_compress.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+d3plot_compress/__init__.py
+d3plot_compress/cli.py
+d3plot_compress/core.py
+d3plot_compress.egg-info/PKG-INFO
+d3plot_compress.egg-info/SOURCES.txt
+d3plot_compress.egg-info/dependency_links.txt
+d3plot_compress.egg-info/entry_points.txt
+d3plot_compress.egg-info/top_level.txt

d3plot_compress-0.1.0/d3plot_compress.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

d3plot_compress-0.1.0/d3plot_compress.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+d3plot-compress = d3plot_compress.cli:main

d3plot_compress-0.1.0/d3plot_compress.egg-info/top_level.txt

@@ -0,0 +1 @@
+d3plot_compress

d3plot_compress-0.1.0/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "d3plot-compress"
+version = "0.1.0"
+description = "Lossless gzip compression for LS-DYNA d3plot binary result files"
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.9"
+keywords = ["ls-dyna", "d3plot", "fea", "compression", "cae"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Science/Research",
+    "Topic :: Scientific/Engineering",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+
+[project.scripts]
+d3plot-compress = "d3plot_compress.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["d3plot_compress*"]

d3plot_compress-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+