mobase

Subpackages

• mobase.widgets

Attributes

GameFeatureType
INVALID_HANDLE_VALUE
MoVariant
__version__

Classes

BSAInvalidation	Base class for all game features, cannot be inherited, used only for typing
DataArchives	Base class for all game features, cannot be inherited, used only for typing
EndorsedState	Create a collection of name/value pairs.
ExecutableForcedLoadSetting
ExecutableInfo
FileInfo	Information about a virtualized file
FileTreeEntry	Represent an entry in a file tree, either a file or a directory. This class
GameFeature	Base class for all game features, cannot be inherited, used only for typing
GamePlugins	Base class for all game features, cannot be inherited, used only for typing
GuessQuality	Describes how good the code considers a guess (i.e. for a mod name) this is used to
GuessedString	Represents a string that may be set from different places. Each time the value is
IDownloadManager
IFileTree	Interface to classes that provides way to visualize and alter file trees. The tree
IGameFeatures	Interface for the game features, accessible through IOrganizer.gameFeatures().
IInstallationManager
IModInterface
IModList	Interface to the mod-list.
IModRepositoryBridge
IOrganizer	Interface to class that provides information about the running session
IPlugin	Base class for all plugins.
IPluginDiagnose	Plugins that create problem reports to be displayed in the UI.
IPluginFileMapper	Plugins that adds virtual file links.
IPluginGame	Base classes for game plugins.
IPluginInstaller	This is the top-level class for installer. Actual installers should inherit either:
IPluginInstallerCustom	Custom installer for mods. Custom installers receive the archive name and have to go
IPluginInstallerSimple	Simple installer for mods. Simple installers only deal with an in-memory structure
IPluginList	Primary interface to the list of plugins.
IPluginModPage	Base class for all plugins.
IPluginPreview	These plugins add support for previewing files in the data pane. Right now all image formats supported
IPluginRequirement	Class representing requirements for plugins.
IPluginTool	This is the simplest of plugin interfaces. Such plugins simply place an icon inside the tools sub-menu
IProfile	Interface to interact with Mod Organizer 2 profiles.
ISaveGame	Base class for information about what is in a save game.
ISaveGameInfoWidget	Base class for a save game info widget.
InstallResult	Create a collection of name/value pairs.
LoadOrderMechanism	Create a collection of name/value pairs.
LocalSavegames	Base class for all game features, cannot be inherited, used only for typing
Mapping
ModDataChecker	Game feature that is used to check the content of a data tree.
ModDataContent	The ModDataContent feature is used (when available) to indicate to users the content
ModRepositoryFileInfo
ModState	Create a collection of name/value pairs.
PluginRequirementFactory
PluginSetting	Class to hold the user-configurable parameters a plugin accepts. The purpose of this class is
PluginState	Create a collection of name/value pairs.
ProfileSetting	Create a collection of name/value pairs.
ReleaseType	Create a collection of name/value pairs.
SaveGameInfo	Feature to get hold of stuff to do with save games.
ScriptExtender	Base class for all game features, cannot be inherited, used only for typing
SortMechanism	Create a collection of name/value pairs.
TrackedState	Create a collection of name/value pairs.
UnmanagedMods	Base class for all game features, cannot be inherited, used only for typing
VersionInfo	Represents the version of a mod or plugin.
VersionScheme	Create a collection of name/value pairs.

Functions

getFileVersion(→ str)	Retrieve the file version of the given executable.
getIconForExecutable(→ PyQt6.QtGui.QIcon)	Retrieve the icon of an executable. Currently this always extracts the biggest icon.
getProductVersion(→ str)	Retrieve the product version of the given executable.

Package Contents

class mobase.BSAInvalidation

Bases: GameFeature

Base class for all game features, cannot be inherited, used only for typing purpose in Python.

abstract activate(profile: IProfile) → None

abstract deactivate(profile: IProfile) → None

abstract isInvalidationBSA(name: str) → bool

class mobase.DataArchives

Bases: GameFeature

Base class for all game features, cannot be inherited, used only for typing purpose in Python.

abstract addArchive(profile: IProfile, index: int, name: str) → None

Add an archive to the archive list.

Parameters:

• profile – Profile to add the archive to.

• index – Index to insert before. Use 0 for the beginning of the list or INT_MAX for the end of the list).

• name – Name of the archive to add.

abstract archives(profile: IProfile) → Sequence[str]

Retrieve the list of archives in the given profile.

Parameters:

profile – Profile to retrieve archives from.

Returns:

The list of archives in the given profile.

abstract removeArchive(profile: IProfile, name: str) → None

Remove the given archive from the given profile.

Parameters:

• profile – Profile to remove the archive from.

• name – Name of the archive to remove.

abstract vanillaArchives() → Sequence[str]

Retrieve the list of vanilla archives.

Vanilla archives are archive files that are shipped with the original game.

Returns:

The list of vanilla archives.

class mobase.EndorsedState(*args, **kwds)

Bases: enum.Enum

Create a collection of name/value pairs.

Example enumeration:

>>> class Color(Enum):
...     RED = 1
...     BLUE = 2
...     GREEN = 3

Access them by:

• attribute access:

  >>> Color.RED
  <Color.RED: 1>
  

• value lookup:

  >>> Color(1)
  <Color.RED: 1>
  

• name lookup:

  >>> Color['RED']
  <Color.RED: 1>
  

Enumerations can be iterated over, and know how many members they have:

>>> len(Color)
3

>>> list(Color)
[<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]

Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.

__eq__(other: object) → bool

Return self==value.

__ge__(other: EndorsedState) → bool

Return self>=value.

__gt__(other: EndorsedState) → bool

Return self>value.

__int__() → int

__le__(other: EndorsedState) → bool

Return self<=value.

__lt__(other: EndorsedState) → bool

Return self<value.

__ne__(other: object) → bool

Return self!=value.

__str__() → str

Return str(self).

ENDORSED_FALSE = Ellipsis

ENDORSED_NEVER = Ellipsis

ENDORSED_TRUE = Ellipsis

ENDORSED_UNKNOWN = Ellipsis

property name: str

The name of the Enum member.

property value: int

The value of the Enum member.

class mobase.ExecutableForcedLoadSetting(process: str, library: str)

enabled() → bool

forced() → bool

library() → str

process() → str

withEnabled(enabled: bool) → ExecutableForcedLoadSetting

withForced(forced: bool) → ExecutableForcedLoadSetting

class mobase.ExecutableInfo(title: str, binary: str | os.PathLike[str] | PyQt6.QtCore.QFileInfo)

arguments() → Sequence[str]

asCustom() → ExecutableInfo

binary() → PyQt6.QtCore.QFileInfo

isCustom() → bool

isValid() → bool

steamAppID() → str

title() → str

withArgument(argument: str) → ExecutableInfo

withSteamAppId(app_id: str) → ExecutableInfo

withWorkingDirectory(directory: str | os.PathLike[str] | PyQt6.QtCore.QDir) → ExecutableInfo

workingDirectory() → PyQt6.QtCore.QDir

class mobase.FileInfo

Information about a virtualized file

property archive: str

property filePath: str

property origins: list[str]

class mobase.FileTreeEntry

Represent an entry in a file tree, either a file or a directory. This class inherited by IFileTree so that operations on entry are the same for a file or a directory.

This class provides convenience methods to query information on the file, like its name or the its last modification time. It also provides a convenience astree() method that can be used to retrieve the tree corresponding to its entry in case the entry represent a directory.

class FileTypes(*args, **kwds)

Bases: enum.Enum

Enumeration of the different file type or combinations.

__and__(other: FileTreeEntry) → FileTreeEntry

__eq__(other: object) → bool

Return self==value.

__ge__(other: FileTreeEntry) → bool

Return self>=value.

__gt__(other: FileTreeEntry) → bool

Return self>value.

__int__() → int

__invert__() → FileTreeEntry

__le__(other: FileTreeEntry) → bool

Return self<=value.

__lt__(other: FileTreeEntry) → bool

Return self<value.

__ne__(other: object) → bool

Return self!=value.

__or__(other: FileTreeEntry) → FileTreeEntry

__rand__(other: FileTreeEntry) → FileTreeEntry

__ror__(other: FileTreeEntry) → FileTreeEntry

__rxor__(other: FileTreeEntry) → FileTreeEntry

__str__() → str

Return str(self).

__xor__(other: FileTreeEntry) → FileTreeEntry

DIRECTORY = Ellipsis

FILE = Ellipsis

FILE_OR_DIRECTORY = Ellipsis

property name: str

The name of the Enum member.

property value: int

The value of the Enum member.

__eq__(other: object) → bool

Return self==value.

detach() → bool

Detach this entry from its parent tree.

Returns:

True if the entry was removed correctly, False otherwise.

fileType() → FileTreeEntry

Returns:

The filetype of this entry.

hasSuffix(suffixes: Sequence[str]) → bool

hasSuffix(suffix: str) → bool

Check if this entry has the given suffix.

Parameters:

suffix – Suffix to check.

Returns:

True if this entry is a file and has the given suffix.

isDir() → bool

Returns:

True if this entry is a directory, False otherwise.

isFile() → bool

Returns:

True if this entry is a file, False otherwise.

moveTo(tree: IFileTree) → bool

Move this entry to the given tree.

Parameters:

tree – The tree to move this entry to.

Returns:

True if the entry was moved correctly, False otherwise.

name() → str

Returns:

The name of this entry.

parent() → IFileTree | None

Returns:

The parent tree containing this entry, or a None if this entry is the root

or the parent tree is unreachable.

path(sep: str = '\\') → str

Retrieve the path from this entry up to the root of the tree.

This method propagate up the tree so is not constant complexity as the full path is never stored.

Parameters:

sep – The type of separator to use to create the path.

Returns:

The path from this entry to the root, including the name of this entry.

pathFrom(tree: IFileTree, sep: str = '\\') → str

Retrieve the path from the given tree to this entry.

Parameters:

• tree – The tree to reach, must be a parent of this entry.

• sep – The type of separator to use to create the path.

Returns:

The path from the given tree to this entry, including the name of this entry, or

an empty string if the given tree is not a parent of this entry.

suffix() → str

Retrieve the “last” extension of this entry.

The “last” extension is everything after the last dot in the file name.

Returns:

The last extension of this entry, or an empty string if the file has no extension

or is directory.

DIRECTORY: FileTreeEntry.FileTypes = Ellipsis

FILE: FileTreeEntry.FileTypes = Ellipsis

FILE_OR_DIRECTORY: FileTreeEntry.FileTypes = Ellipsis

class mobase.GameFeature

Bases: abc.ABC

Base class for all game features, cannot be inherited, used only for typing purpose in Python.

class mobase.GamePlugins

Bases: GameFeature

Base class for all game features, cannot be inherited, used only for typing purpose in Python.

abstract getLoadOrder() → Sequence[str]

abstract lightPluginsAreSupported() → bool

Returns:

True if light plugins are supported, False otherwise.

abstract mediumPluginsAreSupported() → bool

Returns:

True if medium plugins are supported, False otherwise.

abstract readPluginLists(plugin_list: IPluginList) → None

abstract writePluginLists(plugin_list: IPluginList) → None

class mobase.GuessQuality(*args, **kwds)

Bases: enum.Enum

Describes how good the code considers a guess (i.e. for a mod name) this is used to determine if a name from another source should overwrite or not.

__eq__(other: object) → bool

Return self==value.

__int__() → int

__ne__(other: object) → bool

Return self!=value.

__str__() → str

Return str(self).

FALLBACK = Ellipsis

GOOD = Ellipsis

INVALID = Ellipsis

META = Ellipsis

PRESET = Ellipsis

USER = Ellipsis

property name: str

The name of the Enum member.

property value: int

The value of the Enum member.

class mobase.GuessedString

class mobase.GuessedString(value: str, quality: GuessQuality = GuessQuality.USER)

Represents a string that may be set from different places. Each time the value is changed a “quality” is specified to say how probable it is the value is the best choice. Only the best choice should be used in the end but alternatives can be queried. This class also allows a filter to be set. If a “guess” doesn’t pass the filter, it is ignored.

__str__() → str

Return str(self).

reset() → GuessedString

reset(value: str, quality: GuessQuality) → GuessedString

reset(other: GuessedString) → GuessedString

Reset this GuessedString object by copying the given one, only if the given one has better quality.

Parameters:

other – The GuessedString to copy.

Returns:

This GuessedString object.

setFilter(filter: Callable[[str], str | bool]) → None

Set the filter for this GuessedString.

The filter is applied on every update() and can reject the new value altogether or modify it (by returning a new value).

Parameters:

filter – The new filter.

update(value: str) → GuessedString

update(value: str, quality: GuessQuality) → GuessedString

Update this GuessedString by adding a new variants with the given quality.

If the specified quality is better than the current one, the actual value of the GuessedString is also updated.

The GuessedString is only updated if the given value passes the filter.

Parameters:

• value – The new variant to add.

• quality – The quality of the variant.

Returns:

This GuessedString object.

variants() → set[str]

Returns:

The list of variants for this GuessedString.

class mobase.IDownloadManager

downloadPath(id: int) → str

Retrieve the (absolute) path of the specified download.

Parameters:

id – ID of the download.

Returns:

The absolute path to the file corresponding to the given download. This file

may not exist yet if the download is incomplete.

onDownloadComplete(callback: Callable[[int], None]) → bool

Installs a handler to be called when a download completes.

Parameters:

callback – The function to be called when a download complete. The parameter is the download ID.

Returns:

True if the handler was installed properly (there are currently no reasons for this to fail).

onDownloadFailed(callback: Callable[[int], None]) → bool

Installs a handler to be called when a download fails.

Parameters:

callback – The function to be called when a download fails. The parameter is the download ID.

Returns:

True if the handler was installed properly (there are currently no reasons for this to fail).

onDownloadPaused(callback: Callable[[int], None]) → bool

Installs a handler to be called when a download is paused.

Parameters:

callback – The function to be called when a download is paused. The parameter is the download ID.

Returns:

True if the handler was installed properly (there are currently no reasons for this to fail).

onDownloadRemoved(callback: Callable[[int], None]) → bool

Installs a handler to be called when a download is removed.

Parameters:

callback – The function to be called when a download is removed. The parameter is the download ID.

Returns:

True if the handler was installed properly (there are currently no reasons for this to fail).

startDownloadNexusFile(mod_id: int, file_id: int) → int

Download a file from www.nexusmods.com/<game>. <game> is always the game currently being managed.

Parameters:

• mod_id – ID of the mod to download the file from.

• file_id – ID of the file to download.

Returns:

An ID identifying the download.

startDownloadURLs(urls: Sequence[str]) → int

Download a file by url.

The list can contain alternative URLs to allow the download manager to switch in case of download problems

Parameters:

urls – List of urls to download from.

Returns:

An ID identifying the download.

class mobase.IFileTree

Bases: FileTreeEntry

Interface to classes that provides way to visualize and alter file trees. The tree may not correspond to an actual file tree on the disk (e.g., inside an archive, from a QTree Widget, …).

Read-only operations on the tree are thread-safe, even when the tree has not been populated yet.

In order to prevent wrong usage of the tree, implementing classes may throw UnsupportedOperationException if an operation is not supported. By default, all operations are supported, but some may not make sense in many situations.

The goal of this is not reflect the change made to a IFileTree to the disk, but child classes may override relevant methods to do so.

The tree is built upon FileTreeEntry. A given tree holds shared pointers to its entries while each entry holds a weak pointer to its parent, this means that the descending link are strong (shared pointers) but the uplink are weak.

Accessing the parent is always done by locking the weak pointer so that returned pointer or either null or valid. This structure implies that as long as the initial root lives, entry should not be destroyed, unless the entry are detached from the root and no shared pointers are kept.

However, it is not guarantee that one can go up the tree from a single node entry. If the root node is destroyed, it will not be possible to go up the tree, even if we still have a valid shared pointer.

class InsertPolicy(*args, **kwds)

Bases: enum.Enum

Create a collection of name/value pairs.

Example enumeration:

>>> class Color(Enum):
...     RED = 1
...     BLUE = 2
...     GREEN = 3

Access them by:

• attribute access:

  >>> Color.RED
  <Color.RED: 1>
  

• value lookup:

  >>> Color(1)
  <Color.RED: 1>
  

• name lookup:

  >>> Color['RED']
  <Color.RED: 1>
  

Enumerations can be iterated over, and know how many members they have:

>>> len(Color)
3

>>> list(Color)
[<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]

Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.

__eq__(other: object) → bool

Return self==value.

__int__() → int

__ne__(other: object) → bool

Return self!=value.

__str__() → str

Return str(self).

FAIL_IF_EXISTS = Ellipsis

MERGE = Ellipsis

REPLACE = Ellipsis

property name: str

The name of the Enum member.

property value: int

The value of the Enum member.

class WalkReturn(*args, **kwds)

Bases: enum.Enum

Enumeration that can be returned by the callback for the walk() method to stop the walking operation early.

__eq__(other: object) → bool

Return self==value.

__int__() → int

__ne__(other: object) → bool

Return self!=value.

__str__() → str

Return str(self).

CONTINUE = Ellipsis

SKIP = Ellipsis

STOP = Ellipsis

property name: str

The name of the Enum member.

property value: int

The value of the Enum member.

__bool__() → bool

Returns:

True if this tree is not empty, False otherwise.

__getitem__(index: int) → FileTreeEntry

Retrieve the entry at the given index in this tree.

Parameters:

index – Index of the entry to retrieve, must be less than the size.

Returns:

The entry at the given index.

Raises:

IndexError – If the given index is not in range for this tree.

__iter__() → Iterator[FileTreeEntry]

Retrieves an iterator for entries directly under this tree.

This method does not recurse into subtrees, see walk() for this.

Returns:

An iterator object that can be used to iterate over entries in this tree.

__len__() → int

Returns:

The number of entries directly under this tree.

addDirectory(path: str) → IFileTree

Create a new directory tree under this tree.

This method will create missing folders in the given path and will not fail if the directory already exists but will fail if the given path contains “.” or “..”. This method invalidates iterators to this tree and all the subtrees present in the given path.

Parameters:

path – Path to the directory to create.

Returns:

An IFileTree corresponding to the created directory.

Raises:

RuntimeError – If the directory could not be created.

addFile(path: str, replace_if_exists: bool = False) → FileTreeEntry

Create a new file directly under this tree.

This method will fail if the file already exists and replace_if_exists is False. This method invalidates iterators to this tree and all the subtrees present in the given path.

Parameters:

• path – Path to the file to create.

• replace_if_exists – If True and an entry already exists at the given location, it will be replaced by a new entry. This will replace both files and directories.

Returns:

A FileTreeEntry corresponding to the created file.

Raises:

RuntimeError – If the file could not be created.

clear() → bool

Delete (detach) all the entries from this tree.

This method will go through the entries in this tree and stop at the first entry that cannot be deleted, this means that the tree can be partially cleared.

Returns:

True if all entries have been detached, False otherwise.

copy(entry: FileTreeEntry, path: str = '', insert_policy: IFileTree = InsertPolicy.FAIL_IF_EXISTS) → FileTreeEntry

Move the given entry to the given path under this tree.

The entry must not be a parent tree of this tree. This method can also be used to rename entries.

If the insert policy if FAIL_IF_EXISTS, the call will fail if an entry at the same location already exists. If the policy is REPLACE, an existing entry will be replaced. If MERGE, the entry will be merged with the existing one (if the entry is a file, and a file exists, the file will be replaced).

This method invalidates iterator to this tree, to the parent tree of the given entry, and to subtrees of this tree if the insert policy is MERGE.

Parameters:

• entry – Entry to copy.

• path – The path to copy the entry to. If the path ends with / or , the entry will be copied in the corresponding directory instead of replacing it. If the given path is empty (“”), the entry is copied directly under this tree.

• insert_policy – Policy to use to resolve conflicts.

Returns:

The new entry (copy of the specified entry).

Raises:

RuntimeError – If the entry could not be copied.

createOrphanTree(name: str = '') → IFileTree

Create a new orphan empty tree.

Parameters:

name – Name of the tree.

Returns:

A new tree without any parent.

exists(path: str, type: FileTreeEntry = FileTreeEntry.FileTypes.FILE_OR_DIRECTORY) → bool

Check if the given entry exists.

Parameters:

• path – Path to the entry, separated by / or .

• type – The type of the entry to check.

Returns:

True if the entry was found, False otherwise.

find(path: str, type: FileTreeEntry = FileTreeEntry.FileTypes.FILE_OR_DIRECTORY) → IFileTree | FileTreeEntry | None

Retrieve the given entry.

If no entry exists at the given path, or if the entry is not of the right type, None is returned.

Parameters:

• path – Path to the entry, separated by / or .

• type – The type of the entry to check.

Returns:

The entry at the given location, or None if the entry was not found or

was not of the correct type.

insert(entry: FileTreeEntry, policy: IFileTree = InsertPolicy.FAIL_IF_EXISTS) → bool

Insert the given entry in this tree, removing it from its previous parent.

The entry must not be this tree or a parent entry of this tree.

• If the insert policy if FAIL_IF_EXISTS, the call will fail if an entry with the same name already exists.

• If the policy is REPLACE, an existing entry will be replaced by the given entry.

• If the policy is MERGE:

  • If there is no entry with the same name, the new entry is inserted.

  • If there is an entry with the same name:

    • If both entries are files, the old file is replaced by the given entry.

    • If both entries are directories, a merge is performed as if using merge().

    • Otherwise the insertion fails (two entries with different types).

This method invalidates iterator to this tree, to the parent tree of the given entry, and to subtrees of this tree if the insert policy is MERGE.

Parameters:

• entry – Entry to insert.

• policy – Policy to use to resolve conflicts.

Returns:

True if the entry was insert, False otherwise.

merge(other: IFileTree, overwrites: bool = False) → dict[FileTreeEntry, FileTreeEntry] | int

Merge the given tree with this tree, i.e., insert all entries of the given tree into this tree.

The tree must not be this tree or a parent entry of this tree. Files present in both tree will be replaced by files in the given tree. After a merge, the source tree will be empty but still attached to its parent.

If overwrites is True, a map from overridden files to new files will be returned.

Note that the merge process makes no distinction between files and directories when merging: if a directory is present in this tree and a file from source is in conflict with it, the tree will be removed and the file inserted; if a file is in this tree and a directory from source is in conflict with it, the file will be replaced with the directory.

This method invalidates iterators to this tree, all the subtrees under this tree present in the given path, and all the subtrees of the given source.

Parameters:

• other – Tree to merge.

• overwrites – If True, a mapping from overridden files to new files will be returned.

Returns:

If overwrites is True, a mapping from overridden files to new files, otherwise

the number of overwritten entries.

Raises:

RuntimeError – If the merge failed.

move(entry: FileTreeEntry, path: str, policy: IFileTree = InsertPolicy.FAIL_IF_EXISTS) → bool

Move the given entry to the given path under this tree.

The entry must not be a parent tree of this tree. This method can also be used to rename entries.

If the insert policy if FAIL_IF_EXISTS, the call will fail if an entry at the same location already exists. If the policy is REPLACE, an existing entry will be replaced. If MERGE, the entry will be merged with the existing one (if the entry is a file, and a file exists, the file will be replaced).

This method invalidates iterator to this tree, to the parent tree of the given entry, and to subtrees of this tree if the insert policy is MERGE.

Parameters:

• entry – Entry to move.

• path – The path to move the entry to. If the path ends with / or , the entry will be inserted in the corresponding directory instead of replacing it. If the given path is empty (“”), this is equivalent to insert().

• policy – Policy to use to resolve conflicts.

Returns:

True if the entry was moved correctly, False otherwise.

pathTo(entry: FileTreeEntry, sep: str = '\\') → str

Retrieve the path from this tree to the given entry.

Parameters:

• entry – The entry to reach, must be in this tree.

• sep – The type of separator to use to create the path.

Returns:

The path from this tree to the given entry, including the name of the entry, or

an empty string if the given entry was not found under this tree.

remove(name: str) → bool

remove(entry: FileTreeEntry) → bool

Delete the given entry.

Parameters:

entry – Entry to delete. The entry must belongs to this tree (and not to a subtree).

Returns:

True if the entry was deleted, False otherwise.

removeAll(names: Sequence[str]) → int

Delete the entries with the given names from the tree.

This method does not recurse into subtrees, so only entries accessible directly from this tree will be removed. This method invalidates iterators.

Parameters:

names – Names of the entries to delete.

Returns:

The number of deleted entry.

removeIf(filter: Callable[[FileTreeEntry], bool]) → int

Delete entries matching the given predicate from the tree.

This method does not recurse into subtrees, so only entries accessible directly from this tree will be removed. This method invalidates iterators.

Parameters:

filter – Predicate that should return true for entries to delete.

Returns:

The number of deleted entry.

walk(callback: Callable[[str, FileTreeEntry], IFileTree], sep: str = '\\') → None

Walk this tree, calling the given function for each entry in it.

The given callback will be called with two parameters: the path from this tree to the given entry (with a trailing separator, not including the entry name), and the actual entry. The method returns a WalkReturn object to indicates what to do.

Parameters:

• callback – Method to call for each entry in the tree.

• sep – Type of separator to use to construct the path.

CONTINUE: IFileTree.WalkReturn = Ellipsis

FAIL_IF_EXISTS: IFileTree.InsertPolicy = Ellipsis

MERGE: IFileTree.InsertPolicy = Ellipsis

REPLACE: IFileTree.InsertPolicy = Ellipsis

SKIP: IFileTree.WalkReturn = Ellipsis

STOP: IFileTree.WalkReturn = Ellipsis

class mobase.IGameFeatures

Interface for the game features, accessible through IOrganizer.gameFeatures().

gameFeature(feature_type: Type[GameFeatureType]) → GameFeatureType

Retrieve the given game feature, if one exists.

Parameters:

feature_type – The class of feature to retrieve.

Returns:

The game feature corresponding to the given type, or None if the feature is

not available.

registerFeature(games: Sequence[str], feature: GameFeature, priority: int, replace: bool = False) → bool

registerFeature(game: IPluginGame, feature: GameFeature, priority: int, replace: bool = False) → bool

registerFeature(feature: GameFeature, priority: int, replace: bool = False) → bool

Register game feature for all games.

This method register a game feature to combine or replace with other features of the same kind. Some features are merged (e.g., ModDataContent, ModDataChecker), while other override previous features (e.g., SaveGameInfo).

For features that can be combined, the priority argument indicates the order of priority (e.g., the order of the checks for ModDataChecker). For other features, the feature with the highest priority will be used. The features provided by the game plugin itself always have lowest priority.

The feature is associated to the plugin that registers it, if the plugin is disabled, the feature will not be available.

This function will return True if the feature was registered, even if the feature is not used du to its low priority.

Parameters:

• feature – Game feature to register.

• priority – Priority of the game feature. If the plugin registering the feature is a game plugin, this parameter is ignored.

• replace – If True, remove features of the same kind registered by the current plugin, otherwise add the feature alongside existing ones.

Returns:

True if the game feature was properly registered, False otherwise.

unregisterFeature(feature: GameFeature) → bool

Unregister the given game feature.

This function is safe to use even if the given feature was never registered.

Parameters:

feature – Feature to unregister.

Returns:

True if the feature was successfully unregistered, False otherwise.

unregisterFeatures(feature_type: Type[GameFeatureType]) → int

Unregister all features of the given type registered by the calling plugin.

This function is safe to use even if the plugin has no feature of the given type register.

Parameters:

feature_type – The class of feature to unregister.

Returns:

The number of unregistered features.

class mobase.IInstallationManager

createFile(entry: FileTreeEntry) → str

Create a new file on the disk corresponding to the given entry.

This method can be used by installer that needs to create files that are not in the original archive. At the end of the installation, if there are entries in the final tree that were used to create files, the corresponding files will be moved to the mod folder.

Temporary files corresponding to created files are automatically cleaned up at the end of the installation.

Parameters:

entry – The entry for which a temporary file should be created.

Returns:

The path to the created file, or an empty string if the file could not be created.

extractFile(entry: FileTreeEntry, silent: bool = False) → str

Extract the specified file from the currently opened archive to a temporary location.

This method cannot be used to extract directory.

The call will fail with an exception if no archive is open (plugins deriving from IPluginInstallerSimple can rely on that, custom installers should not). The temporary file is automatically cleaned up after the installation. This call can be very slow if the archive is large and “solid”.

Parameters:

• entry – Entry corresponding to the file to extract.

• silent – If true, the dialog showing extraction progress will not be shown.

Returns:

The absolute path to the temporary file, or an empty string if the file was not extracted.

extractFiles(entries: list[FileTreeEntry], silent: bool = False) → Sequence[str]

Extract the specified files from the currently opened archive to a temporary location.

This method cannot be used to extract directories.

The call will fail with an exception if no archive is open (plugins deriving from IPluginInstallerSimple can rely on that, custom installers should not). The temporary files are automatically cleaned up after the installation. This call can be very slow if the archive is large and “solid”.

Parameters:

• entries – Entries corresponding to the files to extract.

• silent – If true, the dialog showing extraction progress will not be shown.

Returns:

A list containing absolute paths to the temporary files.

getSupportedExtensions() → Sequence[str]

Returns:

The extensions of archives supported by this installation manager.

installArchive(mod_name: GuessedString, archive: str | os.PathLike[str] | PyQt6.QtCore.QFileInfo, mod_id: int = 0) → tuple[InstallResult, str, int]

Install the given archive.

Parameters:

• mod_name – Suggested name of the mod.

• archive – Path to the archive to install.

• mod_id – ID of the mod, if available.

Returns:

The result of the installation.

class mobase.IModInterface

absolutePath() → str

Returns:

Absolute path to the mod to be used in file system operations.

addCategory(name: str) → None

Assign a category to the mod. If the named category does not exist it is created.

Parameters:

name – Name of the new category to assign.

addNexusCategory(category_id: int) → None

Set the category id from a nexus category id. Conversion to MO ID happens internally.

If a mapping is not possible, the category is set to the default value.

Parameters:

category_id – The Nexus category ID.

categories() → Sequence[str]

Returns:

The list of categories this mod belongs to.

clearPluginSettings(plugin_name: str) → dict[str, MoVariant]

Remove all the settings of the specified plugin this mod.

Parameters:

plugin_name – Name of the plugin for which settings should be removed. This should always be IPlugin.name() unless you have a really good reason to access settings of another plugin.

Returns:

The old settings from the given plugin, as returned by pluginSettings().

color() → PyQt6.QtGui.QColor

Returns:

The color of the ‘Notes’ column chosen by the user.

comments() → str

Returns:

The comments for this mod, if any.

converted() → bool

Check if the mod was marked as converted by the user.

When a mod is for a different game, a flag is shown to users to warn them, but they can mark mods as converted to remove this flag.

Returns:

True if this mod was marked as converted by the user.

endorsedState() → EndorsedState

Returns:

The endorsement state of this mod.

fileTree() → IFileTree

Retrieve a file tree corresponding to the underlying disk content of this mod.

The file tree should not be cached by plugins since it is already and updated when required.

Returns:

A file tree representing the content of this mod.

gameName() → str

Retrieve the short name of the game associated with this mod. This may differ from the current game plugin (e.g. you can install a Skyrim LE game in a SSE installation).

Returns:

The name of the game associated with this mod.

ignoredVersion() → VersionInfo

Returns:

The ignored version of this mod (for update), or an invalid version if the user

did not ignore version for this mod.

installationFile() → str

Returns:

The absolute path to the file that was used to install this mod.

isBackup() → bool

Returns:

True if this mod represents a backup.

isForeign() → bool

Returns:

True if this mod represents a foreign mod, not managed by MO2.

isOverwrite() → bool

Returns:

True if this mod represents the overwrite mod.

isSeparator() → bool

Returns:

True if this mod represents a separator.

name() → str

Returns:

The name of this mod.

newestVersion() → VersionInfo

Returns:

The newest version of this mod (as known by MO2). If this matches version(),

then the mod is up-to-date.

nexusId() → int

Returns:

The Nexus ID of this mod.

notes() → str

Returns:

The notes for this mod, if any.

pluginSetting(plugin_name: str, key: str, default: MoVariant = None) → MoVariant

Retrieve the specified setting in this mod for a plugin.

Parameters:

• plugin_name – Name of the plugin for which to retrieve a setting. This should always be IPlugin.name() unless you have a really good reason to access settings of another plugin.

• key – Identifier of the setting.

• default – The default value to return if the setting does not exist.

Returns:

The setting, if found, or the default value.

pluginSettings(plugin_name: str) → dict[str, MoVariant]

Retrieve the settings in this mod for a plugin.

Parameters:

plugin_name – Name of the plugin for which to retrieve settings. This should always be IPlugin.name() unless you have a really good reason to access settings of another plugin.

Returns:

A map from setting key to value. The map is empty if there are not settings for this mod.

primaryCategory() → int

Returns:

The ID of the primary category of this mod.

removeCategory(name: str) → bool

Unassign a category from this mod.

Parameters:

name – Name of the category to remove.

Returns:

True if the category was removed, False otherwise (e.g. if no such category

was assigned).

repository() → str

Returns:

The name of the repository from which this mod was installed.

setGameName(name: str) → None

Set the source game of this mod.

Parameters:

name – The new source game short name of this mod.

setIsEndorsed(endorsed: bool) → None

Set endorsement state of the mod.

Parameters:

endorsed – New endorsement state of this mod.

setNewestVersion(version: VersionInfo) → None

Set the latest known version of this mod.

Parameters:

version – The latest known version of this mod.

setNexusID(nexus_id: int) → None

Set the Nexus ID of this mod.

Parameters:

nexus_id – Thew new Nexus ID of this mod.

setPluginSetting(plugin_name: str, key: str, value: MoVariant) → bool

Set the specified setting in this mod for a plugin.

Parameters:

• plugin_name – Name of the plugin for which to retrieve a setting. This should always be IPlugin.name() unless you have a really good reason to access settings of another plugin.

• key – Identifier of the setting.

• value – New value for the setting to set.

Returns:

True if the setting was set correctly, False otherwise.

setUrl(url: str) → None

Set the URL of this mod.

Parameters:

url – The URL of this mod.

setVersion(version: VersionInfo) → None

Set the version of this mod.

Parameters:

version – The new version of this mod.

trackedState() → TrackedState

Returns:

The tracked state of this mod.

url() → str

Returns:

The URL of this mod, or an empty QString() if no URL is associated

with this mod.

validated() → bool

Check if the mod was marked as validated by the user.

MO2 uses ModDataChecker to check the content of mods, but sometimes these fail, in which case mods are incorrectly marked as ‘not containing valid games data’. Users can choose to mark these mods as valid to hide the warning / flag.

Returns:

True if th is mod was marked as containing valid game data.

version() → VersionInfo

Returns:

The current version of this mod.

class mobase.IModList

Interface to the mod-list.

All api functions in this interface work need the internal name of a mod to find a mod. For regular mods (mods the user installed) the display name (as shown to the user) and internal name are identical. For other mods (non-MO mods) there is currently no way to translate from display name to internal name because the display name might not me un-ambiguous.

allMods() → Sequence[str]

Returns:

A list containing the internal names of all installed mods.

allModsByProfilePriority(profile: IProfile | None = None) → Sequence[str]

Returns:

The list of mod (names), sorted according to the current profile priorities.

displayName(name: str) → str

Retrieve the display name of a mod from its internal name.

If you received an internal name from the API (e.g. IPluginList.origin) then you should use that name to identify the mod in all other api calls but use this function to retrieve the name to show to the user.

Parameters:

name – Internal name of the mod.

Returns:

The display name of the given mod.

getMod(name: str) → IModInterface

Retrieve an interface to a mod using its name.

Parameters:

name – Name of the mod to retrieve.

Returns:

An interface to the given mod, or None if there is no mod with this name.

onModInstalled(callback: Callable[[IModInterface], None]) → bool

Install a new handler to be called when a new mod is installed.

Parameters:

callback – The function to call when a mod is installed. The parameter of the function is the name of the newly installed mod.

Returns:

True if the handler was installed properly (there are currently no reasons for this to fail).

onModMoved(callback: Callable[[str, int, int], None]) → bool

Install a handler to be called when a mod is moved.

Parameters:

callback – The function to call when a mod is moved. The first argument is the internal name of the mod, the second argument the old priority and the third argument the new priority.

Returns:

True if the handler was installed properly (there are currently no reasons for this to fail).

onModRemoved(callback: Callable[[str], None]) → bool

Install a new handler to be called when a mod is removed.

Parameters:

callback – The function to call when a mod is removed. The parameter of the function is the name of the removed mod.

Returns:

True if the handler was installed properly (there are currently no reasons for this to fail).

onModStateChanged(callback: Callable[[dict[str, ModState]], None]) → bool

Install a handler to be called when mod states change (enabled/disabled, endorsed, …).

Parameters:

callback – The function to call when the states of mod change. The argument is a map containing the mods whose states have changed. Keys are internal mod names and values are mod states.

Returns:

True if the handler was installed properly (there are currently no reasons for this to fail).

priority(name: str) → int

Retrieve the priority of a mod.

Parameters:

name – Internal name of the mod.

Returns:

The priority of the given mod.

removeMod(mod: IModInterface) → bool

Remove a mod (from disc and from the UI).

Parameters:

mod – The mod to remove.

Returns:

True if the mod was removed, False otherwise.

renameMod(mod: IModInterface, name: str) → IModInterface

Rename the given mod.

This method usually invalidates the given mod so you should use the returned value after calling it instead of the passed value.

Parameters:

• mod – The mod to rename.

• name – The new name of the mod.

Returns:

A valid reference to the given mod after renaming it.

setActive(names: Sequence[str], active: bool) → int

setActive(name: str, active: bool) → bool

Enable or disable a mod.

Calling this will cause MO to re-evaluate its virtual file system so this is a fairly expensive call.

Parameters:

• name – Internal name of the mod to enable or disable.

• active – True to enable the mod, False to disable it.

Returns:

True on success, False otherwise.

setPriority(name: str, priority: int) → bool

Change the priority of a mod.

priority is the new priority after the move. Keep in mind that the mod disappears from its old location and all mods with higher priority than the moved mod decrease in priority by one.

Parameters:

• name – Internal name of the mod.

• priority – The new priority of the mod.

Returns:

True if the priority was changed, False otherwise (if the name or priority were invalid).

state(name: str) → ModState

Retrieve the state of a mod.

Parameters:

name – Internal name of the mod.

Returns:

The state of the given mod.

class mobase.IModRepositoryBridge

Bases: PyQt6.QtCore.QObject

__getattr__(arg0: str) → object

_object() → PyQt6.QtCore.QObject

Returns:

The underlying QObject for the bridge.

requestDescription(game_name: str, mod_id: int, user_data: MoVariant) → None

Request description of a mod.

Parameters:

• game_name – Name of the game containing the mod.

• mod_id – Nexus ID of the mod.

• user_data – User data to be returned with the result.

requestDownloadURL(game_name: str, mod_id: int, file_id: int, user_data: MoVariant) → None

Request download URL for mod file.0

Parameters:

• game_name – Name of the game containing the mod.

• mod_id – Nexus ID of the mod.

• file_id – ID of the file for which a URL should be returned.

• user_data – User data to be returned with the result.

requestFileInfo(game_name: str, mod_id: int, file_id: int, user_data: MoVariant) → None

Parameters:

• game_name – Name of the game containing the mod.

• mod_id – Nexus ID of the mod.

• file_id – ID of the file for which information is requested.

• user_data – User data to be returned with the result.

requestFiles(game_name: str, mod_id: int, user_data: MoVariant) → None

Request the list of files belonging to a mod.

Parameters:

• game_name – Name of the game containing the mod.

• mod_id – Nexus ID of the mod.

• user_data – User data to be returned with the result.

requestToggleEndorsement(game_name: str, mod_id: int, mod_version: str, endorse: bool, user_data: MoVariant) → None

Parameters:

• game_name – Name of the game containing the mod.

• mod_id – Nexus ID of the mod.

• mod_version – Version of the mod.

• endorse

• user_data – User data to be returned with the result.

descriptionAvailable: PyQt6.QtCore.pyqtSignal = Ellipsis

downloadURLsAvailable: PyQt6.QtCore.pyqtSignal = Ellipsis

endorsementToggled: PyQt6.QtCore.pyqtSignal = Ellipsis

endorsementsAvailable: PyQt6.QtCore.pyqtSignal = Ellipsis

fileInfoAvailable: PyQt6.QtCore.pyqtSignal = Ellipsis

filesAvailable: PyQt6.QtCore.pyqtSignal = Ellipsis

requestFailed: PyQt6.QtCore.pyqtSignal = Ellipsis

trackedModsAvailable: PyQt6.QtCore.pyqtSignal = Ellipsis

trackingToggled: PyQt6.QtCore.pyqtSignal = Ellipsis

class mobase.IOrganizer

Interface to class that provides information about the running session of Mod Organizer to be used by plugins.

appVersion() → VersionInfo

Returns:

The running version of Mod Organizer.

basePath() → str

Returns:

The absolute path to the base directory of Mod Organizer.

createMod(name: GuessedString) → IModInterface

Create a new mod with the specified name.

If a mod with the same name already exists, the user will be queried. If the user chooses to merge or replace, the call will succeed, otherwise the call will fail.

Parameters:

name – Name of the mod to create.

Returns:

An interface to the newly created mod that can be used to modify it, or None if the mod

could not be created.

createNexusBridge() → IModRepositoryBridge

Create a new Nexus interface.

Returns:

The newly created Nexus interface.

downloadManager() → IDownloadManager

Returns:

The interface to the download manager.

downloadsPath() → str

Returns:

The absolute path to the download directory.

findFileInfos(path: str | os.PathLike[str] | PyQt6.QtCore.QDir, filter: Callable[[FileInfo], bool]) → Sequence[FileInfo]

Find files in the virtual directory matching the specified filter.

Parameters:

• path – The path to search in (relative to the ‘data’ folder).

• filter – The function to use to filter files. Should return True for the files to keep.

Returns:

The list of QFileInfo corresponding to the matching files.

findFiles(path: str | os.PathLike[str] | PyQt6.QtCore.QDir, filter: Callable[[str], bool]) → Sequence[str]

findFiles(path: str | os.PathLike[str] | PyQt6.QtCore.QDir, patterns: Sequence[str]) → Sequence[str]

findFiles(path: str | os.PathLike[str] | PyQt6.QtCore.QDir, pattern: str) → Sequence[str]

Find files in the given folder that matches the given glob pattern.

Parameters:

• path – The path to search in (relative to the ‘data’ folder).

• pattern – The glob pattern to use to filter files.

Returns:

The list of matching files.

gameFeatures() → IGameFeatures

Returns:

The interface to the game features.

getFileOrigins(filename: str) → Sequence[str]

Retrieve the file origins for the specified file.

The origins are listed with their internal name. The internal name of a mod can differ from the display name for disambiguation.

Parameters:

filename – Path to the file to retrieve origins for (relative to the ‘data’ folder).

Returns:

The list of origins that contain the specified file, sorted by their priority.

getGame(name: str) → IPluginGame

Retrieve the game plugin matching the given name.

Parameters:

name – Name of the game (short name).

Returns:

The plugin for the given game, or None if none was found.

static getPluginDataPath() → str

Returns:

The directory for plugin data, typically plugins/data.

installMod(filename: str | os.PathLike[str] | PyQt6.QtCore.QFileInfo, name_suggestion: str = '') → IModInterface

Install a mod archive at the specified location.

Parameters:

• filename – Absolute filepath to the archive to install.

• name_suggestion – Suggested name for this mod. This can still be changed by the user.

Returns:

An interface to the new installed mod, or None if no installation took place (canceled or failure).

isPluginEnabled(plugin: IPlugin) → bool

isPluginEnabled(plugin: str) → bool

Check if a plugin is enabled.

Parameters:

plugin – The name of the plugin to check.

Returns:

True if the plugin is enabled, False otherwise.

listDirectories(directory: str) → Sequence[str]

Retrieve the list of (virtual) subdirectories in the given path.

Parameters:

directory – Path to the directory to list (relative to the ‘data’ folder).

Returns:

The list of directories in the given directory.

managedGame() → IPluginGame

Returns:

The plugin corresponding to the current game.

modDataChanged(mod: IModInterface) → None

Notify the organizer that the given mod has changed.

Parameters:

mod – The mod that has changed.

modList() → IModList

Returns:

The interface to the mod list.

modsPath() → str

Returns:

The (absolute) path to the mods directory.

onAboutToRun(callback: Callable[[str, PyQt6.QtCore.QDir, str], bool]) → bool

onAboutToRun(callback: Callable[[str], bool]) → bool

Install a new handler to be called when an application is about to run.

Multiple handlers can be installed. If any of the handler returns False, the application will not run.

Parameters:

callback – The function to call when an application is about to run. The parameter is the absolute path to the application to run. The function can return False to prevent the application from running.

Returns:

True if the handler was installed properly (there are currently no reasons for

this to fail).

onFinishedRun(callback: Callable[[str, int], None]) → bool

Install a new handler to be called when an application has finished running.

Parameters:

callback – The function to call when an application has finished running. The first parameter is the absolute path to the application, and the second parameter is the exit code of the application.

Returns:

True if the handler was installed properly (there are currently no reasons for

this to fail).

onNextRefresh(callback: Callable[[], None], immediate_if_possible: bool = True) → bool

Install a new handler to be called on the next refresh or immediately.

Parameters:

• callback – Function to call on the next refresh (or immediately).

• immediate_if_possible – If True, immediately run the callback if no refresh is currently running.

Returns:

True if the handler was installed properly (there are currently no reasons for

this to fail).

onPluginDisabled(callback: Callable[[IPlugin], None]) → None

onPluginDisabled(name: str, callback: Callable[[], None]) → None

Install a new handler to be called when the given plugin is disabled.

Parameters:

• name – Name of the plugin to watch.

• callback – The function to call when the plugin is disabled.

onPluginEnabled(callback: Callable[[IPlugin], None]) → None

onPluginEnabled(name: str, callback: Callable[[], None]) → None

Install a new handler to be called when the given plugin is enabled.

Parameters:

• name – Name of the plugin to watch.

• callback – The function to call when the plugin is enabled.

onPluginSettingChanged(callback: Callable[[str, str, MoVariant, MoVariant], None]) → bool

Install a new handler to be called when a plugin setting is changed.

Parameters:

callback – The function to call when a plugin setting is changed. The parameters are: The name of the plugin, the name of the setting, the old value (or None if the setting did not exist before) and the new value of the setting (or None if the setting has been removed).

Returns:

True if the handler was installed properly (there are currently no reasons for this to fail).

onProfileChanged(callback: Callable[[IProfile, IProfile], None]) → bool

Install a new handler to be called when the current profile is changed.

The function is called when the profile is changed but some operations related to the profile might not be finished when this is called (e.g., the virtual file system might not be up-to-date).

Parameters:

callback – The function to call when the current profile is changed. The first parameter is the old profile (can be None, e.g. at startup), and the second parameter is the new profile (cannot be None).

Returns:

True if the handler was installed properly (there are currently no reasons for this to fail).

onProfileCreated(callback: Callable[[IProfile], None]) → bool

Install a new handler to be called when a new profile is created.

Parameters:

callback – The function to call when a new profile is created. The parameter is the new profile (can be a temporary object and should not be stored).

Returns:

True if the handler was installed properly (there are currently no reasons for this to fail).

onProfileRemoved(callback: Callable[[str], None]) → bool

Install a new handler to be called when a profile is remove.

The callbacks are called after the profile has been removed so the profile is not accessible anymore.

Parameters:

callback – The function to call when a profile is remove. The parameter is the name of the profile that was removed.

Returns:

True if the handler was installed properly (there are currently no reasons for this to fail).

onProfileRenamed(callback: Callable[[IProfile, str, str], None]) → bool

Install a new handler to be called when a profile is renamed.

Parameters:

callback – The function to call when a profile is renamed. The first parameter is the profile being renamed, the second parameter the previous name and the third parameter the new name.

Returns:

True if the handler was installed properly (there are currently no reasons for this to fail).

onUserInterfaceInitialized(callback: Callable[[PyQt6.QtWidgets.QMainWindow], None]) → bool

Install a new handler to be called when the UI has been fully initialized.

Parameters:

callback – The function to call when the user-interface has been fully initialized. The parameter is the main window of the application (QMainWindow).

Returns:

True if the handler was installed properly (there are currently no reasons for this to fail).

overwritePath() → str

Returns:

The (absolute) path to the overwrite directory.

persistent(plugin_name: str, key: str, default: MoVariant = None) → MoVariant

Retrieve the specified persistent value for a plugin.

A persistent is an arbitrary value that the plugin can set and retrieve that is persistently stored by the main application. There is no UI for the user to change this value but they can directly access the storage

Parameters:

• plugin_name – Name of the plugin for which to retrieve the value. This should always be IPlugin.name() unless you have a really good reason to access data of another mod AND if you can verify that plugin is actually installed.

• key – Identifier of the setting.

• default – Default value to return if the key is not set (yet).

Returns:

The value corresponding to the given persistent setting, or def is the key is not found.

pluginDataPath() → str

Retrieve the path to a directory where plugin data should be stored.

For python plugins, it is recommended to use a dedicated folder (per plugin) if you need to store data (resources, or multiple python files).

Returns:

Path to a directory where plugin data should be stored.

pluginList() → IPluginList

Returns:

The plugin list interface.

pluginSetting(plugin_name: str, key: str) → MoVariant

Retrieve settings of plugins.

Parameters:

• plugin_name – Name of the plugin to retrieve the setting for.

• key – Name of the setting to retrieve the value for.

Returns:

The value of the setting.

profile() → IProfile

Returns:

The interface to the current profile.

profileName() → str

Returns:

The name of the current profile, or an empty string if no profile has been loaded (yet).

profilePath() → str

Returns:

The absolute path to the active profile or an empty string if no profile has been loaded (yet).

refresh(save_changes: bool = True) → None

Refresh the internal mods file structure from disk. This includes the mod list, the plugin list, data tab and other smaller things like problems button (same as pressing F5).

The main part of the refresh of the mods file structure, mod list and plugin list is done asynchronously, so you should not expect them to be up-to-date when this function returns.

Parameters:

save_changes – If True, the relevant profile information is saved first (enabled mods and order of mods).

resolvePath(filename: str | os.PathLike[str] | PyQt6.QtCore.QFileInfo) → str

Resolves a path relative to the virtual data directory to its absolute real path.

Parameters:

filename – Path to resolve.

Returns:

The absolute real path, or an empty string if the path was not found.

setPersistent(plugin_name: str, key: str, value: MoVariant, sync: bool = True) → None

Set the specified persistent value for a plugin.

This does not update the in-memory value for this setting, see setPluginSetting() for this.

Parameters:

• plugin_name – Name of the plugin for which to change a value. This should always be IPlugin.name() unless you have a really good reason to access data of another mod AND if you can verify that plugin is actually installed.

• key – Identifier of the setting.

• value – New value for the setting.

• sync – If True, the storage is immediately written to disc. This costs performance but is safer against data loss.

setPluginSetting(plugin_name: str, key: str, value: MoVariant) → None

Set the specified setting for a plugin.

This automatically notify handlers register with onPluginSettingChanged, so you do not have to do it yourself.

Parameters:

• plugin_name – Name of the plugin for which to change a value. This should always be IPlugin.name() unless you have a really good reason to access data of another mod AND if you can verify that plugin is actually installed.

• key – Identifier of the setting.

• value – New value for the setting.

startApplication(executable: str | os.PathLike[str] | PyQt6.QtCore.QFileInfo, args: Sequence[str] = [], cwd: str | os.PathLike[str] | PyQt6.QtCore.QDir = '', profile: str = '', forcedCustomOverwrite: str = '', ignoreCustomOverwrite: bool = False) → int

Starts an application with virtual filesystem active.

Parameters:

• executable – Name or path of the executable. If this is only a filename, it will only work if it has been configured in MO as an executable. If it is a relative path it is expected to be relative to the game directory.

• args – Arguments to pass to the executable. If the list is empty, and executable refers to a configured executable, the configured arguments are used.

• cwd – The working directory for the executable. If this is empty, the path to the executable is used unless executable referred to a configured MO executable, in which case the configured cwd is used.

• profile – Profile to use. If this is empty (the default) the current profile is used.

• forcedCustomOverwrite – The mod to set as the custom overwrite, regardless of what the profile has configured.

• ignoreCustomOverwrite – Set to true to ignore the profile’s configured custom overwrite.

Returns:

The handle to the started application, or 0 if the application failed to start.

virtualFileTree() → IFileTree

Retrieve a IFileTree object representing the virtual file tree.

Returns:

An IFileTree representing the virtual file tree.

waitForApplication(handle: int, refresh: bool = True) → tuple[bool, int]

Wait for the application corresponding to the given handle to finish.

This will always show the lock overlay, regardless of whether the user has disabled locking in the setting, so use this with care. Note that the lock overlay will always allow the user to unlock, in which case this will return False.

Parameters:

• handle – Handle of the application to wait for (as returned by startApplication()).

• refresh – Whether ModOrganizer should refresh after the process completed or not.

Returns:

A tuple (result, exitcode), where result is a boolean indicating if the application

completed successfully, and exitcode is the exit code of the application.

class mobase.IPlugin

Bases: abc.ABC

Base class for all plugins.

abstract author() → str

Returns:

The name of the plugin author.

abstract description() → str

Returns:

The description for this plugin.

enabledByDefault() → bool

Check whether this plugin should be enabled by default.

Returns:

True if this plugin should be enabled by default, False otherwise.

abstract init(organizer: IOrganizer) → bool

Initialize this plugin.

Note that this function may never be called if no IOrganizer is available at that time, such as when creating the first instance in MO.

Plugins will probably want to store the organizer pointer. It is guaranteed to be valid as long as the plugin is loaded.

These functions may be called before init():

• name()

• see IPluginGame for more.

Parameters:

organizer – The main organizer interface.

Returns:

True if the plugin was initialized correctly, False otherwise.

localizedName() → str

Retrieve the localized name of the plugin.

Unlike name(), this method can (and should!) return a localized name for the plugin. This method returns name() by default.

Returns:

The localized name of the plugin.

master() → str

Retrieve the master plugin of this plugin.

It is often easier to implement a functionality as multiple plugins in MO2, but ship the plugins together, e.g. as a Python module or using createFunctions(). In this case, having a master plugin (one of the plugin, or a separate one) tells MO2 that these plugins are linked and should also be displayed together in the UI. If MO2 ever implements automatic updates for plugins, the master() plugin will also be used for this purpose.

Returns:

The master plugin of this plugin, or a null pointer if this plugin does not have a master.

abstract name() → str

Retrieve the name of the plugin.

The name of the plugin is used for internal storage purpose so it should not change, and it should be static. In particular, you should not use a localized string (tr()) for the plugin name.

In the future, we will provide a way to localized plugin names using a distinct method, such as localizedName().

Returns:

The name of the plugin.

requirements() → list[IPluginRequirement]

Retrieve the requirements for this plugin.

This method is called right after init() and the ownership the requirements is

Returns:

The list of requirements for this plugin.

abstract settings() → Sequence[PluginSetting]

Returns:

A list of settings for this plugin.

abstract version() → VersionInfo

Returns:

The version of this plugin.

class mobase.IPluginDiagnose

Bases: IPlugin

Plugins that create problem reports to be displayed in the UI.

This can be used to report problems related to the same plugin (which implements further interfaces) or as a stand-alone diagnosis tool.

_invalidate() → None

Invalidate the problems corresponding to this plugin.

abstract activeProblems() → list[int]

Retrieve the list of active problems found by this plugin.

This method returns a list of problem IDs, that are then used when calling other methods such as shortDescription() or hasGuidedFix().

Returns:

The list of active problems for this plugin.

abstract fullDescription(key: int) → str

Retrieve the full description of the problem corresponding to the given key.

Parameters:

key – ID of the problem.

Returns:

The full description of the problem.

Raises:

IndexError – If the key is not valid.

abstract hasGuidedFix(key: int) → bool

Check if the problem corresponding to the given key has a guided fix.

Parameters:

key – ID of the problem.

Returns:

True if there is a guided fix for the problem, False otherwise.

Raises:

IndexError – If the key is not valid.

abstract shortDescription(key: int) → str

Retrieve the short description of the problem corresponding to the given key.

Parameters:

key – ID of the problem.

Returns:

The short description of the problem.

Raises:

IndexError – If the key is not valid.

abstract startGuidedFix(key: int) → None

Starts a guided fix for the problem corresponding to the given key.

This method should throw ValueError if there is no guided fix for the corresponding problem.

Parameters:

key – ID of the problem.

Raises:

• IndexError – If the key is not valid.

• ValueError – If there is no guided fix for this problem.

class mobase.IPluginFileMapper

Bases: IPlugin

Plugins that adds virtual file links.

abstract mappings() → list[Mapping]

Returns:

Mapping for the virtual file system (VFS).

class mobase.IPluginGame

Bases: IPlugin

Base classes for game plugins.

Each game requires a specific game plugin. These plugins were initially designed for Bethesda games, so a lot of methods and attributes are irrelevant for other games. If you wish to write a plugin for a much simpler game, please consider the basic_games plugin: https://github.com/ModOrganizer2/modorganizer-basic_games

CCPlugins() → Sequence[str]

Returns:

The current list of active Creation Club plugins.

DLCPlugins() → Sequence[str]

Returns:

The list of esp/esm files that are part of known DLCs.

abstract binaryName() → str

Returns:

The name of the default executable to run (relative to the game folder).

abstract dataDirectory() → PyQt6.QtCore.QDir

Returns:

The path to the directory containing data (absolute path).

abstract detectGame() → None

Detect the game.

This method is the first called for game plugins (before init()). The following methods should work properly after the call to detectGame() (and before init()):

• gameName()

• isInstalled()

• gameIcon()

• gameDirectory()

• dataDirectory()

• gameVariants()

• looksValid()

See IPlugin.init() for more.

displayGameName() → str

Returns:

The name of the game to user for display, default to gameName().

abstract documentsDirectory() → PyQt6.QtCore.QDir

Returns:

The directory of the documents folder where configuration files and such for this game reside.

enabledPlugins() → Sequence[str]

Returns:

A list of plugins enabled by the game but not in a strict load order.

abstract executableForcedLoads() → Sequence[ExecutableForcedLoadSetting]

Returns:

A list of automatically discovered libraries that can be force loaded with executables.

executables() → Sequence[ExecutableInfo]

Returns:

A list of automatically discovered executables of the game itself and tools surrounding it.

abstract gameDirectory() → PyQt6.QtCore.QDir

Returns:

The directory containing the game installation.

abstract gameIcon() → PyQt6.QtGui.QIcon

Returns:

The icon representing the game.

abstract gameName() → str

Returns:

The name of the game (for internal usage).

gameNexusName() → str

Returns:

The name of the game identifier for Nexus.

abstract gameShortName() → str

Returns:

The short name of the game.

gameVariants() → Sequence[str]

Retrieve the list of variants for this game.

If there are multiple variants of a game (and the variants make a difference to the plugin), like a regular one and a GOTY-edition, the plugin can return a list of them and the user gets to chose which one he owns.

Returns:

The list of variants of the game.

abstract gameVersion() → str

Returns:

The version of the game.

abstract getLauncherName() → str

Returns:

The name of the launcher executable to run (relative to the game folder), or an

empty string if there is no launcher.

abstract getSupportURL() → str

Returns:

An URL for the support page of this game.

iniFiles() → Sequence[str]

Returns:

The list of INI files this game uses. The first file in the list should be the

‘main’ INI file.

abstract initializeProfile(directory: PyQt6.QtCore.QDir, settings: ProfileSetting) → None

Initialize a profile for this game.

The MO app does not yet support virtualizing only specific aspects but plugins should be written with this future functionality in mind.

This function will be used to initially create a profile, potentially to repair it or upgrade/downgrade it so the implementations have to gracefully handle the case that the directory already contains files.

Parameters:

• directory – The directory where the profile is to be initialized.

• settings – The parameters for how the profile should be initialized.

abstract isInstalled() → bool

Returns:

True if this game has been discovered as installed, False otherwise.

abstract listSaves(folder: PyQt6.QtCore.QDir) → list[ISaveGame]

List saves in the given directory.

Parameters:

folder – The folder to list saves from.

Returns:

The list of game saves in the given folder.

loadOrderMechanism() → LoadOrderMechanism

Returns:

The load order mechanism used by this game.

abstract looksValid(directory: PyQt6.QtCore.QDir) → bool

Check if the given directory looks like a valid game installation.

Parameters:

directory – Directory to check.

Returns:

True if the directory looks like a valid installation of this game, False otherwise.

lootGameName() → str

Returns:

The game name to use when calling LOOT from MO2, default to gameShortName().

abstract nexusGameID() → int

Retrieve the Nexus game ID for this game.

Example: For Skyrim, the Nexus game ID is 110.

Returns:

The Nexus game ID for this game.

nexusModOrganizerID() → int

Retrieve the Nexus mod ID of Mod Organizer for this game.

Example: For Skyrim SE, the mod ID of MO2 is 6194. You can find the mod ID in the URL:

https://www.nexusmods.com/skyrimspecialedition/mods/6194

Returns:

The Nexus mod ID of Mod Organizer for this game.

primaryPlugins() → Sequence[str]

Returns:

The list of plugins that are part of the game and not considered optional.

primarySources() → Sequence[str]

Retrieve primary alternative ‘short’ names for this game.

This is used to determine if a Nexus (or other) download source should be considered as a primary source for the game so that it is not flagged as an alternative one.

Returns:

The list of primary alternative ‘short’ names for this game, or an empty list.

abstract savesDirectory() → PyQt6.QtCore.QDir

Returns:

The directory where save games are stored.

secondaryDataDirectories() → Dict[str, PyQt6.QtCore.QDir]

Retrieve the list of secondary data directories. Each directories should be assigned a unique name that differs from “data” which is the name of the main data directory returned by dataDirectory().

Returns:

A mapping from unique name to secondary data directories.

abstract setGamePath(path: str) → None

Set the path to the managed game.

This is called during instance creation if the game is not auto-detected and the user has to specify the installation location. This is not called if the game has been auto-detected, so isInstalled() should call this.

Parameters:

path – Path to the game installation.

abstract setGameVariant(variant: str) → None

Set the game variant.

If there are multiple variants of game (as returned by gameVariants()), this will be called on start with the user-selected game variant.

Parameters:

variant – The game variant selected by the user.

sortMechanism() → SortMechanism

Returns:

The sort mechanism for this game.

steamAPPId() → str

Retrieve the Steam app ID for this game.

If the game is not available on Steam, this should return an empty string.

If a game is available in multiple versions, those might have different app ids. The plugin should try to return the right one

Returns:

The Steam app ID for this game. Should be empty for games not available on steam.

abstract validShortNames() → Sequence[str]

Retrieve the valid ‘short’ names for this game.

This is used to determine if a Nexus download is valid for the current game since not all game variants have their own nexus pages and others can handle downloads from other nexus game pages and should be allowed to do so (e.g., you can install some Skyrim LE mod even when using Skyrim SE).

The short name should be considered the primary handler for a directly supported game for purposes of auto-launching an instance.

Returns:

The list of valid short names for this game.

class mobase.IPluginInstaller

Bases: IPlugin

This is the top-level class for installer. Actual installers should inherit either:

• IPluginInstallerSimple if the installer can work directly with the archive. This is what most installers use.

• IPluginInstallerCustom if the installer needs to perform custom operations. This is only used by the external NCC installer and the OMOD installer.

_manager() → IInstallationManager

Returns:

The installation manager.

_parentWidget() → PyQt6.QtWidgets.QWidget

Returns:

The parent widget.

abstract isArchiveSupported(tree: IFileTree) → bool

Check if the given file tree corresponds to a supported archive for this installer.

Parameters:

tree – The tree representing the content of the archive.

Returns:

True if this installer can handle the archive, False otherwise.

abstract isManualInstaller() → bool

Check if this installer is a manual installer.

Returns:

True if this installer is a manual installer, False otherwise.

onInstallationEnd(result: InstallResult, new_mod: IModInterface) → None

Method calls at the end of the installation process. This method is only called once per installation process, even for recursive installations (e.g. with the bundle installer).

Parameters:

• result – The result of the installation.

• new_mod – If the installation succeeded (result is RESULT_SUCCESS), contains the newly installed mod, otherwise it contains a null pointer.

onInstallationStart(archive: str, reinstallation: bool, current_mod: IModInterface) → None

Method calls at the start of the installation process, before any other methods. This method is only called once per installation process, even for recursive installations (e.g. with the bundle installer).

If reinstallation is true, then the given mod is the mod being reinstalled (the one selected by the user). If reinstallation is false and currentMod is not null, then it corresponds to a mod MO2 thinks corresponds to the archive (e.g. based on matching Nexus ID or name).

The default implementation does nothing.

Parameters:

• archive – Path to the archive that is going to be installed.

• reinstallation – True if this is a reinstallation, False otherwise.

• current_mod – A currently installed mod corresponding to the archive being installed, or None if there is no such mod.

abstract priority() → int

Retrieve the priority of this installer.

If multiple installers are able to handle an archive, the one with the highest priority wins.

Returns:

The priority of this installer.

setInstallationManager(manager: IInstallationManager) → None

Set the installation manager for this installer.

Python plugins usually do not need to re-implement this and can directly access the installation manager using _manager().

Parameters:

manager – The installation manager.

setParentWidget(parent: PyQt6.QtWidgets.QWidget) → None

Set the parent widget for this installer.

Python plugins usually do not need to re-implement this and can directly access the parent widget using _parentWidget() once the UI has been initialized.

Parameters:

parent – The parent widget.

class mobase.IPluginInstallerCustom

Bases: IPluginInstaller

Custom installer for mods. Custom installers receive the archive name and have to go from there. They have to be able to extract the archive themselves.

Example of such installers are the external NCC installer or the OMOD installer.

abstract install(mod_name: GuessedString, game_name: str, archive_name: str, version: str, nexus_id: int) → InstallResult

Install the given archive.

The mod needs to be created by calling IOrganizer.createMod first.

Parameters:

• mod_name – Name of the mod to install. As an input parameter this is the suggested name (e.g. from meta data) The installer may change this parameter to rename the mod).

• game_name – Name of the game for which the mod is installed.

• archive_name – Name of the archive to install.

• version – Version of the mod. May be empty if the version is not yet known. The plugin is responsible for setting the version on the created mod.

• nexus_id – ID of the mod or -1 if unknown. The plugin is responsible for setting the mod ID for the created mod.

Returns:

The result of the installation process.

abstract isArchiveSupported(tree: IFileTree) → bool

abstract isArchiveSupported(archive_name: str) → bool

Check if the given file is a supported archive for this installer.

Parameters:

archive_name – Name of the archive.

Returns:

True if this installer can handle the archive, False otherwise.

abstract supportedExtensions() → set[str]

Returns:

A list of file extensions that this installer can handle.

class mobase.IPluginInstallerSimple

Bases: IPluginInstaller

Simple installer for mods. Simple installers only deal with an in-memory structure representing the archive and can modify what to install and where by editing this structure. Actually extracting the archive is handled by the manager.

abstract install(name: GuessedString, tree: IFileTree, version: str, nexus_id: int) → InstallResult | IFileTree | tuple[InstallResult, IFileTree, str, int]

Install a mod from an archive filetree.

The installer can modify the given tree and use the manager to extract or create new files.

This method returns different type of objects depending on the actual result of the installation. The C++ bindings for this method always returns a tuple (result, tree, version, id).

Parameters:

• name – Name of the mod to install. As an input parameter this is the suggested name (e.g. from meta data) The installer may change this parameter to rename the mod).

• tree – In-memory representation of the archive content.

• version – Version of the mod, or an empty string is unknown.

• nexus_id – ID of the mod, or -1 if unknown.

Returns:

In case of failure, the result of the installation, otherwise the modified tree or

a tuple (result, tree, version, id) containing the result of the installation, the modified tree, the new version and the new ID. The tuple can be returned even if the installation did not succeed.

class mobase.IPluginList

Primary interface to the list of plugins.

hasLightExtension(name: str) → bool

Determine if a plugin has a .esl extension.

Parameters:

name – Filename of the plugin (without path but with file extension).

Returns:

True if the given file has a .esl extension, False otherwise or if the

file does not exist.

hasMasterExtension(name: str) → bool

Determine if a plugin has a .esm extension.

Parameters:

name – Filename of the plugin (without path but with file extension).

Returns:

True if the given file has a .esm extension, False otherwise or if the

file does not exist.

hasNoRecords(name: str) → bool

Determine if a plugin has no records.

Parameters:

name – Filename of the plugin (without path but with file extension).

Returns:

True if the given file plugin contains no records, False if it does OR if the

file does not exist.

isLightFlagged(name: str) → bool

Determine if a plugin is flagged as light.

In gamebryo games, a master file will usually have a .esl file extension but technically an esp can be flagged as light.

Parameters:

name – Filename of the plugin (without path but with file extension).

Returns:

True if the given plugin is a light plugin, False otherwise or if the

file does not exist.

isMasterFlagged(name: str) → bool

Determine if a plugin is flagged as mater, i.e., a library, reference by other plugins.

In gamebryo games, a master file will usually have a .esm file extension but technically an esp can be flagged as master and an esm might not be.

Parameters:

name – Filename of the plugin (without path but with file extension).

Returns:

True if the given plugin is a master plugin, False otherwise or if the

file does not exist.

isMediumFlagged(name: str) → bool

Determine if a plugin is flagged as medium.

This plugin flag was added in Starfield and signifies plugin records that update existing records

Parameters:

name – Filename of the plugin (without path but with file extension).

Returns:

True if the given plugin is a medium plugin, False otherwise or if the

file does not exist.

loadOrder(name: str) → int

Retrieve the load order of a plugin.

Parameters:

name – Filename of the plugin (without path but with file extension).

Returns:

The load order of the plugin (the order in which the game loads it). If all plugins are enabled this

is the same as the priority but disabled plugins will have a load order of -1. This also returns -1 if the plugin does not exist.

masters(name: str) → Sequence[str]

Retrieve the list of masters required for a plugin.

Parameters:

name – Filename of the plugin (without path but with file extension).

Returns:

The list of masters for the plugin (filenames with extension, no path).

onPluginMoved(callback: Callable[[str, int, int], None]) → bool

Install a new handler to be called when a plugin is moved.

Parameters:

callback – The function to call when a plugin is moved. The first parameter is the plugin name, the second the old priority of the plugin and the third one the new priority.

Returns:

True if the handler was installed properly (there are currently no reasons for this to fail).

onPluginStateChanged(callback: Callable[[dict[str, PluginState]], None]) → bool

Install a new handler to be called when plugin states change.

Parameters:

callback – The function to call when a plugin states change. The parameter is a map from plugin names to new plugin states for the plugin whose states have changed.

Returns:

True if the handler was installed properly (there are currently no reasons for this to fail).

onRefreshed(callback: Callable[[], None]) → bool

Install a new handler to be called when the list of plugins is refreshed.

Parameters:

callback – The function to call when the list of plugins is refreshed.

Returns:

True if the handler was installed properly (there are currently no reasons for this to fail).

origin(name: str) → str

Retrieve the origin of a plugin. This is either the (internal) name of a mod, “overwrite” or “data”.

The internal name of a mod can differ from the display name for disambiguation.

Parameters:

name – Filename of the plugin (without path but with file extension).

Returns:

The name of the origin of the plugin, or an empty string if the plugin does not exist.

pluginNames() → Sequence[str]

Returns:

The list of all plugin names.

priority(name: str) → int

Retrieve the priority of a plugin.

The higher the priority, the more important.

Parameters:

name – Filename of the plugin (without path but with file extension).

Returns:

The priority of the given plugin, or -1 if the plugin does not exist.

setLoadOrder(loadorder: Sequence[str]) → None

Set the load order.

Plugins not included in the list will be placed at highest priority in the order they were before.

Parameters:

loadorder – The new load order, specified by the list of plugin names, sorted.

setPriority(name: str, priority: int) → bool

Change the priority of a plugin.

Parameters:

• name – Filename of the plugin (without path but with file extension).

• priority – New priority of the plugin.

Returns:

True on success, False if the priority change was not possible. This is usually because

one of the parameters is invalid. The function returns true even if the plugin was not moved at the specified priority (e.g. when trying to move a non-master plugin before a master one).

setState(name: str, state: PluginState) → None

Set the state of a plugin.

Parameters:

• name – Filename of the plugin (without path but with file extension).

• state – New state of the plugin (INACTIVE or ACTIVE).

state(name: str) → PluginState

Retrieve the state of a plugin.

Parameters:

name – Filename of the plugin (without path but with file extension).

Returns:

The state of the plugin.

class mobase.IPluginModPage

Bases: IPlugin

Base class for all plugins.

_parentWidget() → PyQt6.QtWidgets.QWidget

Returns:

The parent widget.

abstract displayName() → str

Returns:

The name of the page as displayed in the UI.

abstract handlesDownload(page_url: PyQt6.QtCore.QUrl, download_url: PyQt6.QtCore.QUrl, fileinfo: ModRepositoryFileInfo) → bool

Check if the plugin handles the specified download.

Parameters:

• page_url – URL of the page that contains the download link.

• download_url – The download URL.

• fileinfo – Not usable in python.

Returns:

True if this plugin wants to handle the specified download, False otherwise.

abstract icon() → PyQt6.QtGui.QIcon

Returns:

The icon to display with the page.

abstract pageURL() → PyQt6.QtCore.QUrl

Returns:

The URL to open when the user wants to visit this mod page.

setParentWidget(parent: PyQt6.QtWidgets.QWidget) → None

Set the parent widget for this mod page.

Python plugins usually do not need to re-implement this and can directly access the parent widget using _parentWidget() once the UI has been initialized.

Parameters:

parent – The parent widget.

abstract useIntegratedBrowser() → bool

Indicates if the page should be displayed in the integrated browser.

Unless the page provides a special means of starting downloads (like the nxm:// url schema on nexus), it will not be possible to handle downloads unless the integrated browser is used!

Returns:

True if the page should be opened in the integrated browser, False otherwise.

class mobase.IPluginPreview

Bases: IPlugin

These plugins add support for previewing files in the data pane. Right now all image formats supported by qt are implemented (including dds) but no audio files and no 3d mesh formats.

abstract genDataPreview(file_data: PyQt6.QtCore.QByteArray, filename: str, max_size: PyQt6.QtCore.QSize) → PyQt6.QtWidgets.QWidget

Generate a preview widget from in-memory data.

Parameters:

• file_data – In-memory data to preview.

• filename – Name of the file the data comes from.

• max_size – Maximum size of the generated widget.

Returns:

The widget showing a preview of the in-memory data.

abstract genFilePreview(filename: str, max_size: PyQt6.QtCore.QSize) → PyQt6.QtWidgets.QWidget

Generate a preview widget for the specified file.

Parameters:

• filename – Path to the file to preview.

• max_size – Maximum size of the generated widget.

Returns:

The widget showing a preview of the file.

abstract supportedExtensions() → set[str]

Returns:

The list of file extensions that are supported by this preview plugin.

abstract supportsArchives() → bool

Check if this preview plugin supports preview from in-memory data.

Returns:

True if the plugin supports preview from raw data, False otherwise.

class mobase.IPluginRequirement

Class representing requirements for plugins.

class Problem(short_description: str, long_description: str = '')

Class representing a problem found by a requirement.

longDescription() → str

Returns:

A long description of the problem.

shortDescription() → str

Returns:

A short description of the problem.

check(organizer: IOrganizer) → IPluginRequirement | None

Check if the requirement is met, and return a problem if not.

Parameters:

organizer – The IOrganizer instance.

Returns:

The problem found if the requirement is not met, otherwise None.

class mobase.IPluginTool

Bases: IPlugin

This is the simplest of plugin interfaces. Such plugins simply place an icon inside the tools sub-menu and get invoked when the user clicks it. They are expected to have a user interface of some sort. These are almost like independent applications except they can access all Mod Organizer interfaces like querying and modifying the current profile, mod list, load order, use MO to install mods and so on. A tool plugin can (and should!) integrate its UI as a window inside MO and thus doesn’t have to initialize a windows application itself.

_parentWidget() → PyQt6.QtWidgets.QWidget

Returns:

The parent widget.

abstract display() → None

Called when the user starts the tool.

abstract displayName() → str

Returns:

The display name for this tool, as shown in the tool menu.

abstract icon() → PyQt6.QtGui.QIcon

Returns:

The icon for this tool, or a default-constructed QICon().

setParentWidget(parent: PyQt6.QtWidgets.QWidget) → None

Set the parent widget for this tool.

Python plugins usually do not need to re-implement this and can directly access the parent widget using _parentWidget() once the UI has been initialized.

Parameters:

parent – The parent widget.

abstract tooltip() → str

Returns:

The tooltip for this tool.

class mobase.IProfile

Interface to interact with Mod Organizer 2 profiles.

absoluteIniFilePath(inifile: str) → str

Retrieve the absolute file path to the corresponding INI file for this profile.

If iniFile does not correspond to a file in the list of INI files for the current game (as returned by IPluginGame::iniFiles), the path to the global file will be returned (if iniFile is absolute, iniFile is returned, otherwise the path is assumed relative to the game documents directory).

Parameters:

inifile – INI file to retrieve a path for. This can either be the name of a file or a path to the absolute file outside of the profile.

Returns:

The absolute path for the given INI file for this profile.

absolutePath() → str

Returns:

The absolute path to the profile folder.

invalidationActive() → tuple[bool, bool]

Returns:

True if automatic archive invalidation is enabled for this profile, False otherwise.

localSavesEnabled() → bool

Returns:

True if profile-specific saves are enabled for this profile, False otherwise.

localSettingsEnabled() → bool

Returns:

True if profile-specific game settings are enabled for this profile, False otherwise.

name() → str

Returns:

The name of this profile.

class mobase.ISaveGame

Base class for information about what is in a save game.

allFiles() → Sequence[str | os.PathLike[str] | PyQt6.QtCore.QFileInfo]

Returns:

The list of all files related to this save.

getCreationTime() → PyQt6.QtCore.QDateTime

Retrieve the creation time of the save.

The creation time of a save is not always the same as the creation time of the file containing the save.

Returns:

The creation time of the save.

getFilepath() → str | os.PathLike[str] | PyQt6.QtCore.QFileInfo

Returns:

The path name to the (main) file or folder for the save.

getName() → str

Returns:

The name of this save, for display purpose.

getSaveGroupIdentifier() → str

Retrieve the name of the group this files belong to.

The name can be used to identify sets of saves to transfer between profiles. For RPG games, this is usually the name of a character.

Returns:

The group identifier for this save game.

class mobase.ISaveGameInfoWidget(parent: PyQt6.QtWidgets.QWidget | None = None)

Bases: PyQt6.QtWidgets.QWidget

Base class for a save game info widget.

__getattr__(arg0: str) → object

_widget() → PyQt6.QtWidgets.QWidget

Returns:

The underlying QWidget.

abstract setSave(save: ISaveGame) → None

Set the save file to display in this widget.

Parameters:

save – The save to display in the widget

class mobase.InstallResult(*args, **kwds)

Bases: enum.Enum

Create a collection of name/value pairs.

Example enumeration:

>>> class Color(Enum):
...     RED = 1
...     BLUE = 2
...     GREEN = 3

Access them by:

• attribute access:

  >>> Color.RED
  <Color.RED: 1>
  

• value lookup:

  >>> Color(1)
  <Color.RED: 1>
  

• name lookup:

  >>> Color['RED']
  <Color.RED: 1>
  

Enumerations can be iterated over, and know how many members they have:

>>> len(Color)
3

>>> list(Color)
[<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]

Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.

__eq__(other: object) → bool

Return self==value.

__int__() → int

__ne__(other: object) → bool

Return self!=value.

__str__() → str

Return str(self).

CANCELED = Ellipsis

FAILED = Ellipsis

MANUAL_REQUESTED = Ellipsis

NOT_ATTEMPTED = Ellipsis

SUCCESS = Ellipsis

property name: str

The name of the Enum member.

property value: int

The value of the Enum member.

class mobase.LoadOrderMechanism(*args, **kwds)

Bases: enum.Enum

Create a collection of name/value pairs.

Example enumeration:

>>> class Color(Enum):
...     RED = 1
...     BLUE = 2
...     GREEN = 3

Access them by:

• attribute access:

  >>> Color.RED
  <Color.RED: 1>
  

• value lookup:

  >>> Color(1)
  <Color.RED: 1>
  

• name lookup:

  >>> Color['RED']
  <Color.RED: 1>
  

Enumerations can be iterated over, and know how many members they have:

>>> len(Color)
3

>>> list(Color)
[<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]

Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.

__eq__(other: object) → bool

Return self==value.

__int__() → int

__ne__(other: object) → bool

Return self!=value.

__str__() → str

Return str(self).

FILE_TIME = Ellipsis

NONE = Ellipsis

PLUGINS_TXT = Ellipsis

property name: str

The name of the Enum member.

property value: int

The value of the Enum member.

class mobase.LocalSavegames

Bases: GameFeature

Base class for all game features, cannot be inherited, used only for typing purpose in Python.

abstract mappings(profile_save_dir: PyQt6.QtCore.QDir) → list[Mapping]

abstract prepareProfile(profile: IProfile) → bool

class mobase.Mapping

class mobase.Mapping(source: str, destination: str, is_directory: bool, create_target: bool = False)

__str__() → str

Return str(self).

property createTarget: bool

property destination: str

property isDirectory: bool

property source: str

class mobase.ModDataChecker

Bases: GameFeature

Game feature that is used to check the content of a data tree.

class CheckReturn(*args, **kwds)

Bases: enum.Enum

Create a collection of name/value pairs.

Example enumeration:

>>> class Color(Enum):
...     RED = 1
...     BLUE = 2
...     GREEN = 3

Access them by:

• attribute access:

  >>> Color.RED
  <Color.RED: 1>
  

• value lookup:

  >>> Color(1)
  <Color.RED: 1>
  

• name lookup:

  >>> Color['RED']
  <Color.RED: 1>
  

Enumerations can be iterated over, and know how many members they have:

>>> len(Color)
3

>>> list(Color)
[<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]

Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.

__eq__(other: object) → bool

Return self==value.

__int__() → int

__ne__(other: object) → bool

Return self!=value.

__str__() → str

Return str(self).

FIXABLE = Ellipsis

INVALID = Ellipsis

VALID = Ellipsis

property name: str

The name of the Enum member.

property value: int

The value of the Enum member.

abstract dataLooksValid(filetree: IFileTree) → ModDataChecker

Check that the given filetree represent a valid mod layout, or can be easily fixed.

This method is mainly used during installation (to find which installer should be used or to recurse into multi-level archives), or to quickly indicates to a user if a mod looks valid.

This method does not have to be exact, it only has to indicate if the given tree looks like a valid mod or not by quickly checking the structure (heavy operations should be avoided).

If the tree can be fixed by the fix() method, this method should return FIXABLE. FIXABLE should only be returned when it is guaranteed that fix() can fix the tree.

Parameters:

filetree – The tree starting at the root of the “data” folder.

Returns:

Whether the tree is invalid, fixable or valid.

fix(filetree: IFileTree) → IFileTree | None

Try to fix the given tree.

This method is used during installation to try to fix invalid archives and will only be called if dataLooksValid returned FIXABLE.

Parameters:

filetree – The tree to try to fix. Can be modified during the process.

Returns:

The fixed tree, or a null pointer if the tree could not be fixed.

FIXABLE: ModDataChecker.CheckReturn = Ellipsis

INVALID: ModDataChecker.CheckReturn = Ellipsis

VALID: ModDataChecker.CheckReturn = Ellipsis

class mobase.ModDataContent

Bases: GameFeature

The ModDataContent feature is used (when available) to indicate to users the content of mods in the “Content” column.

The feature exposes a list of possible content types, each associated with an ID, a name and an icon. The icon is the path to either:

• A Qt resource or;

• A file on the disk.

In order to facilitate the implementation, MO2 already provides a set of icons that can be used. Those icons are all under :/MO/gui/content (e.g. :/MO/gui/content/plugin or :/MO/gui/content/music `).

The list of available icons is:

• plugin:

• skyproc:

• texture:

• music:

• sound:

• interface:

• skse:

• script:

• mesh:

• string:

• bsa:

• menu:

• inifile:

• modgroup:

class Content(id: int, name: str, icon: str, filter_only: bool = False)

isOnlyForFilter() → bool

Returns:

True if this content is only meant to be used as a filter criteria.

property icon: str

property id: int

property name: str

abstract getAllContents() → list[ModDataContent]

Returns:

The list of all possible contents for the corresponding game.

abstract getContentsFor(filetree: IFileTree) → list[int]

Retrieve the list of contents in the given tree.

Parameters:

filetree – The tree corresponding to the mod to retrieve contents for.

Returns:

The IDs of the content in the given tree.

class mobase.ModRepositoryFileInfo(other: ModRepositoryFileInfo)

class mobase.ModRepositoryFileInfo(game_name: str = '', mod_id: int = 0, file_id: int = 0)

__str__() → str

Return str(self).

static createFromJson(data: str) → ModRepositoryFileInfo

property categoryID: int

property description: str

property fileCategory: int

property fileID: int

property fileName: str

property fileSize: int

property fileTime: PyQt6.QtCore.QDateTime

property gameName: str

property modID: int

property modName: str

property name: str

property newestVersion: VersionInfo

property repository: str

property uri: str

property userData: MoVariant

property version: VersionInfo

class mobase.ModState(*args, **kwds)

Bases: enum.Enum

Create a collection of name/value pairs.

Example enumeration:

>>> class Color(Enum):
...     RED = 1
...     BLUE = 2
...     GREEN = 3

Access them by:

• attribute access:

  >>> Color.RED
  <Color.RED: 1>
  

• value lookup:

  >>> Color(1)
  <Color.RED: 1>
  

• name lookup:

  >>> Color['RED']
  <Color.RED: 1>
  

Enumerations can be iterated over, and know how many members they have:

>>> len(Color)
3

>>> list(Color)
[<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]

Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.

__and__(other: ModState) → ModState

__eq__(other: object) → bool

Return self==value.

__ge__(other: ModState) → bool

Return self>=value.

__gt__(other: ModState) → bool

Return self>value.

__int__() → int

__invert__() → ModState

__le__(other: ModState) → bool

Return self<=value.

__lt__(other: ModState) → bool

Return self<value.

__ne__(other: object) → bool

Return self!=value.

__or__(other: ModState) → ModState

__rand__(other: ModState) → ModState

__ror__(other: ModState) → ModState

__rxor__(other: ModState) → ModState

__str__() → str

Return str(self).

__xor__(other: ModState) → ModState

ACTIVE = Ellipsis

ALTERNATE = Ellipsis

EMPTY = Ellipsis

ENDORSED = Ellipsis

ESSENTIAL = Ellipsis

EXISTS = Ellipsis

VALID = Ellipsis

property name: str

The name of the Enum member.

property value: int

The value of the Enum member.

class mobase.PluginRequirementFactory

static basic(checker: Callable[[IOrganizer], bool], description: str) → IPluginRequirement

Create a basic requirement.

Parameters:

• checker – The callable to use to check if the requirement is met. Should return True if the requirement is met, False otherwise.

• description – The description of the problem, when the requirement is not met.

Returns:

The constructed requirement.

static diagnose(diagnose: IPluginDiagnose) → IPluginRequirement

Construct a requirement from a diagnose plugin.

If the wrapped diagnose plugin reports a problem, the requirement fails and the associated message is the one from the diagnose plugin (or the list of messages if multiple problems were reported).

Parameters:

diagnose – The diagnose plugin to wrap in this requirement.

Returns:

The constructed requirement.

static gameDependency(games: Sequence[str]) → IPluginRequirement

static gameDependency(game: str) → IPluginRequirement

Create a new game dependency requirement.

The requirement is met when the managed game is the specified game.

Parameters:

game – The name of the required game.

Returns:

The constructed requirement.

static pluginDependency(plugins: Sequence[str]) → IPluginRequirement

static pluginDependency(plugin: str) → IPluginRequirement

Create a new plugin dependency requirement.

The requirement is met when the specified plugin is enabled.

Parameters:

plugin – The name of the plugin that must be enabled.

Returns:

The constructed requirement.

class mobase.PluginSetting(key: str, description: str, default_value: MoVariant)

Class to hold the user-configurable parameters a plugin accepts. The purpose of this class is only to inform the application what settings to offer to the user, it does not hold the actual value.

property default_value: MoVariant

property description: str

property key: str

class mobase.PluginState(*args, **kwds)

Bases: enum.Enum

Create a collection of name/value pairs.

Example enumeration:

>>> class Color(Enum):
...     RED = 1
...     BLUE = 2
...     GREEN = 3

Access them by:

• attribute access:

  >>> Color.RED
  <Color.RED: 1>
  

• value lookup:

  >>> Color(1)
  <Color.RED: 1>
  

• name lookup:

  >>> Color['RED']
  <Color.RED: 1>
  

Enumerations can be iterated over, and know how many members they have:

>>> len(Color)
3

>>> list(Color)
[<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]

Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.

__and__(other: PluginState) → PluginState

__eq__(other: object) → bool

Return self==value.

__ge__(other: PluginState) → bool

Return self>=value.

__gt__(other: PluginState) → bool

Return self>value.

__int__() → int

__invert__() → PluginState

__le__(other: PluginState) → bool

Return self<=value.

__lt__(other: PluginState) → bool

Return self<value.

__ne__(other: object) → bool

Return self!=value.

__or__(other: PluginState) → PluginState

__rand__(other: PluginState) → PluginState

__ror__(other: PluginState) → PluginState

__rxor__(other: PluginState) → PluginState

__str__() → str

Return str(self).

__xor__(other: PluginState) → PluginState

ACTIVE = Ellipsis

INACTIVE = Ellipsis

MISSING = Ellipsis

property name: str

The name of the Enum member.

property value: int

The value of the Enum member.

class mobase.ProfileSetting(*args, **kwds)

Bases: enum.Enum

Create a collection of name/value pairs.

Example enumeration:

>>> class Color(Enum):
...     RED = 1
...     BLUE = 2
...     GREEN = 3

Access them by:

• attribute access:

  >>> Color.RED
  <Color.RED: 1>
  

• value lookup:

  >>> Color(1)
  <Color.RED: 1>
  

• name lookup:

  >>> Color['RED']
  <Color.RED: 1>
  

Enumerations can be iterated over, and know how many members they have:

>>> len(Color)
3

>>> list(Color)
[<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]

Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.

__and__(other: ProfileSetting) → ProfileSetting

__eq__(other: object) → bool

Return self==value.

__ge__(other: ProfileSetting) → bool

Return self>=value.

__gt__(other: ProfileSetting) → bool

Return self>value.

__int__() → int

__invert__() → ProfileSetting

__le__(other: ProfileSetting) → bool

Return self<=value.

__lt__(other: ProfileSetting) → bool

Return self<value.

__ne__(other: object) → bool

Return self!=value.

__or__(other: ProfileSetting) → ProfileSetting

__rand__(other: ProfileSetting) → ProfileSetting

__ror__(other: ProfileSetting) → ProfileSetting

__rxor__(other: ProfileSetting) → ProfileSetting

__str__() → str

Return str(self).

__xor__(other: ProfileSetting) → ProfileSetting

CONFIGURATION = Ellipsis

MODS = Ellipsis

PREFER_DEFAULTS = Ellipsis

SAVEGAMES = Ellipsis

property name: str

The name of the Enum member.

property value: int

The value of the Enum member.

class mobase.ReleaseType(*args, **kwds)

Bases: enum.Enum

Create a collection of name/value pairs.

Example enumeration:

>>> class Color(Enum):
...     RED = 1
...     BLUE = 2
...     GREEN = 3

Access them by:

• attribute access:

  >>> Color.RED
  <Color.RED: 1>
  

• value lookup:

  >>> Color(1)
  <Color.RED: 1>
  

• name lookup:

  >>> Color['RED']
  <Color.RED: 1>
  

Enumerations can be iterated over, and know how many members they have:

>>> len(Color)
3

>>> list(Color)
[<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]

Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.

__eq__(other: object) → bool

Return self==value.

__int__() → int

__ne__(other: object) → bool

Return self!=value.

__str__() → str

Return str(self).

ALPHA = Ellipsis

BETA = Ellipsis

CANDIDATE = Ellipsis

FINAL = Ellipsis

PRE_ALPHA = Ellipsis

property name: str

The name of the Enum member.

property value: int

The value of the Enum member.

class mobase.SaveGameInfo

Bases: GameFeature

Feature to get hold of stuff to do with save games.

abstract getMissingAssets(save: ISaveGame) → Dict[str, Sequence[str]]

Retrieve missing assets from the save.

Parameters:

save – The save to find missing assets for.

Returns:

A collection of missing assets and the modules that can supply those assets.

abstract getSaveGameWidget(parent: PyQt6.QtWidgets.QWidget) → ISaveGameInfoWidget | None

Retrieve a widget to display over the save game list.

This method is allowed to return None in case no widget has been implemented.

Parameters:

parent – The parent widget.

Returns:

A SaveGameInfoWidget to display information about save game.

class mobase.ScriptExtender

Bases: GameFeature

Base class for all game features, cannot be inherited, used only for typing purpose in Python.

abstract binaryName() → str

Returns:

The name of the script extender binary.

abstract getArch() → int

Returns:

The CPU platform of the extender.

abstract getExtenderVersion() → str

Returns:

The version of the script extender.

abstract isInstalled() → bool

Returns:

True if the script extender is installed, False otherwise.

abstract loaderName() → str

Returns:

The loader to use to ensure the game runs with the script extender.

abstract loaderPath() → str | os.PathLike[str] | PyQt6.QtCore.QFileInfo

Returns:

The full path to the script extender loader.

abstract pluginPath() → str | os.PathLike[str] | PyQt6.QtCore.QDir

Returns:

The script extender plugin path, relative to the data folder.

abstract savegameExtension() → str

Retrieve the extension of script extender save files.

Returns:

The extension of script extender save files (e.g. “skse”).

class mobase.SortMechanism(*args, **kwds)

Bases: enum.Enum

Create a collection of name/value pairs.

Example enumeration:

>>> class Color(Enum):
...     RED = 1
...     BLUE = 2
...     GREEN = 3

Access them by:

• attribute access:

  >>> Color.RED
  <Color.RED: 1>
  

• value lookup:

  >>> Color(1)
  <Color.RED: 1>
  

• name lookup:

  >>> Color['RED']
  <Color.RED: 1>
  

Enumerations can be iterated over, and know how many members they have:

>>> len(Color)
3

>>> list(Color)
[<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]

Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.

__eq__(other: object) → bool

Return self==value.

__int__() → int

__ne__(other: object) → bool

Return self!=value.

__str__() → str

Return str(self).

BOSS = Ellipsis

LOOT = Ellipsis

MLOX = Ellipsis

NONE = Ellipsis

property name: str

The name of the Enum member.

property value: int

The value of the Enum member.

class mobase.TrackedState(*args, **kwds)

Bases: enum.Enum

Create a collection of name/value pairs.

Example enumeration:

>>> class Color(Enum):
...     RED = 1
...     BLUE = 2
...     GREEN = 3

Access them by:

• attribute access:

  >>> Color.RED
  <Color.RED: 1>
  

• value lookup:

  >>> Color(1)
  <Color.RED: 1>
  

• name lookup:

  >>> Color['RED']
  <Color.RED: 1>
  

Enumerations can be iterated over, and know how many members they have:

>>> len(Color)
3

>>> list(Color)
[<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]

Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.

__eq__(other: object) → bool

Return self==value.

__ge__(other: TrackedState) → bool

Return self>=value.

__gt__(other: TrackedState) → bool

Return self>value.

__int__() → int

__le__(other: TrackedState) → bool

Return self<=value.

__lt__(other: TrackedState) → bool

Return self<value.

__ne__(other: object) → bool

Return self!=value.

__str__() → str

Return str(self).

TRACKED_FALSE = Ellipsis

TRACKED_TRUE = Ellipsis

TRACKED_UNKNOWN = Ellipsis

property name: str

The name of the Enum member.

property value: int

The value of the Enum member.

class mobase.UnmanagedMods

Bases: GameFeature

Base class for all game features, cannot be inherited, used only for typing purpose in Python.

abstract displayName(mod_name: str) → str

Retrieve the display name of a given mod.

Parameters:

mod_name – Internal name of the mod.

Returns:

The display name of the mod.

abstract mods(official_only: bool) → Sequence[str]

Retrieve the list of unmanaged mods for the corresponding game.

Parameters:

official_only – Retrieve only unmanaged official mods.

Returns:

The list of unmanaged mods (internal names).

abstract referenceFile(mod_name: str) → str | os.PathLike[str] | PyQt6.QtCore.QFileInfo

Retrieve the reference file for the requested mod.

Example: For Bethesda games, the reference file may be the main plugin (esp or esm) for the game or a DLCs.

Parameters:

mod_name – Internal name of the mod.

Returns:

The reference file (absolute path) for the requested mod.

abstract secondaryFiles(mod_name: str) → Sequence[str | os.PathLike[str] | PyQt6.QtCore.QFileInfo]

Retrieve the secondary files for the requested mod.

Example: For Bethesda games, the secondary files may be the archives corresponding to the reference file.

Parameters:

mod_name – Internal name of the mod.

Returns:

The secondary files (absolute paths) for the request mod.

class mobase.VersionInfo

class mobase.VersionInfo(value: str, scheme: VersionScheme = VersionScheme.DISCOVER)

class mobase.VersionInfo(major: int, minor: int, subminor: int, subsubminor: int, release_type: ReleaseType = ReleaseType.FINAL)

class mobase.VersionInfo(major: int, minor: int, subminor: int, release_type: ReleaseType = ReleaseType.FINAL)

Represents the version of a mod or plugin.

__eq__(other: object) → bool

Return self==value.

__ge__(arg0: VersionInfo) → bool

Return self>=value.

__gt__(arg0: VersionInfo) → bool

Return self>value.

__le__(arg0: VersionInfo) → bool

Return self<=value.

__lt__(arg0: VersionInfo) → bool

Return self<value.

__ne__(other: object) → bool

Return self!=value.

__str__() → str

Returns:

See canonicalString().

canonicalString() → str

Returns:

A canonical string representing this version, that can be stored and then parsed using the parse() method.

clear() → None

Resets this VersionInfo to an invalid version.

displayString(forced_segments: int = 2) → str

Parameters:

forced_segments – The number of version segments to display even if the version is 0. 1 is major, 2 is major and minor, etc. The only implemented ranges are (-inf,2] for major/minor, [3] for major/minor/subminor, and [4,inf) for major/minor/subminor/subsubminor. This only versions with a regular scheme.

Returns:

A string for display to the user. The returned string may not contain enough information to reconstruct this version info.

isValid() → bool

Returns:

True if this VersionInfo is valid, False otherwise.

parse(value: str, scheme: VersionScheme = VersionScheme.DISCOVER, is_manual: bool = False) → None

Update this VersionInfo by parsing the given string using the given scheme.

Parameters:

• value – String to parse.

• scheme – Scheme to use to parse the string.

• is_manual – True if the given string should be treated as user input.

scheme() → VersionScheme

Returns:

The version scheme in effect for this VersionInfo.

class mobase.VersionScheme(*args, **kwds)

Bases: enum.Enum

Create a collection of name/value pairs.

Example enumeration:

>>> class Color(Enum):
...     RED = 1
...     BLUE = 2
...     GREEN = 3

Access them by:

• attribute access:

  >>> Color.RED
  <Color.RED: 1>
  

• value lookup:

  >>> Color(1)
  <Color.RED: 1>
  

• name lookup:

  >>> Color['RED']
  <Color.RED: 1>
  

Enumerations can be iterated over, and know how many members they have:

>>> len(Color)
3

>>> list(Color)
[<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]

Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.

__eq__(other: object) → bool

Return self==value.

__int__() → int

__ne__(other: object) → bool

Return self!=value.

__str__() → str

Return str(self).

DATE = Ellipsis

DECIMAL_MARK = Ellipsis

DISCOVER = Ellipsis

LITERAL = Ellipsis

NUMBERS_AND_LETTERS = Ellipsis

REGULAR = Ellipsis

property name: str

The name of the Enum member.

property value: int

The value of the Enum member.

mobase.getFileVersion(filepath: str | os.PathLike[str] | PyQt6.QtCore.QFileInfo) → str

Retrieve the file version of the given executable.

Parameters:

filepath – Absolute path to the executable.

Returns:

The file version, or an empty string if the file version could not be retrieved.

mobase.getIconForExecutable(executable: str | os.PathLike[str] | PyQt6.QtCore.QFileInfo) → PyQt6.QtGui.QIcon

Retrieve the icon of an executable. Currently this always extracts the biggest icon.

Parameters:

executable – Absolute path to the executable.

Returns:

The icon for this executable, if any.

mobase.getProductVersion(executable: str | os.PathLike[str] | PyQt6.QtCore.QFileInfo) → str

Retrieve the product version of the given executable.

Parameters:

executable – Absolute path to the executable.

Returns:

The product version, or an empty string if the product version could not be retrieved.

mobase.GameFeatureType

mobase.INVALID_HANDLE_VALUE: int = Ellipsis

mobase.MoVariant

mobase.__version__ = '2.5.2'