PyCriCodecsEx 0.0.2__cp311-cp311-musllinux_1_2_i686.whl → 0.0.5__cp311-cp311-musllinux_1_2_i686.whl

PyCriCodecsEx/hca.py

@@ -5,7 +5,7 @@ from array import array
 import CriCodecsEx
 
 from PyCriCodecsEx.chunk import *
-
+from PyCriCodecsEx.utf import UTFTypeValues, UTFBuilder
 HcaHeaderStruct = Struct(">4sHH")
 HcaFmtHeaderStruct = Struct(">4sIIHH")
 HcaCompHeaderStruct = Struct(">4sHBBBBBBBBBB")
@@ -17,6 +17,10 @@ HcaCiphHeaderStruct = Struct(">4sH")
 HcaRvaHeaderStruct = Struct(">4sf")
 
 class HCA:
+    """HCA class for decoding and encoding HCA files
+
+    **NOTE:** Direct usage of this class is not recommended, use the `HCACodec` wrapper instead.
+    """
     stream: BinaryIO
     hcastream: BinaryIO
     HcaSig: bytes
@@ -205,32 +209,28 @@ class HCA:
                     raise ValueError(f"WAV bitdepth of {self.fmtBitCount} is not supported, only 16 bit WAV files are supported.")
                 elif self.fmtSize != 16:
                     raise ValueError(f"WAV file has an FMT chunk of an unsupported size: {self.fmtSize}, the only supported size is 16.")
-                if self.stream.read(4) == b"smpl":
-                    self.stream.seek(-4, 1)
-                    self.looping = True
-                    # Will just be naming the important things here.
-                    smplsig, smplesize, _, _, _, _, _, _, _, self.LoopCount, _, _, _, self.LoopStartSample, self.LoopEndSample, _, _ = WavSmplHeaderStruct.unpack(
-                        self.stream.read(WavSmplHeaderStruct.size)
-                    )
-                    if self.LoopCount != 1:
-                        self.looping = False # Unsupported multiple looping points, so backtracks, and ignores looping data.
-                        self.stream.seek(-WavSmplHeaderStruct.size, 1)
-                        self.stream.seek(8 + smplesize, 1)
-                else:
-                    self.stream.seek(-4, 1)
-                    self.looping = False
-                if self.stream.read(4) == b"note": # There's no use for this on ADX.
-                    len = self.stream.read(4)
-                    self.stream.seek(len+4) # + 1? + padding maybe?
-                else:
-                    self.stream.seek(-4, 1)
-                if self.stream.read(4) == b"data":
-                    self.stream.seek(-4, 1)
-                    self.dataSig, self.dataSize = WavDataHeaderStruct.unpack(
-                        self.stream.read(WavDataHeaderStruct.size)
-                    )
-                else:
-                    raise ValueError("Invalid or an unsupported wav file.")
+                while (hdr := self.stream.read(4)):
+                    size = int.from_bytes(self.stream.read(4), 'little')
+                    size += (size & 1) # padding
+                    offset = self.stream.tell()
+                    match hdr:
+                        case b"smpl":
+                            self.stream.seek(-4, 1)
+                            self.looping = True
+                            # Will just be naming the important things here.
+                            smplsig, smplesize, _, _, _, _, _, _, _, self.LoopCount, _, _, _, self.LoopStartSample, self.LoopEndSample, _, _ = WavSmplHeaderStruct.unpack(
+                                self.stream.read(WavSmplHeaderStruct.size)
+                            )
+                            if self.LoopCount != 1:
+                                self.looping = False # Unsupported multiple looping points, so backtracks, and ignores looping data.
+                                self.stream.seek(-WavSmplHeaderStruct.size, 1)
+                                self.stream.seek(8 + smplesize, 1)
+                        case b"data":
+                            self.stream.seek(-4, 1)
+                            self.dataSig, self.dataSize = WavDataHeaderStruct.unpack(
+                                self.stream.read(WavDataHeaderStruct.size)
+                            )
+                    self.stream.seek(offset + size, 0)
         else:
             raise ValueError("Invalid HCA or WAV file.")
         self.stream.seek(0)
@@ -309,3 +309,146 @@ class HCA:
         header = self.hcastream.read(self.header_size)
         self.hcastream.seek(0)
         return header
+
+
+class HCACodec(HCA):
+    """Use this class for encoding and decoding HCA files, from and to WAV."""
+    CHUNK_INTERVAL = 64
+    BASE_FRAMERATE = 2997 # dt = CHUNK_INTERVAL / BASE_FRAMERATE
+    AUDIO_CODEC = 4
+    METADATA_COUNT = 1
+
+    filename: str
+
+    chnls: int
+    sampling_rate: int
+    total_samples: int
+    avbps: int
+
+    filesize: int
+
+    def __init__(self, stream: str | bytes, filename: str = "default.hca", quality: CriHcaQuality = CriHcaQuality.High, key=0, subkey=0, **kwargs):
+        """Initializes the HCA encoder/decoder
+
+        Args:
+            stream (str | bytes): Path to the HCA or WAV file, or a BinaryIO stream. WAV files will be automatically encoded with the given settings first.
+            filename (str, optional): Filename, used by USMBuilder. Defaults to "default.hca".
+            quality (CriHcaQuality, optional): Encoding quality. Defaults to CriHcaQuality.High.
+            key (int, optional): HCA key. Defaults to 0.
+            subkey (int, optional): HCA subkey. Defaults to 0.
+        """
+        self.filename = filename
+        super().__init__(stream, key, subkey)
+        if self.filetype == "wav":
+            self.encode(
+                force_not_looping=True,
+                encrypt=key != 0,
+                keyless=False,
+                quality_level=quality
+            )
+        self.hcastream.seek(0, 2)
+        self.filesize = self.hcastream.tell()
+        self.hcastream.seek(0)
+
+        if self.filetype == "wav":
+            self.chnls = self.fmtChannelCount
+            self.sampling_rate = self.fmtSamplingRate
+            self.total_samples = int(self.dataSize // self.fmtSamplingSize)
+        else:
+            self.chnls = self.hca["ChannelCount"]
+            self.sampling_rate = self.hca["SampleRate"]
+            self.total_samples = self.hca["FrameCount"]
+        # I don't know how this is derived so I am putting my best guess here. TODO
+        self.avbps = int(self.filesize / self.chnls)
+
+    def generate_SFA(self, index: int, builder):
+        # USMBuilder usage
+        current_interval = 0
+        padding = (
+            0x20 - (self.hca["HeaderSize"] % 0x20)
+            if self.hca["HeaderSize"] % 0x20 != 0
+            else 0
+        )
+        SFA_chunk = USMChunkHeader.pack(
+            USMChunckHeaderType.SFA.value,
+            self.hca["HeaderSize"] + 0x18 + padding,
+            0,
+            0x18,
+            padding,
+            index,
+            0,
+            0,
+            0,
+            current_interval,
+            self.BASE_FRAMERATE,
+            0,
+            0,
+        )
+        SFA_chunk += self.get_header().ljust(self.hca["HeaderSize"] + padding, b"\x00")
+        res = []
+        res.append(SFA_chunk)
+        for i, frame in enumerate(self.get_frames(), start=1):
+            padding = (
+                0x20 - (self.hca["FrameSize"] % 0x20)
+                if self.hca["FrameSize"] % 0x20 != 0
+                else 0
+            )
+            SFA_chunk = USMChunkHeader.pack(
+                USMChunckHeaderType.SFA.value,
+                self.hca["FrameSize"] + 0x18 + padding,
+                0,
+                0x18,
+                padding,
+                index,
+                0,
+                0,
+                0,
+                current_interval,
+                self.BASE_FRAMERATE,
+                0,
+                0,
+            )
+            SFA_chunk += frame[1].ljust(self.hca["FrameSize"] + padding, b"\x00")
+            current_interval = round(i * self.CHUNK_INTERVAL)            
+            res.append(SFA_chunk)
+        else:
+            SFA_chunk = USMChunkHeader.pack(
+                USMChunckHeaderType.SFA.value,
+                0x38,
+                0,
+                0x18,
+                0,
+                index,
+                0,
+                0,
+                2,
+                0,
+                30,
+                0,
+                0,
+            )
+            SFA_chunk += b"#CONTENTS END   ===============\x00"
+            res[-1] += SFA_chunk
+
+        return res
+
+    def get_metadata(self):
+        payload = [dict(hca_header=(UTFTypeValues.bytes, self.get_header()))]
+        p = UTFBuilder(payload, table_name="AUDIO_HEADER")
+        p.strings = b"<NULL>\x00" + p.strings
+        return p.bytes()
+
+    def get_encoded(self) -> bytes:
+        """Gets the encoded HCA audio data."""
+        self.hcastream.seek(0)
+        res = self.hcastream.read()
+        self.hcastream.seek(0)
+        return res
+    
+    def save(self, filepath: str | BinaryIO):
+        """Saves the decoded WAV audio to filepath or a writable stream"""
+        if type(filepath) == str:
+            with open(filepath, "wb") as f:
+                f.write(self.decode())
+        else:
+            filepath.write(self.decode())

PyCriCodecsEx/usm.py

@@ -6,8 +6,6 @@ from functools import cached_property
 
 from PyCriCodecsEx.chunk import *
 from PyCriCodecsEx.utf import UTF, UTFBuilder
-from PyCriCodecsEx.adx import ADX
-from PyCriCodecsEx.hca import HCA
 try:
     import ffmpeg
 except ImportError:
@@ -15,13 +13,10 @@ except ImportError:
 import tempfile
 
 # Big thanks and credit for k0lb3 and 9th helping me write this specific code.
-# Also credit for the original C++ code from Nyagamon/bnnm.
-
-# Apparently there is an older USM format called SofDec? This is for SofDec2 though.
-# Extraction working only for now, although check https://github.com/donmai-me/WannaCRI/
-# code for a complete breakdown of the USM format.
+# Also credit for the original C++ code from Nyagamon/bnnm and https://github.com/donmai-me/WannaCRI/
 
 class USMCrypt:
+    """USM related crypto functions"""
     videomask1: bytearray
     videomask2: bytearray
     audiomask: bytearray
@@ -151,6 +146,7 @@ class USMCrypt:
 # are still unknown how to derive them, at least video wise it is possible, no idea how it's calculated audio wise nor anything else
 # seems like it could be random values and the USM would still work.
 class FFmpegCodec:
+    """Base codec for FFMpeg-based Video streams"""
     filename: str
     filesize: int
 
@@ -162,6 +158,13 @@ class FFmpegCodec:
     avbps: int
 
     def __init__(self, stream: str | bytes):
+        """Initialize FFmpegCodec with a media stream, gathering metadata and frame info.
+
+        Args:
+            stream (str | bytes): The media stream to process.
+        NOTE:
+            A temp file maybe created for probing only. Which will be deleted after use.
+        """
         if type(stream) == str:
             self.filename = stream
         else:
@@ -226,7 +229,7 @@ class FFmpegCodec:
         return len(self.packets)
 
     def frames(self):
-        """frame data, frame dict, is keyframe, duration"""
+        """Generator of [frame data, frame dict, is keyframe, duration]"""
         offsets = [int(packet["pos"]) for packet in self.packets] + [self.filesize]
         for i, frame in enumerate(self.packets):
             frame_size = offsets[i + 1] - offsets[i]
@@ -284,13 +287,16 @@ class FFmpegCodec:
         return SFV_list
 
     def save(self, filepath: str):
-        '''Saves the raw, underlying video stream to a file.'''
+        '''Saves the underlying video stream to a file.'''
         tell = self.file.tell()
         self.file.seek(0)
         shutil.copyfileobj(self.file, open(filepath, 'wb'))
         self.file.seek(tell)
 
 class VP9Codec(FFmpegCodec):
+    """VP9 Video stream codec.
+    
+    Only streams with `.ivf` containers are supported."""
     MPEG_CODEC = 9
     MPEG_DCPREC = 0
     VERSION = 16777984
@@ -299,6 +305,9 @@ class VP9Codec(FFmpegCodec):
         super().__init__(filename)
         assert self.format == "ivf", "must be ivf format."
 class H264Codec(FFmpegCodec):
+    """H264 Video stream codec.
+
+    Only streams with `.h264` containers are supported."""
     MPEG_CODEC = 5
     MPEG_DCPREC = 11
     VERSION = 0
@@ -309,6 +318,9 @@ class H264Codec(FFmpegCodec):
             self.format == "h264"
         ), "must be raw h264 data. transcode with '.h264' suffix as output"
 class MPEG1Codec(FFmpegCodec):
+    """MPEG1 Video stream codec.
+
+    Only streams with `.mpeg1` containers are supported."""
     MPEG_CODEC = 1
     MPEG_DCPREC = 11
     VERSION = 0
@@ -317,260 +329,11 @@ class MPEG1Codec(FFmpegCodec):
         super().__init__(stream)
         assert self.format == "mpegvideo", "must be m1v format (mpegvideo)."
 
-class HCACodec(HCA):
-    CHUNK_INTERVAL = 64
-    BASE_FRAMERATE = 2997 # dt = CHUNK_INTERVAL / BASE_FRAMERATE
-    AUDIO_CODEC = 4
-    METADATA_COUNT = 1
-
-    filename: str
-
-    chnls: int
-    sampling_rate: int
-    total_samples: int
-    avbps: int
-
-    filesize: int
-
-    def __init__(self, stream: str | bytes, filename: str = "default.hca", quality: CriHcaQuality = CriHcaQuality.High, key=0, subkey=0, **kwargs):
-        self.filename = filename
-        super().__init__(stream, key, subkey)
-        if self.filetype == "wav":
-            self.encode(
-                force_not_looping=True,
-                encrypt=key != 0,
-                keyless=False,
-                quality_level=quality
-            )
-        self.hcastream.seek(0, 2)
-        self.filesize = self.hcastream.tell()
-        self.hcastream.seek(0)
-
-        if self.filetype == "wav":
-            self.chnls = self.fmtChannelCount
-            self.sampling_rate = self.fmtSamplingRate
-            self.total_samples = int(self.dataSize // self.fmtSamplingSize)
-        else:
-            self.chnls = self.hca["ChannelCount"]
-            self.sampling_rate = self.hca["SampleRate"]
-            self.total_samples = self.hca["FrameCount"]
-        # I don't know how this is derived so I am putting my best guess here. TODO
-        self.avbps = int(self.filesize / self.chnls)
-
-    def generate_SFA(self, index: int, builder: "USMBuilder"):
-        current_interval = 0
-        padding = (
-            0x20 - (self.hca["HeaderSize"] % 0x20)
-            if self.hca["HeaderSize"] % 0x20 != 0
-            else 0
-        )
-        SFA_chunk = USMChunkHeader.pack(
-            USMChunckHeaderType.SFA.value,
-            self.hca["HeaderSize"] + 0x18 + padding,
-            0,
-            0x18,
-            padding,
-            index,
-            0,
-            0,
-            0,
-            current_interval,
-            self.BASE_FRAMERATE,
-            0,
-            0,
-        )
-        SFA_chunk += self.get_header().ljust(self.hca["HeaderSize"] + padding, b"\x00")
-        res = []
-        res.append(SFA_chunk)
-        for i, frame in enumerate(self.get_frames(), start=1):
-            padding = (
-                0x20 - (self.hca["FrameSize"] % 0x20)
-                if self.hca["FrameSize"] % 0x20 != 0
-                else 0
-            )
-            SFA_chunk = USMChunkHeader.pack(
-                USMChunckHeaderType.SFA.value,
-                self.hca["FrameSize"] + 0x18 + padding,
-                0,
-                0x18,
-                padding,
-                index,
-                0,
-                0,
-                0,
-                current_interval,
-                self.BASE_FRAMERATE,
-                0,
-                0,
-            )
-            SFA_chunk += frame[1].ljust(self.hca["FrameSize"] + padding, b"\x00")
-            current_interval = round(i * self.CHUNK_INTERVAL)            
-            res.append(SFA_chunk)
-        else:
-            SFA_chunk = USMChunkHeader.pack(
-                USMChunckHeaderType.SFA.value,
-                0x38,
-                0,
-                0x18,
-                0,
-                index,
-                0,
-                0,
-                2,
-                0,
-                30,
-                0,
-                0,
-            )
-            SFA_chunk += b"#CONTENTS END   ===============\x00"
-            res[-1] += SFA_chunk
-
-        return res
-
-    def get_metadata(self):
-        payload = [dict(hca_header=(UTFTypeValues.bytes, self.get_header()))]
-        p = UTFBuilder(payload, table_name="AUDIO_HEADER")
-        p.strings = b"<NULL>\x00" + p.strings
-        return p.bytes()
-
-    def get_encoded(self):
-        """Gets the encoded HCA audio data."""
-        self.hcastream.seek(0)
-        res = self.hcastream.read()
-        self.hcastream.seek(0)
-        return res
-    
-    def save(self, filepath: str):
-        """Saves the decoded WAV audio to filepath"""
-        with open(filepath, "wb") as f:
-            f.write(self.decode())
-
-class ADXCodec(ADX):
-    CHUNK_INTERVAL = 99.9
-    BASE_FRAMERATE = 2997
-    # TODO: Move these to an enum
-    AUDIO_CODEC = 2
-    METADATA_COUNT = 0
-
-    filename : str
-    filesize : int
-
-    adx : bytes
-    header : bytes
-    sfaStream: BinaryIO    
-
-    AdxDataOffset: int
-    AdxEncoding: int
-    AdxBlocksize: int
-    AdxSampleBitdepth: int
-    AdxChannelCount: int
-    AdxSamplingRate: int
-    AdxSampleCount: int
-    AdxHighpassFrequency: int
-    AdxVersion: int
-    AdxFlags: int
-
-    chnls: int
-    sampling_rate: int
-    total_samples: int
-    avbps: int
-
-    def __init__(self, stream: str | bytes, filename: str = "default.adx", bitdepth: int = 4, **kwargs):
-        if type(stream) == str:
-            self.adx = open(stream, "rb").read()
-        else:
-            self.adx = stream
-        self.filename = filename
-        self.filesize = len(self.adx)
-        magic = self.adx[:4]
-        if magic == b"RIFF":
-            self.adx = self.encode(self.adx, bitdepth, force_not_looping=True)        
-        self.sfaStream = BytesIO(self.adx)
-        header = AdxHeaderStruct.unpack(self.sfaStream.read(AdxHeaderStruct.size))
-        FourCC, self.AdxDataOffset, self.AdxEncoding, self.AdxBlocksize, self.AdxSampleBitdepth, self.AdxChannelCount, self.AdxSamplingRate, self.AdxSampleCount, self.AdxHighpassFrequency, self.AdxVersion, self.AdxFlags = header
-        assert FourCC == 0x8000, "either ADX or WAV is supported"
-        assert self.AdxVersion in {3,4}, "unsupported ADX version"
-        if self.AdxVersion == 4:
-            self.sfaStream.seek(4 + 4  * self.AdxChannelCount, 1)  # Padding + Hist values, they always seem to be 0.
-        self.sfaStream.seek(0)
-        self.chnls = self.AdxChannelCount
-        self.sampling_rate = self.AdxSamplingRate
-        self.total_samples = self.AdxSampleCount
-        self.avbps = int(self.filesize * 8 * self.chnls) - self.filesize
-    
-    def generate_SFA(self, index: int, builder: "USMBuilder"):
-        current_interval = 0
-        stream_size = len(self.adx) - self.AdxBlocksize
-        chunk_size = int(self.AdxSamplingRate // (self.BASE_FRAMERATE / 100) // 32) * (self.AdxBlocksize * self.AdxChannelCount)
-        self.sfaStream.seek(0)
-        res = []
-        while self.sfaStream.tell() < stream_size:
-            if self.sfaStream.tell() > 0:
-                if self.sfaStream.tell() + chunk_size < stream_size:
-                    datalen = chunk_size
-                else:
-                    datalen = (stream_size - (self.AdxDataOffset + 4) - chunk_size) % chunk_size
-            else:
-                datalen = self.AdxDataOffset + 4
-            if not datalen:
-                break
-            padding = (0x20 - (datalen % 0x20) if datalen % 0x20 != 0 else 0)
-            SFA_chunk = USMChunkHeader.pack(
-                    USMChunckHeaderType.SFA.value,
-                    datalen + 0x18 + padding,
-                    0,
-                    0x18,
-                    padding,
-                    index,
-                    0,
-                    0,
-                    0,
-                    round(current_interval),
-                    self.BASE_FRAMERATE,
-                    0,
-                    0
-                    )
-            chunk_data = self.sfaStream.read(datalen)
-            if builder.encrypt_audio:
-                SFA_chunk = builder.AudioMask(chunk_data)
-            SFA_chunk += chunk_data.ljust(datalen + padding, b"\x00")            
-            current_interval += self.CHUNK_INTERVAL
-            res.append(SFA_chunk)
-        # ---
-        SFA_chunk = USMChunkHeader.pack(
-                    USMChunckHeaderType.SFA.value,
-                    0x38,
-                    0,
-                    0x18,
-                    0,
-                    index,
-                    0,
-                    0,
-                    2,
-                    0,
-                    30,
-                    0,
-                    0
-                    )
-        SFA_chunk += b"#CONTENTS END   ===============\x00"
-        res[-1] += SFA_chunk
-        return res
-
-    def get_metadata(self):
-        return None
-
-    def get_encoded(self):
-        """Gets the encoded ADX audio data."""
-        return self.adx
-
-    def save(self, filepath: str):
-        """Saves the encoded ADX audio to filepath"""
-        with open(filepath, "wb") as f:
-            f.write(self.decode(self.adx))
-
+from PyCriCodecsEx.hca import HCACodec
+from PyCriCodecsEx.adx import ADXCodec
 
 class USM(USMCrypt):
-    """USM class for extracting infromation and data from a USM file."""
+    """Use this class to extract infromation and data from a USM file."""
 
     filename: str
     decrypt: bool
@@ -585,7 +348,7 @@ class USM(USMCrypt):
 
     metadata: list
 
-    def __init__(self, filename, key: str | int = None):
+    def __init__(self, filename : str | BinaryIO, key: str | int = None):
         """Loads a USM file into memory and prepares it for processing.
 
         Args:
@@ -601,7 +364,10 @@ class USM(USMCrypt):
         self._load_file()
     
     def _load_file(self):
-        self.stream = open(self.filename, "rb")
+        if type(self.filename) == str:
+            self.stream = open(self.filename, "rb")
+        else:
+            self.stream = self.filename
         self.stream.seek(0, 2)
         self.size = self.stream.tell()
         self.stream.seek(0)
@@ -716,13 +482,13 @@ class USM(USMCrypt):
 
     @property
     def streams(self):
-        """[Type (@SFV, @SFA), Filename, Raw stream data]"""
+        """Generator of Tuple[Stream Type ("@SFV", "@SFA"), File name, Raw stream data]"""
         for stream in self.CRIDObj.dictarray[1:]:
             filename, stmid, chno = stream["filename"][1], stream["stmid"][1], stream["chno"][1]
             stmid = int.to_bytes(stmid, 4, 'big', signed='False')
             yield stmid, str(filename), self.output.get(f'{stmid.decode()}_{chno}', None)
     
-    def get_video(self):
+    def get_video(self) -> VP9Codec | H264Codec | MPEG1Codec:
         """Create a video codec from the available streams.
 
         NOTE: A temporary file may be created with this process to determine the stream information."""
@@ -751,7 +517,7 @@ class USM(USMCrypt):
                 return []
 
 class USMBuilder(USMCrypt):
-    """USM class for building USM files."""
+    """Use this class to build USM files."""
     video_stream: VP9Codec | H264Codec | MPEG1Codec
     audio_streams: List[HCACodec | ADXCodec]
 

PyCriCodecsEx/utf.py

@@ -8,6 +8,7 @@ from struct import unpack, calcsize, pack
 from PyCriCodecsEx.chunk import *
 
 class UTF:
+    """Use this class to unpack @UTF table binary payload."""
 
     _dictarray: list
 
@@ -23,11 +24,11 @@ class UTF:
     recursive: bool
     encoding : str = 'utf-8'
 
-    def __init__(self, stream, recursive=False):
+    def __init__(self, stream : str | BinaryIO, recursive=False):
         """Unpacks UTF table binary payload
 
         Args:
-            stream (Union[str, bytes]): The input stream or file path to read the UTF table from.
+            stream (Union[str | BinaryIO]): The input stream or file path to read the UTF table from.
             recursive (bool): Whether to recursively unpack nested UTF tables.
         """
         if type(stream) == str:
@@ -290,6 +291,7 @@ class UTF:
         return self._dictarray
 
 class UTFBuilder:
+    """Use this class to build UTF table binary payloads from a `dictarray`."""
 
     encoding: str
     dictarray: list
@@ -591,34 +593,16 @@ class UTFBuilder:
         return dataarray
 
 class UTFViewer:
+    """Use this class to create dataclass-like access to `dictarray`s."""
+
     _payload: dict
 
     def __init__(self, payload):
         """Construct a non-owning read-write, deletable view of a UTF table dictarray.
+
         Nested classes are supported.
-        Sorting (using .sort()) is done in-place and affects the original payload.
 
-        Example:
-        ```python
-            class CueNameTable(UTFViewer):
-                CueName : str
-                CueIndex : int
-            class ACBTable(UTFViewer):
-                CueNameTable : List[CueNameTable]
-                Awb : AWB
-            src = ACB(ACB_sample)
-            payload = ACBTable(src.payload)
-            >>> Referencing items through Python is allowed
-            name = payload.CueNameTable
-            >>> Lists can be indexed
-            name_str = name[0].CueName
-            >>> Deleting items from lists is also allowed
-            src.view.CueNameTable.pop(1)
-            src.view.CueTable.pop(1)
-            >>> The changes will be reflected in the original UTF payload
-            
-            See __new__ for the actual constructor.
-        ```
+        Sorting (using .sort()) is done in-place and affects the original payload.
         """
         assert isinstance(payload, dict), "payload must be a dictionary."
         super().__setattr__("_payload", payload)