polyfile-weave 0.5.5__py3-none-any.whl

polyfile/iterators.py

@@ -0,0 +1,72 @@
+from collections.abc import Sequence as AbstractSequence, Set as AbstractSet
+from typing import Generic, TypeVar, Iterable, Iterator, List, Optional, Sequence, Set
+
+T = TypeVar("T")
+
+
+class LazyIterableSequence(Generic[T], Sequence[T], AbstractSequence):
+    """A thread-safe list lazily generated from an iterator"""
+    def __init__(self, source: Iterable[T]):
+        self._source_iter: Optional[Iterator[T]] = iter(source)
+        self._items: List[T] = []
+
+    def _get_next_source_item(self) -> T:
+        if self._source_iter is None:
+            raise StopIteration()
+        return next(self._source_iter)
+
+    def _complete(self):
+        """Finishes reading all source items from the input iterator"""
+        while self._source_iter is not None:
+            try:
+                _ = self[len(self._items)]
+            except IndexError:
+                assert self._source_iter is None
+
+    def __getitem__(self, index: int) -> T:
+        while self._source_iter is not None and len(self._items) <= index:
+            # we have not yet read enough items
+            try:
+                self._items.append(next(self._source_iter))
+            except StopIteration:
+                self._source_iter = None
+                break
+        return self._items[index]
+
+    def __len__(self) -> int:
+        self._complete()
+        return len(self._items)
+
+    def __iter__(self) -> Iterator[T]:
+        i = 0
+        while True:
+            try:
+                yield self[i]
+                i += 1
+            except IndexError:
+                break
+
+
+def unique(iterator: Iterator[T], elements: Optional[Set[T]] = None) -> Iterator[T]:
+    """Yields all of the unique elements of the input sequence"""
+    if elements is None:
+        elements = set()
+    for t in iterator:
+        if t not in elements:
+            yield t
+            elements.add(t)
+
+
+class LazyIterableSet(Generic[T], AbstractSet, LazyIterableSequence[T]):
+    """
+    A collection that is both a set and a sequence that
+    """
+    def __init__(self, source: Iterable[T]):
+        self._set: Set[T] = set()
+        super().__init__(unique(iter(source), elements=self._set))
+
+    def __contains__(self, x: object) -> bool:
+        if x in self._set:
+            return True
+        self._complete()
+        return x in self._set

polyfile/jpeg.py

@@ -0,0 +1,24 @@
+import base64
+from io import BytesIO
+
+from .fileutils import FileStream, Tempfile
+from .polyfile import Match, register_parser, Submatch
+
+from PIL import Image
+
+
+@register_parser("image/jp2")
+def parse_jpeg2000(file_stream: FileStream, parent: Match):
+    with Tempfile(file_stream.read(parent.length)) as input_bytes:
+        img = Image.open(input_bytes)
+        with BytesIO() as img_data:
+            img.save(img_data, "PNG")
+            b64data = f"data:image/png;base64,{base64.b64encode(img_data).decode('utf-8')}"
+    yield Submatch(
+        name='ImageData',
+        img_data=b64data,
+        match_obj="",
+        relative_offset=0,
+        length=parent.length,
+        parent=parent
+    )

polyfile/kaitai/compiler.py

@@ -0,0 +1,156 @@
+#!/usr/bin/env python3
+
+"""
+This module automates compilation of Kaitai Struct definitions into Python code.
+
+This script is called from PolyFile's setup.py to compile the entire Kaitai Struct format library at build time.
+Therefore, this script should always be self-contained and not require any dependencies other than the Python standard
+library.
+
+"""
+from io import BytesIO
+import json
+import os
+from pathlib import Path
+import shutil
+import stat
+import subprocess
+import sys
+from typing import Iterable, List, Optional, Union
+from urllib.request import urlopen
+from zipfile import ZipFile
+
+
+if os.name == "nt":
+    KAITAI_COMPILER_NAME: str = "kaitai-struct-compiler.bat"
+else:
+    KAITAI_COMPILER_NAME = "kaitai-struct-compiler"
+
+
+COMPILER_DIR = Path(__file__).absolute().parent / "kaitai-struct-compiler-0.9"
+COMPILER_BIN_DIR = COMPILER_DIR / "bin"
+COMPILER_BIN = COMPILER_BIN_DIR / KAITAI_COMPILER_NAME
+
+
+class KaitaiError(RuntimeError):
+    pass
+
+
+class CompilationError(KaitaiError):
+    def __init__(self, ksy_file: str, message: str):
+        super().__init__(message)
+        self.ksy_file: str = ksy_file
+
+    def __str__(self):
+        return f"{self.ksy_file}: {super().__str__()}"
+
+
+class CompiledKSY:
+    def __init__(self, class_name: str, python_path: Union[str, Path], dependencies: Iterable["CompiledKSY"] = ()):
+        self.class_name: str = class_name
+        if not isinstance(python_path, Path):
+            python_path = Path(python_path)
+        self.python_path: Path = python_path
+        self.dependencies: List[CompiledKSY] = list(dependencies)
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}(class_name={self.class_name!r}, python_path={self.python_path!r}, "\
+               f"dependencies={self.dependencies!r})"
+
+
+def install_compiler():
+    resp = urlopen("https://github.com/kaitai-io/kaitai_struct_compiler/releases/download/0.9/"
+                   "kaitai-struct-compiler-0.9.zip")
+    zipfile = ZipFile(BytesIO(resp.read()))
+    COMPILER_DIR.mkdir(exist_ok=True)
+    zipfile.extractall(COMPILER_DIR.parent)
+    if COMPILER_BIN.exists():
+        COMPILER_BIN.chmod(COMPILER_BIN.stat().st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
+        sys.stderr.write(f"Installed the Kaitai Struct Compiler to {COMPILER_BIN}\n")
+
+
+def compiler_path(auto_install: bool = True) -> Optional[Path]:
+    if COMPILER_BIN.exists():
+        return COMPILER_BIN
+    global_path = shutil.which(KAITAI_COMPILER_NAME)
+    if global_path is not None:
+        return Path(global_path)
+    if not auto_install:
+        return None
+    install_compiler()
+    return compiler_path(auto_install=False)
+
+
+def compile(ksy_path: Union[str, Path], output_directory: Union[str, Path], auto_install: bool = True) -> CompiledKSY:
+    """Returns the list of compiled KSYs; the original spec being first, followed by its dependencies"""
+    compiler = compiler_path(auto_install=auto_install)
+    if compiler is None:
+        raise KaitaiError(f"{KAITAI_COMPILER_NAME} not found! Please make sure it is in your PATH. "
+                          f"See https://kaitai.io/#download")
+
+    # sys.stderr.write(f"Using Kaitai Struct Compiler: {compiler!s}\n")
+
+    if not isinstance(output_directory, Path):
+        output_directory = Path(output_directory)
+
+    output_directory.mkdir(parents=True, exist_ok=True)
+
+    cmd = [
+        str(compiler), "--target", "python", "--outdir", str(output_directory), str(ksy_path),
+        "--debug", "--ksc-json-output", "-I", str(Path.cwd()), "--python-package", "polyfile.kaitai.parsers"
+    ]
+
+    proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    out, err = proc.communicate()
+    if err:
+        raise KaitaiError(err.decode("utf-8"))
+    elif proc.returncode != 0:
+        raise KaitaiError(f"`{' '.join(cmd)}` returned with non-zero exit code {proc.returncode}")
+
+    result = json.loads(out)
+
+    if "errors" in result[ksy_path] and result[ksy_path]["errors"]:
+        raise KaitaiError(f"Error compiling {ksy_path}: {result[ksy_path]['errors'][0]['message']}")
+
+    first_spec_name = result[ksy_path]["firstSpecName"]
+    first_spec = result[ksy_path]["output"]["python"][first_spec_name]
+    if "errors" in first_spec:
+        for error in first_spec["errors"]:
+            raise CompilationError(ksy_file=error["file"], message=error["message"])
+    return CompiledKSY(
+        class_name=first_spec["topLevelName"],
+        python_path=output_directory / first_spec["files"][0]["fileName"],
+        dependencies=(
+            CompiledKSY(
+                class_name=compiled["topLevelName"],
+                python_path=output_directory / compiled["files"][0]["fileName"]
+            )
+            for spec_name, compiled in result[ksy_path]["output"]["python"].items()
+            if spec_name != first_spec_name
+        )
+    )
+
+
+if __name__ == "__main__":
+    import argparse
+
+    if len(sys.argv) == 2 and sys.argv[1] == "--install":
+        if compiler_path() is None:
+            sys.exit(1)
+        else:
+            sys.exit(0)
+
+    parser = argparse.ArgumentParser(description="A Kaitai Struct to Python compiler")
+    parser.add_argument("KSY_PATH", type=str, help="path to the Kaitai Struct definition file")
+    parser.add_argument("OUTPUT_DIRECTORY", type=str, help="path to which to save the resulting Python")
+
+    args = parser.parse_args(sys.argv[1:])
+
+    try:
+        compiled = compile(args.KSY_PATH, args.OUTPUT_DIRECTORY)
+        print(f"{compiled.class_name}\t{compiled.python_path}")
+        for dep in compiled.dependencies:
+            print(f"{dep.class_name}\t{dep.python_path}")
+    except KaitaiError as e:
+        sys.stderr.write(f"{e!s}\n\n")
+        sys.exit(1)

polyfile/kaitai/parser.py

@@ -0,0 +1,312 @@
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from enum import Enum
+from importlib import resources
+import importlib.util
+import inspect
+from io import BufferedReader, BytesIO
+import json
+from pathlib import Path
+import sys
+from typing import Any, Dict, Iterator, List, Optional, Set, Type, Union
+
+from . import parsers
+from .compiler import CompiledKSY
+from ..fileutils import FileStream
+
+from kaitaistruct import KaitaiStruct
+
+with resources.path(parsers, "manifest.json") as manifest_path:
+    PARSER_DIR: Path = manifest_path.parent
+if sys.version_info >= (3, 9):
+    with (resources.files(parsers) / "manifest.json").open("r") as f:
+        MANIFEST: Dict[str, Dict[str, Any]] = json.load(f)
+else:
+    with resources.open_text(parsers, "manifest.json") as f:
+        MANIFEST = json.load(f)
+
+COMPILED_INFO_BY_KSY: Dict[str, CompiledKSY] = {
+    ksy_path: CompiledKSY(
+        class_name=component["class_name"],
+        python_path=PARSER_DIR / component["python_path"],
+        dependencies=(
+            CompiledKSY(class_name=dep["class_name"], python_path=PARSER_DIR / dep["python_path"])
+            for dep in component["dependencies"]
+        )
+    )
+    for ksy_path, component in MANIFEST.items()
+}
+del MANIFEST
+
+_IMPORTED_SPECS: Set[Path] = set()
+_PARSERS_BY_KSY: Dict[str, Type[KaitaiStruct]] = {}
+
+
+def import_spec(compiled: CompiledKSY) -> Optional[Type[KaitaiStruct]]:
+    if compiled.python_path in _IMPORTED_SPECS:
+        return None
+    _IMPORTED_SPECS.add(compiled.python_path)
+    module_name = compiled.python_path.name
+    assert module_name.lower().endswith(".py")
+    module_name = module_name[:-3]
+    module_name = f"{__name__}.parsers.{module_name}"
+    spec = importlib.util.spec_from_file_location(module_name, compiled.python_path)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    for objname, obj in inspect.getmembers(module):
+        if inspect.isclass(obj) and objname == compiled.class_name:
+            return obj
+    raise ImportError(f"Could not find parser class {compiled.class_name!r} in {compiled.python_path}")
+
+
+@dataclass(unsafe_hash=True, order=True, frozen=True)
+class Segment:
+    start: int
+    end: int
+
+    def __contains__(self, item):
+        return isinstance(item, Segment) and item.start >= self.start and item.end <= self.end
+
+    def __len__(self):
+        return self.end - self.start
+
+    def __bool__(self):
+        return len(self) > 0
+
+    def __getitem__(self, index_or_slice: Union[int, slice]):
+        if isinstance(index_or_slice, slice):
+            if index_or_slice.step is not None and index_or_slice.step != 1:
+                raise ValueError(f"{self.__class__.__name__}.__getitem__ only supports slices with step=1")
+            if index_or_slice.start is None:
+                new_start = self.start
+            else:
+                new_start = self.start + index_or_slice.start
+            if index_or_slice.stop is None:
+                new_end = self.end
+            elif index_or_slice.stop < 0:
+                new_end = self.end + index_or_slice.stop
+            else:
+                new_end = self.start + index_or_slice.stop
+            if new_start > self.end:
+                new_start = self.end
+            if new_end < new_start or new_end > self.end:
+                new_end = new_start
+            return Segment(new_start, new_end)
+        elif self.start + index_or_slice >= self.end or (index_or_slice < 0 and -index_or_slice > len(self)):
+            raise IndexError(index_or_slice)
+        elif index_or_slice < 0:
+            return Segment(self.end + index_or_slice, self.end + index_or_slice + 1)
+        else:
+            return Segment(self.start + index_or_slice, self.start + index_or_slice + 1)
+
+
+class ASTNode:
+    """Represents an element in a parse."""
+
+    def __init__(
+            self,
+            name: str,
+            segment: Segment,
+            offset: int,
+            parent: Optional["CompoundNode"] = None
+    ):
+        self.name: str = name
+        self.segment: Segment = segment
+        self.offset: int = offset
+        if parent is None:
+            if not isinstance(self, RootNode):
+                raise ValueError(f"Only a RootNode can have no parent, not {self!r}")
+            self.root: RootNode = self
+            self.level: int = 0
+        else:
+            self.root = parent.root
+            self.level = parent.level + 1
+        self.parent: Optional[CompoundNode] = parent
+
+    def dfs(self) -> Iterator["ASTNode"]:
+        yield self
+
+    @property
+    def start(self) -> int:
+        return self.offset + self.segment.start
+
+    @property
+    def end(self) -> int:
+        return self.offset + self.segment.end
+
+    @property
+    def raw_value(self):
+        """Sequence of bytes of this segment."""
+        return self.root.get_value(self.start, self.end)
+
+    @property
+    def size(self) -> int:
+        return self.end - self.start
+
+    @property
+    def children(self) -> List["ASTNode"]:
+        return []
+
+    def __repr__(self):
+        return f"{self.name}({self.__class__.__name__}) [{self.start}:{self.end}]"
+
+
+class ValueNode(ASTNode):
+    """A leaf in the parse tree."""
+
+    TYPES = (int, float, str, bytes, Enum)
+
+    def __init__(self, value: bytes, *args, **kwargs):
+        self._value: bytes = value
+        super().__init__(*args, **kwargs)
+
+    @property
+    def value(self) -> bytes:
+        return self._value
+
+    def __repr__(self):
+        return f"{self.name}({self.__class__.__name__}<{self.value.__class__.__name__}>) [{self.start}:{self.end}]"
+
+
+class CompoundNode(ASTNode, ABC):
+    """A node that can have children"""
+
+    def __init__(self, obj: KaitaiStruct, *args, **kwargs):
+        self.obj: KaitaiStruct = obj
+        super().__init__(*args, **kwargs)
+        self._children: Optional[List[ASTNode]] = None
+
+    @property
+    def children(self) -> List[ASTNode]:
+        if self._children is None:
+            self._children = list(self.explore())
+        return self._children
+
+    @abstractmethod
+    def explore(self) -> Iterator[ASTNode]:
+        raise NotImplementedError()
+
+    def dfs(self) -> Iterator[ASTNode]:
+        stack = [self]
+        while stack:
+            top = stack.pop()
+            yield top
+            stack.extend(reversed(top.children))
+
+    def make_child(
+            self,
+            obj: KaitaiStruct,
+            name: str,
+            segment: Segment,
+            offset: int,
+    ) -> ASTNode:
+        if isinstance(obj, KaitaiStruct):
+            node_class = StructNode
+        elif isinstance(obj, ValueNode.TYPES):
+            node_class = ValueNode
+        elif isinstance(obj, list):
+            node_class = ArrayNode
+        else:
+            raise TypeError(f"Unknown object type: {type(obj)}")
+
+        return node_class(obj, name, segment, offset, self)
+
+
+class StructNode(CompoundNode):
+    """Represents node of the subtype."""
+
+    def explore(self) -> Iterator[ASTNode]:
+        for name in self.obj.SEQ_FIELDS:
+            markers = self.obj._debug[name].copy()
+            if "arr" in markers:
+                del markers["arr"]
+            if "start" not in markers or "end" not in markers:
+                continue
+            segment = Segment(**markers)
+            offset = self.offset
+            if isinstance(self.parent, StructNode):
+                if self.obj._io != self.parent.obj._io:
+                    offset = self.start
+            if hasattr(self.obj, name):
+                yield self.make_child(getattr(self.obj, name), name, segment, offset)
+
+
+class ArrayNode(CompoundNode):
+    """Represents node of array of subtype items."""
+
+    def explore(self) -> Iterator[ASTNode]:
+        for i, obj in enumerate(self.obj):
+            markers = self.parent.obj._debug[self.name]["arr"][i]
+            segment = Segment(**markers)
+            name = f"{self.name}[{i}]"
+            yield self.make_child(obj, name, segment, self.offset)
+
+
+class RootNode(StructNode):
+    def __init__(self, buffer: bytes, obj: KaitaiStruct):
+        self.buffer: bytes = buffer
+        super().__init__(obj, name=obj.__class__.__name__, segment=Segment(0, len(self.buffer)), offset=0)
+
+    def get_value(self, start, end):
+        return self.buffer[start:end]
+
+
+class KaitaiInspector:
+    def __init__(self, struct: KaitaiStruct):
+        self.struct: KaitaiStruct = struct
+        self._ast: Optional[RootNode] = None
+
+    @property
+    def ast(self) -> RootNode:
+        if self._ast is None:
+            _io = self.struct._io._io
+            if isinstance(_io, FileStream):
+                buffer = _io.content
+            elif isinstance(_io, BytesIO):
+                buffer = _io.getbuffer().tobytes()
+            elif isinstance(_io, BufferedReader):
+                with open(self.struct._io._io.name, 'rb') as f:
+                    buffer = f.read()
+            else:
+                raise TypeError('Unsupported stream type')
+
+            self._ast = RootNode(buffer, self.struct)
+
+        return self._ast
+
+
+class KaitaiParser:
+    def __init__(self, struct_type: Type[KaitaiStruct]):
+        self.struct_type: Type[KaitaiStruct] = struct_type
+
+    @staticmethod
+    def load(ksy_path: str) -> "KaitaiParser":
+        """Returns a parser for the given KSY file and input file.
+
+        The KSY file is specified as a relative path to the file within the Kaitai struct format library.
+        Examples:
+
+             "executable/dos_mz.ksy"
+             "image/jpeg.ksy"
+             "network/pcap.ksy"
+
+        """
+        if ksy_path not in _PARSERS_BY_KSY:
+            if ksy_path not in COMPILED_INFO_BY_KSY:
+                raise KeyError(ksy_path)
+            info = COMPILED_INFO_BY_KSY[ksy_path]
+            _PARSERS_BY_KSY[ksy_path] = import_spec(info)  # type: ignore
+        return KaitaiParser(_PARSERS_BY_KSY[ksy_path])
+
+    def parse(self, input_file_path_or_content: Union[str, Path, bytes, BytesIO]) -> KaitaiInspector:
+        if isinstance(input_file_path_or_content, Path):
+            input_file_path_or_content = str(input_file_path_or_content)
+        if isinstance(input_file_path_or_content, str):
+            struct = self.struct_type.from_file(input_file_path_or_content)
+        elif isinstance(input_file_path_or_content, bytes):
+            struct = self.struct_type.from_bytes(input_file_path_or_content)
+        else:
+            # Treat it like BytesIO
+            struct = self.struct_type.from_io(input_file_path_or_content)
+        struct._read()
+        return KaitaiInspector(struct)

polyfile/kaitai/parsers/aix_utmp.py

@@ -0,0 +1,116 @@
+# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
+
+from pkg_resources import parse_version
+import kaitaistruct
+from kaitaistruct import KaitaiStruct, KaitaiStream, BytesIO
+from enum import Enum
+import collections
+
+
+if parse_version(kaitaistruct.__version__) < parse_version('0.9'):
+    raise Exception("Incompatible Kaitai Struct Python API: 0.9 or later is required, but you have %s" % (kaitaistruct.__version__))
+
+class AixUtmp(KaitaiStruct):
+    """This spec can be used to parse utmp, wtmp and other similar as created by IBM AIX.
+    
+    .. seealso::
+       Source - https://www.ibm.com/docs/en/aix/7.1?topic=files-utmph-file
+    """
+
+    class EntryType(Enum):
+        empty = 0
+        run_lvl = 1
+        boot_time = 2
+        old_time = 3
+        new_time = 4
+        init_process = 5
+        login_process = 6
+        user_process = 7
+        dead_process = 8
+        accounting = 9
+    SEQ_FIELDS = ["records"]
+    def __init__(self, _io, _parent=None, _root=None):
+        self._io = _io
+        self._parent = _parent
+        self._root = _root if _root else self
+        self._debug = collections.defaultdict(dict)
+
+    def _read(self):
+        self._debug['records']['start'] = self._io.pos()
+        self.records = []
+        i = 0
+        while not self._io.is_eof():
+            if not 'arr' in self._debug['records']:
+                self._debug['records']['arr'] = []
+            self._debug['records']['arr'].append({'start': self._io.pos()})
+            _t_records = AixUtmp.Record(self._io, self, self._root)
+            _t_records._read()
+            self.records.append(_t_records)
+            self._debug['records']['arr'][len(self.records) - 1]['end'] = self._io.pos()
+            i += 1
+
+        self._debug['records']['end'] = self._io.pos()
+
+    class Record(KaitaiStruct):
+        SEQ_FIELDS = ["user", "inittab_id", "device", "pid", "type", "timestamp", "exit_status", "hostname", "dbl_word_pad", "reserved_a", "reserved_v"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['user']['start'] = self._io.pos()
+            self.user = (self._io.read_bytes(256)).decode(u"ascii")
+            self._debug['user']['end'] = self._io.pos()
+            self._debug['inittab_id']['start'] = self._io.pos()
+            self.inittab_id = (self._io.read_bytes(14)).decode(u"ascii")
+            self._debug['inittab_id']['end'] = self._io.pos()
+            self._debug['device']['start'] = self._io.pos()
+            self.device = (self._io.read_bytes(64)).decode(u"ascii")
+            self._debug['device']['end'] = self._io.pos()
+            self._debug['pid']['start'] = self._io.pos()
+            self.pid = self._io.read_u8be()
+            self._debug['pid']['end'] = self._io.pos()
+            self._debug['type']['start'] = self._io.pos()
+            self.type = KaitaiStream.resolve_enum(AixUtmp.EntryType, self._io.read_s2be())
+            self._debug['type']['end'] = self._io.pos()
+            self._debug['timestamp']['start'] = self._io.pos()
+            self.timestamp = self._io.read_s8be()
+            self._debug['timestamp']['end'] = self._io.pos()
+            self._debug['exit_status']['start'] = self._io.pos()
+            self.exit_status = AixUtmp.ExitStatus(self._io, self, self._root)
+            self.exit_status._read()
+            self._debug['exit_status']['end'] = self._io.pos()
+            self._debug['hostname']['start'] = self._io.pos()
+            self.hostname = (self._io.read_bytes(256)).decode(u"ascii")
+            self._debug['hostname']['end'] = self._io.pos()
+            self._debug['dbl_word_pad']['start'] = self._io.pos()
+            self.dbl_word_pad = self._io.read_s4be()
+            self._debug['dbl_word_pad']['end'] = self._io.pos()
+            self._debug['reserved_a']['start'] = self._io.pos()
+            self.reserved_a = self._io.read_bytes(8)
+            self._debug['reserved_a']['end'] = self._io.pos()
+            self._debug['reserved_v']['start'] = self._io.pos()
+            self.reserved_v = self._io.read_bytes(24)
+            self._debug['reserved_v']['end'] = self._io.pos()
+
+
+    class ExitStatus(KaitaiStruct):
+        SEQ_FIELDS = ["termination_code", "exit_code"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['termination_code']['start'] = self._io.pos()
+            self.termination_code = self._io.read_s2be()
+            self._debug['termination_code']['end'] = self._io.pos()
+            self._debug['exit_code']['start'] = self._io.pos()
+            self.exit_code = self._io.read_s2be()
+            self._debug['exit_code']['end'] = self._io.pos()
+
+
+