Files
mtusi2026lab5/student-tests/filegen.py
T
2026-10-26 19:40:34 +03:00

435 lines
24 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""lab4–lab5: тестовые картинки и низкоуровневая загрузка — только стандартная библиотека Python.
- png(): настоящий PNG любого размера (шум не сжимается — так получаются файлы на 9 МБ);
- bomb_png(): «бомба» — файл ~150 КБ, внутри 42 млн пикселей (больше лимита 40 млн);
- SAMPLE_JPEG: синтетический JPEG 48×32 (781 байт), создан для курса программно;
- garbage_scan_jpeg(): JPEG с правильной структурой, но мусором вместо сжатых данных (lab5:
API его принимает — структура цела, а worker при строгом декодировании даёт invalid_image);
- bad_filter_png(): PNG с недопустимым типом фильтра строки (lab5: 415 уже в API);
- raw_upload(): POST через сокет. Нужен там, где urllib не справится: сервер отвечает 413
и закрывает соединение, пока клиент ещё отправляет тело, или клиент сам обрывает передачу;
- in_api() / psql(): выполнить код внутри контейнера API или SQL в PostgreSQL (для проверок
S3 и уборщика). Секреты не печатаются: код внутри контейнера сам читает их из /run/secrets.
"""
import base64
import json
import os
import select
import socket
import struct
import subprocess
import time
import zlib
from urllib.parse import urlsplit
from helpers import ROOT, Failure, check
BASE_URL = os.environ.get("BASE_URL", "http://127.0.0.1:8080").rstrip("/")
SAMPLE_PNG = (ROOT / "tests" / "fixtures" / "sample.png").read_bytes()
SAMPLE_JPEG = base64.b64decode(
"/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAYEBQYFBAYGBQYHBwYIChAKCgkJChQODwwQFxQYGBcUFhYaHSUfGhsjHBYWICwgIyYn"
"KSopGR8tMC0oMCUoKSj/2wBDAQcHBwoIChMKChMoGhYaKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgo"
"KCgoKCgoKCj/wAARCAAgADADASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUF"
"BAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVW"
"V1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi"
"4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAEC"
"AxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVm"
"Z2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq"
"8vP09fb3+Pn6/9oADAMBAAIRAxEAPwDwGCw9q0ILD2rcgsPatCCw9q+pqYw4MFj9tTDgsPatCCw9q24LD2rQgsPauCpjD67BY/bU"
"xILD2q/BYe1bkFh7VoQWHtXBUxh9dgsftqc3BYe1aEFh7VuQWHtWhBYe1cdTGH824LH7amHBYe1aEFh7VuQWHtWhBYe1cFTGH12C"
"x+2phwWHtWhBYe1bkFh7VoQWHtXn1MYfXYLH7an/2Q==")
# Ещё два синтетических JPEG 40×24 (созданы для курса Pillow): progressive и с маркерами RST (DRI = 1 MCU).
PROGRESSIVE_JPEG = base64.b64decode(
"/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAA0JCgsKCA0LCgsODg0PEyAVExISEyccHhcgLikxMC4pLSwzOko+MzZGNywtQFdBRkxOUlNS"
"Mj5aYVpQYEpRUk//2wBDAQ4ODhMREyYVFSZPNS01T09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09P"
"T0//wgARCAAYACgDASIAAhEBAxEB/8QAFwABAQEBAAAAAAAAAAAAAAAAAAMEBf/EABgBAAMBAQAAAAAAAAAAAAAAAAIDBAEG/9oADAMB"
"AAIQAxAAAAHg11WxeWuqzbMreOuNSLlrVG22B1f/xAAWEAADAAAAAAAAAAAAAAAAAAAAAQL/2gAIAQEAAQUCUCgUCgUCgUCgUCgUCgUC"
"gUH/xAAXEQADAQAAAAAAAAAAAAAAAAAAAQID/9oACAEDAQE/AY2I2FsRTIpipn//xAAXEQEBAQEAAAAAAAAAAAAAAAABABAR/9oACAEC"
"AQE/ARhuxGf/xAAUEAEAAAAAAAAAAAAAAAAAAAAw/9oACAEBAAY/An//xAAUEAEAAAAAAAAAAAAAAAAAAAAw/9oACAEBAAE/IXAAAAA/"
"/9oADAMBAAIAAwAAABBpk59wP//EABcRAQADAAAAAAAAAAAAAAAAABAAESH/2gAIAQMBAT8QKydq0//EABYRAQEBAAAAAAAAAAAAAAAA"
"AAEAEP/aAAgBAgEBPxDPK2bC3//EABUQAQEAAAAAAAAAAAAAAAAAAABh/9oACAEBAAE/EJJJJJJJJJJJJJJJP//Z")
RESTART_JPEG = base64.b64decode(
"/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAA0JCgsKCA0LCgsODg0PEyAVExISEyccHhcgLikxMC4pLSwzOko+MzZGNywtQFdBRkxOUlNS"
"Mj5aYVpQYEpRUk//2wBDAQ4ODhMREyYVFSZPNS01T09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09P"
"T0//wAARCAAYACgDASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQID"
"AAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlq"
"c3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3"
"+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEI"
"FEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImK"
"kpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/90ABAAB/9oADAMBAAIR"
"AxEAPwDg4rP2q3FZ+1akVn7Vbis/alCZz0MYf//Q5mKz9qtxWftWpFZ+1W4rP2rohM9GhjD/0c+Kz9qK34rP2orvUz6aGM0P/9J0Vn7V"
"bis/aiiuSDZ8pQqyP//T2IrP2q3FZ+1FFTBs82hVkf/U66Kz9qKKK1TZcKsrH//Z")
def _chunk(kind: bytes, data: bytes) -> bytes:
return struct.pack(">I", len(data)) + kind + data + struct.pack(">I", zlib.crc32(kind + data) & 0xFFFFFFFF)
def png(width: int, height: int, noise: bool = False) -> bytes:
"""RGB PNG. noise=True — случайные пиксели (файл почти не сжимается), иначе однотонный."""
compressor = zlib.compressobj(1)
parts = []
row = b"\x00" + b"\x40\x80\xc0" * width
for _ in range(height):
parts.append(compressor.compress(b"\x00" + os.urandom(width * 3) if noise else row))
parts.append(compressor.flush())
ihdr = struct.pack(">IIBBBBB", width, height, 8, 2, 0, 0, 0)
return b"\x89PNG\r\n\x1a\n" + _chunk(b"IHDR", ihdr) + _chunk(b"IDAT", b"".join(parts)) + _chunk(b"IEND", b"")
def bomb_png() -> bytes:
"""7000×6000 = 42 млн пикселей нулей: файл маленький, распакованный — 126 МБ."""
return png(7000, 6000)
def png_exact_size(total: int) -> bytes:
"""Корректный PNG ровно total байт: маленькая картинка + служебный блок-заполнитель (tEXt)."""
base = png(64, 64, noise=True)
head, iend = base[:-12], base[-12:]
filler = total - len(base) - 12 # 12 байт — длина, тип и CRC блока-заполнителя
check(filler >= 6, "total is too small")
return head + _chunk(b"tEXt", b"pad\x00" + b"x" * (filler - 4)) + iend
def gray_png(width: int, height: int) -> bytes:
"""Оттенки серого, нули: 40 млн пикселей сжимаются в ~40 КБ."""
compressor = zlib.compressobj(9)
row = b"\x00" + bytes(width)
data = b"".join(compressor.compress(row) for _ in range(height)) + compressor.flush()
ihdr = struct.pack(">IIBBBBB", width, height, 8, 0, 0, 0, 0)
return b"\x89PNG\r\n\x1a\n" + _chunk(b"IHDR", ihdr) + _chunk(b"IDAT", data) + _chunk(b"IEND", b"")
def bad_filter_png() -> bytes:
"""PNG 40×30, у 11-й строки тип фильтра 7 (допустимы 0–4)."""
raw = b"".join(bytes([7 if y == 10 else 0]) + bytes(40 * 3) for y in range(30))
ihdr = struct.pack(">IIBBBBB", 40, 30, 8, 2, 0, 0, 0)
return b"\x89PNG\r\n\x1a\n" + _chunk(b"IHDR", ihdr) + _chunk(b"IDAT", zlib.compress(raw)) + _chunk(b"IEND", b"")
# ---------- JPEG по сегментам: чтобы портить структуру точечно ----------
def jpeg_parts(data: bytes) -> list:
"""JPEG -> [("seg", маркер, данные) | ("scan", заголовок SOS, сжатые данные) | ("eoi", хвост)]."""
i, parts = 2, []
while True:
marker = data[i + 1]
i += 2
if marker == 0xD9:
parts.append(("eoi", data[i:]))
return parts
length = int.from_bytes(data[i:i + 2], "big")
payload, i = data[i + 2:i + length], i + length
if marker != 0xDA:
parts.append(("seg", marker, payload))
continue
j = i
while data[j] != 0xFF or data[j + 1] == 0x00 or 0xD0 <= data[j + 1] <= 0xD7:
j += 1
parts.append(("scan", payload, data[i:j]))
i = j
def jpeg_join(parts: list) -> bytes:
out = bytearray(b"\xff\xd8")
for part in parts:
if part[0] == "seg":
out += bytes([0xFF, part[1]]) + struct.pack(">H", len(part[2]) + 2) + part[2]
elif part[0] == "scan":
out += b"\xff\xda" + struct.pack(">H", len(part[1]) + 2) + part[1] + part[2]
else:
out += b"\xff\xd9" + part[1]
return bytes(out)
def _edit(data: bytes, kind, fn, index: int = 0) -> bytes:
"""Поменять index-й сегмент вида kind (маркер или "scan"): fn(bytearray) -> bytes."""
parts, seen = jpeg_parts(data), 0
for k, part in enumerate(parts):
hit = part[0] == "scan" if kind == "scan" else part[0] == "seg" and part[1] == kind
if hit:
if seen == index:
if kind == "scan":
parts[k] = ("scan", fn(bytearray(part[1])), part[2])
else:
parts[k] = ("seg", kind, fn(bytearray(part[2])))
return jpeg_join(parts)
seen += 1
raise AssertionError(f"segment {kind} #{index} not found")
def _set(position: int, value: int):
def change(payload: bytearray) -> bytes:
payload[position] = value
return bytes(payload)
return change
def teacher_bad_sos_jpeg() -> bytes:
"""Воспроизведение из замечания: в первом SOS (FF DA по смещению i) байт i+5 — первый
идентификатор компонента — заменить на 250, которого нет в SOF."""
data = bytearray(SAMPLE_JPEG)
i = data.index(b"\xff\xda")
data[i + 5] = 250
return bytes(data)
def broken_structure_jpegs() -> list[tuple[str, bytes]]:
"""JPEG, которые строгий декодер worker отвергает по маркерам и заголовкам (API: 415)."""
def drop(data, test):
return jpeg_join([p for p in jpeg_parts(data) if not test(p)])
def scans(data):
return [p for p in jpeg_parts(data) if p[0] == "scan"]
def swap_rst(entropy: bytes) -> bytes:
e = bytearray(entropy)
positions = [k for k in range(len(e) - 1) if e[k] == 0xFF and 0xD0 <= e[k + 1] <= 0xD7]
e[positions[0] + 1], e[positions[1] + 1] = e[positions[1] + 1], e[positions[0] + 1]
return bytes(e)
seq_scan = scans(SAMPLE_JPEG)[0]
first_progressive = scans(PROGRESSIVE_JPEG)[0]
no_jfif = drop(SAMPLE_JPEG, lambda p: p[0] == "seg" and p[1] == 0xE0)
restart_parts = jpeg_parts(RESTART_JPEG)
return [
("SOS: компонент 250, которого нет в SOF (замечание к MR)", teacher_bad_sos_jpeg()),
("SOS: один компонент дважды в скане", _edit(SAMPLE_JPEG, "scan", _set(3, 1))),
("SOS: таблица Хаффмана DC 2 не определена", _edit(SAMPLE_JPEG, "scan", _set(2, 0x20))),
("SOS: номер таблицы Хаффмана AC 5", _edit(SAMPLE_JPEG, "scan", _set(4, 0x05))),
("SOS: Se=62 в последовательном JPEG", _edit(SAMPLE_JPEG, "scan", _set(-2, 62))),
("SOS: Ah/Al не нули в последовательном JPEG", _edit(SAMPLE_JPEG, "scan", _set(-1, 0x10))),
("SOS: 5 компонентов в скане", _edit(SAMPLE_JPEG, "scan", _set(0, 5))),
("SOF: таблица квантования 3 не определена", _edit(SAMPLE_JPEG, 0xC0, _set(8, 3))),
("SOF: повторяется идентификатор компонента", _edit(SAMPLE_JPEG, 0xC0, _set(9, 1))),
("SOF: субдискретизация 1×4 (не понимает декодер)", _edit(SAMPLE_JPEG, 0xC0, _set(7, 0x14))),
("SOF: коэффициент субдискретизации 0", _edit(SAMPLE_JPEG, 0xC0, _set(10, 0x01))),
("SOF: 12 бит на канал", _edit(SAMPLE_JPEG, 0xC0, _set(0, 12))),
("SOF: 2 компонента", _edit(SAMPLE_JPEG, 0xC0, lambda p: bytes(p[:5]) + b"\x02" + bytes(p[6:12]))),
("DHT: коды не помещаются в длину (3 кода по 1 биту)",
_edit(SAMPLE_JPEG, 0xC4, lambda p: b"\x00" + bytes([3] + [0] * 15) + b"\x00\x01\x02")),
("DHT: символ 16 в таблице DC", _edit(SAMPLE_JPEG, 0xC4, lambda p: bytes(p[:-1]) + b"\x10")),
("DHT: номер таблицы 4", _edit(SAMPLE_JPEG, 0xC4, _set(0, 0x04))),
("DQT: таблица обрезана", _edit(SAMPLE_JPEG, 0xDB, lambda p: bytes(p[:-1]))),
("сегмент с зарезервированным маркером 0xF0",
jpeg_join([("seg", 0xF0, b"\x00\x00")] + jpeg_parts(SAMPLE_JPEG))),
("мусорные байты между сегментами", SAMPLE_JPEG.replace(b"\xff\xdb", b"\x00\x00\xff\xdb", 1)),
("APP0: JFIF версии 3", _edit(SAMPLE_JPEG, 0xE0, _set(5, 3))),
("APP14: неизвестное преобразование Adobe 7",
jpeg_join([("seg", 0xEE, b"Adobe\x00\x64\x00\x00\x00\x00\x07")] + jpeg_parts(no_jfif))),
("второй скан после полного скана",
jpeg_join(jpeg_parts(SAMPLE_JPEG)[:-1] + [seq_scan, ("eoi", b"")])),
("progressive: AC-скан раньше DC-скана", drop(PROGRESSIVE_JPEG, lambda p: p is not None and p == first_progressive)),
("progressive: Al=14", _edit(PROGRESSIVE_JPEG, "scan", _set(-1, 14))),
("RST: маркеры RST0 и RST1 поменяны местами",
jpeg_join([("scan", p[1], swap_rst(p[2])) if p[0] == "scan" else p for p in restart_parts])),
("RST: маркеры есть, а интервала DRI нет", drop(RESTART_JPEG, lambda p: p[0] == "seg" and p[1] == 0xDD)),
("RST: интервал DRI 2 вместо 1", _edit(RESTART_JPEG, 0xDD, lambda p: b"\x00\x02")),
]
def garbage_scan_jpeg() -> bytes:
"""SAMPLE_JPEG с мусором вместо сжатых данных скана: маркеры и длины целы, данные — нет."""
sos = SAMPLE_JPEG.index(b"\xff\xda")
length = int.from_bytes(SAMPLE_JPEG[sos + 2:sos + 4], "big")
noise = bytes((i * 37 + 11) % 255 for i in range(400)) # без 0xFF: маркеры не появятся
return SAMPLE_JPEG[:sos + 2 + length] + noise + b"\xff\xd9"
def corrupt_crc(data: bytes) -> bytes:
"""Испортить один байт внутри данных IDAT: контрольная сумма блока перестаёт сходиться."""
position = data.index(b"IDAT") + 8
return data[:position] + bytes([data[position] ^ 0xFF]) + data[position + 1:]
def truncated(data: bytes) -> bytes:
return data[: len(data) // 2]
# ---------- загрузка через сокет ----------
def raw_upload(path: str, token: str, body: bytes = b"", content_type: str = "image/png",
content_length: int | None = None, abort_after: int | None = None, timeout: float = 30):
"""POST path через балансировщик. Возвращает (status, headers, json) или None, если ответа нет.
content_length — что заявить в заголовке (по умолчанию len(body));
abort_after — отправить столько байт тела и оборвать соединение (имитация обрыва загрузки).
Тело шлётся кусками; если сервер уже ответил (413) и закрыл соединение — перестаём слать
и читаем ответ.
"""
url = urlsplit(BASE_URL)
sock = socket.create_connection((url.hostname, url.port or 80), timeout=timeout)
length = len(body) if content_length is None else content_length
# content_length=-1: Transfer-Encoding: chunked, размер заранее неизвестен серверу.
framing = "Transfer-Encoding: chunked" if length == -1 else f"Content-Length: {length}"
head = (f"POST {path} HTTP/1.1\r\nHost: {url.hostname}\r\nAuthorization: Bearer {token}\r\n"
f"Content-Type: {content_type}\r\n{framing}\r\nConnection: close\r\n\r\n")
to_send = body if abort_after is None else body[:abort_after]
if length == -1:
step = 64 * 1024
to_send = b"".join(b"%x\r\n%s\r\n" % (len(to_send[i:i + step]), to_send[i:i + step])
for i in range(0, len(to_send), step)) + b"0\r\n\r\n"
try:
sock.sendall(head.encode("ascii"))
for start in range(0, len(to_send), 64 * 1024):
# Сервер уже ответил (например, 413 до конца тела)? Тогда перестаём слать и читаем ответ:
# продолжение отправки в закрытое соединение может стереть ответ (RST).
if select.select([sock], [], [], 0)[0]:
break
sock.sendall(to_send[start:start + 64 * 1024])
except OSError:
pass # сервер закрыл соединение раньше — читаем то, что он успел ответить
if abort_after is not None:
sock.close()
return None
data = b""
try:
while True:
part = sock.recv(65536)
if not part:
break
data += part
if _complete(data): # ответ получен целиком: не ждём, пока балансировщик закроет соединение
break
except OSError:
pass
finally:
sock.close()
if not data.startswith(b"HTTP/1."):
return None
header_blob, _, payload = data.partition(b"\r\n\r\n")
lines = header_blob.decode("latin-1").split("\r\n")
status = int(lines[0].split()[1])
headers = {k.strip().lower(): v.strip() for k, v in (line.split(":", 1) for line in lines[1:] if ":" in line)}
try:
payload_json = json.loads(payload.decode("utf-8")) if payload else None
except ValueError:
payload_json = None
return status, headers, payload_json
def _complete(data: bytes) -> bool:
head, sep, body = data.partition(b"\r\n\r\n")
if not sep:
return False
for line in head.decode("latin-1").split("\r\n")[1:]:
name, _, value = line.partition(":")
if name.strip().lower() == "content-length":
return len(body) >= int(value.strip())
return False
def upload_when_ready(api, actor, chat, data=None, name="ready.png", seconds=60, ctype="image/png"):
"""Загрузить файл; пока стенд только запускается (503) — повторять до seconds. Возвращает ответ 202."""
path = f"/api/v1/chats/{chat['id']}/attachments?filename={name}"
deadline = time.monotonic() + seconds
while True:
try:
reply = api.call("POST", path, [202, 503], actor=actor, raw=data or SAMPLE_PNG,
headers={"Content-Type": ctype}, schema="Attachment")
except Failure: # балансировщик без готовых реплик или обрыв соединения
reply = {"status": 0}
if reply["status"] == 202:
check(reply["json"]["status"] == "queued", "upload must return a queued snapshot")
return reply
check(time.monotonic() < deadline, f"stand is not ready for uploads after {seconds} s")
time.sleep(1)
def wait_status(api, actor, attachment_id, statuses=("ready",), seconds=60, step=0.3):
"""Опрашивать GET вложения, пока статус не станет одним из statuses. Возвращает Attachment."""
deadline = time.monotonic() + seconds
last = None
while True:
try:
last = api.call("GET", f"/api/v1/attachments/{attachment_id}", actor=actor, schema="Attachment")["json"]
if last["status"] in statuses:
return last
check(last["status"] != "failed" or "failed" in statuses,
f"attachment failed with {last['error_code']}")
except Failure as exc:
if "attachment failed" in str(exc):
raise
check(time.monotonic() < deadline,
f"attachment is {last and last['status']} after {seconds} s, expected {statuses}")
time.sleep(step)
def webp_size(data: bytes) -> tuple[int, int]:
"""Ширина и высота WebP по заголовку RIFF (VP8, VP8L или VP8X) — без библиотек."""
check(data[:4] == b"RIFF" and data[8:12] == b"WEBP", "not a WebP file")
kind = data[12:16]
if kind == b"VP8 ":
return int.from_bytes(data[26:28], "little") & 0x3FFF, int.from_bytes(data[28:30], "little") & 0x3FFF
if kind == b"VP8L":
bits = int.from_bytes(data[21:25], "little")
return (bits & 0x3FFF) + 1, ((bits >> 14) & 0x3FFF) + 1
check(kind == b"VP8X", "unknown WebP chunk")
return int.from_bytes(data[24:27], "little") + 1, int.from_bytes(data[27:30], "little") + 1
def webp_chunks(data: bytes) -> list[bytes]:
"""Типы блоков RIFF внутри WebP (EXIF, XMP , ICCP — метаданные)."""
kinds, i = [], 12
while i + 8 <= len(data):
kinds.append(data[i:i + 4])
i += 8 + ((int.from_bytes(data[i + 4:i + 8], "little") + 1) & ~1)
return kinds
def jpeg_markers(data: bytes) -> list[int]:
"""Маркеры JPEG до начала скана: по ним видно, есть ли EXIF (APP1) или ICC (APP2)."""
found, i = [], 2
while i + 4 <= len(data) and data[i] == 0xFF:
marker = data[i + 1]
found.append(marker)
if marker == 0xDA:
break
i += 2 + int.from_bytes(data[i + 2:i + 4], "big")
return found
# ---------- внутри стенда ----------
def in_api(code: str) -> str:
"""Выполнить Python-код в контейнере API (сеть backend, модули messenger). Возвращает stdout."""
result = subprocess.run(["docker", "compose", "exec", "-T", "api", "python", "-"], cwd=ROOT,
input=code.encode("utf-8"), capture_output=True)
last_error = (result.stderr.decode("utf-8", "replace").strip().splitlines() or [""])[-1]
check(result.returncode == 0, "code inside the api container failed: " + last_error)
return result.stdout.decode("utf-8", "replace").strip()
def exec_python(container: str, code: str) -> str:
"""Python-код в конкретном контейнере через stdin (переводы строк одинаково работают и на Windows)."""
result = subprocess.run(["docker", "exec", "-i", container, "python", "-"], cwd=ROOT,
input=code.encode("utf-8"), capture_output=True)
check(result.returncode == 0, f"code inside {container[:12]} failed")
return result.stdout.decode("utf-8", "replace").strip()
def psql(sql: str) -> str:
"""SQL в PostgreSQL стенда (только для проверок; значения в SQL — проверенные UUID и числа)."""
result = subprocess.run(["docker", "compose", "exec", "-T", "postgres", "psql", "-X", "-q", "-t", "-A",
"-U", "messenger", "-d", "messenger", "-v", "ON_ERROR_STOP=1", "-c", sql],
cwd=ROOT, capture_output=True)
check(result.returncode == 0, "psql failed: " + result.stderr.decode("utf-8", "replace").strip())
return result.stdout.decode("utf-8", "replace").strip()
def cleanup_cli(*args: str) -> dict:
"""python -m messenger.cleanup внутри контейнера API -> словарь счётчиков."""
result = subprocess.run(["docker", "compose", "exec", "-T", "api", "python", "-m", "messenger.cleanup", *args],
cwd=ROOT, capture_output=True)
output = result.stdout.decode("utf-8", "replace").strip().splitlines()
check(result.returncode == 0 and output, "cleanup failed: " + result.stderr.decode("utf-8", "replace")[-300:])
return json.loads(output[-1])
def wait_until(condition, seconds: float, message: str, step: float = 0.5):
deadline = time.monotonic() + seconds
while not condition():
check(time.monotonic() < deadline, message)
time.sleep(step)