libscanner-dmgen 1.0.0__py3-none-win_amd64.whl

dmgen/__init__.py

@@ -0,0 +1,248 @@
+"""dmgen — генератор DataMatrix ECC 200 (ГОСТ Р ИСО/МЭК 16022) с проверкой
+GS1 и профиля «Честного знака». Обёртка на ctypes над dmgen_c.
+
+    import dmgen
+    png = dmgen.make_image("0104601234567893215Abc12Xyz!-\\x1d93dGVz", gs1="cz")
+
+Лицензия — подмодуль dmgen.license (как namespace dmgen::license в C++ API).
+Без пробного периода и лицензии кодирование поднимает UnlicensedError.
+"""
+
+from __future__ import annotations
+
+import ctypes
+import os
+from dataclasses import dataclass, field
+from typing import List, Optional, Tuple, Union
+
+from . import _ffi
+from . import license  # noqa: F401  (публичный подмодуль)
+
+__all__ = [
+    "make_image", "save", "encode_matrix", "validate_gs1", "version", "SIZES",
+    "DmgenError", "EncodeError", "Gs1Error", "UnlicensedError", "Report", "Element", "Issue",
+    "license",
+]
+
+Data = Union[str, bytes, bytearray, memoryview]
+
+# Коды возврата dmgen_c.
+_OK = 0
+_E_GS1_INVALID = 5
+_E_UNLICENSED = 8
+
+_GS1 = {None: 0, False: 0, "off": 0, True: 1, "gs1": 1, "cz": 2, "chestny_znak": 2}
+_SEPARATOR = {"gs": 0, "fnc1": 1}
+_INPUT = {"auto": 0, "raw": 1, "bracketed": 2}
+_SCHEME = {"auto": 0, "ascii": 1, "c40": 2, "text": 3, "x12": 4, "edifact": 5,
+           "base256": 6, "minimal": 7}
+_FORMAT = {"png": 0, "jpeg": 1, "jpg": 1}
+
+
+class DmgenError(RuntimeError):
+    """Ошибка dmgen: code — код dmgen_status, message — описание по-русски."""
+
+    def __init__(self, code: int, message: str):
+        super().__init__(message)
+        self.code = code
+        self.message = message
+
+
+class EncodeError(DmgenError):
+    """Данные не удалось закодировать (размер, недопустимый знак, запись файла…)."""
+
+
+class UnlicensedError(DmgenError):
+    """Пробный период кончился, лицензии нет — см. dmgen.license.status()."""
+
+
+class Gs1Error(DmgenError):
+    """Строка не прошла проверку GS1; подробности — в report."""
+
+    def __init__(self, code: int, message: str, report: "Report"):
+        super().__init__(code, message)
+        self.report = report
+
+
+@dataclass(frozen=True)
+class Element:
+    ai: str
+    value: str
+
+
+@dataclass(frozen=True)
+class Issue:
+    code: int
+    warning: bool
+    position: int
+    ai: str
+    message: str
+
+
+@dataclass(frozen=True)
+class Report:
+    ok: bool
+    elements: List[Element] = field(default_factory=list)
+    issues: List[Issue] = field(default_factory=list)
+    normalized: str = ""   # с символом GS (\x1d) — как вернёт ридер
+
+
+def _bytes(data: Data) -> bytes:
+    if isinstance(data, str):
+        return data.encode("utf-8")
+    return bytes(data)
+
+
+def _lookup(table: dict, value, what: str) -> int:
+    key = value.lower() if isinstance(value, str) else value
+    if key not in table:
+        raise ValueError(f"{what}: недопустимое значение {value!r}; допустимо: "
+                         + ", ".join(str(k) for k in table if isinstance(k, str)))
+    return table[key]
+
+
+_INT32_MIN, _INT32_MAX = -2**31, 2**31 - 1
+
+
+def _int32(value, what: str) -> int:
+    # ctypes.c_int32 молча обрезает большое число по модулю 2**32: 2**32 + 8
+    # дошло бы до библиотеки как 8. Поэтому диапазон — до приведения;
+    # допустимые значения по смыслу (module_px до 1000 и т.п.) проверяет dmgen_c.
+    v = int(value)
+    if not _INT32_MIN <= v <= _INT32_MAX:
+        raise ValueError(f"{what}: {value!r} вне диапазона int32")
+    return v
+
+
+def _options(gs1=None, separator="gs", gs1_input="auto", scheme="auto", side=0, verify=True,
+             module_px=8, quiet_zone=2, invert=False, dark=0, light=255, dpi=0.0,
+             quality=100) -> _ffi.Options:
+    o = _ffi.Options()
+    _ffi.lib.dmgen_options_init(ctypes.byref(o))
+    o.gs1 = _lookup(_GS1, gs1, "gs1")
+    o.separator = _lookup(_SEPARATOR, separator, "separator")
+    o.gs1_input = _lookup(_INPUT, gs1_input, "gs1_input")
+    o.scheme = _lookup(_SCHEME, scheme, "scheme")
+    o.side = _int32(side, "side")
+    o.verify = 1 if verify else 0
+    o.module_px = _int32(module_px, "module_px")
+    o.quiet_zone = _int32(quiet_zone, "quiet_zone")
+    o.invert = 1 if invert else 0
+    o.dark = _int32(dark, "dark")
+    o.light = _int32(light, "light")
+    o.dpi = float(dpi)
+    o.jpeg_quality = _int32(quality, "quality")
+    return o
+
+
+def _raise(status: int, err: _ffi.Error, data: bytes, opts: _ffi.Options) -> None:
+    message = err.message.decode("utf-8", "replace")
+    if status == _E_GS1_INVALID:
+        mode = "cz" if opts.gs1 == 2 else "gs1"
+        raise Gs1Error(status, message, _validate(data, mode, opts.gs1_input))
+    if status == _E_UNLICENSED:
+        raise UnlicensedError(status, message)
+    raise EncodeError(status, message)
+
+
+def make_image(data: Data, *, fmt: str = "png", **kw) -> bytes:
+    """Данные → файл PNG или JPEG в памяти.
+
+    Ключи: gs1 (None | "gs1" | "cz"), separator ("gs" | "fnc1"), gs1_input,
+    scheme, side (0 или 10…144), verify, module_px, quiet_zone, invert, dark,
+    light, dpi, quality (JPEG).
+    """
+    raw = _bytes(data)
+    opts = _options(**kw)
+    out = ctypes.c_void_p()
+    out_len = ctypes.c_size_t()
+    err = _ffi.Error()
+    st = _ffi.lib.dmgen_make_image(raw, len(raw), ctypes.byref(opts), _lookup(_FORMAT, fmt, "fmt"),
+                                   ctypes.byref(out), ctypes.byref(out_len), ctypes.byref(err))
+    if st != _OK:
+        _raise(st, err, raw, opts)
+    try:
+        return ctypes.string_at(out.value, out_len.value)
+    finally:
+        _ffi.lib.dmgen_free(out)
+
+
+def save(data: Data, path: Union[str, os.PathLike], *, fmt: Optional[str] = None, **kw) -> None:
+    """Данные → файл. Формат — по расширению (.jpg/.jpeg — JPEG, иначе PNG)."""
+    raw = _bytes(data)
+    p = os.fspath(path)
+    if fmt is None:
+        fmt = "jpeg" if p.lower().endswith((".jpg", ".jpeg")) else "png"
+    opts = _options(**kw)
+    err = _ffi.Error()
+    st = _ffi.lib.dmgen_save_image(raw, len(raw), ctypes.byref(opts), _lookup(_FORMAT, fmt, "fmt"),
+                                   p.encode("utf-8"), ctypes.byref(err))
+    if st != _OK:
+        _raise(st, err, raw, opts)
+
+
+def encode_matrix(data: Data, **kw) -> List[List[int]]:
+    """Данные → матрица модулей (строки сверху вниз, 1 — тёмный)."""
+    raw = _bytes(data)
+    opts = _options(**kw)
+    mods = ctypes.c_void_p()
+    side = ctypes.c_int32()
+    err = _ffi.Error()
+    st = _ffi.lib.dmgen_encode_matrix(raw, len(raw), ctypes.byref(opts), ctypes.byref(mods),
+                                      ctypes.byref(side), ctypes.byref(err))
+    if st != _OK:
+        _raise(st, err, raw, opts)
+    try:
+        n = side.value
+        flat = ctypes.string_at(mods.value, n * n)
+        return [list(flat[r * n:(r + 1) * n]) for r in range(n)]
+    finally:
+        _ffi.lib.dmgen_free(mods)
+
+
+def _validate(raw: bytes, mode, gs1_input) -> Report:
+    rep = ctypes.POINTER(_ffi.Gs1Report)()
+    err = _ffi.Error()
+    m = _lookup(_GS1, mode, "mode") or 1
+    inp = gs1_input if isinstance(gs1_input, int) else _lookup(_INPUT, gs1_input, "gs1_input")
+    st = _ffi.lib.dmgen_gs1_validate(raw, len(raw), m, inp, ctypes.byref(rep), ctypes.byref(err))
+    if st != _OK:
+        raise DmgenError(st, err.message.decode("utf-8", "replace"))
+    try:
+        r = rep.contents
+        elements = [
+            # AI берётся из ввода как есть и бывает не ASCII («(é1)…»): отчёт
+            # об ошибке, а не UnicodeDecodeError. Обрезка AI до 7 байт может
+            # разрезать знак UTF-8 — тоже "replace".
+            Element(r.elements[i].ai.decode("utf-8", "replace"),
+                    ctypes.string_at(r.elements[i].value, r.elements[i].value_len).decode("utf-8", "replace"))
+            for i in range(r.element_count)
+        ]
+        issues = [
+            Issue(r.issues[i].code, bool(r.issues[i].warning), r.issues[i].position,
+                  r.issues[i].ai.decode("utf-8", "replace"), r.issues[i].message.decode("utf-8", "replace"))
+            for i in range(r.issue_count)
+        ]
+        normalized = ctypes.string_at(r.normalized, r.normalized_len).decode("utf-8", "replace")
+        return Report(bool(r.ok), elements, issues, normalized)
+    finally:
+        _ffi.lib.dmgen_gs1_report_free(rep)
+
+
+def validate_gs1(data: Data, mode: str = "gs1", gs1_input: str = "auto") -> Report:
+    """Проверка строки по GS1 (mode="gs1") или профилю «Честного знака» (mode="cz")."""
+    return _validate(_bytes(data), mode, gs1_input)
+
+
+def version() -> str:
+    """Версия библиотеки dmgen_c."""
+    return _ffi.lib.dmgen_version_string().decode("ascii")
+
+
+def _sizes() -> Tuple[int, ...]:
+    buf = (ctypes.c_int32 * 32)()
+    n = _ffi.lib.dmgen_symbol_sizes(buf, 32)
+    return tuple(buf[i] for i in range(n))
+
+
+SIZES: Tuple[int, ...] = _sizes()

dmgen/__main__.py

@@ -0,0 +1,7 @@
+"""``python -m dmgen ...`` — то же, что команда ``dmgen`` (см. _cli.py)."""
+
+import sys
+
+from ._cli import main
+
+sys.exit(main())

dmgen/_cli.py

@@ -0,0 +1,50 @@
+"""Команда ``dmgen`` и ``python -m dmgen`` — собранная утилита-оболочка из колеса.
+
+Колесо поставки (tools/build_wheel.py) кладёт утилиту ``dmgen`` (``dmgen.exe`` и
+DLL её рантайма на Windows) в ``dmgen/_lib/`` — рядом с библиотекой dmgen_c, — а
+``pip install`` делает из этой функции команду ``dmgen`` в PATH окружения. Всё,
+что умеет утилита, — как у неё: ``dmgen "текст" -o код.png``, ``dmgen --license status``,
+``dmgen --help``; аргументы и код возврата передаются как есть.
+
+Файл ключа ``dmgen.key`` для неё и для библиотеки — один, в ``dmgen/_lib/``:
+утилита ищет его рядом с собой, библиотека — рядом с dmgen_c.
+"""
+
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+
+def executable() -> Path:
+    name = "dmgen.exe" if sys.platform == "win32" else "dmgen"
+    return Path(__file__).resolve().parent / "_lib" / name
+
+
+def main() -> int:
+    exe = executable()
+    if not exe.is_file():
+        sys.stderr.write(
+            f"утилиты dmgen нет в пакете ({exe}): она приходит с колесом поставки "
+            "(раздел «Загрузки» личного кабинета); пакет из исходников её не содержит.\n"
+        )
+        return 2
+    if sys.platform != "win32" and not os.access(exe, os.X_OK):
+        # Колесо, где бит исполнения не дошёл до установки (pip берёт его из
+        # режима файла в zip), — чиним на месте, если каталог наш.
+        try:
+            exe.chmod(exe.stat().st_mode | 0o111)
+        except OSError:
+            sys.stderr.write(f"утилита {exe} не исполняемая: chmod +x {exe}\n")
+            return 2
+    args = [str(exe), *sys.argv[1:]]
+    if sys.platform == "win32":
+        # На Windows exec заменяет процесс не так, как в POSIX (консоль и код
+        # возврата теряются) — запускаем дочерним и ждём.
+        return subprocess.call(args)
+    os.execv(args[0], args)
+    return 127  # недостижимо: execv не возвращается
+
+
+if __name__ == "__main__":
+    sys.exit(main())

dmgen/_ffi.py

@@ -0,0 +1,157 @@
+"""Граница ctypes над dmgen_c (include/dmgen/dmgen_c.h).
+
+Не публичный модуль: здесь только загрузка библиотеки и сигнатуры функций.
+Возвращаемые библиотекой буферы объявлены c_void_p/POINTER, а не c_char_p:
+иначе ctypes сделает копию, а указатель для dmgen_free потеряется; к тому
+же данные GS1 содержат байт 0x1D и не обязаны кончаться нулём.
+"""
+
+from __future__ import annotations
+
+import ctypes
+import os
+import sys
+from pathlib import Path
+
+ABI_VERSION = 1
+
+
+class Options(ctypes.Structure):
+    _fields_ = [
+        ("struct_size", ctypes.c_uint32),
+        ("gs1", ctypes.c_int32),
+        ("separator", ctypes.c_int32),
+        ("gs1_input", ctypes.c_int32),
+        ("scheme", ctypes.c_int32),
+        ("side", ctypes.c_int32),
+        ("verify", ctypes.c_int32),
+        ("module_px", ctypes.c_int32),
+        ("quiet_zone", ctypes.c_int32),
+        ("invert", ctypes.c_int32),
+        ("dark", ctypes.c_int32),
+        ("light", ctypes.c_int32),
+        ("jpeg_quality", ctypes.c_int32),
+        ("reserved", ctypes.c_int32),
+        ("dpi", ctypes.c_double),
+    ]
+
+
+class Error(ctypes.Structure):
+    _fields_ = [("code", ctypes.c_int32), ("message", ctypes.c_char * 512)]
+
+
+class Gs1Element(ctypes.Structure):
+    _fields_ = [
+        ("ai", ctypes.c_char * 8),
+        ("value", ctypes.c_void_p),
+        ("value_len", ctypes.c_size_t),
+    ]
+
+
+class Gs1Issue(ctypes.Structure):
+    _fields_ = [
+        ("code", ctypes.c_int32),
+        ("warning", ctypes.c_int32),
+        ("position", ctypes.c_int32),
+        ("ai", ctypes.c_char * 8),
+        ("message", ctypes.c_char * 256),
+    ]
+
+
+class Gs1Report(ctypes.Structure):
+    _fields_ = [
+        ("ok", ctypes.c_int32),
+        ("element_count", ctypes.c_int32),
+        ("elements", ctypes.POINTER(Gs1Element)),
+        ("issue_count", ctypes.c_int32),
+        ("issues", ctypes.POINTER(Gs1Issue)),
+        ("normalized", ctypes.c_void_p),
+        ("normalized_len", ctypes.c_size_t),
+    ]
+
+
+def _packaged():
+    here = Path(__file__).resolve().parent / "_lib"
+    if sys.platform == "win32":
+        return [here / "dmgen_c.dll"]
+    if sys.platform == "darwin":
+        return [here / "libdmgen_c.dylib"]
+    return [here / "libdmgen_c.so", *sorted(here.glob("libdmgen_c.so.*"))]
+
+
+def _candidates():
+    # Библиотека колеса — только из _lib пакета, по абсолютному пути: ни
+    # переменная окружения, ни PATH/системные каталоги (ctypes.util.find_library)
+    # не подменяют её чужой или старой копией (аудит 2026-10-01, P-16).
+    packaged = [p for p in _packaged() if p.is_file()]
+    if packaged:
+        return packaged
+    # Пакет из исходников (разработка, meson test): _lib пуст — путь даёт DMGEN_LIB.
+    env = os.environ.get("DMGEN_LIB")
+    if env and Path(env).is_absolute():
+        return [Path(env)]
+    return []
+
+
+def _load():
+    tried = []
+    for p in _candidates():
+        tried.append(str(p))
+        try:
+            return ctypes.CDLL(str(p))
+        except OSError:
+            continue
+    raise OSError("не найдена библиотека dmgen_c" + ("; проверено: " + ", ".join(tried) if tried else "") +
+                  ". Она приходит с колесом поставки (dmgen/_lib); для пакета из исходников "
+                  "укажите абсолютный путь к ней в переменной DMGEN_LIB.")
+
+
+lib = _load()
+
+u8p = ctypes.POINTER(ctypes.c_uint8)
+
+lib.dmgen_abi_version.restype = ctypes.c_uint32
+lib.dmgen_abi_version.argtypes = []
+lib.dmgen_version_string.restype = ctypes.c_char_p
+lib.dmgen_version_string.argtypes = []
+lib.dmgen_options_init.restype = None
+lib.dmgen_options_init.argtypes = [ctypes.POINTER(Options)]
+lib.dmgen_make_image.restype = ctypes.c_int32
+lib.dmgen_make_image.argtypes = [ctypes.c_char_p, ctypes.c_size_t, ctypes.POINTER(Options), ctypes.c_int32,
+                                 ctypes.POINTER(ctypes.c_void_p), ctypes.POINTER(ctypes.c_size_t),
+                                 ctypes.POINTER(Error)]
+lib.dmgen_save_image.restype = ctypes.c_int32
+lib.dmgen_save_image.argtypes = [ctypes.c_char_p, ctypes.c_size_t, ctypes.POINTER(Options), ctypes.c_int32,
+                                 ctypes.c_char_p, ctypes.POINTER(Error)]
+lib.dmgen_encode_matrix.restype = ctypes.c_int32
+lib.dmgen_encode_matrix.argtypes = [ctypes.c_char_p, ctypes.c_size_t, ctypes.POINTER(Options),
+                                    ctypes.POINTER(ctypes.c_void_p), ctypes.POINTER(ctypes.c_int32),
+                                    ctypes.POINTER(Error)]
+lib.dmgen_gs1_validate.restype = ctypes.c_int32
+lib.dmgen_gs1_validate.argtypes = [ctypes.c_char_p, ctypes.c_size_t, ctypes.c_int32, ctypes.c_int32,
+                                   ctypes.POINTER(ctypes.POINTER(Gs1Report)), ctypes.POINTER(Error)]
+lib.dmgen_gs1_report_free.restype = None
+lib.dmgen_gs1_report_free.argtypes = [ctypes.POINTER(Gs1Report)]
+lib.dmgen_symbol_sizes.restype = ctypes.c_int32
+lib.dmgen_symbol_sizes.argtypes = [ctypes.POINTER(ctypes.c_int32), ctypes.c_int32]
+lib.dmgen_free.restype = None
+lib.dmgen_free.argtypes = [ctypes.c_void_p]
+
+# Лицензия: строки JSON — c_void_p, чтобы указатель дошёл до dmgen_free.
+lib.dmgen_license_configure.restype = None
+lib.dmgen_license_configure.argtypes = [ctypes.c_char_p, ctypes.c_char_p, ctypes.c_int32, ctypes.c_int32]
+for _name, _args in [
+    ("dmgen_license_status_json", []),
+    ("dmgen_license_activate_json", [ctypes.c_char_p]),
+    ("dmgen_license_refresh_json", []),
+    ("dmgen_license_deactivate_json", [ctypes.c_char_p]),
+    ("dmgen_license_deactivate_to_file_json", [ctypes.c_char_p, ctypes.c_char_p]),
+    ("dmgen_license_write_activation_request_json", [ctypes.c_char_p]),
+    ("dmgen_license_import_license_file_json", [ctypes.c_char_p]),
+    ("dmgen_license_fingerprint_json", []),
+]:
+    getattr(lib, _name).restype = ctypes.c_void_p
+    getattr(lib, _name).argtypes = _args
+
+if lib.dmgen_abi_version() != ABI_VERSION:
+    raise OSError(f"dmgen_c: версия ABI {lib.dmgen_abi_version()}, обёртка ждёт {ABI_VERSION}")

dmgen/license.py

@@ -0,0 +1,107 @@
+"""Лицензия — обёртка над dmgen_license_* (dmgen_c.h). Функции отдают тот же
+JSON, что и "dmgen --license ... --json", разобранный в обычный dict.
+
+Пока нет ни пробного периода, ни лицензии, make_image/save/encode_matrix
+поднимают dmgen.UnlicensedError. Основной способ активации — файл dmgen.key
+с ключом рядом с dmgen_c.dll / libdmgen_c.so: вызывать ничего не нужно.
+
+Отказ операции (неверный ключ, сеть недоступна и т.п.) — НЕ исключение: это
+ожидаемый исход с понятной причиной, и он приходит как обычный dict
+{"ok": False, "error": "...", "message": "...", "status": {...}}. Исключение
+(DmgenError) — только если граница вернула NULL, то есть внутри поймано
+исключение C++.
+
+Пример::
+
+    import dmgen
+
+    s = dmgen.license.status()
+    if not s["can_encode"]:
+        print(s["message"])
+
+    r = dmgen.license.activate("XXXXX-XXXXX-XXXXX-XXXXX-XXXXX")
+    if not r["ok"]:
+        print(r["error"], r["message"])
+"""
+
+from __future__ import annotations
+
+import ctypes
+import json
+import os
+from typing import Any, Dict, Optional, Union
+
+from . import _ffi
+
+__all__ = [
+    "configure", "status", "activate", "refresh", "deactivate", "deactivate_to_file",
+    "write_activation_request", "import_license_file", "fingerprint",
+]
+
+PathLike = Union[str, os.PathLike]
+
+
+def _take(ptr: Optional[int]) -> Dict[str, Any]:
+    """JSON из строки библиотеки; строку освобождает dmgen_free."""
+    if not ptr:
+        from . import DmgenError   # здесь: __init__ импортирует этот модуль
+        raise DmgenError(-1, "dmgen_c вернула NULL вместо ответа (внутренняя ошибка)")
+    try:
+        return json.loads(ctypes.string_at(ptr).decode("utf-8"))
+    finally:
+        _ffi.lib.dmgen_free(ptr)
+
+
+def _utf8(s: Optional[str]) -> Optional[bytes]:
+    return s.encode("utf-8") if s else None
+
+
+def _path(p: PathLike) -> bytes:
+    return os.fspath(p).encode("utf-8")
+
+
+def configure(server_url: Optional[str] = None, app_version: Optional[str] = None,
+              timeout_ms: Optional[int] = None, auto_check: bool = True) -> None:
+    """Настроить до первого сетевого вызова и первого кодирования. Можно не звать вовсе."""
+    _ffi.lib.dmgen_license_configure(_utf8(server_url), _utf8(app_version),
+                                     int(timeout_ms) if timeout_ms else 0, 1 if auto_check else 0)
+
+
+def status() -> Dict[str, Any]:
+    """Состояние: state, can_encode, valid_until, days_left, message, …"""
+    return _take(_ffi.lib.dmgen_license_status_json())
+
+
+def activate(key: str) -> Dict[str, Any]:
+    """Онлайн-активация ключом."""
+    return _take(_ffi.lib.dmgen_license_activate_json(key.encode("utf-8")))
+
+
+def refresh() -> Dict[str, Any]:
+    """Сверить с сервером СЕЙЧАС, не дожидаясь суточной автосверки."""
+    return _take(_ffi.lib.dmgen_license_refresh_json())
+
+
+def deactivate(reason: Optional[str] = None) -> Dict[str, Any]:
+    """Отвязать машину по сети: расписка уходит на сервер."""
+    return _take(_ffi.lib.dmgen_license_deactivate_json(_utf8(reason)))
+
+
+def deactivate_to_file(path: PathLike, reason: Optional[str] = None) -> Dict[str, Any]:
+    """Отвязать без сети: лицензия удаляется сразу, расписка — в файл."""
+    return _take(_ffi.lib.dmgen_license_deactivate_to_file_json(_path(path), _utf8(reason)))
+
+
+def write_activation_request(path: PathLike) -> Dict[str, Any]:
+    """Файл запроса офлайн-активации — отпечаток этой машины."""
+    return _take(_ffi.lib.dmgen_license_write_activation_request_json(_path(path)))
+
+
+def import_license_file(path: PathLike) -> Dict[str, Any]:
+    """Принять license.lic. Годится и для продления."""
+    return _take(_ffi.lib.dmgen_license_import_license_file_json(_path(path)))
+
+
+def fingerprint() -> str:
+    """Сводный отпечаток этой машины, hex — для поддержки."""
+    return _take(_ffi.lib.dmgen_license_fingerprint_json())["fingerprint"]

libscanner_dmgen-1.0.0.dist-info/BUILD-INFO.json

@@ -0,0 +1,15 @@
+{
+  "product": "dmgen",
+  "version": "1.0.0",
+  "license": "enforced",
+  "insecure_test": false,
+  "license_server": "https://libscanner.com",
+  "license_product": "047e3e03-2e12-4d7f-95cf-16af8cf23302",
+  "license_key_prefix": "DMG",
+  "license_keys": "53942d61d057e01edf4042c8838cd692a979c05ed452be163c879979f41210d4",
+  "dev_env": false,
+  "buildtype": "release",
+  "system": "windows",
+  "cpu_family": "x86_64",
+  "date": "2026-10-04T07:59:07Z"
+}

libscanner_dmgen-1.0.0.dist-info/METADATA

@@ -0,0 +1,82 @@
+Metadata-Version: 2.1
+Name: libscanner-dmgen
+Version: 1.0.0
+Summary: Генератор DataMatrix ECC 200 с проверкой GS1 и «Честного знака» — DataMatrix generator with GS1 validation
+Keywords: datamatrix,data-matrix,barcode,generator,gs1,ecc200,chestny-znak,marking,png
+License: Proprietary
+Classifier: License :: Other/Proprietary License
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Multimedia :: Graphics
+Classifier: Topic :: Printing
+Classifier: Natural Language :: Russian
+Project-URL: Homepage, https://libscanner.com
+Project-URL: Documentation, https://libscanner.com/docs/datamatrix-generator/?lang=python
+Project-URL: Source, https://github.com/libscanner/datamatrix-generator
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# dmgen для Python
+
+```sh
+pip install libscanner-dmgen
+```
+
+Пакет импортируется как `dmgen`. Платформы: Windows x64, Linux x86-64, ARM64
+и ARMv7 (glibc 2.36 и новее: Debian 12, Ubuntu 23.04+, Raspberry Pi OS
+Bookworm).
+
+> **English.** A DataMatrix ECC 200 generator for Python with GS1 and
+> Chestny Znak (Russian product marking) validation: PNG/JPEG output, module
+> matrix, readable error reports. Install with `pip install libscanner-dmgen`,
+> import as `dmgen`. 30-day free trial, then a license from
+> https://libscanner.com/en/.
+
+Обёртка на `ctypes` над плоским C ABI библиотеки dmgen (`dmgen_c.dll` /
+`libdmgen_c.so`). Компилируемого расширения нет: одно колесо на платформу
+работает с любым Python 3.8+.
+
+Колесо поставки (раздел «Загрузки» личного кабинета) несёт и собранную
+утилиту-оболочку: после `pip install libscanner-dmgen` в окружении есть команда
+`dmgen` (и `python -m dmgen`) — `dmgen "текст" -o код.png`,
+`dmgen --license status`. Файл ключа `dmgen.key` — в `dmgen/_lib/`, общий для
+утилиты и библиотеки.
+
+```python
+import dmgen
+
+png = dmgen.make_image("0104601234567893215Abc12Xyz!-\x1d93dGVz", gs1="cz")
+dmgen.save("(01)04601234567893(21)5Abc12Xyz!-(93)dGVz", "code.png", gs1="cz", module_px=10)
+jpg = dmgen.make_image("Hello", fmt="jpeg", quality=100, side=26)
+
+rep = dmgen.validate_gs1("(01)04601234567894(21)ABC")
+rep.ok          # False
+rep.issues[0]   # Issue(code=…, warning=False, message='AI (01) GTIN: контрольная цифра 4, должна быть 3', …)
+
+dmgen.encode_matrix("ABC")   # [[1, 0, 1, …], …] — 1 тёмный модуль
+dmgen.SIZES                  # (10, 12, 14, …, 144)
+```
+
+Строка `str` кодируется в байты UTF-8; `bytes` передаются как есть. Ошибки —
+исключения `dmgen.Gs1Error` (с отчётом `.report`), `dmgen.EncodeError`,
+`dmgen.UnlicensedError` (нет ни пробного периода, ни лицензии),
+`dmgen.DmgenError` (общий предок).
+
+Лицензия — `dmgen.license`: `status()`, `activate(key)`, `refresh()`,
+`deactivate()`, `write_activation_request(path)`, `import_license_file(path)`,
+`fingerprint()`; ответы — dict из того же JSON, что у `dmgen --license ... --json`.
+Проще всего положить файл `dmgen.key` с ключом рядом с `dmgen_c.dll` /
+`libdmgen_c.so` в пакете (`dmgen/_lib/`): библиотека активирует его сама.
+
+Библиотека грузится только из `dmgen/_lib/` пакета. Переменная `DMGEN_LIB`
+(абсолютный путь) — для пакета из исходников, где `_lib` пуст, и колесо не
+переопределяет; системный поиск (PATH, каталоги библиотек) не используется.
+
+## Документация и лицензия
+
+Документация: https://libscanner.com/docs/datamatrix-generator/?lang=python
+
+Пробный период — 30 дней с первого запуска на машине, без регистрации и без
+сети. Без интернета: личный кабинет https://libscanner.com → Лицензии → «Активация без
+интернета».