Datasets:
Download tools/transform.py from Battam/training-data-foundation: direct link, hf CLI and curl.
- Browser
- Download file 21.8 kB
-
https://huggingface.co/datasets/Battam/training-data-foundation/resolve/refs%2Fpr%2F54/tools/transform.py
- Command line
-
hf download hf://datasets/Battam/training-data-foundation@refs/pr/54/tools/transform.py
-
curl -L -o transform.py https://huggingface.co/datasets/Battam/training-data-foundation/resolve/refs%2Fpr%2F54/tools/transform.py
21.8 kB
| """Make a delivered file out of an upstream file: take a member out of a zip or tar archive, decompress, turn a hex | |
| dump or a uuencoded file back into bytes, recompress. | |
| Standard library only, so it can sit next to fetch.py and to_pool.py and be imported by both. | |
| A transform is a list of steps, applied in order: | |
| unzip:<member> the member with exactly this name inside a zip archive (a directory entry is refused) | |
| bunzip2 decompress bzip2 (several concatenated streams are read as one) | |
| gunzip decompress gzip (several concatenated members are read as one) | |
| unxz decompress xz (several concatenated streams are read as one) | |
| untar:<member> the member with exactly this name inside an uncompressed tar archive (put unxz, gunzip or | |
| bunzip2 before it for a compressed one); it must be a regular file, read at its full size | |
| when it is stored sparse; a member that is a link, a directory or a device is refused, and | |
| so is a name that is absolute, has a .. part, or is found more than once in the archive | |
| unxxd turn a hex dump written by xxd (or xxd -a) back into bytes, without running xxd; see below | |
| uudecode turn a uuencoded file back into bytes, without running uudecode; see below | |
| uncompress decompress a .Z file written by Unix compress (LZW), without running uncompress; see below | |
| gzip compress with gzip at level 9, modification time 0 and no file name in the header; | |
| allowed once, as the last step | |
| validate(steps) checks a list of steps and raises ValueError for anything else. | |
| apply(src_path, steps, out_path) writes the result to out_path (atomically: a temporary file in the same | |
| directory, renamed at the end) and returns {"sha256", "bytes", "content_sha256"}: the sha256 and size of the | |
| written file, and the sha256 of the bytes before a final gzip step (equal to sha256 when the last step is not | |
| gzip). The gzip bytes depend on the zlib build, so compare content_sha256 to check a transform made elsewhere. | |
| Only the named member is read out of an archive, and the result is written only to out_path: no name found | |
| inside an archive is ever used as a path. | |
| The output of unxz, untar, unxxd, uudecode and uncompress may be at most max_bytes (a keyword of apply; default | |
| MAX_BYTES, 256,000,000 bytes; None for no limit): apply stops as soon as it passes and raises TooLarge, a ValueError. | |
| A tar member whose size, counted at its expanded size when it is stored sparse, is more than the limit is refused | |
| before it is read. The other steps have no limit. | |
| unxxd reads only the default layout of xxd: each line is an offset of 8 lowercase hex digits, a colon and a | |
| space, 16 bytes in groups of two bytes (4 lowercase hex digits) parted by one space, two spaces and the text | |
| column. The text column is not compared with the bytes; it must hold one character per byte. The first line has | |
| offset 0 and each line starts where the one before it ended. Only the last line may hold fewer than 16 bytes; | |
| its hex part is padded with spaces to the full width. A line holding only * (written by xxd -a) means that the | |
| bytes from the end of the line before it up to the offset of the line after it are all zero: the line before it | |
| must hold 16 zero bytes, the line after it must be a line of bytes, and the zero bytes it stands for must be a | |
| whole number of 16-byte lines, at least one. Every line ends with a newline (a carriage return is refused), and | |
| an empty file gives an empty output. Anything else is refused: nothing is guessed. The whole dump is read and | |
| checked, and the length of the output counted, before anything is written, so a dump that is bad anywhere or | |
| whose output would pass max_bytes writes nothing. | |
| uudecode decodes the lines between the first line of the form "begin <mode> <name>" (mode in octal digits) and | |
| the first line "end" after it, each with binascii.a2b_uu; lines before the begin line and after the end line are | |
| skipped. The name on the begin line is never used: the output goes only to out_path. A file with no begin line, | |
| with a second begin line, with no end line after the begin line, or with a line between them that does not decode | |
| is refused. A line may end with a carriage return before its newline. | |
| uncompress reads the .Z format of Unix compress: the magic bytes 1f 9d, a flags byte whose low five bits are the | |
| maximum code width (9 to 16 bits) and whose high bit is block mode (code 256 then clears the table), and then LZW | |
| codes of 9 bits up to that width, packed from the low bit up. Codes are read in groups of eight, as the original | |
| compress writes them: when the width grows, or after a clear code, the remaining codes of the current group are | |
| skipped and the next group starts at the new width. As in the original compress (and in gzip -d), with a maximum | |
| width of 9 the codes still grow to 10 bits once the table is full, so a file written by ncompress -b 9 does not | |
| decode here, as it does not with ncompress or gzip either. Bits at the end too few for one more code are ignored. | |
| A wrong magic, a maximum width outside 9 to 16, a first code that is not a byte, and a code that is not yet in the | |
| table (other than the next one to be added, the KwKwK case) are refused. The output is written as it is decoded. | |
| Bad archives, a missing member and corrupt compressed data raise ValueError; reading or writing errors (a | |
| missing source file, a full disk) raise OSError. | |
| Deletes: the step outputs .transform-*.part that apply made with tempfile.mkstemp next to the output (listed one by | |
| one in its temps list), once the last one is renamed to the output or a step fails: temporary files. | |
| """ | |
| from __future__ import annotations | |
| import binascii | |
| import bz2 | |
| import gzip | |
| import hashlib | |
| import lzma | |
| import os | |
| import re | |
| import tarfile | |
| import tempfile | |
| import unicodedata | |
| import zipfile | |
| import zlib | |
| UNZIP = "unzip:" | |
| UNTAR = "untar:" | |
| SIMPLE = ("bunzip2", "gunzip", "unxz", "unxxd", "uudecode", "uncompress", "gzip") | |
| MAX_BYTES = 256_000_000 | |
| GZIP_LEVEL = 9 | |
| CHUNK = 1 << 20 | |
| XXD_WIDTH = 16 | |
| _XXD_LINE = re.compile(r"([0-9a-f]{8}): ([0-9a-f ]{39}) ([ -~]*)") | |
| _XXD_HEX = re.compile(r"(?:[0-9a-f]{4} ){0,7}(?:[0-9a-f]{4}|[0-9a-f]{2})") | |
| _XXD_LINE_MAX = 128 | |
| _UU_BEGIN = re.compile(rb"begin [0-7]{1,6} +\S.*") | |
| _UU_LINE_MAX = 1024 | |
| _Z_MAGIC = b"\x1f\x9d" | |
| _Z_BLOCK_MODE = 0x80 | |
| _Z_BITS_MASK = 0x1f | |
| _Z_INIT_BITS = 9 | |
| _Z_MAX_BITS = 16 | |
| _Z_CLEAR = 256 | |
| _Z_KEEP = 256 | |
| _ZEROS = bytes(CHUNK) | |
| _DATA_ERRORS = (OSError, EOFError, zlib.error, zipfile.BadZipFile, RuntimeError, NotImplementedError, | |
| lzma.LZMAError, tarfile.TarError) | |
| class TooLarge(ValueError): | |
| """The output of a step passed max_bytes.""" | |
| def _tar_name_problem(member: str): | |
| if re.match(r"[/\\]|[A-Za-z]:", member): | |
| return "is an absolute path" | |
| if ".." in re.split(r"[/\\]", member): | |
| return "has a .. part" | |
| return None | |
| def validate(steps) -> list: | |
| """-> the steps as a new list; ValueError unless steps is a non-empty list of known steps with gzip only last.""" | |
| if not isinstance(steps, (list, tuple)) or not steps: | |
| raise ValueError(f"transform must be a non-empty list of steps, got {steps!r}") | |
| out = [] | |
| for i, s in enumerate(steps): | |
| if not isinstance(s, str): | |
| raise ValueError(f"step {i + 1} must be a string, got {s!r}") | |
| if s.startswith(UNZIP): | |
| member = s[len(UNZIP):] | |
| if not member or member.endswith("/"): | |
| raise ValueError(f"step {i + 1}: unzip needs a file member name: {s!r}") | |
| if any(unicodedata.category(c) == "Cc" for c in member): | |
| raise ValueError(f"step {i + 1}: member name has a control character: {s!r}") | |
| elif s.startswith(UNTAR): | |
| member = s[len(UNTAR):] | |
| if not member or member.endswith("/"): | |
| raise ValueError(f"step {i + 1}: untar needs a file member name: {s!r}") | |
| if any(unicodedata.category(c) == "Cc" for c in member): | |
| raise ValueError(f"step {i + 1}: member name has a control character: {s!r}") | |
| why = _tar_name_problem(member) | |
| if why: | |
| raise ValueError(f"step {i + 1}: member name {why}: {s!r}") | |
| elif s not in SIMPLE: | |
| raise ValueError(f"step {i + 1}: unknown step {s!r} " | |
| "(use unzip:<member>, untar:<member>, bunzip2, gunzip, unxz, unxxd, uudecode, uncompress " | |
| "or gzip)") | |
| if s == "gzip" and i != len(steps) - 1: | |
| raise ValueError(f"step {i + 1}: gzip is allowed only as the last step") | |
| out.append(s) | |
| return out | |
| def _copy(fin, fout, h=None, limit=None) -> None: | |
| n = 0 | |
| while True: | |
| b = fin.read(CHUNK) | |
| if not b: | |
| return | |
| n += len(b) | |
| if limit is not None and n > limit: | |
| raise TooLarge(f"output passes the limit of {limit} bytes") | |
| if h is not None: | |
| h.update(b) | |
| fout.write(b) | |
| def _unzip(src: str, member: str, fout) -> None: | |
| with zipfile.ZipFile(src) as zf: | |
| try: | |
| info = zf.getinfo(member) | |
| except KeyError: | |
| raise ValueError(f"no member {member!r} in the zip archive") from None | |
| if info.is_dir(): | |
| raise ValueError(f"member {member!r} is a directory") | |
| with zf.open(info) as fin: | |
| _copy(fin, fout) | |
| def _untar(src: str, member: str, fout, limit) -> None: | |
| with tarfile.open(src, "r:") as tf: | |
| found = [m for m in tf.getmembers() if m.name == member] | |
| if not found: | |
| raise ValueError(f"no member {member!r} in the tar archive") | |
| if len(found) > 1: | |
| raise ValueError(f"member {member!r} is in the tar archive {len(found)} times") | |
| info = found[0] | |
| if info.issym() or info.islnk(): | |
| raise ValueError(f"member {member!r} is a link") | |
| if not info.isfile(): | |
| raise ValueError(f"member {member!r} is not a regular file") | |
| if limit is not None and info.size > limit: | |
| raise TooLarge(f"member {member!r} is {info.size} bytes" | |
| f"{' when expanded' if info.sparse else ''}, more than the limit of {limit} bytes") | |
| fin = tf.extractfile(info) | |
| _copy(fin, fout, limit=limit) | |
| def _xxd_parts(fin): | |
| """Yield the bytes a hex dump stands for, in order: a bytes object per line, an int (that many zero bytes) per * | |
| line. Raises ValueError at the first thing that does not fit the layout.""" | |
| pos = 0 | |
| last = None | |
| n = 0 | |
| while True: | |
| raw = fin.readline(_XXD_LINE_MAX) | |
| if not raw: | |
| break | |
| n += 1 | |
| if not raw.endswith(b"\n"): | |
| raise ValueError(f"line {n}: " + ("too long" if len(raw) >= _XXD_LINE_MAX else "no newline at the end")) | |
| try: | |
| line = raw[:-1].decode("ascii") | |
| except UnicodeDecodeError: | |
| raise ValueError(f"line {n}: not ASCII") from None | |
| if line == "*": | |
| if last is None: | |
| raise ValueError(f"line {n}: a * line cannot come first") | |
| if last == "*": | |
| raise ValueError(f"line {n}: two * lines in a row") | |
| if len(last) != XXD_WIDTH or any(last): | |
| raise ValueError(f"line {n}: the line before a * line must hold {XXD_WIDTH} zero bytes") | |
| last = "*" | |
| continue | |
| m = _XXD_LINE.fullmatch(line) | |
| hexpart = m.group(2).rstrip(" ") if m else "" | |
| if not m or not _XXD_HEX.fullmatch(hexpart): | |
| raise ValueError(f"line {n}: not a line of xxd output: {line[:80]!r}") | |
| data = bytes.fromhex(hexpart) | |
| if len(m.group(3)) != len(data): | |
| raise ValueError(f"line {n}: the text column has {len(m.group(3))} characters for {len(data)} bytes") | |
| if isinstance(last, bytes) and len(last) < XXD_WIDTH: | |
| raise ValueError(f"line {n - 1}: only the last line may hold fewer than {XXD_WIDTH} bytes") | |
| off = int(m.group(1), 16) | |
| if last == "*": | |
| gap = off - pos | |
| if gap <= 0: | |
| raise ValueError(f"line {n}: offset {off:08x} after a * line does not pass {pos:08x}") | |
| if gap % XXD_WIDTH: | |
| raise ValueError(f"line {n}: the * line before it stands for {gap} bytes, " | |
| f"not a whole number of {XXD_WIDTH}-byte lines") | |
| yield gap | |
| pos = off | |
| elif off != pos: | |
| raise ValueError(f"line {n}: offset {off:08x}, expected {pos:08x}") | |
| yield data | |
| pos += len(data) | |
| last = data | |
| if last == "*": | |
| raise ValueError("the dump ends with a * line") | |
| def _unxxd(src: str, fout, limit) -> None: | |
| with open(src, "rb") as fin: | |
| total = 0 | |
| for part in _xxd_parts(fin): | |
| total += part if isinstance(part, int) else len(part) | |
| if limit is not None and total > limit: | |
| raise TooLarge(f"output would pass the limit of {limit} bytes") | |
| fin.seek(0) | |
| for part in _xxd_parts(fin): | |
| if isinstance(part, int): | |
| while part: | |
| k = min(part, CHUNK) | |
| fout.write(_ZEROS[:k] if k < CHUNK else _ZEROS) | |
| part -= k | |
| else: | |
| fout.write(part) | |
| def _uu_lines(fin): | |
| """Yield (line number, line without its line end) for each line of fin; a line of _UU_LINE_MAX bytes or more | |
| is read to its end and yielded as None, so it never matches a begin or end line and never decodes.""" | |
| n = 0 | |
| while True: | |
| raw = fin.readline(_UU_LINE_MAX) | |
| if not raw: | |
| return | |
| n += 1 | |
| if len(raw) >= _UU_LINE_MAX and not raw.endswith(b"\n"): | |
| while raw and not raw.endswith(b"\n"): | |
| raw = fin.readline(CHUNK) | |
| yield n, None | |
| continue | |
| line = raw[:-1] if raw.endswith(b"\n") else raw | |
| if line.endswith(b"\r"): | |
| line = line[:-1] | |
| yield n, line | |
| def _uudecode(src: str, fout, limit) -> None: | |
| with open(src, "rb") as fin: | |
| state = "before" | |
| total = 0 | |
| for n, line in _uu_lines(fin): | |
| is_begin = line is not None and _UU_BEGIN.fullmatch(line) is not None | |
| if state == "before": | |
| if is_begin: | |
| state = "body" | |
| continue | |
| if is_begin: | |
| raise ValueError(f"line {n}: a second begin line") | |
| if state == "after": | |
| continue | |
| if line == b"end": | |
| state = "after" | |
| continue | |
| if line is None: | |
| raise ValueError(f"line {n}: too long for a uuencoded line") | |
| try: | |
| data = binascii.a2b_uu(line) | |
| except binascii.Error as e: | |
| raise ValueError(f"line {n}: does not decode: {e}") from None | |
| total += len(data) | |
| if limit is not None and total > limit: | |
| raise TooLarge(f"output passes the limit of {limit} bytes") | |
| fout.write(data) | |
| if state == "before": | |
| raise ValueError("no begin line") | |
| if state == "body": | |
| raise ValueError("no end line after the begin line") | |
| def _uncompress(src: str, fout, limit) -> None: | |
| with open(src, "rb") as fin: | |
| head = fin.read(3) | |
| if len(head) < 3 or head[:2] != _Z_MAGIC: | |
| raise ValueError("not a .Z file (no 1f 9d magic)") | |
| maxbits = head[2] & _Z_BITS_MASK | |
| block = bool(head[2] & _Z_BLOCK_MODE) | |
| if not _Z_INIT_BITS <= maxbits <= _Z_MAX_BITS: | |
| raise ValueError(f"maximum code width {maxbits} is outside {_Z_INIT_BITS} to {_Z_MAX_BITS}") | |
| maxmaxcode = 1 << maxbits | |
| # an entry is kept as bytes when it is at most _Z_KEEP bytes long, else as its prefix code and last byte | |
| strs = [bytes([i]) for i in range(256)] + [None] * (maxmaxcode - 256) | |
| pre = [0] * maxmaxcode | |
| suf = [0] * maxmaxcode | |
| n_bits = _Z_INIT_BITS | |
| maxcode = (1 << n_bits) - 1 | |
| free_ent = 257 if block else 256 | |
| oldcode = -1 | |
| prev = b"" | |
| total = 0 | |
| buf = bytearray() | |
| while True: | |
| group = fin.read(n_bits) | |
| if not group: | |
| break | |
| v = int.from_bytes(group, "little") | |
| mask = (1 << n_bits) - 1 | |
| for k in range(len(group) * 8 // n_bits): | |
| code = (v >> (k * n_bits)) & mask | |
| if oldcode == -1: | |
| if code >= 256: | |
| raise ValueError(f"first code {code} is not a byte") | |
| oldcode = code | |
| prev = strs[code] | |
| out = prev | |
| elif code == _Z_CLEAR and block: | |
| free_ent = 256 | |
| n_bits = _Z_INIT_BITS | |
| maxcode = (1 << n_bits) - 1 | |
| break | |
| else: | |
| if code > free_ent: | |
| raise ValueError(f"code {code} is not in the table (next entry is {free_ent})") | |
| if code == free_ent: | |
| out = prev + prev[:1] | |
| else: | |
| out = strs[code] | |
| if out is None: | |
| tail = [] | |
| c = code | |
| while out is None: | |
| tail.append(suf[c]) | |
| c = pre[c] | |
| out = strs[c] | |
| tail.reverse() | |
| out = out + bytes(tail) | |
| if free_ent < maxmaxcode: | |
| if len(prev) < _Z_KEEP: | |
| strs[free_ent] = prev + out[:1] | |
| else: | |
| strs[free_ent] = None | |
| pre[free_ent] = oldcode | |
| suf[free_ent] = out[0] | |
| free_ent += 1 | |
| oldcode = code | |
| prev = out | |
| total += len(out) | |
| if limit is not None and total > limit: | |
| raise TooLarge(f"output passes the limit of {limit} bytes") | |
| buf += out | |
| if len(buf) >= CHUNK: | |
| fout.write(buf) | |
| buf.clear() | |
| if free_ent > maxcode: | |
| n_bits += 1 | |
| maxcode = maxmaxcode if n_bits == maxbits else (1 << n_bits) - 1 | |
| break | |
| fout.write(buf) | |
| def _step(src: str, step: str, fout, content, limit=None) -> None: | |
| if step.startswith(UNZIP): | |
| _unzip(src, step[len(UNZIP):], fout) | |
| elif step.startswith(UNTAR): | |
| _untar(src, step[len(UNTAR):], fout, limit) | |
| elif step == "unxz": | |
| with lzma.open(src, "rb", format=lzma.FORMAT_XZ) as fin: | |
| _copy(fin, fout, limit=limit) | |
| elif step == "unxxd": | |
| _unxxd(src, fout, limit) | |
| elif step == "uudecode": | |
| _uudecode(src, fout, limit) | |
| elif step == "uncompress": | |
| _uncompress(src, fout, limit) | |
| elif step == "bunzip2": | |
| with bz2.open(src, "rb") as fin: | |
| _copy(fin, fout) | |
| elif step == "gunzip": | |
| with gzip.open(src, "rb") as fin: | |
| _copy(fin, fout) | |
| else: | |
| with open(src, "rb") as fin, gzip.GzipFile(filename="", mode="wb", fileobj=fout, | |
| compresslevel=GZIP_LEVEL, mtime=0) as gz: | |
| _copy(fin, gz, content) | |
| def _sha256_file(path: str) -> tuple: | |
| h = hashlib.sha256() | |
| n = 0 | |
| with open(path, "rb") as f: | |
| while True: | |
| b = f.read(CHUNK) | |
| if not b: | |
| return h.hexdigest(), n | |
| h.update(b) | |
| n += len(b) | |
| def apply(src_path, steps, out_path, *, max_bytes: int | None = MAX_BYTES) -> dict: | |
| """Apply steps to src_path, write out_path -> {"sha256", "bytes", "content_sha256"}. max_bytes limits the | |
| output of unxz, untar, unxxd, uudecode and uncompress (TooLarge when it passes).""" | |
| steps = validate(steps) | |
| src = os.fspath(src_path) | |
| out = os.path.abspath(os.fspath(out_path)) | |
| if not os.path.isfile(src): | |
| raise FileNotFoundError(src) | |
| d = os.path.dirname(out) | |
| os.makedirs(d, exist_ok=True) | |
| temps = [] | |
| cur = src | |
| content = None | |
| try: | |
| for i, step in enumerate(steps): | |
| fd, tmp = tempfile.mkstemp(dir=d, prefix=".transform-", suffix=".part") | |
| temps.append(tmp) | |
| if step == "gzip": | |
| content = hashlib.sha256() | |
| with os.fdopen(fd, "wb") as fout: | |
| limited = step in ("unxz", "unxxd", "uudecode", "uncompress") or step.startswith(UNTAR) | |
| try: | |
| _step(cur, step, fout, content, max_bytes if limited else None) | |
| except ValueError as e: | |
| kind = TooLarge if isinstance(e, TooLarge) else ValueError | |
| raise kind(f"step {i + 1} ({step}): {e}") from None | |
| except _DATA_ERRORS as e: | |
| if isinstance(e, OSError) and e.errno is not None: | |
| raise | |
| raise ValueError(f"step {i + 1} ({step}): {type(e).__name__}: {e}") from e | |
| cur = tmp | |
| sha, n = _sha256_file(cur) | |
| os.chmod(cur, 0o644) | |
| os.replace(cur, out) | |
| temps.remove(cur) | |
| finally: | |
| for t in temps: | |
| try: | |
| os.unlink(t) | |
| except OSError: | |
| pass | |
| return {"sha256": sha, "bytes": n, "content_sha256": content.hexdigest() if content is not None else sha} | |