polyfile-weave 0.5.5__py3-none-any.whl

polyfile/kaitai/parsers/pcx.py

@@ -0,0 +1,195 @@
+# 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 Pcx(KaitaiStruct):
+    """PCX is a bitmap image format originally used by PC Paintbrush from
+    ZSoft Corporation. Originally, it was a relatively simple 128-byte
+    header + uncompressed bitmap format, but latest versions introduced
+    more complicated palette support and RLE compression.
+    
+    There's an option to encode 32-bit or 16-bit RGBA pixels, and thus
+    it can potentially include transparency. Theoretically, it's
+    possible to encode resolution or pixel density in the some of the
+    header fields too, but in reality there's no uniform standard for
+    these, so different implementations treat these differently.
+    
+    PCX format was never made a formal standard. "ZSoft Corporation
+    Technical Reference Manual" for "Image File (.PCX) Format", last
+    updated in 1991, is likely the closest authoritative source.
+    
+    .. seealso::
+       Source - https://web.archive.org/web/20100206055706/http://www.qzx.com/pc-gpe/pcx.txt
+    """
+
+    class Versions(Enum):
+        v2_5 = 0
+        v2_8_with_palette = 2
+        v2_8_without_palette = 3
+        paintbrush_for_windows = 4
+        v3_0 = 5
+
+    class Encodings(Enum):
+        rle = 1
+    SEQ_FIELDS = ["hdr"]
+    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['hdr']['start'] = self._io.pos()
+        self._raw_hdr = self._io.read_bytes(128)
+        _io__raw_hdr = KaitaiStream(BytesIO(self._raw_hdr))
+        self.hdr = Pcx.Header(_io__raw_hdr, self, self._root)
+        self.hdr._read()
+        self._debug['hdr']['end'] = self._io.pos()
+
+    class Header(KaitaiStruct):
+        """
+        .. seealso::
+           - "ZSoft .PCX FILE HEADER FORMAT" - https://web.archive.org/web/20100206055706/http://www.qzx.com/pc-gpe/pcx.txt
+        """
+        SEQ_FIELDS = ["magic", "version", "encoding", "bits_per_pixel", "img_x_min", "img_y_min", "img_x_max", "img_y_max", "hdpi", "vdpi", "palette_16", "reserved", "num_planes", "bytes_per_line", "palette_info", "h_screen_size", "v_screen_size"]
+        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['magic']['start'] = self._io.pos()
+            self.magic = self._io.read_bytes(1)
+            self._debug['magic']['end'] = self._io.pos()
+            if not self.magic == b"\x0A":
+                raise kaitaistruct.ValidationNotEqualError(b"\x0A", self.magic, self._io, u"/types/header/seq/0")
+            self._debug['version']['start'] = self._io.pos()
+            self.version = KaitaiStream.resolve_enum(Pcx.Versions, self._io.read_u1())
+            self._debug['version']['end'] = self._io.pos()
+            self._debug['encoding']['start'] = self._io.pos()
+            self.encoding = KaitaiStream.resolve_enum(Pcx.Encodings, self._io.read_u1())
+            self._debug['encoding']['end'] = self._io.pos()
+            self._debug['bits_per_pixel']['start'] = self._io.pos()
+            self.bits_per_pixel = self._io.read_u1()
+            self._debug['bits_per_pixel']['end'] = self._io.pos()
+            self._debug['img_x_min']['start'] = self._io.pos()
+            self.img_x_min = self._io.read_u2le()
+            self._debug['img_x_min']['end'] = self._io.pos()
+            self._debug['img_y_min']['start'] = self._io.pos()
+            self.img_y_min = self._io.read_u2le()
+            self._debug['img_y_min']['end'] = self._io.pos()
+            self._debug['img_x_max']['start'] = self._io.pos()
+            self.img_x_max = self._io.read_u2le()
+            self._debug['img_x_max']['end'] = self._io.pos()
+            self._debug['img_y_max']['start'] = self._io.pos()
+            self.img_y_max = self._io.read_u2le()
+            self._debug['img_y_max']['end'] = self._io.pos()
+            self._debug['hdpi']['start'] = self._io.pos()
+            self.hdpi = self._io.read_u2le()
+            self._debug['hdpi']['end'] = self._io.pos()
+            self._debug['vdpi']['start'] = self._io.pos()
+            self.vdpi = self._io.read_u2le()
+            self._debug['vdpi']['end'] = self._io.pos()
+            self._debug['palette_16']['start'] = self._io.pos()
+            self.palette_16 = self._io.read_bytes(48)
+            self._debug['palette_16']['end'] = self._io.pos()
+            self._debug['reserved']['start'] = self._io.pos()
+            self.reserved = self._io.read_bytes(1)
+            self._debug['reserved']['end'] = self._io.pos()
+            if not self.reserved == b"\x00":
+                raise kaitaistruct.ValidationNotEqualError(b"\x00", self.reserved, self._io, u"/types/header/seq/11")
+            self._debug['num_planes']['start'] = self._io.pos()
+            self.num_planes = self._io.read_u1()
+            self._debug['num_planes']['end'] = self._io.pos()
+            self._debug['bytes_per_line']['start'] = self._io.pos()
+            self.bytes_per_line = self._io.read_u2le()
+            self._debug['bytes_per_line']['end'] = self._io.pos()
+            self._debug['palette_info']['start'] = self._io.pos()
+            self.palette_info = self._io.read_u2le()
+            self._debug['palette_info']['end'] = self._io.pos()
+            self._debug['h_screen_size']['start'] = self._io.pos()
+            self.h_screen_size = self._io.read_u2le()
+            self._debug['h_screen_size']['end'] = self._io.pos()
+            self._debug['v_screen_size']['start'] = self._io.pos()
+            self.v_screen_size = self._io.read_u2le()
+            self._debug['v_screen_size']['end'] = self._io.pos()
+
+
+    class TPalette256(KaitaiStruct):
+        SEQ_FIELDS = ["magic", "colors"]
+        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['magic']['start'] = self._io.pos()
+            self.magic = self._io.read_bytes(1)
+            self._debug['magic']['end'] = self._io.pos()
+            if not self.magic == b"\x0C":
+                raise kaitaistruct.ValidationNotEqualError(b"\x0C", self.magic, self._io, u"/types/t_palette_256/seq/0")
+            self._debug['colors']['start'] = self._io.pos()
+            self.colors = [None] * (256)
+            for i in range(256):
+                if not 'arr' in self._debug['colors']:
+                    self._debug['colors']['arr'] = []
+                self._debug['colors']['arr'].append({'start': self._io.pos()})
+                _t_colors = Pcx.Rgb(self._io, self, self._root)
+                _t_colors._read()
+                self.colors[i] = _t_colors
+                self._debug['colors']['arr'][i]['end'] = self._io.pos()
+
+            self._debug['colors']['end'] = self._io.pos()
+
+
+    class Rgb(KaitaiStruct):
+        SEQ_FIELDS = ["r", "g", "b"]
+        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['r']['start'] = self._io.pos()
+            self.r = self._io.read_u1()
+            self._debug['r']['end'] = self._io.pos()
+            self._debug['g']['start'] = self._io.pos()
+            self.g = self._io.read_u1()
+            self._debug['g']['end'] = self._io.pos()
+            self._debug['b']['start'] = self._io.pos()
+            self.b = self._io.read_u1()
+            self._debug['b']['end'] = self._io.pos()
+
+
+    @property
+    def palette_256(self):
+        """
+        .. seealso::
+           - "VGA 256 Color Palette Information" - https://web.archive.org/web/20100206055706/http://www.qzx.com/pc-gpe/pcx.txt
+        """
+        if hasattr(self, '_m_palette_256'):
+            return self._m_palette_256 if hasattr(self, '_m_palette_256') else None
+
+        if  ((self.hdr.version == Pcx.Versions.v3_0) and (self.hdr.bits_per_pixel == 8) and (self.hdr.num_planes == 1)) :
+            _pos = self._io.pos()
+            self._io.seek((self._io.size() - 769))
+            self._debug['_m_palette_256']['start'] = self._io.pos()
+            self._m_palette_256 = Pcx.TPalette256(self._io, self, self._root)
+            self._m_palette_256._read()
+            self._debug['_m_palette_256']['end'] = self._io.pos()
+            self._io.seek(_pos)
+
+        return self._m_palette_256 if hasattr(self, '_m_palette_256') else None
+
+

polyfile/kaitai/parsers/pcx_dcx.py

@@ -0,0 +1,79 @@
+# 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
+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__))
+
+from polyfile.kaitai.parsers import pcx
+class PcxDcx(KaitaiStruct):
+    """DCX is a simple extension of PCX image format allowing to bundle
+    many PCX images (typically, pages of a document) in one file. It saw
+    some limited use in DOS-era fax software, but was largely
+    superseded with multi-page TIFFs and PDFs since then.
+    """
+    SEQ_FIELDS = ["magic", "files"]
+    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['magic']['start'] = self._io.pos()
+        self.magic = self._io.read_bytes(4)
+        self._debug['magic']['end'] = self._io.pos()
+        if not self.magic == b"\xB1\x68\xDE\x3A":
+            raise kaitaistruct.ValidationNotEqualError(b"\xB1\x68\xDE\x3A", self.magic, self._io, u"/seq/0")
+        self._debug['files']['start'] = self._io.pos()
+        self.files = []
+        i = 0
+        while True:
+            if not 'arr' in self._debug['files']:
+                self._debug['files']['arr'] = []
+            self._debug['files']['arr'].append({'start': self._io.pos()})
+            _t_files = PcxDcx.PcxOffset(self._io, self, self._root)
+            _t_files._read()
+            _ = _t_files
+            self.files.append(_)
+            self._debug['files']['arr'][len(self.files) - 1]['end'] = self._io.pos()
+            if _.ofs_body == 0:
+                break
+            i += 1
+        self._debug['files']['end'] = self._io.pos()
+
+    class PcxOffset(KaitaiStruct):
+        SEQ_FIELDS = ["ofs_body"]
+        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['ofs_body']['start'] = self._io.pos()
+            self.ofs_body = self._io.read_u4le()
+            self._debug['ofs_body']['end'] = self._io.pos()
+
+        @property
+        def body(self):
+            if hasattr(self, '_m_body'):
+                return self._m_body if hasattr(self, '_m_body') else None
+
+            if self.ofs_body != 0:
+                _pos = self._io.pos()
+                self._io.seek(self.ofs_body)
+                self._debug['_m_body']['start'] = self._io.pos()
+                self._m_body = pcx.Pcx(self._io)
+                self._m_body._read()
+                self._debug['_m_body']['end'] = self._io.pos()
+                self._io.seek(_pos)
+
+            return self._m_body if hasattr(self, '_m_body') else None
+
+
+

polyfile/kaitai/parsers/phar_without_stub.py

@@ -0,0 +1,399 @@
+# 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__))
+
+from polyfile.kaitai.parsers import php_serialized_value
+class PharWithoutStub(KaitaiStruct):
+    """A phar (PHP archive) file. The phar format is a custom archive format
+    from the PHP ecosystem that is used to package a complete PHP library
+    or application into a single self-contained archive.
+    All phar archives start with an executable PHP stub, which can be used to
+    allow executing or including phar files as if they were regular PHP scripts.
+    PHP 5.3 and later include the phar extension, which adds native support for
+    reading and manipulating phar files.
+    
+    The phar format was originally developed as part of the PEAR library
+    PHP_Archive, first released in 2005. Later, a native PHP extension
+    named "phar" was developed, which was first released on PECL in 2007,
+    and is included with PHP 5.3 and later. The phar extension has effectively
+    superseded the PHP_Archive library, which has not been updated since 2010.
+    The phar extension is also no longer released independently on PECL;
+    it is now developed and released as part of PHP itself.
+    
+    Because of current limitations in Kaitai Struct
+    (seekaitai-io/kaitai_struct#158 and kaitai-io/kaitai_struct#538),
+    the executable PHP stub that precedes the rest of the archive is not handled
+    by this spec. Before parsing a phar using this spec, the stub must be
+    removed manually.
+    
+    A phar's stub is terminated by the special token `__HALT_COMPILER();`
+    (which may be followed by at most one space, the PHP tag end `?>`,
+    and an optional line terminator). The stub termination sequence is
+    immediately followed by the remaining parts of the phar format,
+    as described in this spec.
+    
+    The phar stub usually contains code that loads the phar and runs
+    a contained PHP file, but this is not required. A minimal valid phar stub
+    is `<?php __HALT_COMPILER();` - such a stub makes it impossible to execute
+    the phar directly, but still allows loading or manipulating it using the
+    phar extension.
+    
+    Note: The phar format does not specify any encoding for text fields
+    (stub, alias name, and all file names), so these fields may contain arbitrary
+    binary data. The actual text encoding used in a specific phar file usually
+    depends on the application that created the phar, and on the
+    standard encoding of the system on which the phar was created.
+    
+    .. seealso::
+       Source - https://www.php.net/manual/en/phar.fileformat.php
+    
+    
+    .. seealso::
+       Source - https://github.com/php/php-src/tree/master/ext/phar
+    
+    
+    .. seealso::
+       Source - https://svn.php.net/viewvc/pecl/phar/
+    
+    
+    .. seealso::
+       Source - https://svn.php.net/viewvc/pear/packages/PHP_Archive/
+    """
+
+    class SignatureType(Enum):
+        md5 = 1
+        sha1 = 2
+        sha256 = 4
+        sha512 = 8
+        openssl = 16
+    SEQ_FIELDS = ["manifest", "files", "signature"]
+    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['manifest']['start'] = self._io.pos()
+        self.manifest = PharWithoutStub.Manifest(self._io, self, self._root)
+        self.manifest._read()
+        self._debug['manifest']['end'] = self._io.pos()
+        self._debug['files']['start'] = self._io.pos()
+        self.files = [None] * (self.manifest.num_files)
+        for i in range(self.manifest.num_files):
+            if not 'arr' in self._debug['files']:
+                self._debug['files']['arr'] = []
+            self._debug['files']['arr'].append({'start': self._io.pos()})
+            self.files[i] = self._io.read_bytes(self.manifest.file_entries[i].len_data_compressed)
+            self._debug['files']['arr'][i]['end'] = self._io.pos()
+
+        self._debug['files']['end'] = self._io.pos()
+        if self.manifest.flags.has_signature:
+            self._debug['signature']['start'] = self._io.pos()
+            self._raw_signature = self._io.read_bytes_full()
+            _io__raw_signature = KaitaiStream(BytesIO(self._raw_signature))
+            self.signature = PharWithoutStub.Signature(_io__raw_signature, self, self._root)
+            self.signature._read()
+            self._debug['signature']['end'] = self._io.pos()
+
+
+    class SerializedValue(KaitaiStruct):
+        SEQ_FIELDS = ["raw"]
+        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['raw']['start'] = self._io.pos()
+            self.raw = self._io.read_bytes_full()
+            self._debug['raw']['end'] = self._io.pos()
+
+        @property
+        def parsed(self):
+            """The serialized value, parsed as a structure."""
+            if hasattr(self, '_m_parsed'):
+                return self._m_parsed if hasattr(self, '_m_parsed') else None
+
+            _pos = self._io.pos()
+            self._io.seek(0)
+            self._debug['_m_parsed']['start'] = self._io.pos()
+            self._m_parsed = php_serialized_value.PhpSerializedValue(self._io)
+            self._m_parsed._read()
+            self._debug['_m_parsed']['end'] = self._io.pos()
+            self._io.seek(_pos)
+            return self._m_parsed if hasattr(self, '_m_parsed') else None
+
+
+    class Signature(KaitaiStruct):
+        SEQ_FIELDS = ["data", "type", "magic"]
+        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['data']['start'] = self._io.pos()
+            self.data = self._io.read_bytes(((self._io.size() - self._io.pos()) - 8))
+            self._debug['data']['end'] = self._io.pos()
+            self._debug['type']['start'] = self._io.pos()
+            self.type = KaitaiStream.resolve_enum(PharWithoutStub.SignatureType, self._io.read_u4le())
+            self._debug['type']['end'] = self._io.pos()
+            self._debug['magic']['start'] = self._io.pos()
+            self.magic = self._io.read_bytes(4)
+            self._debug['magic']['end'] = self._io.pos()
+            if not self.magic == b"\x47\x42\x4D\x42":
+                raise kaitaistruct.ValidationNotEqualError(b"\x47\x42\x4D\x42", self.magic, self._io, u"/types/signature/seq/2")
+
+
+    class FileFlags(KaitaiStruct):
+        SEQ_FIELDS = ["value"]
+        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['value']['start'] = self._io.pos()
+            self.value = self._io.read_u4le()
+            self._debug['value']['end'] = self._io.pos()
+
+        @property
+        def permissions(self):
+            """The file's permission bits."""
+            if hasattr(self, '_m_permissions'):
+                return self._m_permissions if hasattr(self, '_m_permissions') else None
+
+            self._m_permissions = (self.value & 511)
+            return self._m_permissions if hasattr(self, '_m_permissions') else None
+
+        @property
+        def zlib_compressed(self):
+            """Whether this file's data is stored using zlib compression."""
+            if hasattr(self, '_m_zlib_compressed'):
+                return self._m_zlib_compressed if hasattr(self, '_m_zlib_compressed') else None
+
+            self._m_zlib_compressed = (self.value & 4096) != 0
+            return self._m_zlib_compressed if hasattr(self, '_m_zlib_compressed') else None
+
+        @property
+        def bzip2_compressed(self):
+            """Whether this file's data is stored using bzip2 compression."""
+            if hasattr(self, '_m_bzip2_compressed'):
+                return self._m_bzip2_compressed if hasattr(self, '_m_bzip2_compressed') else None
+
+            self._m_bzip2_compressed = (self.value & 8192) != 0
+            return self._m_bzip2_compressed if hasattr(self, '_m_bzip2_compressed') else None
+
+
+    class ApiVersion(KaitaiStruct):
+        """A phar API version number. This version number is meant to indicate
+        which features are used in a specific phar, so that tools reading
+        the phar can easily check that they support all necessary features.
+        
+        The following API versions exist so far:
+        
+        * 0.5, 0.6, 0.7, 0.7.1: The first official API versions. At this point,
+          the phar format was only used by the PHP_Archive library, and the
+          API version numbers were identical to the PHP_Archive versions that
+          supported them. Development of the native phar extension started around
+          API version 0.7. These API versions could only be queried using the
+          `PHP_Archive::APIversion()` method, but were not stored physically
+          in archives. These API versions are not supported by this spec.
+        * 0.8.0: Used by PHP_Archive 0.8.0 (released 2006-07-18) and
+          later development versions of the phar extension. This is the first
+          version number to be physically stored in archives. This API version
+          is not supported by this spec.
+        * 0.9.0: Used by later development/early beta versions of the
+          phar extension. Also temporarily used by PHP_Archive 0.9.0
+          (released 2006-12-15), but reverted back to API version 0.8.0 in
+          PHP_Archive 0.9.1 (released 2007-01-05).
+        * 1.0.0: Supported since PHP_Archive 0.10.0 (released 2007-05-29)
+          and phar extension 1.0.0 (released 2007-03-28). This is the first
+          stable, forwards-compatible and documented version of the format.
+        * 1.1.0: Supported since PHP_Archive 0.12.0 (released 2015-07-06)
+          and phar extension 1.1.0 (released 2007-04-12). Adds SHA-256 and
+          SHA-512 signature types.
+        * 1.1.1: Supported since phar extension 2.0.0 (released 2009-07-29 and
+          included with PHP 5.3 and later). (PHP_Archive 0.12.0 also supports
+          all features from API verison 1.1.1, but it reports API version 1.1.0.)
+          Adds the OpenSSL signature type and support for storing
+          empty directories.
+        """
+        SEQ_FIELDS = ["release", "major", "minor", "unused"]
+        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['release']['start'] = self._io.pos()
+            self.release = self._io.read_bits_int_be(4)
+            self._debug['release']['end'] = self._io.pos()
+            self._debug['major']['start'] = self._io.pos()
+            self.major = self._io.read_bits_int_be(4)
+            self._debug['major']['end'] = self._io.pos()
+            self._debug['minor']['start'] = self._io.pos()
+            self.minor = self._io.read_bits_int_be(4)
+            self._debug['minor']['end'] = self._io.pos()
+            self._debug['unused']['start'] = self._io.pos()
+            self.unused = self._io.read_bits_int_be(4)
+            self._debug['unused']['end'] = self._io.pos()
+
+
+    class GlobalFlags(KaitaiStruct):
+        SEQ_FIELDS = ["value"]
+        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['value']['start'] = self._io.pos()
+            self.value = self._io.read_u4le()
+            self._debug['value']['end'] = self._io.pos()
+
+        @property
+        def any_zlib_compressed(self):
+            """Whether any of the files in this phar are stored using
+            zlib compression.
+            """
+            if hasattr(self, '_m_any_zlib_compressed'):
+                return self._m_any_zlib_compressed if hasattr(self, '_m_any_zlib_compressed') else None
+
+            self._m_any_zlib_compressed = (self.value & 4096) != 0
+            return self._m_any_zlib_compressed if hasattr(self, '_m_any_zlib_compressed') else None
+
+        @property
+        def any_bzip2_compressed(self):
+            """Whether any of the files in this phar are stored using
+            bzip2 compression.
+            """
+            if hasattr(self, '_m_any_bzip2_compressed'):
+                return self._m_any_bzip2_compressed if hasattr(self, '_m_any_bzip2_compressed') else None
+
+            self._m_any_bzip2_compressed = (self.value & 8192) != 0
+            return self._m_any_bzip2_compressed if hasattr(self, '_m_any_bzip2_compressed') else None
+
+        @property
+        def has_signature(self):
+            """Whether this phar contains a signature."""
+            if hasattr(self, '_m_has_signature'):
+                return self._m_has_signature if hasattr(self, '_m_has_signature') else None
+
+            self._m_has_signature = (self.value & 65536) != 0
+            return self._m_has_signature if hasattr(self, '_m_has_signature') else None
+
+
+    class Manifest(KaitaiStruct):
+        SEQ_FIELDS = ["len_manifest", "num_files", "api_version", "flags", "len_alias", "alias", "len_metadata", "metadata", "file_entries"]
+        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['len_manifest']['start'] = self._io.pos()
+            self.len_manifest = self._io.read_u4le()
+            self._debug['len_manifest']['end'] = self._io.pos()
+            self._debug['num_files']['start'] = self._io.pos()
+            self.num_files = self._io.read_u4le()
+            self._debug['num_files']['end'] = self._io.pos()
+            self._debug['api_version']['start'] = self._io.pos()
+            self.api_version = PharWithoutStub.ApiVersion(self._io, self, self._root)
+            self.api_version._read()
+            self._debug['api_version']['end'] = self._io.pos()
+            self._debug['flags']['start'] = self._io.pos()
+            self.flags = PharWithoutStub.GlobalFlags(self._io, self, self._root)
+            self.flags._read()
+            self._debug['flags']['end'] = self._io.pos()
+            self._debug['len_alias']['start'] = self._io.pos()
+            self.len_alias = self._io.read_u4le()
+            self._debug['len_alias']['end'] = self._io.pos()
+            self._debug['alias']['start'] = self._io.pos()
+            self.alias = self._io.read_bytes(self.len_alias)
+            self._debug['alias']['end'] = self._io.pos()
+            self._debug['len_metadata']['start'] = self._io.pos()
+            self.len_metadata = self._io.read_u4le()
+            self._debug['len_metadata']['end'] = self._io.pos()
+            if self.len_metadata != 0:
+                self._debug['metadata']['start'] = self._io.pos()
+                self._raw_metadata = self._io.read_bytes(self.len_metadata)
+                _io__raw_metadata = KaitaiStream(BytesIO(self._raw_metadata))
+                self.metadata = PharWithoutStub.SerializedValue(_io__raw_metadata, self, self._root)
+                self.metadata._read()
+                self._debug['metadata']['end'] = self._io.pos()
+
+            self._debug['file_entries']['start'] = self._io.pos()
+            self.file_entries = [None] * (self.num_files)
+            for i in range(self.num_files):
+                if not 'arr' in self._debug['file_entries']:
+                    self._debug['file_entries']['arr'] = []
+                self._debug['file_entries']['arr'].append({'start': self._io.pos()})
+                _t_file_entries = PharWithoutStub.FileEntry(self._io, self, self._root)
+                _t_file_entries._read()
+                self.file_entries[i] = _t_file_entries
+                self._debug['file_entries']['arr'][i]['end'] = self._io.pos()
+
+            self._debug['file_entries']['end'] = self._io.pos()
+
+
+    class FileEntry(KaitaiStruct):
+        SEQ_FIELDS = ["len_filename", "filename", "len_data_uncompressed", "timestamp", "len_data_compressed", "crc32", "flags", "len_metadata", "metadata"]
+        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['len_filename']['start'] = self._io.pos()
+            self.len_filename = self._io.read_u4le()
+            self._debug['len_filename']['end'] = self._io.pos()
+            self._debug['filename']['start'] = self._io.pos()
+            self.filename = self._io.read_bytes(self.len_filename)
+            self._debug['filename']['end'] = self._io.pos()
+            self._debug['len_data_uncompressed']['start'] = self._io.pos()
+            self.len_data_uncompressed = self._io.read_u4le()
+            self._debug['len_data_uncompressed']['end'] = self._io.pos()
+            self._debug['timestamp']['start'] = self._io.pos()
+            self.timestamp = self._io.read_u4le()
+            self._debug['timestamp']['end'] = self._io.pos()
+            self._debug['len_data_compressed']['start'] = self._io.pos()
+            self.len_data_compressed = self._io.read_u4le()
+            self._debug['len_data_compressed']['end'] = self._io.pos()
+            self._debug['crc32']['start'] = self._io.pos()
+            self.crc32 = self._io.read_u4le()
+            self._debug['crc32']['end'] = self._io.pos()
+            self._debug['flags']['start'] = self._io.pos()
+            self.flags = PharWithoutStub.FileFlags(self._io, self, self._root)
+            self.flags._read()
+            self._debug['flags']['end'] = self._io.pos()
+            self._debug['len_metadata']['start'] = self._io.pos()
+            self.len_metadata = self._io.read_u4le()
+            self._debug['len_metadata']['end'] = self._io.pos()
+            if self.len_metadata != 0:
+                self._debug['metadata']['start'] = self._io.pos()
+                self._raw_metadata = self._io.read_bytes(self.len_metadata)
+                _io__raw_metadata = KaitaiStream(BytesIO(self._raw_metadata))
+                self.metadata = PharWithoutStub.SerializedValue(_io__raw_metadata, self, self._root)
+                self.metadata._read()
+                self._debug['metadata']['end'] = self._io.pos()
+
+
+
+