dicom-dre 1.0.0.dev1__tar.gz

dicom_dre-1.0.0.dev1/.devcontainer/devcontainer-lock.json

@@ -0,0 +1,24 @@
+{
+  "features": {
+    "ghcr.io/devcontainers-extra/features/apt-packages:1": {
+      "version": "1.0.6",
+      "resolved": "ghcr.io/devcontainers-extra/features/apt-packages@sha256:55c54412112da81b9381e470cdbbe55278564950d1ff536ce925b1e8e096babd",
+      "integrity": "sha256:55c54412112da81b9381e470cdbbe55278564950d1ff536ce925b1e8e096babd"
+    },
+    "ghcr.io/devcontainers/features/common-utils:2": {
+      "version": "2.5.9",
+      "resolved": "ghcr.io/devcontainers/features/common-utils@sha256:cb0c4d3c276f157eed17935747e364178d75fee17f55c4e129966f64633deb3a",
+      "integrity": "sha256:cb0c4d3c276f157eed17935747e364178d75fee17f55c4e129966f64633deb3a"
+    },
+    "ghcr.io/devcontainers/features/github-cli:1": {
+      "version": "1.1.0",
+      "resolved": "ghcr.io/devcontainers/features/github-cli@sha256:d22f50b70ed75339b4eed1ba9ecde3a1791f90e88d37936517e3bace0bbad671",
+      "integrity": "sha256:d22f50b70ed75339b4eed1ba9ecde3a1791f90e88d37936517e3bace0bbad671"
+    },
+    "ghcr.io/jsburckhardt/devcontainer-features/uv:1": {
+      "version": "1.0.0",
+      "resolved": "ghcr.io/jsburckhardt/devcontainer-features/uv@sha256:542a0bc2203205b3c696de650ba862f280b20af3543493cc232edd9ac35791f7",
+      "integrity": "sha256:542a0bc2203205b3c696de650ba862f280b20af3543493cc232edd9ac35791f7"
+    }
+  }
+}

dicom_dre-1.0.0.dev1/.devcontainer/devcontainer.json

@@ -0,0 +1,48 @@
+// For format details, see https://aka.ms/devcontainer.json. For config options, see the README at:
+// https://containers.dev/
+{
+  "name": "dicom-dre",
+  "image": "python:3.12-slim-trixie",
+  "remoteUser": "${localEnv:USER}${localEnv:USERNAME}",
+  "containerEnv": {
+    "UV_COMPILE_BYTECODE": "1",
+    "UV_LINK_MODE": "copy",
+    "UV_PYTHON_DOWNLOADS": "never",
+    "UV_TOOL_BIN_DIR": "/usr/local/bin"
+  },
+  "customizations": {
+    "vscode": {
+      "settings": {
+        "python.defaultInterpreterPath": "${workspaceFolder}/.venv/bin/python",
+        "extensions.verifySignature": false, // https://github.com/microsoft/vscode-remote-release/issues/9628
+        "remote.autoForwardPorts": false,
+        "extensions.ignoreRecommendations": true
+      },
+      "extensions": [
+        "bierner.markdown-mermaid",
+        "charliermarsh.ruff",
+        "GitHub.copilot",
+        "GitHub.vscode-pull-request-github",
+        "ms-python.python",
+        "meta.pyrefly",
+        "redhat.vscode-yaml"
+      ]
+    }
+  },
+  "features": {
+    "ghcr.io/devcontainers/features/common-utils:2": {
+      "username": "${localEnv:USER}${localEnv:USERNAME}",
+      "userUid": "1000",
+      "userGid": "1000",
+      "upgradePackages": "false",
+      "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"
+    },
+    "ghcr.io/jsburckhardt/devcontainer-features/uv:1": {},
+    "ghcr.io/devcontainers/features/github-cli:1": {}
+  },
+  "postCreateCommand": "bash ./.devcontainer/post-create.sh",
+  "waitFor": "postCreateCommand"
+}

dicom_dre-1.0.0.dev1/.devcontainer/post-create.sh

@@ -0,0 +1,34 @@
+#!/bin/bash
+set -euo pipefail
+
+WORKSPACE_DIR="$(pwd)"
+
+BLUE='\033[0;34m'
+NC='\033[0m'
+
+# Git doesn't like the UID changes from bind-mounting the source into the container.
+if ! git config --global --get-all safe.directory | grep -qx "${WORKSPACE_DIR}"; then
+  git config --global --add safe.directory "${WORKSPACE_DIR}"
+fi
+
+# Convenience aliases.
+if ! grep -q "#dicom-dre#" "${HOME}/.bashrc" 2>/dev/null; then
+  {
+    echo '#dicom-dre#'
+    echo 'alias ll="ls -alF"'
+    echo 'alias la="ls -A"'
+    echo 'alias l="ls -CF"'
+  } >> "${HOME}/.bashrc"
+fi
+
+# Sync dependencies and build the CFFI JPEG-DCT extension (and python-gdcm from source).
+echo -e "${BLUE}Running uv sync...${NC}"
+uv sync
+
+# Compile the CFFI JPEG-DCT acceleration extension into src/dicom_dre/.
+# Without this the engine silently falls back to the ~300x-slower pure-Python
+# entropy codec. Building from src/ so the module 'dicom_dre._jpeg_dct_accel'
+# lands at src/dicom_dre/_jpeg_dct_accel.*.so.
+echo -e "${BLUE}Compiling JPEG-DCT acceleration extension...${NC}"
+(cd src && uv run python -m dicom_dre._jpeg_dct_accel_build)
+rm -f src/dicom_dre/_jpeg_dct_accel.c src/dicom_dre/_jpeg_dct_accel.o

dicom_dre-1.0.0.dev1/.github/copilot-instructions.md

@@ -0,0 +1,232 @@
+COPILOT INSTRUCTIONS
+
+This document defines how the AI pair programmer should reason, communicate, and write code.
+It sets style rules, workflow expectations, and interaction guidelines to ensure consistent,
+high-quality, and safe contributions.
+
+CORE DIRECTIVE
+You are an expert AI pair programmer.
+Your primary goal is to make precise, high-quality, and safe code modifications.
+Follow every rule in this document meticulously.
+
+INTERACTION & REASONING GUIDELINES
+
+- Concise communication:
+  Use one clear sentence before each tool call to explain what you are doing.
+
+- Continuity:
+  If the user says "resume" or "continue", pick up exactly where your last step ended.
+
+- Thorough thinking:
+  Think rigorously and document reasoning internally.
+  Share only concise results externally.
+
+- Communication style:
+  Use factual, descriptive language in the style of internal engineering specifications.
+  Never use marketing terms (efficient, compelling, comprehensively, effectively, successfully).
+  Never use promotional adjectives (comprehensive, robust, powerful, optimized, seamless, flexible, scalable, intuitive, advanced, cutting-edge).
+  Never use enthusiastic phrases (Perfect! Excellent! Great! Awesome! I have successfully...).
+  Avoid evaluative or subjective judgments.
+  Prefer verbs and concrete nouns over adjectives.
+  Omit unverifiable or unquantifiable claims.
+  Provide factual summaries that describe actions and results without celebration.
+  When uncertain if a word is promotional, omit it.
+  Do not use emphatic markers (CRITICAL, IMPORTANT, WARNING) in code comments or documentation unless explicitly requested by the user.
+
+- File creation:
+  Do not create summary documentation unless explicitly requested.
+  Do not create test files without asking first.
+  Only create files directly required to fulfill the user's request.
+
+- Error checking:
+  After making any code changes, automatically check for linter errors using get_errors.
+  Fix all errors before reporting completion.
+  Never wait for the user to point out linter errors.
+
+CODING STANDARDS
+General Rule:
+
+- Implement the smallest possible change that satisfies the request.
+- Follow the Google Python coding standards except when they conflict with this document.
+- Do not create trailing whitespace, and immediately remove trailing whitespace when found.
+- Avoid spaces in empty lines.
+- Avoid the use of emojis in log messages or documentation.
+
+Naming Conventions:
+
+- Modules: lowercase_with_underscores
+- Classes: CapWords
+- Functions & variables: lowercase_with_underscores
+- Constants: UPPERCASE_WITH_UNDERSCORES
+- Private members: prefix with \_
+
+Strings:
+
+- Prefer double quotes ("...")
+- Use triple quotes ("""...""") for docstrings
+
+Error Handling:
+
+- CRITICAL: Never use assert statements for runtime validation
+- Assert statements are removed in optimized byte code compilation
+- Use explicit ValueError, TypeError, or other appropriate exceptions instead
+- Provide clear, descriptive error messages
+
+Example:
+# Wrong
+assert value is not None
+assert len(items) > 0
+
+# Correct
+if value is None:
+    raise ValueError("value must not be None")
+if len(items) == 0:
+    raise ValueError("items list cannot be empty")
+
+IMPORTS
+
+Rules:
+
+- All imports must be at the top of the file
+- Only use inline imports when necessary for performance or to avoid circular import issues
+- One import per line
+- Order: standard library -> third-party -> local
+- Always use absolute imports, inside **init**.py is ok
+- Avoid importing Prefect functions and modules in a file that does not contain @task and @flow functions.
+
+PACKAGE RESOURCES
+
+- Use importlib.resources, never Path(__file__).parent
+- Pattern: import importlib.resources as pkg_resources, then Path(str(pkg_resources.files(resource_module)))
+
+DOCSTRINGS & COMMENTS
+
+- Follow PEP 257
+- First line: short summary sentence
+- Document all public classes, methods, and functions
+- Never write obvious comments that simply restate what the code does
+
+Example:
+def add(x: int, y: int) -> int:
+    """Return the sum of x and y."""
+    return x + y
+
+TYPE ANNOTATIONS
+
+- Use PEP 484 type hints
+- Forward-declare types with TYPE_CHECKING if needed
+- Use quoted annotations ("State") when types are not available at runtime
+
+DATACLASSES
+
+- Fields with default values MUST come after fields without defaults
+- Order fields: required fields first, then optional/default fields
+- Use field(default=...) or field(default_factory=...) for fields with defaults
+- Never mix required and default fields in arbitrary order
+
+Example:
+@dataclass
+class MyClass:
+    # Required fields first
+    name: str
+    age: int
+    # Default fields last
+    status: str = "active"
+    tags: List[str] = field(default_factory=list)
+
+TESTING
+
+- Run tests using `uv run pytest` (NEVER `python -m pytest`)
+- Place tests in tests/ using pytest
+- Mock external services in unit tests especially if they use network calls
+- Prefer small, isolated tests over broad coverage in a single test
+- Avoid disabling, skipping, or commenting out failing unit tests. If a unit test fails, fix the root cause of the exception.
+- Avoid removing assertions, adding empty try/catch blocks, or making tests trivial in order to make tests pass.
+- Avoid introducing conditional logic that skips test cases under certain conditions, for example a missing dependency.
+- Always ensure the unit test continues to properly validate the intended functionality.
+
+DOCUMENTATION
+
+- When making changes to workflows, always update the corresponding documentation in the docs/ folder
+- Keep workflow documentation synchronized with code changes
+- Update relevant .md files in docs/workflows/ when modifying flow implementations
+- When adding CLI documentation, verify all commands and options against actual --help output
+- When adding new documentation files, add them to the `nav` section in mkdocs.yml
+
+CLI REGISTRATION
+
+- When creating new CLI commands, always register them in src/dicom_dre/cli.py
+- Add the new command or command group to the `cli` group following the pattern of existing subcommands
+- Group related subcommands under a click group (as done for the redactor subgroup)
+
+PYTHON PACKAGE MANAGEMENT
+
+- Always use `uv` instead of `pip` for all package management operations
+- Installation: `uv pip install <package>`
+- Editable install: `uv pip install -e .`
+- Multiple packages: `uv pip install package1 package2`
+- Upgrading packages: `uv add package_name>=package_version --upgrade-package package_name`
+- Never use bare `pip` commands
+- `uv` is faster and more reliable than pip for this project
+
+SAFETY & ERROR HANDLING
+
+- Never suggest destructive commands without confirmation
+- Validate API usage against latest documentation
+- Do not expose secrets, credentials, or tokens in code
+
+PHI PROTECTION
+
+This project processes medical imaging data. Protected Health Information (PHI) must never
+be transmitted to external services, including MCP servers configured in .vscode/mcp.json.
+
+- Never include PHI in tool queries sent to external MCP servers
+- PHI includes: patient names, MRNs, accession numbers, dates of birth, addresses,
+  phone numbers, Social Security numbers, and any other HIPAA-defined identifiers
+- When formulating search queries for external documentation servers, use generic
+  placeholders (e.g., "accession number" instead of an actual value)
+- If the user pastes PHI in the chat, do not echo it in tool queries
+- Safe test values: The accession numbers "TEST" and "TESTING" exist on the server
+  and contain no PHI. These are safe to use in examples and testing.
+
+GIT
+
+- Avoid suggesting git commands that modify history (rebase, reset, amend) without explicit user confirmation.
+
+COMMIT MESSAGES
+
+Use Conventional Commits format for all commit messages. This format is parsed by
+python-semantic-release to determine version bumps automatically.
+
+Format: <type>[optional scope]: <description>
+
+Types that trigger releases:
+- feat: A new feature (triggers MINOR version bump, e.g., 1.0.0 -> 1.1.0)
+- fix: A bug fix (triggers PATCH version bump, e.g., 1.0.0 -> 1.0.1)
+- perf: A performance improvement (triggers PATCH version bump)
+
+Types that do NOT trigger releases:
+- chore: Maintenance tasks, dependency updates
+- docs: Documentation changes
+- refactor: Code refactoring without behavior change
+- style: Formatting, whitespace changes
+- test: Adding or updating tests
+- ci: CI/CD configuration changes
+- build: Build system changes
+
+Breaking changes (trigger MAJOR version bump, e.g., 1.0.0 -> 2.0.0):
+- Add ! after type: feat!: remove deprecated API
+- Or add BREAKING CHANGE: footer in commit body
+
+Examples:
+- feat: add new DICOM anonymization option
+- fix(pipeline): handle missing patient ID gracefully
+- docs: update workflow documentation
+- feat!: change CLI argument format
+- fix: resolve memory leak in image processing
+
+  BREAKING CHANGE: The --format flag now requires explicit value
+
+FINALLY
+
+Provide short, concise summaries without the use of emoji when completing a large task.

dicom_dre-1.0.0.dev1/.github/instructions/dicom-io.instructions.md

@@ -0,0 +1,25 @@
+---
+description: Reading and writing DICOM with pydicom
+applyTo: "src/dicom_dre/**/*.py"
+---
+
+# DICOM I/O Conventions
+
+## Process-wide pydicom config
+
+Any module that reads or writes DICOM with pydicom (`dcmread`, `dcmwrite`,
+`save_as`, `Dataset` I/O) depends on the global settings in
+`dicom_dre.pydicom_config`, which make reads tolerant of malformed
+production data.
+
+- The settings are process-global: one import applies them everywhere, so the
+  import only has to run before the first read or write in the process.
+- Add the side-effect import to any new DICOM reader/writer whose module (or its
+  import chain) does not already reach it:
+
+  ```python
+  import dicom_dre.pydicom_config  # noqa: F401  applies process-wide pydicom config
+  ```
+
+- Modules that import the pipeline (`dicom_dre.pipeline`) or an anonymizer entry
+  module already inherit it transitively and do not need the direct import.

dicom_dre-1.0.0.dev1/.github/instructions/tests.instructions.md

@@ -0,0 +1,314 @@
+---
+description: Writing tests in tests/unit/
+applyTo: "tests/**/*.py"
+---
+
+# Writing Tests in dicom-dre
+
+Instructions for creating and maintaining tests in the `tests/` directory.
+
+## Test Structure
+
+All tests live in `tests/unit/` and mirror the `src/dicom_dre/` module structure:
+
+```
+tests/
+├── conftest.py          # Root config: GDCM/ARM64 segfault guard (pytest_configure)
+└── unit/
+    ├── conftest.py      # Shared fixtures: synthetic GE SIGNA Premier MR dataset
+    ├── test_catalog.py
+    ├── test_cli.py
+    ├── test_default_catalog.py
+    ├── test_jpeg_dct_anonymizer.py
+    ├── test_pipeline_preservation.py
+    ├── test_pixel_blanker.py
+    ├── test_profile.py
+    └── test_text_redactor.py
+```
+
+## Placing New Tests
+
+All new tests go in `tests/unit/`. They must use only mocks, `tmp_path`, pure Python
+logic, or `pydicom` test data — no network calls, no cloud services, no external
+processes. For example, a test for `src/dicom_dre/catalog.py` belongs at
+`tests/unit/test_catalog.py`.
+
+## Test Framework
+
+Use pytest for all tests. Configuration is in `pyproject.toml`:
+
+- Test timeout: 90 seconds (configurable per test with `@pytest.mark.timeout`)
+- Coverage requirement: 20% minimum
+
+## GDCM / ARM64 Import Note
+
+`python-gdcm` (SWIG bindings) can segfault on ARM64 if loaded during pytest's
+assertion-rewriting phase. The root `conftest.py` imports `pydicom` in
+`pytest_configure` to trigger GDCM loading before collection begins. To stay
+safe, import `pydicom` inside test functions or fixtures rather than at module
+level in test files.
+
+## File Naming Conventions
+
+- Test files: `test_*.py`
+- Benchmark files: `bench_*.py`
+- Test functions: `test_*`
+- Benchmark functions: `bench_*`
+
+## Test Class Organization
+
+Group related tests in classes with descriptive names:
+
+```python
+"""Tests for the device catalog lookup."""
+
+import pytest
+
+from dicom_dre.catalog import DeviceCatalog
+from dicom_dre.catalog import CatalogDecision
+
+
+class TestDeviceCatalogLookup:
+    """Test device catalog manufacturer/model matching."""
+
+    def test_known_device_returns_decision(self):
+        """A known manufacturer/model pair returns a catalog decision."""
+        catalog = DeviceCatalog.from_default()
+        decision = catalog.lookup("GE MEDICAL SYSTEMS", "SIGNA Premier")
+        assert decision is not None, "Known device should return a decision"
+
+    def test_unknown_device_returns_none(self):
+        """An unrecognised manufacturer/model pair returns None."""
+        catalog = DeviceCatalog.from_default()
+        decision = catalog.lookup("UNKNOWN_MFR", "UNKNOWN_MODEL")
+        assert decision is None, "Unknown device should return None"
+```
+
+## Docstrings
+
+- Module docstring: Describe what is being tested
+- Class docstring: Describe the test suite purpose
+- Test function docstring: Describe the expected behavior being validated
+- Use present tense and be specific about what is being tested
+- Avoid vague descriptions like "Test validation" or wordy phrases like "This test validates..."
+
+## Temporary Files and Directories
+
+**CRITICAL**: Always use pytest's `tmp_path` fixture. Never use hardcoded paths like `/tmp/test.dcm` or `Path.home()`.
+
+```python
+def test_operation(tmp_path):
+    """Test with temporary files."""
+    input_file = tmp_path / "test.dcm"
+    output_dir = tmp_path / "output"
+    output_dir.mkdir()
+    # tmp_path is automatically cleaned up after the test
+```
+
+For custom fixtures, use `tempfile.mkdtemp()`:
+
+```python
+@pytest.fixture
+def temp_dir():
+    """Create a temporary directory for test files."""
+    temp_path = Path(tempfile.mkdtemp())
+    yield temp_path
+    shutil.rmtree(temp_path, ignore_errors=True)
+```
+
+## Mocking External Services
+
+Mock any calls that cross a process boundary (file I/O to real paths, network calls).
+
+```python
+from unittest.mock import Mock, patch
+
+def test_with_mock():
+    """Test with mocked external service."""
+    mock_client = Mock()
+    mock_client.download.return_value = b"test data"
+
+    with patch("module.get_client", return_value=mock_client):
+        result = function_that_uses_client()
+        assert result is not None, "Result should not be None"
+```
+
+## Environment Variables in Tests
+
+Use `monkeypatch.setenv()` and `monkeypatch.delenv()` to set and clear environment
+variables. Never use `os.environ` directly in tests or fixtures, as it leaks state
+across tests.
+
+```python
+def test_requires_env_var(monkeypatch):
+    """Test behavior when environment variable is set."""
+    monkeypatch.setenv("SECRET_KEY", "test-secret-key")
+    result = load_config()
+    assert result.secret_key == "test-secret-key", "Config should read SECRET_KEY"
+
+
+def test_missing_env_var(monkeypatch):
+    """Test behavior when environment variable is absent."""
+    monkeypatch.delenv("DATABASE_URL", raising=False)
+    with pytest.raises(ValueError, match="DATABASE_URL"):
+        load_config()
+```
+
+## Session-Scoped Temporary Directories
+
+For session-scoped fixtures that need a temporary directory, use `tmp_path_factory`:
+
+```python
+@pytest.fixture(scope="session")
+def shared_output_dir(tmp_path_factory):
+    """Shared output directory for session-scoped tests."""
+    return tmp_path_factory.mktemp("output")
+```
+
+## Testing with Real Data
+
+### Using pydicom Test Data
+
+Use pydicom test data for DICOM file tests:
+
+```python
+from pathlib import Path
+from pydicom.data import get_testdata_file
+
+def test_dicom_processing(tmp_path):
+    """Test DICOM file processing."""
+    input_file_str = get_testdata_file("CT_small.dcm")
+    if not isinstance(input_file_str, str):
+        raise ValueError("get_testdata_file did not return a string path")
+
+    source_file = Path(input_file_str)
+    test_file = tmp_path / "test.dcm"
+    shutil.copy2(source_file, test_file)
+
+    result = process_dicom(test_file)
+    assert result is not None
+```
+
+**Important**: Do not skip tests if pydicom is not available. All project dependencies (including pydicom) are listed in `pyproject.toml` and must be present. If a test cannot import pydicom, the test should **fail**, not skip. This ensures the development environment is correctly set up.
+
+### Assertions
+
+**EVERY assertion MUST include a message.** Never write bare `assert` statements without explanatory text. Include expected and actual values in assertion messages to make test failures immediately understandable.
+
+```python
+# Correct - always include messages
+assert result.success is True, "Operation should succeed"
+assert len(items) == 3, f"Expected 3 items, got {len(items)}"
+assert status.used_percent == 50.0, f"Expected 50.0%, got {status.used_percent}"
+
+# Wrong - bare assertions without messages
+assert result.success is True  # NO - missing message
+assert len(items) == 3  # NO - missing message
+
+# Testing exceptions - use match parameter or check exc_info
+def test_invalid_input_raises_error():
+    """Invalid input raises ValueError."""
+    with pytest.raises(ValueError, match="cannot be None"):
+        validate_input(None)
+
+    # Or with exc_info for more complex checks
+    with pytest.raises(ValueError) as exc_info:
+        validate_input(None)
+    assert "cannot be None" in str(exc_info.value), f"Expected 'cannot be None' in error, got {exc_info.value}"
+
+# Testing optional values - use explicit None checks
+assert result.output_file is None, "No output file should be created"
+```
+
+### Test Isolation
+
+Each test must be independent. Never share state between tests.
+
+```python
+def test_operation(tmp_path):
+    """Test operation with fresh data."""
+    input_file = tmp_path / "input.txt"
+    input_file.write_text("test data")
+    result = process_file(input_file)
+    assert result.success
+
+# Use fixtures for setup/teardown
+@pytest.fixture
+def test_database():
+    """Set up test database."""
+    db = create_test_db()
+    yield db
+    db.cleanup()
+
+def test_with_database(test_database):
+    """Test with isolated database."""
+    test_database.insert(record)
+    assert test_database.count() == 1
+
+### Maintain Test Integrity
+
+If a test fails, fix the root cause in the code or the test. Do not remove assertions, add empty try/catch blocks to hide errors, or add conditional logic to skip test cases. Never skip or disable failing tests. Tests must fail (not skip) when dependencies are missing.
+
+### Parametrized Tests
+
+Test multiple inputs efficiently:
+
+```python
+@pytest.mark.parametrize("method,expected", [
+    ("equals", True),
+    ("contains", True),
+    ("startsWith", True),
+    ("invalid_method", False),
+])
+def test_method_validation(method, expected):
+    """Test method name validation."""
+    result = is_valid_method(method)
+    assert result == expected
+```
+
+### Testing Time-Dependent Code
+
+```python
+from unittest.mock import patch
+from datetime import datetime
+
+def test_timestamp_logic():
+    """Test time-dependent logic with fixed time."""
+    fixed_time = datetime(2024, 1, 1, 12, 0, 0)
+    with patch("module.datetime") as mock_datetime:
+        mock_datetime.now.return_value = fixed_time
+        result = function_using_current_time()
+        assert result.timestamp == fixed_time
+```
+
+## Running Tests
+
+```bash
+# Run the full test suite
+just test
+
+# Run tests with coverage report
+just cov
+
+# Run a single test file
+just test-one tests/unit/test_pipeline_preservation.py
+
+# Verify the pure-Python fallback (without compiled C extension)
+just test-fallback
+```
+
+## PHI Protection
+
+Never use real PHI in tests. Use the synthetic `signa_premier_file` fixture from
+`tests/unit/conftest.py` or pydicom's built-in test files. Never commit test files
+containing real patient data.
+
+## Common Anti-patterns
+
+Never use hardcoded paths like `Path("/tmp/test.dcm")`. Always use `tmp_path` for
+temporary files. Never skip failing tests or remove assertions to make tests pass.
+Tests must fail (not skip) when dependencies are missing. Do not share state between
+tests using global variables. Do not comment out failing assertions or catch
+exceptions to hide failures. Keep all dependencies in `pyproject.toml`. **Never
+write bare assertions without messages** — every `assert` statement must include an
+explanatory message with expected and actual values.