python-msilib 0.4.2__cp314-cp314-win32.whl

msilib/__init__.py

@@ -0,0 +1,778 @@
+"""Read and write Microsoft Installer files."""
+
+# Copyright (C) 2005 Martin v. Löwis
+# Licensed to PSF under a Contributor Agreement.
+import contextlib
+import fnmatch
+import os
+import platform
+import re
+import string
+from tempfile import mkstemp
+
+from msilib._msi import (
+    MSICOLINFO_NAMES,
+    MSICOLINFO_TYPES,
+    MSIDBOPEN_CREATE,
+    MSIDBOPEN_CREATEDIRECT,
+    MSIDBOPEN_DIRECT,
+    MSIDBOPEN_PATCHFILE,
+    MSIDBOPEN_READONLY,
+    MSIDBOPEN_TRANSACT,
+    MSIMODIFY_ASSIGN,
+    MSIMODIFY_DELETE,
+    MSIMODIFY_INSERT,
+    MSIMODIFY_INSERT_TEMPORARY,
+    MSIMODIFY_MERGE,
+    MSIMODIFY_REFRESH,
+    MSIMODIFY_REPLACE,
+    MSIMODIFY_SEEK,
+    MSIMODIFY_UPDATE,
+    MSIMODIFY_VALIDATE,
+    MSIMODIFY_VALIDATE_DELETE,
+    MSIMODIFY_VALIDATE_FIELD,
+    MSIMODIFY_VALIDATE_NEW,
+    PID_APPNAME,
+    PID_AUTHOR,
+    PID_CHARCOUNT,
+    PID_CODEPAGE,
+    PID_COMMENTS,
+    PID_CREATE_DTM,
+    PID_KEYWORDS,
+    PID_LASTAUTHOR,
+    PID_LASTPRINTED,
+    PID_LASTSAVE_DTM,
+    PID_PAGECOUNT,
+    PID_REVNUMBER,
+    PID_SECURITY,
+    PID_SUBJECT,
+    PID_TEMPLATE,
+    PID_TITLE,
+    PID_WORDCOUNT,
+    CreateRecord,
+    FCICreate,
+    MSIError,
+    OpenDatabase,
+    UuidCreate,
+)
+
+__version__ = "0.4.2"
+
+__all__ = [
+    "CAB",
+    "MSICOLINFO_NAMES",
+    "MSICOLINFO_TYPES",
+    "MSIDBOPEN_CREATE",
+    "MSIDBOPEN_CREATEDIRECT",
+    "MSIDBOPEN_DIRECT",
+    "MSIDBOPEN_PATCHFILE",
+    "MSIDBOPEN_READONLY",
+    "MSIDBOPEN_TRANSACT",
+    "MSIMODIFY_ASSIGN",
+    "MSIMODIFY_DELETE",
+    "MSIMODIFY_INSERT",
+    "MSIMODIFY_INSERT_TEMPORARY",
+    "MSIMODIFY_MERGE",
+    "MSIMODIFY_REFRESH",
+    "MSIMODIFY_REPLACE",
+    "MSIMODIFY_SEEK",
+    "MSIMODIFY_UPDATE",
+    "MSIMODIFY_VALIDATE",
+    "MSIMODIFY_VALIDATE_DELETE",
+    "MSIMODIFY_VALIDATE_FIELD",
+    "MSIMODIFY_VALIDATE_NEW",
+    "PID_APPNAME",
+    "PID_AUTHOR",
+    "PID_CHARCOUNT",
+    "PID_CODEPAGE",
+    "PID_COMMENTS",
+    "PID_CREATE_DTM",
+    "PID_KEYWORDS",
+    "PID_LASTAUTHOR",
+    "PID_LASTPRINTED",
+    "PID_LASTSAVE_DTM",
+    "PID_PAGECOUNT",
+    "PID_REVNUMBER",
+    "PID_SECURITY",
+    "PID_SUBJECT",
+    "PID_TEMPLATE",
+    "PID_TITLE",
+    "PID_WORDCOUNT",
+    "Binary",
+    "Control",
+    "CreateRecord",
+    "Dialog",
+    "Directory",
+    "FCICreate",
+    "Feature",
+    "MSIError",
+    "OpenDatabase",
+    "RadioButtonGroup",
+    "Table",
+    "UuidCreate",
+    "add_data",
+    "add_stream",
+    "add_tables",
+    "change_sequence",
+    "datasizemask",
+    "gen_uuid",
+    "init_database",
+    "knownbits",
+    "make_id",
+    "type_binary",
+    "type_key",
+    "type_localizable",
+    "type_long",
+    "type_nullable",
+    "type_short",
+    "type_string",
+    "type_valid",
+    "typemask",
+]
+
+
+# Should work in windows, but also in mingw, cygwin, ...
+AMD64 = platform.machine() in ("x64", "x86_64", "AMD64")
+ARM64 = platform.machine() in ("aarch64", "arm64", "ARM64")
+
+# Keep msilib.Win64 around to preserve backwards compatibility.
+Win64 = AMD64
+
+# Partially taken from Wine
+datasizemask = 0x00FF
+type_valid = 0x0100
+type_localizable = 0x0200
+
+typemask = 0x0C00
+type_long = 0x0000
+type_short = 0x0400
+type_string = 0x0C00
+type_binary = 0x0800
+
+type_nullable = 0x1000
+type_key = 0x2000
+# XXX temporary, localizable?
+knownbits = (
+    datasizemask
+    | type_valid
+    | type_localizable
+    | typemask
+    | type_nullable
+    | type_key
+)
+
+
+class Table:
+    def __init__(self, name) -> None:
+        self.name = name
+        self.fields = []
+
+    def add_field(self, index, name, type) -> None:
+        self.fields.append((index, name, type))
+
+    def sql(self) -> str:
+        fields = []
+        keys = []
+        self.fields.sort()
+        fields = [None] * len(self.fields)
+        for index, name, ftype in self.fields:
+            idx = index - 1
+            unk = ftype & ~knownbits
+            if unk:
+                print(f"{self.name}.{name} unknown bits {unk:x}")
+            size = ftype & datasizemask
+            dtype = ftype & typemask
+            if dtype == type_string:
+                tname = f"CHAR({size})" if size else "CHAR"
+            elif dtype == type_short:
+                assert size == 2
+                tname = "SHORT"
+            elif dtype == type_long:
+                assert size == 4
+                tname = "LONG"
+            elif dtype == type_binary:
+                assert size == 0
+                tname = "OBJECT"
+            else:
+                tname = "unknown"
+                print(f"{self.name}.{name} unknown integer type {size}")
+            flags = "" if ftype & type_nullable else " NOT NULL"
+            if ftype & type_localizable:
+                flags += " LOCALIZABLE"
+            fields[idx] = f"`{name}` {tname}{flags}"
+            if ftype & type_key:
+                keys.append(f"`{name}`")
+        fields = ", ".join(fields)
+        keys = ", ".join(keys)
+        return f"CREATE TABLE {self.name} ({fields} PRIMARY KEY {keys})"
+
+    def create(self, db) -> None:
+        v = db.OpenView(self.sql())
+        v.Execute(None)
+        v.Close()
+
+
+class _Unspecified:
+    pass
+
+
+def change_sequence(
+    seq, action, seqno=_Unspecified, cond=_Unspecified
+) -> None:
+    """Change the sequence number of an action in a sequence list."""
+    for i in range(len(seq)):
+        if seq[i][0] == action:
+            if cond is _Unspecified:
+                cond = seq[i][1]
+            if seqno is _Unspecified:
+                seqno = seq[i][2]
+            seq[i] = (action, cond, seqno)
+            return
+    msg = "Action not found in sequence"
+    raise ValueError(msg)
+
+
+def add_data(db, table, values) -> None:
+    v = db.OpenView(f"SELECT * FROM `{table}`")
+    count = v.GetColumnInfo(MSICOLINFO_NAMES).GetFieldCount()
+    r = CreateRecord(count)
+    for value in values:
+        assert len(value) == count, value
+        for i in range(count):
+            field = value[i]
+            if isinstance(field, int):
+                r.SetInteger(i + 1, field)
+            elif isinstance(field, str):
+                r.SetString(i + 1, field)
+            elif field is None:
+                pass
+            elif isinstance(field, Binary):
+                r.SetStream(i + 1, field.name)
+            else:
+                msg = f"Unsupported type {field.__class__.__name__}"
+                raise TypeError(msg)
+        try:
+            v.Modify(MSIMODIFY_INSERT, r)
+        except Exception:  # noqa: BLE001
+            msg = f"Could not insert {values!r} into {table}"
+            raise MSIError(msg) from None
+
+        r.ClearData()
+    v.Close()
+
+
+def add_stream(db, name, path) -> None:
+    v = db.OpenView(f"INSERT INTO _Streams (Name, Data) VALUES ('{name}', ?)")
+    r = CreateRecord(1)
+    r.SetStream(1, path)
+    v.Execute(r)
+    v.Close()
+
+
+def init_database(
+    name, schema, ProductName, ProductCode, ProductVersion, Manufacturer
+):
+    with contextlib.suppress(OSError):
+        os.unlink(name)
+    ProductCode = ProductCode.upper()
+    # Create the database
+    db = OpenDatabase(name, MSIDBOPEN_CREATE)
+    # Create the tables
+    for t in schema.tables:
+        t.create(db)
+    # Fill the validation table
+    add_data(db, "_Validation", schema._Validation_records)  # noqa: SLF001
+    # Initialize the summary information, allowing at most 20 properties
+    si = db.GetSummaryInformation(20)
+    si.SetProperty(PID_TITLE, "Installation Database")
+    si.SetProperty(PID_SUBJECT, ProductName)
+    si.SetProperty(PID_AUTHOR, Manufacturer)
+    # https://learn.microsoft.com/en-us/windows/win32/msi/template-summary
+    if AMD64:
+        si.SetProperty(PID_TEMPLATE, "x64;1033")
+    elif ARM64:
+        si.SetProperty(PID_TEMPLATE, "Arm64;1033")
+    else:
+        si.SetProperty(PID_TEMPLATE, "Intel;1033")
+    si.SetProperty(PID_REVNUMBER, gen_uuid())
+    # https://learn.microsoft.com/en-us/windows/win32/msi/word-count-summary
+    # 2 = long file names, compressed, original media
+    si.SetProperty(PID_WORDCOUNT, 2)
+    # https://learn.microsoft.com/en-us/windows/win32/msi/page-count-summary
+    # https://learn.microsoft.com/en-us/windows/win32/msi/using-64-bit-windows-installer-packages
+    if ARM64:
+        si.SetProperty(PID_PAGECOUNT, 500)  # minimum of Windows Installer 5.0
+    else:
+        si.SetProperty(PID_PAGECOUNT, 200)  # minimum of Windows Installer 2.0
+    si.SetProperty(PID_APPNAME, "Python MSI Library")
+    # XXX more properties
+    si.Persist()
+    add_data(
+        db,
+        "Property",
+        [
+            ("ProductName", ProductName),
+            ("ProductCode", ProductCode),
+            ("ProductVersion", ProductVersion),
+            ("Manufacturer", Manufacturer),
+            ("ProductLanguage", "1033"),
+        ],
+    )
+    db.Commit()
+    return db
+
+
+def add_tables(db, module) -> None:
+    for table in module.tables:
+        add_data(db, table, getattr(module, table))
+
+
+def make_id(value: str) -> str:
+    identifier_chars = string.ascii_letters + string.digits + "._"
+    value = "".join([c if c in identifier_chars else "_" for c in value])
+    if value[0] in (string.digits + "."):
+        value = "_" + value
+    assert re.match("^[A-Za-z_][A-Za-z0-9_.]*$", value), "FILE" + value
+    return value
+
+
+def gen_uuid() -> str:
+    return "{" + UuidCreate().upper() + "}"
+
+
+class CAB:
+    def __init__(self, name) -> None:
+        self.name = name
+        self.files = []
+        self.filenames = set()
+        self.index = 0
+
+    def gen_id(self, file) -> str:
+        logical = _logical = make_id(file)
+        pos = 1
+        while logical in self.filenames:
+            logical = f"{_logical}.{pos}"
+            pos += 1
+        self.filenames.add(logical)
+        return logical
+
+    def append(self, full, file, logical) -> tuple[int, str]:
+        if os.path.isdir(full):
+            return None
+        if not logical:
+            logical = self.gen_id(file)
+        self.index += 1
+        self.files.append((full, logical))
+        return self.index, logical
+
+    def commit(self, db) -> None:
+        fd, filename = mkstemp()
+        os.close(fd)
+        FCICreate(filename, self.files)
+        add_data(
+            db, "Media", [(1, self.index, None, "#" + self.name, None, None)]
+        )
+        add_stream(db, self.name, filename)
+        os.unlink(filename)
+        db.Commit()
+
+
+_directories = set()
+
+
+class Directory:
+    def __init__(
+        self,
+        db,
+        cab,
+        basedir,
+        physical,
+        _logical,
+        default,
+        componentflags=None,
+    ) -> None:
+        """Create a new directory in the Directory table. There is a current
+        component at each point in time for the directory, which is either
+        explicitly created through start_component, or implicitly when files
+        are added for the first time. Files are added into the current
+        component, and into the cab file. To create a directory, a base
+        directory object needs to be specified (can be None), the path to the
+        physical directory, and a logical directory name. Default specifies the
+        DefaultDir slot in the directory table. componentflags specifies the
+        default flags that new components get.
+        """
+        index = 1
+        _logical = make_id(_logical)
+        logical = _logical
+        while logical in _directories:
+            logical = f"{_logical}{index}"
+            index += 1
+        _directories.add(logical)
+        self.db = db
+        self.cab = cab
+        self.basedir = basedir
+        self.physical = physical
+        self.logical = logical
+        self.component = None
+        self.short_names = set()
+        self.ids = set()
+        self.keyfiles = {}
+        self.componentflags = componentflags
+        if basedir:
+            self.absolute = os.path.join(basedir.absolute, physical)
+            blogical = basedir.logical
+        else:
+            self.absolute = physical
+            blogical = None
+        add_data(db, "Directory", [(logical, blogical, default)])
+
+    def start_component(
+        self, component=None, feature=None, flags=None, keyfile=None, uuid=None
+    ) -> None:
+        """Add an entry to the Component table, and make this component the
+        current for this directory. If no component name is given, the
+        directory name is used. If no feature is given, the current feature is
+        used. If no flags are given, the directory's default flags are used. If
+        no keyfile is given, the KeyPath is left null in the Component table.
+        """
+        if flags is None:
+            flags = self.componentflags
+        uuid = gen_uuid() if uuid is None else uuid.upper()
+        if component is None:
+            component = self.logical
+        self.component = component
+        # https://learn.microsoft.com/en-us/windows/win32/msi/component-table
+        if AMD64 or ARM64:
+            flags |= 256  # msidbComponentAttributes64bit
+        if keyfile:
+            keyid = self.cab.gen_id(keyfile)
+            self.keyfiles[keyfile] = keyid
+        else:
+            keyid = None
+        add_data(
+            self.db,
+            "Component",
+            [(component, uuid, self.logical, flags, None, keyid)],
+        )
+        if feature is None:
+            feature = current_feature
+        add_data(self.db, "FeatureComponents", [(feature.id, component)])
+
+    def make_short(self, file: str) -> str:
+        oldfile = file
+        file = file.replace("+", "_")
+        file = "".join(c for c in file if c not in r' "/\[]:;=,')
+        parts = file.split(".")
+        if len(parts) > 1:
+            prefix = "".join(parts[:-1]).upper()
+            suffix = parts[-1].upper()
+            if not prefix:
+                prefix = suffix
+                suffix = None
+        else:
+            prefix = file.upper()
+            suffix = None
+        if (
+            len(parts) < 3
+            and len(prefix) <= 8
+            and file == oldfile
+            and (not suffix or len(suffix) <= 3)
+        ):
+            file = f"{prefix}.{suffix}" if suffix else prefix
+        else:
+            file = None
+        if file is None or file in self.short_names:
+            prefix = prefix[:6]
+            if suffix:
+                suffix = suffix[:3]
+            pos = 1
+            while 1:
+                if suffix:
+                    file = f"{prefix}~{pos}.{suffix}"
+                else:
+                    file = f"{prefix}~{pos}"
+                if file not in self.short_names:
+                    break
+                pos += 1
+                assert pos < 10000
+                if pos in (10, 100, 1000):
+                    prefix = prefix[:-1]
+        self.short_names.add(file)
+        # restrictions on short names
+        assert not re.search(r'[\?|><:/*"+,;=\[\]]', file)
+        return file
+
+    def add_file(
+        self,
+        file: str,
+        src: str | None = None,
+        version: str | None = None,
+        language: str | None = None,
+    ) -> str:
+        """Add a file to the current component of the directory, starting a new
+        one if there is no current component. By default, the file name in the
+        source and the file table will be identical. If the src file is
+        specified, it is interpreted relative to the current directory.
+        Optionally, a version and a language can be specified for the entry in
+        the File table.
+        """
+        if not self.component:
+            self.start_component(self.logical, current_feature, 0)
+        if not src:
+            # Allow relative paths for file if src is not specified
+            src = file
+            file = os.path.basename(file)
+        absolute = os.path.join(self.absolute, src)
+        # restrictions on long names
+        assert not re.search(r'[\?|><:/*]"', file)
+        logical = self.keyfiles.get(file, None)
+        sequence, logical = self.cab.append(absolute, file, logical)
+        assert logical not in self.ids
+        self.ids.add(logical)
+        short = self.make_short(file)
+        full = f"{short}|{file}"
+        filesize = os.stat(absolute).st_size
+        # constants.msidbFileAttributesVital
+        # Compressed omitted, since it is the database default
+        # could add r/o, system, hidden
+        attributes = 512
+        add_data(
+            self.db,
+            "File",
+            [
+                (
+                    logical,
+                    self.component,
+                    full,
+                    filesize,
+                    version,
+                    language,
+                    attributes,
+                    sequence,
+                )
+            ],
+        )
+        # if not version:
+        #    # Add hash if the file is not versioned
+        #    filehash = FileHash(absolute, 0)
+        #    add_data(self.db, "MsiFileHash",
+        #             [(logical, 0, filehash.IntegerData(1),
+        #               filehash.IntegerData(2), filehash.IntegerData(3),
+        #               filehash.IntegerData(4))])
+        # Automatically remove .pyc files on uninstall (2)
+        # XXX: adding so many RemoveFile entries makes installer unbelievably
+        # slow. So instead, we have to use wildcard remove entries
+        if file.endswith(".py"):
+            add_data(
+                self.db,
+                "RemoveFile",
+                [
+                    (
+                        logical + "c",
+                        self.component,
+                        f"{short}C|{file}c",
+                        self.logical,
+                        2,
+                    ),
+                    (
+                        logical + "o",
+                        self.component,
+                        f"{short}O|{file}o",
+                        self.logical,
+                        2,
+                    ),
+                ],
+            )
+        return logical
+
+    def glob(self, pattern: str, exclude=None) -> list[str]:
+        """Add a list of files to the current component as specified in the
+        glob pattern. Individual files can be excluded in the exclude list.
+        """
+        try:
+            files = os.listdir(self.absolute)
+        except OSError:
+            return []
+        if pattern[:1] != ".":
+            files = (f for f in files if f[0] != ".")
+        files = fnmatch.filter(files, pattern)
+        for f in files:
+            if exclude and f in exclude:
+                continue
+            self.add_file(f)
+        return files
+
+    def remove_pyc(self) -> None:
+        """Remove .pyc files on uninstall."""
+        add_data(
+            self.db,
+            "RemoveFile",
+            [(self.component + "c", self.component, "*.pyc", self.logical, 2)],
+        )
+
+
+class Binary:
+    def __init__(self, fname) -> None:
+        self.name = fname
+
+    def __repr__(self) -> str:
+        return f'msilib.Binary(os.path.join(dirname,"{self.name}"))'
+
+
+class Feature:
+    def __init__(
+        self,
+        db,
+        id,
+        title,
+        desc,
+        display,
+        level=1,
+        parent=None,
+        directory=None,
+        attributes=0,
+    ) -> None:
+        self.id = id
+        if parent:
+            parent = parent.id
+        add_data(
+            db,
+            "Feature",
+            [(id, parent, title, desc, display, level, directory, attributes)],
+        )
+
+    def set_current(self) -> None:
+        global current_feature
+        current_feature = self
+
+
+class Control:
+    def __init__(self, dlg, name) -> None:
+        self.dlg = dlg
+        self.name = name
+
+    def event(self, event, argument, condition="1", ordering=None) -> None:
+        add_data(
+            self.dlg.db,
+            "ControlEvent",
+            [(self.dlg.name, self.name, event, argument, condition, ordering)],
+        )
+
+    def mapping(self, event, attribute) -> None:
+        add_data(
+            self.dlg.db,
+            "EventMapping",
+            [(self.dlg.name, self.name, event, attribute)],
+        )
+
+    def condition(self, action, condition) -> None:
+        add_data(
+            self.dlg.db,
+            "ControlCondition",
+            [(self.dlg.name, self.name, action, condition)],
+        )
+
+
+class RadioButtonGroup(Control):
+    def __init__(self, dlg, name, property) -> None:
+        self.dlg = dlg
+        self.name = name
+        self.property = property
+        self.index = 1
+
+    def add(self, name, x, y, w, h, text, value=None) -> None:
+        if value is None:
+            value = name
+        add_data(
+            self.dlg.db,
+            "RadioButton",
+            [(self.property, self.index, value, x, y, w, h, text, None)],
+        )
+        self.index += 1
+
+
+class Dialog:
+    def __init__(
+        self, db, name, x, y, w, h, attr, title, first, default, cancel
+    ) -> None:
+        self.db = db
+        self.name = name
+        self.x, self.y, self.w, self.h = x, y, w, h
+        add_data(
+            db,
+            "Dialog",
+            [(name, x, y, w, h, attr, title, first, default, cancel)],
+        )
+
+    def control(
+        self, name, type, x, y, w, h, attr, prop, text, next, help
+    ) -> Control:
+        add_data(
+            self.db,
+            "Control",
+            [
+                (
+                    self.name,
+                    name,
+                    type,
+                    x,
+                    y,
+                    w,
+                    h,
+                    attr,
+                    prop,
+                    text,
+                    next,
+                    help,
+                )
+            ],
+        )
+        return Control(self, name)
+
+    def text(self, name, x, y, w, h, attr, text) -> Control:
+        return self.control(
+            name, "Text", x, y, w, h, attr, None, text, None, None
+        )
+
+    def bitmap(self, name, x, y, w, h, text) -> Control:
+        return self.control(
+            name, "Bitmap", x, y, w, h, 1, None, text, None, None
+        )
+
+    def line(self, name, x, y, w, h) -> Control:
+        return self.control(
+            name, "Line", x, y, w, h, 1, None, None, None, None
+        )
+
+    def pushbutton(self, name, x, y, w, h, attr, text, next) -> Control:
+        return self.control(
+            name, "PushButton", x, y, w, h, attr, None, text, next, None
+        )
+
+    def radiogroup(self, name, x, y, w, h, attr, prop, text, next) -> Control:
+        add_data(
+            self.db,
+            "Control",
+            [
+                (
+                    self.name,
+                    name,
+                    "RadioButtonGroup",
+                    x,
+                    y,
+                    w,
+                    h,
+                    attr,
+                    prop,
+                    text,
+                    next,
+                    None,
+                )
+            ],
+        )
+        return RadioButtonGroup(self, name, prop)
+
+    def checkbox(self, name, x, y, w, h, attr, prop, text, next) -> Control:
+        return self.control(
+            name, "CheckBox", x, y, w, h, attr, prop, text, next, None
+        )