fctpd 0.2.5__1-py3-none-any.whl

fctpd/__init__.py

@@ -0,0 +1,14 @@
+from . import fetch, fields
+from .enums import AnonymizationLevel, PixelEncoding
+from .headers import (
+    marshal,
+    set_projection_uris,
+    unmarshal,
+    FileHeader,
+    ProjectionHeader,
+)
+from .options import WriteOptions
+from .projection import Projection
+from .readers import FPBReader, FPHReader
+from .sensitive import set_sensitive_fields
+from .writers import FPBWriter, FPHWriter

fctpd/enums.py

@@ -0,0 +1,20 @@
+from enum import Enum
+
+
+class AnonymizationLevel(Enum):
+    """
+    AnonymizationLevel describes how a Reader or Writer should treat
+    the sensitive entry collection.
+    """
+
+    High = 0
+    Low = 2
+
+
+class PixelEncoding(Enum):
+    """
+    PixelEncoding describes how a Writer should serialize pixel data.
+    """
+
+    F32 = 0
+    U16 = 1

fctpd/fetch.py

@@ -0,0 +1,142 @@
+from io import BufferedIOBase
+from msgspec import Struct
+from os import path
+from requests import get, Response
+from urllib.parse import urlparse, ParseResult
+
+
+class URIValue(Struct, omit_defaults=True):
+    """
+    URIValue is a container representing a URI-addressed value
+    from the FPB/FPH specification.
+
+    Fields
+    ------
+    - URI (str): URI referencing the underlying data.
+    - ByteOffset (int | None): File offset to the underlying data.
+    - ByteRange (int | None): Length of the underlying data in bytes.
+    """
+
+    URI: str
+    ByteOffset: int | None = None
+    ByteRange: int | None = None
+
+
+class SelfValue(Struct, omit_defaults=True):
+    """
+    SelfValue is a container representing the file-schemed value
+    from the FPB specification.
+
+    Fields
+    ------
+    - Offset (int): File offset to the underlying data.
+    - Range (int | None): Length of the underlying data in bytes.
+    """
+
+    Offset: int
+    Range: int | None
+
+
+def fetch(val: URIValue) -> bytes | SelfValue:
+    """
+    Fetch URI-linked data from an input value.
+
+    Parameters
+    ----------
+    - val (URIValue): Value to parse.
+
+    Returns
+    -------
+    - data (bytes | SelfValue): Data linked by the value.
+    """
+
+    # Retrieve fields from the value
+    uri: str = val.URI
+    offset: int = val.ByteOffset if val.ByteOffset is not None else 0
+    rng: int | None = val.ByteRange
+
+    # Validate whether the URI is valid
+    uri_parse: ParseResult = urlparse(uri)
+    if not uri_parse.scheme:
+        raise ValueError("invalid URI-addressed value: URI is invalid")
+
+    # Match on the scheme
+    match uri_parse.scheme:
+        case "file":
+            return _fetch_file(uri_parse.path, offset, rng)
+
+        case "http" | "https":
+            return _fetch_http(uri, offset, rng)
+
+        case "self":
+            return SelfValue(offset, rng)
+
+        case _:
+            raise NotImplementedError(f"URI scheme {uri_parse.scheme} not supported")
+
+
+def _fetch_file(infile: str | BufferedIOBase, offset: int, rng: int | None) -> bytes:
+    """
+    Internal fetch function for local files. Returns bytes
+    corresponding to the specified range and offset.
+
+    Parameters
+    ----------
+    - infile (str | BufferedIOBase): Local file to data.
+    - offset (int): File byte offset to data.
+    - rng: (int | None): Size of byte data to read.
+    """
+
+    match infile:
+        case str():
+            # Check the path exists and is a file
+            if not path.exists(infile) or path.isdir(infile):
+                raise FileNotFoundError
+
+            # Adjust the range
+            rng = rng if rng is not None else path.getsize(infile)
+
+            # Load the file pointer into memory
+            with open(infile, "rb", buffering=0) as f:
+                f.seek(offset, 0)
+                data: bytes = f.read(rng)
+                f.close()
+
+        case BufferedIOBase():
+            # Adjust the range
+            if rng is None:
+                infile.seek(0, 0)
+                rng = infile.seek(0, 2)
+
+            # Load the file pointer into memory
+            infile.seek(offset, 0)
+            data: bytes = infile.read(rng)
+
+    return data
+
+
+def _fetch_http(uri: str, offset: int, rng: int | None) -> bytes:
+    """
+    Internal fetch function for HTTP/HTTPS. Returns bytes contained
+    in the corresponding the HTTP response body.
+
+    Parameters
+    ----------
+    - uri (str): HTTP-schemed URI to data.
+    - offset (int): File byte offset to data.
+    - rng: (int | None): Size of byte data to read.
+    """
+
+    # Get the range header
+    range_hdr: dict[str, str] = (
+        {"Range": f"bytes={offset}-"}
+        if rng is None
+        else {"Range": f"bytes={offset}-{offset+rng}"}
+    )
+
+    # Perform the request
+    resp: Response = get(uri, headers=range_hdr)
+    resp.raise_for_status()
+
+    # Return the response body
+    return resp.content

fctpd/fields.py

@@ -0,0 +1,212 @@
+# File IO fields
+ByteOffset: str = "ByteOffset"
+ByteRange: str = "ByteRange"
+URI: str = "URI"
+
+# Scanner fields
+Rows: str = "NumberOfRows"
+Channels: str = "NumberOfChannels"
+CollimatedSliceWidth: str = "CollimatedSliceWidth"
+CentralRow: str = "CentralRow"
+CentralChannel: str = "CentralChannel"
+AcquisitionFOV: str = "AcquisitionFOV"
+RowWidth: str = "RowWidth"
+ChannelWidth: str = "ChannelWidth"
+AnodeAngle: str = "AnodeAngle"
+Manufacturer: str = "Manufacturer"
+ScannerModel: str = "ScannerModel"
+DistanceSourceToIsocenter: str = "DistanceSourceToIsocenter"
+DistanceSourceToDetector: str = "DistanceSourceToDetector"
+Modality: str = "Modality"
+DetectorShape: str = "DetectorShape"
+CentralChannelOffset: str = "CentralChannelOffset"
+WedgeProfile: str = "WedgeProfile"
+
+# Acquisition fields
+TableSpeed: str = "TableSpeed"
+RotationTime: str = "RotationTime"
+ScanTime: str = "ScanTime"
+TableHeight: str = "TableHeight"
+TableFeedDirection: str = "TableFeedDirection"
+TubeAngleDirection: str = "TubeAngleDirection"
+FlyingFocalSpotMode: str = "FlyingFocalSpotMode"
+Exposure: str = "Exposure"
+ExposureNominal: str = "ExposureNominal"
+TubeVoltage: str = "TubeVoltage"
+CTDIvol: str = "CTDIvol"
+CTDIw: str = "CTDIw"
+PatientPosition: str = "PatientPosition"
+BodyPartExamined: str = "BodyPartExamined"
+StartTablePosition: str = "StartTablePosition"
+EndTablePosition: str = "EndTablePosition"
+StartTubeAngle: str = "StartTubeAngle"
+EndTubeAngle: str = "EndTubeAngle"
+ProtocolName: str = "ProtocolName"
+SeriesDescription: str = "SeriesDescription"
+StudyDescription: str = "StudyDescription"
+NumberOfSpectra: str = "NumberOfSpectra"
+SpectrumIndex: str = "SpectrumIndex"
+NoiseEquivalentQuanta: str = "NoiseEquivalentQuanta"
+SourcePath: str = "SourcePath"
+RayGeometry: str = "RayGeometry"
+NumberOfProjections: str = "NumberOfProjections"
+LogarithmicEncoding: str = "LogarithmicEncoding"
+
+# Projection-specific fields
+TablePosition: str = "TablePosition"
+TubeAngle: str = "TubeAngle"
+SourceAngularPositionShift: str = "SourceAngularPositionShift"
+SourceAxialPositionShift: str = "SourceAxialPositionShift"
+SourceRadialDistanceShift: str = "SourceRadialDistanceShift"
+ReadingIndex: str = "ReadingIndex"
+Timestamp: str = "Timestamp"
+MinimumPixelValue: str = "MinimumPixelValue"
+MaximumPixelValue: str = "MaximumPixelValue"
+TubeCurrent: str = "TubeCurrent"
+Data: str = "Data"
+View: str = "View"
+
+# Reconstruction fields
+ConeAngle: str = "ConeAngle"
+ProjectionsPerRotation: str = "ProjectionsPerRotation"
+TableFeedPerRotation: str = "TableFeedPerRotation"
+FanAngleIncrement: str = "FanAngleIncrement"
+Pitch: str = "Pitch"
+
+# Image fields
+RescaleSlope: str = "RescaleSlope"
+RescaleIntercept: str = "RescaleIntercept"
+HounsfieldUnitCalibration: str = "HounsfieldUnitCalibration"
+PixelRepresentation: str = "PixelRepresentation"
+PhotometricInterpretation: str = "PhotometricInterpretation"
+HighBit: str = "HighBit"
+BitsAllocated: str = "BitsAllocated"
+BitsStored: str = "BitsStored"
+SamplesPerPixel: str = "SamplesPerPixel"
+MatrixRows: str = "MatrixRows"
+MatrixColumns: str = "MatrixColumns"
+
+# Sensitive Fields
+PatientAge: str = "PatientAge"
+PatientBirthDate: str = "PatientBirthDate"
+PatientID: str = "PatientID"
+PatientName: str = "PatientName"
+PatientSex: str = "PatientSex"
+PatientSize: str = "PatientSize"
+PatientWeight: str = "PatientWeight"
+PregnancyStatus: str = "PregnancyStatus"
+RequestedProcedure: str = "RequestedProcedure"
+SmokingStatus: str = "SmokingStatus"
+PhysicianName: str = "PhysicianName"
+AccessionNumber: str = "AccessionNumber"
+InstitutionName: str = "InstitutionName"
+InstitutionAddress: str = "InstitutionAddress"
+SOPClassUID: str = "SOPClassUID"
+SOPInstanceUID: str = "SOPInstanceUID"
+StudyInstanceUID: str = "StudyInstanceUID"
+SeriesInstanceUID: str = "SeriesInstanceUID"
+IrradiationEventUID: str = "IrradiationEventUID"
+AcquisitionDate: str = "AcquisitionDate"
+SeriesDate: str = "SeriesDate"
+Diagnosis: str = "Diagnosis"
+EthnicGroup: str = "EthnicGroup"
+AcquisitionTime: str = "AcquisitionTime"
+RangeName: str = "RangeName"
+
+# Sensitive fields
+SensitiveFields: set[str] = {
+    PregnancyStatus,
+    PatientID,
+    PatientWeight,
+    PatientAge,
+    PatientBirthDate,
+    PatientName,
+    PatientSex,
+    PatientSize,
+    RangeName,
+    SmokingStatus,
+    PhysicianName,
+    AccessionNumber,
+    InstitutionName,
+    InstitutionAddress,
+    StudyInstanceUID,
+    SeriesInstanceUID,
+    IrradiationEventUID,
+    AcquisitionDate,
+    AcquisitionTime,
+    SeriesDate,
+    Diagnosis,
+    EthnicGroup,
+    SOPInstanceUID,
+    Timestamp,
+}
+
+
+# Required reconstruction fields
+ReconFieldsRequired: set[str] = {
+    Rows,
+    Channels,
+    NumberOfProjections,
+    ProjectionsPerRotation,
+    CentralRow,
+    CentralChannel,
+    AcquisitionFOV,
+    RowWidth,
+    ChannelWidth,
+    DistanceSourceToIsocenter,
+    DistanceSourceToDetector,
+    TableSpeed,
+    RotationTime,
+    FlyingFocalSpotMode,
+    RayGeometry,
+}
+
+# Recommended reconstruction fields
+ReconFieldsRecommended: set[str] = {
+    TableFeedDirection,
+    TubeAngleDirection,
+    AnodeAngle,
+    HounsfieldUnitCalibration,
+    FanAngleIncrement,
+    Pitch,
+    ScanTime,
+    TableHeight,
+    Manufacturer,
+    PatientPosition,
+    ScannerModel,
+    SpectrumIndex,
+}
+
+
+# Optional reconstruction fields
+ReconFieldsOptional: set[str] = {
+    SourcePath,
+    LogarithmicEncoding,
+    NumberOfSpectra,
+    TubeVoltage,
+    PixelRepresentation,
+    HighBit,
+    BitsAllocated,
+    BitsStored,
+    SamplesPerPixel,
+    CentralChannelOffset,
+    StartTablePosition,
+    EndTablePosition,
+    StartTubeAngle,
+    EndTubeAngle,
+    Exposure,
+    ExposureNominal,
+    CTDIw,
+    CTDIvol,
+    CollimatedSliceWidth,
+    ConeAngle,
+    TableFeedPerRotation,
+    ProtocolName,
+    SOPClassUID,
+    SeriesDescription,
+    StudyDescription,
+    BodyPartExamined,
+    Modality,
+    DetectorShape,
+    PhotometricInterpretation,
+}