dicom-dre 1.0.0.dev4__tar.gz → 1.0.0.dev6__tar.gz

{dicom_dre-1.0.0.dev4 → dicom_dre-1.0.0.dev6}/.devcontainer/devcontainer.json

@@ -40,7 +40,7 @@
       "configureZshAsDefaultShell": "false"
     },
     "ghcr.io/devcontainers-extra/features/apt-packages:1": {
-      "packages": "build-essential,ca-certificates,cmake,curl,dcmtk,file,git,just,ninja-build,patchelf,pkg-config,swig,unzip,wget,zip"
+      "packages": "build-essential,ca-certificates,cmake,curl,dcmtk,file,git,just,ninja-build,patchelf,pkg-config,swig,unzip,wget,zip,bubblewrap,socat"
     },
     "ghcr.io/jsburckhardt/devcontainer-features/uv:1": {},
     "ghcr.io/devcontainers/features/github-cli:1": {}

{dicom_dre-1.0.0.dev4 → dicom_dre-1.0.0.dev6}/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 <!-- version list -->
 
+## v1.0.0-dev.5 (2026-07-28)
+
+### Bug Fixes
+
+- Api for accel check
+  ([`bb0373b`](https://github.com/susom/dicom-dre/commit/bb0373bb0d6686c2100bc1b310958d8592a330f6))
+
+
+## v1.0.0-dev.4 (2026-07-28)
+
+### Bug Fixes
+
+- More public api
+  ([`0dfb8c0`](https://github.com/susom/dicom-dre/commit/0dfb8c0ec19bb5090e9c77348f0dd96ac83978e6))
+
+
 ## v1.0.0-dev.3 (2026-07-27)
 
 ### Documentation

{dicom_dre-1.0.0.dev4 → dicom_dre-1.0.0.dev6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dicom-dre
-Version: 1.0.0.dev4
+Version: 1.0.0.dev6
 Summary: DICOM De-identification & Redaction Engine
 Project-URL: repository, https://github.com/susom/dicom-dre
 Author-email: Stanford <people@stanford.edu>
@@ -121,6 +121,26 @@ dicom-dre deidentify a.dcm b.dcm dir/ -o out/ \
 Sources are read but never modified. The command exits non-zero if any instance
 is `QUARANTINED`; `FILTERED` instances are a normal outcome.
 
+### JPEG DCT accelerator status
+
+JPEG DCT-domain blanking uses an optional compiled C extension that is roughly
+300x faster than the pure-Python fallback. Confirm it is active:
+
+```bash
+dicom-dre accelerator-status
+```
+
+The command prints `JPEG DCT C accelerator: ACTIVE` and exits `0` when the
+extension is loaded, or reports the pure-Python fallback and exits `1`
+otherwise. The same state is available in Python via
+`dicom_dre.jpeg_dct_accelerator_available()`:
+
+```python
+from dicom_dre import jpeg_dct_accelerator_available
+
+assert jpeg_dct_accelerator_available(), "JPEG DCT C accelerator is not compiled"
+```
+
 ### Profiles
 
 Select a de-identification profile with `--profile`:

{dicom_dre-1.0.0.dev4 → dicom_dre-1.0.0.dev6}/README.md

@@ -96,6 +96,26 @@ dicom-dre deidentify a.dcm b.dcm dir/ -o out/ \
 Sources are read but never modified. The command exits non-zero if any instance
 is `QUARANTINED`; `FILTERED` instances are a normal outcome.
 
+### JPEG DCT accelerator status
+
+JPEG DCT-domain blanking uses an optional compiled C extension that is roughly
+300x faster than the pure-Python fallback. Confirm it is active:
+
+```bash
+dicom-dre accelerator-status
+```
+
+The command prints `JPEG DCT C accelerator: ACTIVE` and exits `0` when the
+extension is loaded, or reports the pure-Python fallback and exits `1`
+otherwise. The same state is available in Python via
+`dicom_dre.jpeg_dct_accelerator_available()`:
+
+```python
+from dicom_dre import jpeg_dct_accelerator_available
+
+assert jpeg_dct_accelerator_available(), "JPEG DCT C accelerator is not compiled"
+```
+
 ### Profiles
 
 Select a de-identification profile with `--profile`:

{dicom_dre-1.0.0.dev4 → dicom_dre-1.0.0.dev6}/docs/guides/cli.md

@@ -91,3 +91,31 @@ dicom-dre deidentify studies/ -o out/ -r \
     -p PATIENT_ID=TEST -p ACCESSION_NUMBER=TESTING \
     -j 8
 ```
+
+## Checking the JPEG DCT accelerator
+
+JPEG DCT-domain blanking uses an optional compiled C extension
+(`_jpeg_dct_accel`) that is roughly 300x faster than the pure-Python fallback.
+The `dicom-dre accelerator-status` command reports whether that extension is
+active, so operators can confirm the fast path in CI and health checks.
+
+```bash
+dicom-dre accelerator-status
+```
+
+It prints one line and sets the exit code:
+
+- `JPEG DCT C accelerator: ACTIVE` — exit code `0`.
+- `JPEG DCT C accelerator: NOT AVAILABLE (using pure-Python fallback, ~300x slower)`
+  — exit code `1`.
+
+The same state is available from Python through
+[`dicom_dre.jpeg_dct_accelerator_available`](../reference/api.md):
+
+```python
+from dicom_dre import jpeg_dct_accelerator_available
+
+if not jpeg_dct_accelerator_available():
+    raise SystemExit("JPEG DCT C accelerator is not compiled")
+```
+

{dicom_dre-1.0.0.dev4 → dicom_dre-1.0.0.dev6}/src/dicom_dre/__init__.py

@@ -20,6 +20,8 @@ from dicom_dre.catalog import DeviceCatalog
 from dicom_dre.catalog import DicomTags
 from dicom_dre.catalog import Variant
 from dicom_dre.default_catalog import get_default_catalog
+from dicom_dre.jpeg_dct_scrubber import jpeg_dct_accelerator_available
+from dicom_dre.jpeg_dct_scrubber import jpeg_dct_accelerator_info
 from dicom_dre.parameters import DeidParameters
 from dicom_dre.pipeline import deidentify_file
 from dicom_dre.profile import DeidProfile
@@ -70,6 +72,8 @@ __all__ = [
     "default_profile",
     "get_default_catalog",
     "get_text_redactor",
+    "jpeg_dct_accelerator_available",
+    "jpeg_dct_accelerator_info",
     "lds_no_dob_profile",
     "lds_profile",
     "pixels_only_profile",

{dicom_dre-1.0.0.dev4 → dicom_dre-1.0.0.dev6}/src/dicom_dre/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.0.0.dev4'
-__version_tuple__ = version_tuple = (1, 0, 0, 'dev4')
+__version__ = version = '1.0.0.dev6'
+__version_tuple__ = version_tuple = (1, 0, 0, 'dev6')
 
 __commit_id__ = commit_id = None

{dicom_dre-1.0.0.dev4 → dicom_dre-1.0.0.dev6}/src/dicom_dre/catalog.py

@@ -180,6 +180,10 @@ class DicomTags:
         """Return the string value for *keyword*, or ``""`` if absent."""
         return self._values.get(keyword, "")
 
+    def as_dict(self) -> dict[str, str]:
+        """Return the tag values as a plain dict copy."""
+        return dict(self._values)
+
     def get_list(self, keyword: str) -> list[str]:
         """Return the multi-valued tag as a list of strings.
 

{dicom_dre-1.0.0.dev4 → dicom_dre-1.0.0.dev6}/src/dicom_dre/cli.py

@@ -17,6 +17,7 @@ import click
 
 from dicom_dre import __version__
 from dicom_dre import deidentify_paths
+from dicom_dre import jpeg_dct_accelerator_available
 from dicom_dre.batch import OutputPathCollisionError
 from dicom_dre.batch import ProfileSpec
 from dicom_dre.parameters import DeidParameters
@@ -220,6 +221,21 @@ def deidentify(
         raise SystemExit(1)
 
 
+@cli.command(name="accelerator-status", short_help="Report JPEG DCT C accelerator status.")
+def accelerator_status() -> None:
+    """Report whether the JPEG DCT C accelerator is active.
+
+    Prints a human-readable status line and sets the process exit code: ``0``
+    when the accelerator is active, ``1`` when the pure-Python fallback is in
+    use. Usable in CI and health checks.
+    """
+    if jpeg_dct_accelerator_available():
+        click.echo("JPEG DCT C accelerator: ACTIVE")
+        return
+    click.echo("JPEG DCT C accelerator: NOT AVAILABLE (using pure-Python fallback, ~300x slower)")
+    raise SystemExit(1)
+
+
 def _resolve_allowlist_path(allowlist: str) -> Path:
     """Resolve an allowlist filename or absolute path to a concrete Path.
 

{dicom_dre-1.0.0.dev4 → dicom_dre-1.0.0.dev6}/src/dicom_dre/jpeg_dct_scrubber.py

@@ -68,6 +68,7 @@ Acknowledgements:
 import io
 import logging
 import struct
+import sys
 import warnings
 from typing import TYPE_CHECKING
 
@@ -103,6 +104,39 @@ except ImportError:
     )
 
 
+def jpeg_dct_accelerator_available() -> bool:
+    """Report whether the JPEG DCT C accelerator is active.
+
+    Returns the effective runtime state used by the scrubber to select the fast
+    path. When ``False`` the pure-Python entropy codec fallback is used, which
+    is roughly 300x slower.
+
+    This function is import-safe and side-effect-free: it does not raise and
+    does not re-emit the missing-extension warning.
+
+    Returns:
+        ``True`` if the compiled ``_jpeg_dct_accel`` extension is loaded and in
+        use, ``False`` if the pure-Python fallback is active.
+    """
+    return _HAS_C_ACCEL
+
+
+def jpeg_dct_accelerator_info() -> dict[str, object]:
+    """Return diagnostic details about the JPEG DCT C accelerator.
+
+    Returns:
+        A mapping with at least the key ``"available"`` (``bool``). When the
+        accelerator is loaded, ``"path"`` holds the extension module file path
+        if it can be determined.
+    """
+    info: dict[str, object] = {"available": _HAS_C_ACCEL}
+    if _HAS_C_ACCEL:
+        module_file = getattr(sys.modules.get("dicom_dre._jpeg_dct_accel"), "__file__", None)
+        if module_file is not None:
+            info["path"] = module_file
+    return info
+
+
 # JPEG markers
 SOI = 0xFFD8
 EOI = 0xFFD9

{dicom_dre-1.0.0.dev4 → dicom_dre-1.0.0.dev6}/tests/unit/test_cli.py

@@ -309,3 +309,28 @@ def test_redactor_allow_token(tmp_path: Path) -> None:
     assert "Added 1 token" in result.output
     contents = allowlist.read_text(encoding="utf-8")
     assert "abdomen" in contents, "New token should be written to the allowlist"
+
+
+def test_accelerator_status_active(monkeypatch) -> None:
+    """The command reports ACTIVE and exits 0 when the accelerator is present."""
+    from dicom_dre import cli as cli_module
+
+    monkeypatch.setattr(cli_module, "jpeg_dct_accelerator_available", lambda: True)
+    runner = CliRunner()
+    result = runner.invoke(cli, ["accelerator-status"])
+
+    assert result.exit_code == 0, f"Expected exit code 0 when active, got {result.exit_code}: {result.output}"
+    assert "JPEG DCT C accelerator: ACTIVE" in result.output, f"Expected ACTIVE line, got: {result.output!r}"
+
+
+def test_accelerator_status_fallback(monkeypatch) -> None:
+    """The command reports the fallback and exits non-zero when absent."""
+    from dicom_dre import cli as cli_module
+
+    monkeypatch.setattr(cli_module, "jpeg_dct_accelerator_available", lambda: False)
+    runner = CliRunner()
+    result = runner.invoke(cli, ["accelerator-status"])
+
+    assert result.exit_code == 1, f"Expected exit code 1 on fallback, got {result.exit_code}: {result.output}"
+    assert "NOT AVAILABLE" in result.output, f"Expected NOT AVAILABLE, got: {result.output!r}"
+    assert "pure-Python fallback" in result.output, f"Expected fallback note, got: {result.output!r}"

dicom_dre-1.0.0.dev6/tests/unit/test_public_api.py

@@ -0,0 +1,94 @@
+"""Tests for the stable top-level public API exports."""
+
+import dicom_dre
+
+
+def test_public_names_importable_from_package_root():
+    """The three promoted symbols are importable from the package root."""
+    from dicom_dre import DATE_TAGS
+    from dicom_dre import UID_TAGS
+    from dicom_dre import correct_implicit_vr_elements
+
+    assert callable(correct_implicit_vr_elements)
+    assert isinstance(DATE_TAGS, frozenset)
+    assert isinstance(UID_TAGS, frozenset)
+
+
+def test_tag_set_membership_unchanged():
+    """DATE_TAGS and UID_TAGS retain their published sizes."""
+    assert len(dicom_dre.DATE_TAGS) == 28
+    assert len(dicom_dre.UID_TAGS) == 35
+
+
+def test_private_alias_identity_holds():
+    """The underscore alias resolves to the same public function object."""
+    assert dicom_dre.correct_implicit_vr_elements is dicom_dre.profile._correct_implicit_vr_elements
+
+
+def test_public_names_in_all():
+    """All three names are advertised in the package __all__."""
+    assert "DATE_TAGS" in dicom_dre.__all__
+    assert "UID_TAGS" in dicom_dre.__all__
+    assert "correct_implicit_vr_elements" in dicom_dre.__all__
+
+
+def test_accelerator_functions_in_all():
+    """The accelerator status helpers are advertised in __all__."""
+    assert "jpeg_dct_accelerator_available" in dicom_dre.__all__, "jpeg_dct_accelerator_available should be in __all__"
+    assert "jpeg_dct_accelerator_info" in dicom_dre.__all__, "jpeg_dct_accelerator_info should be in __all__"
+
+
+def test_accelerator_available_importable_from_root():
+    """jpeg_dct_accelerator_available is importable from the package root."""
+    from dicom_dre import jpeg_dct_accelerator_available
+
+    assert isinstance(jpeg_dct_accelerator_available(), bool), (
+        f"Expected bool, got {type(jpeg_dct_accelerator_available())}"
+    )
+
+
+def test_accelerator_available_reflects_runtime_flag():
+    """The function returns the effective runtime accelerator flag."""
+    from dicom_dre import jpeg_dct_accelerator_available
+    from dicom_dre import jpeg_dct_scrubber
+
+    assert jpeg_dct_accelerator_available() is jpeg_dct_scrubber._HAS_C_ACCEL, (
+        "Function should return the same value the scrubber uses (_HAS_C_ACCEL)"
+    )
+
+
+def test_accelerator_available_true(monkeypatch):
+    """When the extension flag is set, the function reports True."""
+    from dicom_dre import jpeg_dct_accelerator_available
+    from dicom_dre import jpeg_dct_scrubber
+
+    monkeypatch.setattr(jpeg_dct_scrubber, "_HAS_C_ACCEL", True)
+    assert jpeg_dct_accelerator_available() is True, "Expected True when _HAS_C_ACCEL is True"
+
+
+def test_accelerator_available_false(monkeypatch):
+    """When the extension flag is unset, the function reports False."""
+    from dicom_dre import jpeg_dct_accelerator_available
+    from dicom_dre import jpeg_dct_scrubber
+
+    monkeypatch.setattr(jpeg_dct_scrubber, "_HAS_C_ACCEL", False)
+    assert jpeg_dct_accelerator_available() is False, "Expected False when _HAS_C_ACCEL is False"
+
+
+def test_accelerator_info_available_key():
+    """jpeg_dct_accelerator_info reports a boolean availability key."""
+    from dicom_dre import jpeg_dct_accelerator_info
+
+    info = jpeg_dct_accelerator_info()
+    assert isinstance(info["available"], bool), f"Expected bool for 'available', got {type(info['available'])}"
+
+
+def test_accelerator_info_absent_has_no_path(monkeypatch):
+    """When the accelerator is absent, no extension path is reported."""
+    from dicom_dre import jpeg_dct_accelerator_info
+    from dicom_dre import jpeg_dct_scrubber
+
+    monkeypatch.setattr(jpeg_dct_scrubber, "_HAS_C_ACCEL", False)
+    info = jpeg_dct_accelerator_info()
+    assert info["available"] is False, "Expected available False when _HAS_C_ACCEL is False"
+    assert "path" not in info, f"Expected no 'path' key when absent, got {info}"

dicom_dre-1.0.0.dev4/tests/unit/test_public_api.py

@@ -1,32 +0,0 @@
-"""Tests for the stable top-level public API exports."""
-
-import dicom_dre
-
-
-def test_public_names_importable_from_package_root():
-    """The three promoted symbols are importable from the package root."""
-    from dicom_dre import DATE_TAGS
-    from dicom_dre import UID_TAGS
-    from dicom_dre import correct_implicit_vr_elements
-
-    assert callable(correct_implicit_vr_elements)
-    assert isinstance(DATE_TAGS, frozenset)
-    assert isinstance(UID_TAGS, frozenset)
-
-
-def test_tag_set_membership_unchanged():
-    """DATE_TAGS and UID_TAGS retain their published sizes."""
-    assert len(dicom_dre.DATE_TAGS) == 28
-    assert len(dicom_dre.UID_TAGS) == 35
-
-
-def test_private_alias_identity_holds():
-    """The underscore alias resolves to the same public function object."""
-    assert dicom_dre.correct_implicit_vr_elements is dicom_dre.profile._correct_implicit_vr_elements
-
-
-def test_public_names_in_all():
-    """All three names are advertised in the package __all__."""
-    assert "DATE_TAGS" in dicom_dre.__all__
-    assert "UID_TAGS" in dicom_dre.__all__
-    assert "correct_implicit_vr_elements" in dicom_dre.__all__