# `msilib` — Read and write Microsoft Installer files

Source code: Lib/msilib/__init__.py

The `msilib` supports the creation of Microsoft Installer (`.msi`) files. Because these files often contain an embedded “cabinet” file (`.cab`), it also exposes an API to create CAB files. Support for reading `.cab` files is currently not implemented; read support for the `.msi` database is possible.

This package aims to provide complete access to all tables in an `.msi` file, therefore, it is a fairly low-level API. Two primary applications of this package are the `distutils` command `bdist_msi`, and the creation of Python installer package itself (although that currently uses a different version of `msilib`).

The package contents can be roughly split into four parts: low-level CAB routines, low-level MSI routines, higher-level MSI routines, and standard table structures.

`msilib.``FCICreate`(cabname, files)

  Create a new CAB file named cabname. files must be a list of tuples, each containing the name of the file on disk, and the name of the file inside the CAB file.

  The files are added to the CAB file in the order they appear in the list. All files are added into a single CAB file, using the MSZIP compression algorithm.

  Callbacks to Python for the various steps of MSI creation are currently not exposed.

`msilib.``UuidCreate`()

  Return the string representation of a new unique identifier. This wraps the Windows API functions `UuidCreate()` and `UuidToString()`.

`msilib.``OpenDatabase`(path, persist)

  Return a new database object by calling MsiOpenDatabase. path is the file name of the MSI file; persist can be one of the constants `MSIDBOPEN_CREATEDIRECT`, `MSIDBOPEN_CREATE`, `MSIDBOPEN_DIRECT`, `MSIDBOPEN_READONLY`, or `MSIDBOPEN_TRANSACT`, and may include the flag `MSIDBOPEN_PATCHFILE`. See the Microsoft documentation for the meaning of these flags; depending on the flags, an existing database is opened, or a new one created.

`msilib.``CreateRecord`(count)

  Return a new record object by calling `MSICreateRecord()`. count is the number of fields of the record.

`msilib.``init_database`(name, schema, ProductName, ProductCode, ProductVersion, Manufacturer)

  Create and return a new database name, initialize it with schema, and set the properties ProductName, ProductCode, ProductVersion, and Manufacturer.

  schema must be a module object containing `tables` and `_Validation_records` attributes; typically, `msilib.schema` should be used.

  The database will contain just the schema and the validation records when this function returns.

`msilib.``add_data`(database, table, records)

  Add all records to the table named table in database.

  The table argument must be one of the predefined tables in the MSI schema, e.g. `'Feature'`, `'File'`, `'Component'`, `'Dialog'`, `'Control'`, etc.

  records should be a list of tuples, each one containing all fields of a record according to the schema of the table. For optional fields, `None` can be passed.

  Field values can be ints, strings, or instances of the Binary class.

class `msilib.``Binary`(filename)

  Represents entries in the Binary table; inserting such an object using `add_data()` reads the file named filename into the table.

`msilib.``add_tables`(database, module)

  Add all table content from module to database. module must contain an attribute tables listing all tables for which content should be added, and one attribute per table that has the actual content.

  This is typically used to install the sequence tables.

`msilib.``add_stream`(database, name, path)

  Add the file path into the `_Stream` table of database, with the stream name name.

`msilib.``gen_uuid`()

  Return a new UUID, in the format that MSI typically requires (i.e. in curly braces, and with all hexdigits in upper-case).

See also

FCICreate UuidCreate UuidToString

## Database Objects

`Database.``OpenView`(sql)

  Return a view object, by calling `MSIDatabaseOpenView()`. sql is the SQL statement to execute.

`Database.``Commit`()

  Commit the changes pending in the current transaction, by calling `MSIDatabaseCommit()`.

`Database.``GetSummaryInformation`(count)

  Return a new summary information object, by calling `MsiGetSummaryInformation()`. count is the maximum number of updated values.

`Database.``Close`()

  Close the database object, through `MsiCloseHandle()`.

  New in version 3.7.

See also

MSIDatabaseOpenView MSIDatabaseCommit MSIGetSummaryInformation MsiCloseHandle

## View Objects

`View.``Execute`(params)

  Execute the SQL query of the view, through `MSIViewExecute()`. If params is not `None`, it is a record describing actual values of the parameter tokens in the query.

`View.``GetColumnInfo`(kind)

  Return a record describing the columns of the view, through calling `MsiViewGetColumnInfo()`. kind can be either `MSICOLINFO_NAMES` or `MSICOLINFO_TYPES`.

`View.``Fetch`()

  Return a result record of the query, through calling `MsiViewFetch()`.

`View.``Modify`(kind, data)

  Modify the view, by calling `MsiViewModify()`. kind can be one of `MSIMODIFY_SEEK`, `MSIMODIFY_REFRESH`, `MSIMODIFY_INSERT`, `MSIMODIFY_UPDATE`, `MSIMODIFY_ASSIGN`, `MSIMODIFY_REPLACE`, `MSIMODIFY_MERGE`, `MSIMODIFY_DELETE`, `MSIMODIFY_INSERT_TEMPORARY`, `MSIMODIFY_VALIDATE`, `MSIMODIFY_VALIDATE_NEW`, `MSIMODIFY_VALIDATE_FIELD`, or `MSIMODIFY_VALIDATE_DELETE`.

  data must be a record describing the new data.

`View.``Close`()

  Close the view, through `MsiViewClose()`.

See also

MsiViewExecute MSIViewGetColumnInfo MsiViewFetch MsiViewModify MsiViewClose

## Summary Information Objects

`SummaryInformation.``GetProperty`(field)

  Return a property of the summary, through `MsiSummaryInfoGetProperty()`. field is the name of the property, and can be one of the constants `PID_CODEPAGE`, `PID_TITLE`, `PID_SUBJECT`, `PID_AUTHOR`, `PID_KEYWORDS`, `PID_COMMENTS`, `PID_TEMPLATE`, `PID_LASTAUTHOR`, `PID_REVNUMBER`, `PID_LASTPRINTED`, `PID_CREATE_DTM`, `PID_LASTSAVE_DTM`, `PID_PAGECOUNT`, `PID_WORDCOUNT`, `PID_CHARCOUNT`, `PID_APPNAME`, or `PID_SECURITY`.

`SummaryInformation.``GetPropertyCount`()

  Return the number of summary properties, through `MsiSummaryInfoGetPropertyCount()`.

`SummaryInformation.``SetProperty`(field, value)

  Set a property through `MsiSummaryInfoSetProperty()`. field can have the same values as in `GetProperty()`, value is the new value of the property. Possible value types are integer and string.

`SummaryInformation.``Persist`()

  Write the modified properties to the summary information stream, using `MsiSummaryInfoPersist()`.

See also

MsiSummaryInfoGetProperty MsiSummaryInfoGetPropertyCount MsiSummaryInfoSetProperty MsiSummaryInfoPersist

## Record Objects

`Record.``GetFieldCount`()

  Return the number of fields of the record, through `MsiRecordGetFieldCount()`.

`Record.``GetInteger`(field)

  Return the value of field as an integer where possible. field must be an integer.

`Record.``GetString`(field)

  Return the value of field as a string where possible. field must be an integer.

`Record.``SetString`(field, value)

  Set field to value through `MsiRecordSetString()`. field must be an integer; value a string.

`Record.``SetStream`(field, value)

  Set field to the contents of the file named value, through `MsiRecordSetStream()`. field must be an integer; value a string.

`Record.``SetInteger`(field, value)

  Set field to value through `MsiRecordSetInteger()`. Both field and value must be an integer.

`Record.``ClearData`()

  Set all fields of the record to 0, through `MsiRecordClearData()`.

See also

MsiRecordGetFieldCount MsiRecordSetString MsiRecordSetStream MsiRecordSetInteger MsiRecordClearData

## Errors

All wrappers around MSI functions raise `MSIError`; the string inside the exception will contain more detail.

## CAB Objects

class `msilib.``CAB`(name)

  The class `CAB` represents a CAB file. During MSI construction, files will be added simultaneously to the `Files` table, and to a CAB file. Then, when all files have been added, the CAB file can be written, then added to the MSI file.

  name is the name of the CAB file in the MSI file.

  `append`(full, file, logical)

    Add the file with the pathname full to the CAB file, under the name logical. If there is already a file named logical, a new file name is created.

    Return the index of the file in the CAB file, and the new name of the file inside the CAB file.

  `commit`(database)

    Generate a CAB file, add it as a stream to the MSI file, put it into the `Media` table, and remove the generated file from the disk.

## Directory Objects

class `msilib.``Directory`(database, cab, basedir, physical, logical, default[, componentflags])

  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.

  `start_component`(component=None, feature=None, flags=None, keyfile=None, uuid=None)

    Add an entry to the Component table, and make this component the current component 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.

  `add_file`(file, src=None, version=None, language=None)

    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.

  `glob`(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.

  `remove_pyc`()

    Remove `.pyc` files on uninstall.

See also

Directory Table File Table Component Table FeatureComponents Table

## Features

class `msilib.``Feature`(db, id, title, desc, display, level=1, parent=None, directory=None, attributes=0)

  Add a new record to the `Feature` table, using the values id, parent.id, title, desc, display, level, directory, and attributes. The resulting feature object can be passed to the `start_component()` method of `Directory`.

  `set_current`()

    Make this feature the current feature of `msilib`. New components are automatically added to the default feature, unless a feature is explicitly specified.

See also

Feature Table

## GUI classes

`msilib` provides several classes that wrap the GUI tables in an MSI database. However, no standard user interface is provided; use `bdist_msi` to create MSI files with a user-interface for installing Python packages.

class `msilib.``Control`(dlg, name)

  Base class of the dialog controls. dlg is the dialog object the control belongs to, and name is the control’s name.

  `event`(event, argument, condition=1, ordering=None)

    Make an entry into the `ControlEvent` table for this control.

  `mapping`(event, attribute)

    Make an entry into the `EventMapping` table for this control.

  `condition`(action, condition)

    Make an entry into the `ControlCondition` table for this control.

class `msilib.``RadioButtonGroup`(dlg, name, property)

  Create a radio button control named name. property is the installer property that gets set when a radio button is selected.

  `add`(name, x, y, width, height, text, value=None)

    Add a radio button named name to the group, at the coordinates x, y, width, height, and with the label text. If value is `None`, it defaults to name.

class `msilib.``Dialog`(db, name, x, y, w, h, attr, title, first, default, cancel)

  Return a new `Dialog` object. An entry in the `Dialog` table is made, with the specified coordinates, dialog attributes, title, name of the first, default, and cancel controls.

  `control`(name, type, x, y, width, height, attributes, property, text, control_next, help)

    Return a new `Control` object. An entry in the `Control` table is made with the specified parameters.

    This is a generic method; for specific types, specialized methods are provided.

  `text`(name, x, y, width, height, attributes, text)

    Add and return a `Text` control.

  `bitmap`(name, x, y, width, height, text)

    Add and return a `Bitmap` control.

  `line`(name, x, y, width, height)

    Add and return a `Line` control.

  `pushbutton`(name, x, y, width, height, attributes, text, next_control)

    Add and return a `PushButton` control.

  `radiogroup`(name, x, y, width, height, attributes, property, text, next_control)

    Add and return a `RadioButtonGroup` control.

  `checkbox`(name, x, y, width, height, attributes, property, text, next_control)

    Add and return a `CheckBox` control.

See also

Dialog Table Control Table Control Types ControlCondition Table ControlEvent Table EventMapping Table RadioButton Table

## Precomputed tables

`msilib` provides a few subpackages that contain only schema and table definitions. Currently, these definitions are based on MSI version 2.0.

`msilib.``schema`

  This is the standard MSI schema for MSI 2.0, with the tables variable providing a list of table definitions, and _Validation_records providing the data for MSI validation.

`msilib.``sequence`

  This module contains table contents for the standard sequence tables: AdminExecuteSequence, AdminUISequence, AdvtExecuteSequence, InstallExecuteSequence, and InstallUISequence.

`msilib.``text`

  This module contains definitions for the UIText and ActionText tables, for the standard installer actions.