python-msilib 0.1.1__cp314-cp314t-win_amd64.whl → 0.3.0__cp314-cp314t-win_amd64.whl

msilib/__init__.py

@@ -7,28 +7,35 @@ import re
 import string
 import sys
 
-__version__ = "0.1.1"
+__version__ = "0.3.0"
 
 AMD64 = "AMD64" in sys.version
 # 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
+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
+knownbits = (
+    datasizemask
+    | type_valid
+    | type_localizable
+    | typemask
+    | type_nullable
+    | type_key
+)
+
 
 class Table:
     def __init__(self, name):
@@ -36,13 +43,13 @@ class Table:
         self.fields = []
 
     def add_field(self, index, name, type):
-        self.fields.append((index,name,type))
+        self.fields.append((index, name, type))
 
     def sql(self):
         fields = []
         keys = []
         self.fields.sort()
-        fields = [None]*len(self.fields)
+        fields = [None] * len(self.fields)
         for index, name, type in self.fields:
             index -= 1
             unk = type & ~knownbits
@@ -52,20 +59,20 @@ class Table:
             dtype = type & typemask
             if dtype == type_string:
                 if size:
-                    tname="CHAR(%d)" % size
+                    tname = "CHAR(%d)" % size
                 else:
-                    tname="CHAR"
+                    tname = "CHAR"
             elif dtype == type_short:
-                assert size==2
+                assert size == 2
                 tname = "SHORT"
             elif dtype == type_long:
-                assert size==4
-                tname="LONG"
+                assert size == 4
+                tname = "LONG"
             elif dtype == type_binary:
-                assert size==0
-                tname="OBJECT"
+                assert size == 0
+                tname = "OBJECT"
             else:
-                tname="unknown"
+                tname = "unknown"
                 print("%s.%sunknown integer type %d" % (self.name, name, size))
             if type & type_nullable:
                 flags = ""
@@ -78,15 +85,23 @@ class Table:
                 keys.append("`%s`" % name)
         fields = ", ".join(fields)
         keys = ", ".join(keys)
-        return "CREATE TABLE %s (%s PRIMARY KEY %s)" % (self.name, fields, keys)
+        return "CREATE TABLE %s (%s PRIMARY KEY %s)" % (
+            self.name,
+            fields,
+            keys,
+        )
 
     def create(self, db):
         v = db.OpenView(self.sql())
         v.Execute(None)
         v.Close()
 
-class _Unspecified:pass
-def change_sequence(seq, action, seqno=_Unspecified, cond = _Unspecified):
+
+class _Unspecified:
+    pass
+
+
+def change_sequence(seq, action, seqno=_Unspecified, cond=_Unspecified):
     "Change the sequence number of an action in a sequence list"
     for i in range(len(seq)):
         if seq[i][0] == action:
@@ -98,6 +113,7 @@ def change_sequence(seq, action, seqno=_Unspecified, cond = _Unspecified):
             return
     raise ValueError("Action not found in sequence")
 
+
 def add_data(db, table, values):
     v = db.OpenView("SELECT * FROM `%s`" % table)
     count = v.GetColumnInfo(MSICOLINFO_NAMES).GetFieldCount()
@@ -107,34 +123,41 @@ def add_data(db, table, values):
         for i in range(count):
             field = value[i]
             if isinstance(field, int):
-                r.SetInteger(i+1,field)
+                r.SetInteger(i + 1, field)
             elif isinstance(field, str):
-                r.SetString(i+1,field)
+                r.SetString(i + 1, field)
             elif field is None:
                 pass
             elif isinstance(field, Binary):
-                r.SetStream(i+1, field.name)
+                r.SetStream(i + 1, field.name)
             else:
-                raise TypeError("Unsupported type %s" % field.__class__.__name__)
+                raise TypeError(
+                    "Unsupported type %s" % field.__class__.__name__
+                )
         try:
             v.Modify(MSIMODIFY_INSERT, r)
         except Exception:
-            raise MSIError("Could not insert "+repr(values)+" into "+table)
+            raise MSIError(
+                "Could not insert " + repr(values) + " into " + table
+            )
 
         r.ClearData()
     v.Close()
 
 
 def add_stream(db, name, path):
-    v = db.OpenView("INSERT INTO _Streams (Name, Data) VALUES ('%s', ?)" % name)
+    v = db.OpenView(
+        "INSERT INTO _Streams (Name, Data) VALUES ('%s', ?)" % name
+    )
     r = CreateRecord(1)
     r.SetStream(1, path)
     v.Execute(r)
     v.Close()
 
-def init_database(name, schema,
-                  ProductName, ProductCode, ProductVersion,
-                  Manufacturer):
+
+def init_database(
+    name, schema, ProductName, ProductCode, ProductVersion, Manufacturer
+):
     try:
         os.unlink(name)
     except OSError:
@@ -147,7 +170,7 @@ def init_database(name, schema,
         t.create(db)
     # Fill the validation table
     add_data(db, "_Validation", schema._Validation_records)
-    # Initialize the summary information, allowing atmost 20 properties
+    # Initialize the summary information, allowing at most 20 properties
     si = db.GetSummaryInformation(20)
     si.SetProperty(PID_TITLE, "Installation Database")
     si.SetProperty(PID_SUBJECT, ProductName)
@@ -157,34 +180,45 @@ def init_database(name, schema,
     else:
         si.SetProperty(PID_TEMPLATE, "Intel;1033")
     si.SetProperty(PID_REVNUMBER, gen_uuid())
-    si.SetProperty(PID_WORDCOUNT, 2) # long file names, compressed, original media
+    si.SetProperty(
+        PID_WORDCOUNT, 2
+    )  # long file names, compressed, original media
     si.SetProperty(PID_PAGECOUNT, 200)
     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")])
+    add_data(
+        db,
+        "Property",
+        [
+            ("ProductName", ProductName),
+            ("ProductCode", ProductCode),
+            ("ProductVersion", ProductVersion),
+            ("Manufacturer", Manufacturer),
+            ("ProductLanguage", "1033"),
+        ],
+    )
     db.Commit()
     return db
 
+
 def add_tables(db, module):
     for table in module.tables:
         add_data(db, table, getattr(module, table))
 
+
 def make_id(str):
     identifier_chars = string.ascii_letters + string.digits + "._"
     str = "".join([c if c in identifier_chars else "_" for c in str])
     if str[0] in (string.digits + "."):
         str = "_" + str
-    assert re.match("^[A-Za-z_][A-Za-z0-9_.]*$", str), "FILE"+str
+    assert re.match("^[A-Za-z_][A-Za-z0-9_.]*$", str), "FILE" + str
     return str
 
+
 def gen_uuid():
-    return "{"+UuidCreate().upper()+"}"
+    return "{" + UuidCreate().upper() + "}"
+
 
 class CAB:
     def __init__(self, name):
@@ -213,17 +247,31 @@ class CAB:
 
     def commit(self, db):
         from tempfile import mktemp
+
         filename = mktemp()
         FCICreate(filename, self.files)
-        add_data(db, "Media",
-                [(1, self.index, None, "#"+self.name, None, None)])
+        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):
+    def __init__(
+        self,
+        db,
+        cab,
+        basedir,
+        physical,
+        _logical,
+        default,
+        componentflags=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
@@ -257,7 +305,9 @@ class Directory:
             blogical = None
         add_data(db, "Directory", [(logical, blogical, default)])
 
-    def start_component(self, component = None, feature = None, flags = None, keyfile = None, uuid=None):
+    def start_component(
+        self, component=None, feature=None, flags=None, keyfile=None, uuid=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
@@ -279,17 +329,19 @@ class Directory:
             self.keyfiles[keyfile] = keyid
         else:
             keyid = None
-        add_data(self.db, "Component",
-                        [(component, uuid, self.logical, flags, None, keyid)])
+        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)])
+        add_data(self.db, "FeatureComponents", [(feature.id, component)])
 
     def make_short(self, file):
         oldfile = file
-        file = file.replace('+', '_')
-        file = ''.join(c for c in file if not c in r' "/\[]:;=,')
+        file = file.replace("+", "_")
+        file = "".join(c for c in file if not c in r' "/\[]:;=,')
         parts = file.split(".")
         if len(parts) > 1:
             prefix = "".join(parts[:-1]).upper()
@@ -300,10 +352,14 @@ class Directory:
         else:
             prefix = file.upper()
             suffix = None
-        if len(parts) < 3 and len(prefix) <= 8 and file == oldfile and (
-                                                not suffix or len(suffix) <= 3):
+        if (
+            len(parts) < 3
+            and len(prefix) <= 8
+            and file == oldfile
+            and (not suffix or len(suffix) <= 3)
+        ):
             if suffix:
-                file = prefix+"."+suffix
+                file = prefix + "." + suffix
             else:
                 file = prefix
         else:
@@ -318,13 +374,16 @@ class Directory:
                     file = "%s~%d.%s" % (prefix, pos, suffix)
                 else:
                     file = "%s~%d" % (prefix, pos)
-                if file not in self.short_names: break
+                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)
-        assert not re.search(r'[\?|><:/*"+,;=\[\]]', file) # restrictions on short names
+        assert not re.search(
+            r'[\?|><:/*"+,;=\[\]]', file
+        )  # restrictions on short names
         return file
 
     def add_file(self, file, src=None, version=None, language=None):
@@ -340,7 +399,9 @@ class Directory:
             src = file
             file = os.path.basename(file)
         absolute = os.path.join(self.absolute, src)
-        assert not re.search(r'[\?|><:/*]"', file) # restrictions on long names
+        assert not re.search(
+            r'[\?|><:/*]"', file
+        )  # restrictions on long names
         if file in self.keyfiles:
             logical = self.keyfiles[file]
         else:
@@ -355,10 +416,23 @@ class Directory:
         # 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_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",
@@ -369,69 +443,114 @@ class Directory:
         # 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, "%sC|%sc" % (short, file),
-                        self.logical, 2),
-                       (logical+"o", self.component, "%sO|%so" % (short, file),
-                        self.logical, 2)])
+            add_data(
+                self.db,
+                "RemoveFile",
+                [
+                    (
+                        logical + "c",
+                        self.component,
+                        "%sC|%sc" % (short, file),
+                        self.logical,
+                        2,
+                    ),
+                    (
+                        logical + "o",
+                        self.component,
+                        "%sO|%so" % (short, file),
+                        self.logical,
+                        2,
+                    ),
+                ],
+            )
         return logical
 
-    def glob(self, pattern, exclude = None):
+    def glob(self, pattern, exclude=None):
         """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] != '.')
+        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
+            if exclude and f in exclude:
+                continue
             self.add_file(f)
         return files
 
     def remove_pyc(self):
         "Remove .pyc files on uninstall"
-        add_data(self.db, "RemoveFile",
-                 [(self.component+"c", self.component, "*.pyc", self.logical, 2)])
+        add_data(
+            self.db,
+            "RemoveFile",
+            [(self.component + "c", self.component, "*.pyc", self.logical, 2)],
+        )
+
 
 class Binary:
     def __init__(self, fname):
         self.name = fname
+
     def __repr__(self):
         return 'msilib.Binary(os.path.join(dirname,"%s"))' % self.name
 
+
 class Feature:
-    def __init__(self, db, id, title, desc, display, level = 1,
-                 parent=None, directory = None, attributes=0):
+    def __init__(
+        self,
+        db,
+        id,
+        title,
+        desc,
+        display,
+        level=1,
+        parent=None,
+        directory=None,
+        attributes=0,
+    ):
         self.id = id
         if parent:
             parent = parent.id
-        add_data(db, "Feature",
-                        [(id, parent, title, desc, display,
-                          level, directory, attributes)])
+        add_data(
+            db,
+            "Feature",
+            [(id, parent, title, desc, display, level, directory, attributes)],
+        )
+
     def set_current(self):
         global current_feature
         current_feature = self
 
+
 class Control:
     def __init__(self, dlg, name):
         self.dlg = dlg
         self.name = name
 
-    def event(self, event, argument, condition = "1", ordering = None):
-        add_data(self.dlg.db, "ControlEvent",
-                 [(self.dlg.name, self.name, event, argument,
-                   condition, ordering)])
+    def event(self, event, argument, condition="1", ordering=None):
+        add_data(
+            self.dlg.db,
+            "ControlEvent",
+            [(self.dlg.name, self.name, event, argument, condition, ordering)],
+        )
 
     def mapping(self, event, attribute):
-        add_data(self.dlg.db, "EventMapping",
-                 [(self.dlg.name, self.name, event, attribute)])
+        add_data(
+            self.dlg.db,
+            "EventMapping",
+            [(self.dlg.name, self.name, event, attribute)],
+        )
 
     def condition(self, action, condition):
-        add_data(self.dlg.db, "ControlCondition",
-                 [(self.dlg.name, self.name, action, condition)])
+        add_data(
+            self.dlg.db,
+            "ControlCondition",
+            [(self.dlg.name, self.name, action, condition)],
+        )
+
 
 class RadioButtonGroup(Control):
     def __init__(self, dlg, name, property):
@@ -440,44 +559,97 @@ class RadioButtonGroup(Control):
         self.property = property
         self.index = 1
 
-    def add(self, name, x, y, w, h, text, value = None):
+    def add(self, name, x, y, w, h, text, value=None):
         if value is None:
             value = name
-        add_data(self.dlg.db, "RadioButton",
-                 [(self.property, self.index, value,
-                   x, y, w, h, text, None)])
+        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):
+    def __init__(
+        self, db, name, x, y, w, h, attr, title, first, default, cancel
+    ):
         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)])
+        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):
-        add_data(self.db, "Control",
-                 [(self.name, name, type, x, y, w, h, attr, prop, text, next, help)])
+        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):
-        return self.control(name, "Text", x, y, w, h, attr, None,
-                     text, None, None)
+        return self.control(
+            name, "Text", x, y, w, h, attr, None, text, None, None
+        )
 
     def bitmap(self, name, x, y, w, h, text):
-        return self.control(name, "Bitmap", x, y, w, h, 1, None, text, None, None)
+        return self.control(
+            name, "Bitmap", x, y, w, h, 1, None, text, None, None
+        )
 
     def line(self, name, x, y, w, h):
-        return self.control(name, "Line", x, y, w, h, 1, None, None, None, None)
+        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):
-        return self.control(name, "PushButton", x, y, w, h, attr, None, text, next, None)
+        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):
-        add_data(self.db, "Control",
-                 [(self.name, name, "RadioButtonGroup",
-                   x, y, w, h, attr, prop, text, next, None)])
+        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):
-        return self.control(name, "CheckBox", x, y, w, h, attr, prop, text, next, None)
+        return self.control(
+            name, "CheckBox", x, y, w, h, attr, prop, text, next, None
+        )