Datasets:

AstroMLCore
/

AstroM3Dataset

"""
Like Python's zipfile, but using mmap instead of a regular file.
Helpful resources:
http://web.archive.org/web/20210219055401/https://blog.yaakov.online/zip64-go-big-or-go-home/
http://web.archive.org/web/20210310084602/https://users.cs.jmu.edu/buchhofp/forensics/formats/pkzip.html
http://web.archive.org/web/20210225050454/https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT
"""

import bz2
import lzma
import mmap
import struct
import zlib
from typing import IO, Dict, List, Optional, no_type_check


class ZipInfo:
    """Contains information about a file stored in a ParallelZipFile."""

    filename: str
    header_offset: int
    CRC: int
    compress_size: int
    file_size: int

    def __init__(
        self,
        filename: str,
        header_offset: int,
        CRC: int,
        compress_size: int,
        file_size: int,
    ) -> None:
        self.filename = filename
        self.header_offset = header_offset
        self.CRC = CRC
        self.compress_size = compress_size
        self.file_size = file_size

    def is_dir(self) -> bool:
        """Directories in a zip file should end with '/'."""
        return self.filename.endswith("/")


def _read_eocd_mmap(m: mmap.mmap) -> Dict[str, ZipInfo]:
    # Read end-of-central-directory (EOCD) from mmaped zipfile.

    # TODO Can zip64 EOCDs be larger?
    max_eocd_size = 22 + 65536
    end = m[-max_eocd_size:]

    # Scan backwards until EOCD signature is found
    # TODO this could fail if a comment contains the EOCD signature.
    # Should employ sanity check to verify that an actual EOCD was found.
    offset32 = end.rfind(b"PK\5\6")

    assert offset32 >= 0

    eocd = struct.unpack("<4sHHHHIIH", end[offset32 : offset32 + 22])

    (
        signature,
        num_disks,
        num_disks2,
        num_files,
        num_files2,
        directory_size,
        directory_offset,
        comment_length,
    ) = eocd

    assert signature == b"PK\5\6"

    # Read zip64 end of central directory if locator exists
    locator_offset = end.rfind(b"PK\6\7")
    if locator_offset != -1:
        offset, = struct.unpack("<Q", end[locator_offset + 8: locator_offset + 16])
        eocd64_data = m[offset: offset + 56]

        eocd64 = struct.unpack("<4sQHHII4Q", eocd64_data)

        (
            eocd64_signature,
            eocd_size,
            version,
            min_version,
            num_disks,
            num_disks2,
            num_files,
            num_files2,
            directory_size,
            directory_offset,
        ) = eocd64

        assert eocd64_signature == b"PK\6\6"

    # Read central directory headers which hold information about stored files
    # as long as the signature matches
    files: Dict[str, ZipInfo] = {}
    mmap_offset = directory_offset
    for _ in range(num_files):
        header = m[mmap_offset : mmap_offset + 46]
        mmap_offset += 46

        (
            signature,
            version,
            min_version,
            unused0,
            compression,
            time,
            date,
            crc32,
            compressed_size,
            uncompressed_size,
            filename_length,
            extra_length,
            comment_length,
            unused1,
            attributes0,
            attributes1,
            offset,
        ) = struct.unpack("<4s6H3I5HII", header)

        assert signature == b"PK\1\2"

        filename_bytes = m[mmap_offset : mmap_offset + filename_length]
        mmap_offset += filename_length
        extra = m[mmap_offset : mmap_offset + extra_length]
        mmap_offset += extra_length + comment_length
        for encoding in ["utf-8", "windows-1252", "CP437"]:
            try:
                filename = filename_bytes.rstrip(b"\0").decode(encoding)
                break
            except UnicodeDecodeError:
                pass
        else:
            raise ValueError(f"Could not decode filename " + str(filename_bytes))

        # TODO Figure out what those bytes mean.
        # TODO Parse extra header correctly
        extra = extra[4:]

        if uncompressed_size == 0xFFFFFFFF:
            assert len(extra) >= 8
            uncompressed_size = struct.unpack("<Q", extra[:8])[0]
            extra = extra[8:]

        if compressed_size == 0xFFFFFFFF:
            assert len(extra) >= 8
            compressed_size = struct.unpack("<Q", extra[:8])[0]
            extra = extra[8:]

        if offset == 0xFFFFFFFF:
            assert len(extra) >= 8
            offset = struct.unpack("<Q", extra[-8:])[0]
            extra = extra[8:]

        info = ZipInfo(
            filename,
            offset,
            crc32,
            compressed_size,
            uncompressed_size,
        )

        files[filename] = info

    return files


def read_files(filename: str) -> Dict[str, ZipInfo]:
    """Read ZipInfo from zip file given its file path."""
    with open(filename, "rb") as f:
        with mmap.mmap(f.fileno(), length=0, access=mmap.ACCESS_READ) as m:
            return _read_eocd_mmap(m)


class ParallelZipFile:
    """Like Python's zipfile.ZipFile, but uses mmap instead of a file object for
    reading."""

    filename: str
    files: Dict[str, ZipInfo]
    f: IO[bytes]
    m: mmap.mmap

    def __init__(
        self, file: str, mode: str = "r", files: Optional[Dict[str, ZipInfo]] = None
    ) -> None:
        assert mode == "r"

        f = open(file, "rb")
        m = mmap.mmap(f.fileno(), length=0, access=mmap.ACCESS_READ)

        if files is None:
            files = _read_eocd_mmap(m)

        self.filename: str = file
        self.files = files
        self.f = f
        self.m = m

    def __contains__(self, filename: str) -> bool:
        return filename in self.files

    def __enter__(self) -> "ParallelZipFile":
        return self

    @no_type_check
    def __exit__(self, exception_type, exception_value, exception_traceback) -> None:
        self.close()

    def close(self) -> None:
        """Close internal file and mmap objects. Will be called automatically
        when using context manager, i.e. "with" statement."""
        if not isinstance(self.m, bytes):
            self.m.close()
        self.f.close()

    def namelist(self) -> List[str]:
        """Get file names for each file stored in zip file."""
        return list(self.files.keys())

    def infolist(self) -> List[ZipInfo]:
        """Get list of ZipInfo objects for each file stored in zip file."""
        return list(self.files.values())

    def read(self, filename: str) -> bytes:
        """Get bytes for file stored in zip file given its filename."""
        files = self.files

        if filename not in files:
            raise ValueError(f"{filename} does not exist")

        fileinfo = files[filename]

        offset = fileinfo.header_offset

        m = self.m

        header = m[offset : offset + 30]

        if len(header) < 30:
            error_message = f"Header for {filename} too small ({len(header)} bytes, but must be at least 30 bytes)"
            raise ValueError(error_message)

        (
            signature,
            version,
            unused,
            compression,
            time,
            date,
            crc32,
            compressed_size,
            uncompressed_size,
            filename_length,
            extra_length,
        ) = struct.unpack("<IHHHHHIIIHH", header)

        # TODO Is this legal/the indented way to do this?
        if compressed_size != fileinfo.compress_size:
            compressed_size = fileinfo.compress_size

        offset += 30 + filename_length + extra_length

        compressed = m[offset : offset + compressed_size]
        assert signature == 0x4034B50

        if compression == 0:
            # No compression
            return compressed
        elif compression == 8:
            # DEFLATE compression
            decompress = zlib.decompressobj(-zlib.MAX_WBITS)
            return decompress.decompress(compressed)
        elif compression == 12:
            return bz2.decompress(compressed)
        elif compression == 14:
            # LZMA compression
            _, size = struct.unpack("<HH", compressed[:4])
            assert len(compressed) >= 4 + size
            filt = lzma._decode_filter_properties(lzma.FILTER_LZMA1, compressed[4:4 + size])
            decompress = lzma.LZMADecompressor(lzma.FORMAT_RAW, filters=[filt])
            decompressed = decompress.decompress(compressed[4 + size:])
            # Decompresses too much data sometimes
            decompressed = decompressed[:uncompressed_size]
            return decompressed
        else:
            error_message = f"Compression method {compression} not implemented"
            raise NotImplementedError(error_message)

	"""
	Like Python's zipfile, but using mmap instead of a regular file.

	Helpful resources:

	http://web.archive.org/web/20210219055401/https://blog.yaakov.online/zip64-go-big-or-go-home/
	http://web.archive.org/web/20210310084602/https://users.cs.jmu.edu/buchhofp/forensics/formats/pkzip.html
	http://web.archive.org/web/20210225050454/https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT
	"""

	import bz2
	import lzma
	import mmap
	import struct
	import zlib
	from typing import IO, Dict, List, Optional, no_type_check


	class ZipInfo:
	"""Contains information about a file stored in a ParallelZipFile."""

	filename: str
	header_offset: int
	CRC: int
	compress_size: int
	file_size: int

	def __init__(
	self,
	filename: str,
	header_offset: int,
	CRC: int,
	compress_size: int,
	file_size: int,
	) -> None:
	self.filename = filename
	self.header_offset = header_offset
	self.CRC = CRC
	self.compress_size = compress_size
	self.file_size = file_size

	def is_dir(self) -> bool:
	"""Directories in a zip file should end with '/'."""
	return self.filename.endswith("/")


	def _read_eocd_mmap(m: mmap.mmap) -> Dict[str, ZipInfo]:
	# Read end-of-central-directory (EOCD) from mmaped zipfile.

	# TODO Can zip64 EOCDs be larger?
	max_eocd_size = 22 + 65536
	end = m[-max_eocd_size:]

	# Scan backwards until EOCD signature is found
	# TODO this could fail if a comment contains the EOCD signature.
	# Should employ sanity check to verify that an actual EOCD was found.
	offset32 = end.rfind(b"PK\5\6")

	assert offset32 >= 0

	eocd = struct.unpack("<4sHHHHIIH", end[offset32 : offset32 + 22])

	(
	signature,
	num_disks,
	num_disks2,
	num_files,
	num_files2,
	directory_size,
	directory_offset,
	comment_length,
	) = eocd

	assert signature == b"PK\5\6"

	# Read zip64 end of central directory if locator exists
	locator_offset = end.rfind(b"PK\6\7")
	if locator_offset != -1:
	offset, = struct.unpack("<Q", end[locator_offset + 8: locator_offset + 16])
	eocd64_data = m[offset: offset + 56]

	eocd64 = struct.unpack("<4sQHHII4Q", eocd64_data)

	(
	eocd64_signature,
	eocd_size,
	version,
	min_version,
	num_disks,
	num_disks2,
	num_files,
	num_files2,
	directory_size,
	directory_offset,
	) = eocd64

	assert eocd64_signature == b"PK\6\6"

	# Read central directory headers which hold information about stored files
	# as long as the signature matches
	files: Dict[str, ZipInfo] = {}
	mmap_offset = directory_offset
	for _ in range(num_files):
	header = m[mmap_offset : mmap_offset + 46]
	mmap_offset += 46

	(
	signature,
	version,
	min_version,
	unused0,
	compression,
	time,
	date,
	crc32,
	compressed_size,
	uncompressed_size,
	filename_length,
	extra_length,
	comment_length,
	unused1,
	attributes0,
	attributes1,
	offset,
	) = struct.unpack("<4s6H3I5HII", header)

	assert signature == b"PK\1\2"

	filename_bytes = m[mmap_offset : mmap_offset + filename_length]
	mmap_offset += filename_length
	extra = m[mmap_offset : mmap_offset + extra_length]
	mmap_offset += extra_length + comment_length
	for encoding in ["utf-8", "windows-1252", "CP437"]:
	try:
	filename = filename_bytes.rstrip(b"\0").decode(encoding)
	break
	except UnicodeDecodeError:
	pass
	else:
	raise ValueError(f"Could not decode filename " + str(filename_bytes))

	# TODO Figure out what those bytes mean.
	# TODO Parse extra header correctly
	extra = extra[4:]

	if uncompressed_size == 0xFFFFFFFF:
	assert len(extra) >= 8
	uncompressed_size = struct.unpack("<Q", extra[:8])[0]
	extra = extra[8:]

	if compressed_size == 0xFFFFFFFF:
	assert len(extra) >= 8
	compressed_size = struct.unpack("<Q", extra[:8])[0]
	extra = extra[8:]

	if offset == 0xFFFFFFFF:
	assert len(extra) >= 8
	offset = struct.unpack("<Q", extra[-8:])[0]
	extra = extra[8:]

	info = ZipInfo(
	filename,
	offset,
	crc32,
	compressed_size,
	uncompressed_size,
	)

	files[filename] = info

	return files


	def read_files(filename: str) -> Dict[str, ZipInfo]:
	"""Read ZipInfo from zip file given its file path."""
	with open(filename, "rb") as f:
	with mmap.mmap(f.fileno(), length=0, access=mmap.ACCESS_READ) as m:
	return _read_eocd_mmap(m)


	class ParallelZipFile:
	"""Like Python's zipfile.ZipFile, but uses mmap instead of a file object for
	reading."""

	filename: str
	files: Dict[str, ZipInfo]
	f: IO[bytes]
	m: mmap.mmap

	def __init__(
	self, file: str, mode: str = "r", files: Optional[Dict[str, ZipInfo]] = None
	) -> None:
	assert mode == "r"

	f = open(file, "rb")
	m = mmap.mmap(f.fileno(), length=0, access=mmap.ACCESS_READ)

	if files is None:
	files = _read_eocd_mmap(m)

	self.filename: str = file
	self.files = files
	self.f = f
	self.m = m

	def __contains__(self, filename: str) -> bool:
	return filename in self.files

	def __enter__(self) -> "ParallelZipFile":
	return self

	@no_type_check
	def __exit__(self, exception_type, exception_value, exception_traceback) -> None:
	self.close()

	def close(self) -> None:
	"""Close internal file and mmap objects. Will be called automatically
	when using context manager, i.e. "with" statement."""
	if not isinstance(self.m, bytes):
	self.m.close()
	self.f.close()

	def namelist(self) -> List[str]:
	"""Get file names for each file stored in zip file."""
	return list(self.files.keys())

	def infolist(self) -> List[ZipInfo]:
	"""Get list of ZipInfo objects for each file stored in zip file."""
	return list(self.files.values())

	def read(self, filename: str) -> bytes:
	"""Get bytes for file stored in zip file given its filename."""
	files = self.files

	if filename not in files:
	raise ValueError(f"{filename} does not exist")

	fileinfo = files[filename]

	offset = fileinfo.header_offset

	m = self.m

	header = m[offset : offset + 30]

	if len(header) < 30:
	error_message = f"Header for {filename} too small ({len(header)} bytes, but must be at least 30 bytes)"
	raise ValueError(error_message)

	(
	signature,
	version,
	unused,
	compression,
	time,
	date,
	crc32,
	compressed_size,
	uncompressed_size,
	filename_length,
	extra_length,
	) = struct.unpack("<IHHHHHIIIHH", header)

	# TODO Is this legal/the indented way to do this?
	if compressed_size != fileinfo.compress_size:
	compressed_size = fileinfo.compress_size

	offset += 30 + filename_length + extra_length

	compressed = m[offset : offset + compressed_size]
	assert signature == 0x4034B50

	if compression == 0:
	# No compression
	return compressed
	elif compression == 8:
	# DEFLATE compression
	decompress = zlib.decompressobj(-zlib.MAX_WBITS)
	return decompress.decompress(compressed)
	elif compression == 12:
	return bz2.decompress(compressed)
	elif compression == 14:
	# LZMA compression
	_, size = struct.unpack("<HH", compressed[:4])
	assert len(compressed) >= 4 + size
	filt = lzma._decode_filter_properties(lzma.FILTER_LZMA1, compressed[4:4 + size])
	decompress = lzma.LZMADecompressor(lzma.FORMAT_RAW, filters=[filt])
	decompressed = decompress.decompress(compressed[4 + size:])
	# Decompresses too much data sometimes
	decompressed = decompressed[:uncompressed_size]
	return decompressed
	else:
	error_message = f"Compression method {compression} not implemented"
	raise NotImplementedError(error_message)