API Reference

Mod Fix

RemapService

Methods

def_fix
def_printModsToFix
def_setupDefaultModType
def_setupLogPath
def_setupModPath
def_setupModTypes
def_setupRemappedTypes
def_setupVersion
defaddTips
defclear
defcreateLog
defcreateMod
deffix
deffixIni
deffixMod
defreportSkippedAsset
defreportSkippedMods
defwarnSkippedBlends

class RemapService(path: Optional[str] = None, keepBackups: bool = True, fixOnly: bool = False, undoOnly: bool = False, readAllInis: bool = False, types: Optional[List[str]] = None, defaultType: Optional[str] = None, log: Optional[str] = None, verbose: bool = True, handleExceptions: bool = False, version: Optional[str] = None, remappedTypes: Optional[List[str]] = None)

The overall class for remapping modss

Parameters

path (Optional[str]) –
The file location of where to run the fix.

If this attribute is set to None, then will run the fix from wherever this class is called

Default: None
keepBackups (bool) –
Whether to keep backup versions of any .ini files that the script fixes

Default: True
fixOnly (bool) –
Whether to only fix the mods without removing any previous changes this fix script may have made

Warning

if this is set to True and undoOnly is also set to True, then the fix will not run and will throw a ConflictingOptions exception

Default: False
undoOnly (bool) –
Whether to only undo the fixes previously made by the fix

Warning

if this is set to True and fixOnly is also set to True, then the fix will not run and will throw a ConflictingOptions exception

Default: True
readAllInis (bool) –
Whether to read all the .ini files that the fix encounters

Default: False
types (Optional[List[str]]) –
The names for all the types of mods to fix.

If this argument is an empty list or this argument is None, then will fix all the types of mods supported by this fix

Default: None
remappedTypes (Optional[List[str]]) –
The names for the types of mods to be remapped based from the types of mods specified at RemapService.types.

For a mod specified at RemapService.types, if none of its corresponding mods to remap are specified in this attribute, then will remap the mod specified at RemapService.types to all its corresponding mods to remap.

If this argument is an empty list or this argument is None, then will fix the mods specified at RemapService.types to all of their corresponding remapped mods

eg. if RemapService.types is ["Kequeen", "jean"] and this attribute is ["jeanSea"], then this class will perform the following remaps:
- Keqing –> KeqingOpulent
- Jean –> JeanSea
**Note: ** Jean –> JeanCN will not be remapped for the above example

Default: None
defaultType (Optional[str]) –
The name for the type to use if a mod has an unidentified type

If this value is None, then mods with unidentified types will be skipped

Default: None
log (Optional[str]) –
The folder location to log the run of the fix into a seperate text file

If this value is None, then will not log the fix

Default: None
verbose (bool) –
Whether to print the progress for fixing mods

Default: True
handleExceptions (bool) –
When an exception is caught, whether to silently stop running the fix

Default: False
version (Optional[str]) –
The game version we want the fix to be compatible with

If This value is None, then will retrieve the hashes/indices of the latest version.

Default: None

_loggerBasePrefix

The prefix string for the logger used when the fix returns back to the original directory that it started to run

Type: str

logger

The logger used to pretty print messages

Type: Logger

_path

The file location of where to run the fix.

Type: str

keepBackups

Whether to keep backup versions of any .ini files that the script fixes

Type: bool

fixOnly

Whether to only fix the mods without removing any previous changes this fix script may have made

Type: bool

undoOnly

Whether to only undo the fixes previously made by the fix

Type: bool

readAllInis

Whether to read all the .ini files that the fix encounters

Type: bool

types

All the types of mods that will be fixed.

Type: Set[ModType]

remappedTypes

The names for the types of mods to be remapped based from the types of mods specified at RemapService.types.

For a mod specified at RemapService.types, if none of its corresponding mods to remap are specified in this attribute, then will remap the mod specified at RemapService.types to all its corresponding mods to remap.

If this argument is an empty list or this argument is None, then will fix the mods specified at RemapService.types to all of their corresponding remapped mods

eg. if RemapService.types is ["Kequeen", "jean"] and this attribute is ["jeanSea"], then this class will perform the following remaps:

Keqing –> KeqingOpulent
Jean –> JeanSea

**Note: ** Jean –> JeanCN will not be remapped for the above example

Type: Set[str]

defaultType

The type to use if a mod has an unidentified type

Type: Optional[ModType]

verbose

Whether to print the progress for fixing mods

Type: bool

version

The game version we want the fix to be compatible with

If This value is None, then will retrieve the hashes/indices of the latest version.

Type: Optional[float]

handleExceptions

When an exception is caught, whether to silently stop running the fix

Type: bool

_logFile

The file path of where to generate a log .txt file

Type: str

_pathIsCWD

Whether the filepath that the program runs from is the current directory where this module is loaded

Type: bool

modsFixed

The number of mods that have been fixed

Type: int

skippedMods

All the mods that have been skipped

The keys are the absolute path to the mod folder and the values are the exception that caused the mod to be skipped

Type: Dict[str, Exception]

blendsFixed

The absolute paths to all the Blend.buf files that have been fixed

Type: Set[str]

skippedBlendsByMods

The RemapBlend.buf files that got skipped :raw-html for each mod

The outer key is the absolute path to the mod folder
The inner key is the absolute path to the RemapBlend.buf file
The value in the inner dictionary is the exception that caused the RemapBlend.buf file to be skipped

Type: DefaultDict[str, Dict[str, Exception]]

skippedBlends

The RemapBlend.buf files that got skipped

The keys are the absolute path to the RemapBlend.buf file and the values are the exception that caused the RemapBlend.buf file to be skipped

Type: Dict[str, Exception]

inisFixed

The absolute paths to the fixed .ini files

Type: Set[str]

inisSkipped

The .ini files that got skipped

The keys are the absolute file paths to the .ini files and the values are exceptions that caused the .ini file to be skipped

Type: Dict[str, Exception]

removedRemapBlends

Previous RemapBlend.buf files that are removed

Type: Set[str]

undoedInis

.ini files that got cleared out of any traces of previous fixes

Note

These .ini files may or may not have been previously fixed. A path to some .ini file in this attribute DOES NOT imply that the .ini file previously had a fix

Type: Set[str]

_fix()

The overall logic for fixing a bunch of mods

For finding out which folders may contain mods, this function:

recursively searches all folders from where the RemapService.path is located
for every .ini file in a valid mod and every Blend.buf file encountered that is encountered, recursively search all the folders from where the .ini file or Blend.buf file is located

Tip

For more info about how we define a ‘mod’, go to Mod

_printModsToFix(): Prints out the types of mods that will be fixed

_setupDefaultModType(): Sets the default mod type to be used for an unidentified mod

_setupLogPath(): Sets the folder path for where the log file will be stored

_setupModPath(): Sets the filepath of where the fix will run from

_setupModTypes(attr: str)

Sets the types of mods that will be fixed / fix to

Parameters: attr (str) – The name of the attribute within this class set the mods for

_setupRemappedTypes(): Sets the names for the types of mods that will be fixed to

_setupVersion(): Sets the game version to fix to

addTips(): Prints out any useful tips for the user to know

clear(clearLog: bool = True)

Clears up all the saved data

Paramters

clearLog: bool: Whether to also clear out any saved data in the logger

createLog(): Creates a log text file that contains all the text printed on the command line

createMod(path: Optional[str] = None, files: Optional[List[str]] = None) → Mod

Creates a mod

Tip

For more info about how we define a ‘mod’, go to Mod

Parameters

path (Optional[str]) –
The absolute path to the mod folder.

If this argument is set to None, then will use the current directory of where this module is loaded
files (Optional[List[str]]) –
The direct children files to the mod folder (does not include files located in a folder within the mod folder).

If this parameter is set to None, then the module will search the folders for you

Returns

The mod that has been created

Return type

Mod

fix()

Fixes a bunch of mods

see _fix() for more info

fixIni(ini: IniFile, mod: Mod, fixedRemapBlends: Set[str]) → bool

Fixes an individual .ini file for a particular mod

Tip

For more info about how we define a ‘mod’, go to Mod

Parameters

ini (IniFile) – The .ini file to fix
mod (Mod) – The mod being fixed
fixedRemapBlends (Set[str]) – All of the RemapBlend.buf files that have already been fixed.

Returns

Whether the particular .ini file has just been fixed

Return type

bool

fixMod(mod: Mod, fixedRemapBlends: Set[str]) → bool

Fixes a particular mod

Tip

For more info about how we define a ‘mod’, go to Mod

Parameters

mod (Mod) – The mod being fixed
fixedRemapBlends (Set[str]) – all of the RemapBlend.buf files that have already been fixed.

Returns

Whether the particular mod has just been fixed

Return type

bool

property log: str

The folder location to log the run of the fix into a seperate text file

Getter: Returns the file path to the log
Setter: Sets the path for the log
Type: str

property path: str

The filepath of where the fix is running from

Getter: Returns the path of where the fix is running
Setter: Sets the path for where the fix runs
Type: str

property pathIsCwd

Whether the filepath that the program runs from is the current directory where this module is loaded

Getter: Returns whether the filepath that the program runs from is the current directory of where the module is loaded
Type: bool

reportSkippedAsset(assetName: str, assetDict: Dict[str, Exception], warnStrFunc: Callable[[str], str])

Prints out the exception message for why a particular .ini file or Blend.buf file has been skipped

Parameters

assetName (str) – The name for the type of asset (files, folders, mods, etc…) that was skipped
assetDict (Dict[str, Exception]) –
Locations of where exceptions have occured for the particular asset

The keys are the absolute folder paths to where the exception occured
wantStrFunc (Callable[[str], str]) –
Function for how we want to print out the warning for each exception

Takes in the folder location of where the exception occured as a parameter

reportSkippedMods(): Prints out all of the mods that were skipped due to exceptions

Tip

For more info about how we define a ‘mod’, go to Mod

warnSkippedBlends(modPath: str)

Prints out all of the Blend.buf files that were skipped due to exceptions

Parameters: modPath (str) – The absolute path to a particular folder

Mod

Attributes

_defaultType
_files
_remappedType
_types
backupInis
files
inis
logger
path
remapBlend
remapCopies
version

Methods

clsMod.blendCorrection
clsMod.isBackupIni
clsMod.isBlend
clsMod.isIni
clsMod.isRemapBlend
clsMod.isRemapCopyIni
clsMod.isSrcIni
def_setupFiles
defcorrectBlend
defgetOptionalFiles
defprint
defremoveBackupInis
defremoveFix
defremoveRemapCopies

class Mod(path: Optional[str] = None, files: Optional[List[str]] = None, logger: Optional[Logger] = None, types: Optional[Set[ModType]] = None, defaultType: Optional[ModType] = None, version: Optional[float] = None, remappedTypes: Optional[Set[str]] = None)

This Class inherits from Model

Used for handling a mod

Note

We define a mod based off the following criteria:

A folder that contains at least 1 .ini file
At least 1 of the .ini files in the folder contains:
- a section with the regex [TextureOverride.*Blend] if RemapService.readAllInis is set to True or the script is ran with the --all flag
  
  OR
- a section that meets the criteria of one of the mod types defined Mod._types by running the mod types’ ModType.isType() function

See ModTypes for some predefined types of mods

Parameters

path (Optional[str]) –
The file location to the mod folder.

If this value is set to None, then will use the current directory of where this module is loaded.

Default: None
files (Optional[List[str]]) –
The direct children files to the mod folder (does not include files located in a folder within the mod folder).

If this parameter is set to None, then the class will search the files for you when the class initializes

Default: None
logger (Optional[Logger]) –
The logger used to pretty print messages

Default: None
types (Optional[Set[ModType]]) –
The types of mods this mod should be.

If this argument is empty or is None, then all the .ini files in this mod will be parsed

Default: None
remappedTypes (Optional[Set[ModType]]) –
The types of mods to the mods specified at Mod._types will be fixed to.

Note

For more details, see RemapService.remappedTypes

Default: None
defaultType (Optional[ModType]) –
The type of mod to use if a mod has an unidentified type

If this argument is None, then will skip the mod with an identified type

Default: None
version (Optional[float]) –
The game version we want the fixed mod

If This value is None, then will fix the mod to using the latest hashes/indices.

path

The file location to the mod folder

Type: Optional[str]

version

The game version we want the fixed mod

Type: Optional[float]

_files

The direct children files to the mod folder (does not include files located in a folder within the mod folder).

Type: List[str]

_types

The types of mods this mod should be

Type: Set[ModType]

_remappedType

The types of mods to the mods specified at Mod.types will be fixed to.

Note

For more details, see RemapService.remappedTypes

Type: Set[str]

_defaultType

The type of mod to use if a mod has an unidentified type

Type: Optional[ModType]

logger

The logger used to pretty print messages

Type: Optional[Logger]

inis

The .ini files found for the mod

Type: List[str]

remapBlend

The RemapBlend.buf files found for the mod

Type: List[str]

backupInis

The DISABLED_RemapBackup.txt files found for the mod

Type: List[str]

remapCopies

The remapFix.ini files found for the mod

Type: List[str]

_setupFiles(): Searches the direct children files to the mod folder if Mod.files is set to None

classmethod blendCorrection(blendFile: Union[str, bytes], modType: ModType, modToFix: str, fixedBlendFile: Optional[str] = None, version: Optional[float] = None) → Union[str, None, bytearray]

Fixes a Blend.buf file

See BlendFile.correct() for more info

Parameters

blendFile (Union[str, bytes]) – The file path to the Blend.buf file to fix
modType (ModType) – The type of mod to fix from
modToFix (str) – The name of the mod to fix to
fixedBlendFile (Optional[str]) –
The file path for the fixed Blend.buf file

Default: None
version (Optional[float]) –
The game version to fix to

If this value is None, then will fix to the latest game version

Default: None

Raises

BlendFileNotRecognized – If the original Blend.buf file provided by the parameter blendFile cannot be read
BadBlendData – If the bytes passed into this function do not correspond to the format defined for a Blend.buf file

Returns

If the argument fixedBlendFile is None, then will return an array of bytes for the fixed Blend.buf file

Otherwise will return the filename to the fixed RemapBlend.buf file if the provided Blend.buf file got corrected

Return type

Union[Optional[str], bytearray]

correctBlend(fixedRemapBlends: Set[str], skippedBlends: Dict[str, Exception], fixOnly: bool = False) → List[Union[Set[str], Dict[str, Exception]]]

Fixes all the Blend.buf files reference by the mod

Requires all the .ini files in the mod to have ran their IniFile.parse() function

Parameters

fixedRemapBlends (Set[str]) – All of the RemapBlend.buf files that have already been fixed.
skippedBlends (Dict[str, Exception]) –
All of the RemapBlend.buf files that have already been skipped due to some error when trying to fix them

The keys are the absolute filepath to the RemapBlend.buf file that was attempted to be fixed and the values are the exception encountered
fixOnly (bool) –
Whether to not correct some Blend.buf file if its corresponding RemapBlend.buf already exists

Default: True

Returns

The absolute file paths of the RemapBlend.buf files that were fixed
The exceptions encountered when trying to fix some RemapBlend.buf files

The keys are absolute filepath to the RemapBlend.buf file and the values are the exception encountered

Return type

[Set[str], Dict[str, Exception]]

property files

The direct children files to the mod folder (does not include files located in a folder within the mod folder).

Getter: Returns the files to the mod
Setter: Sets up the files for the mod
Type: Optional[List[str]]

getOptionalFiles() → List[Optional[str]]

Retrieves a list of each type of files that are not mandatory for the mod

Returns

The resultant files found for the following file categories (listed in the same order as the return type):

.ini files not created by this fix
.RemapBlend.buf files
DISABLED_RemapBackup.txt files
RemapFix.ini files

Note

See Mod.isIni(), Mod.isRemapBlend(), Mod.isBackupIni(), Mod.isRemapCopyIni() for the specifics of each type of file

Return type

[ List[str], List[str], List[str]]

classmethod isBackupIni(file: str) → bool

Determines whether the file is a DISABLED_RemapBackup.txt file that is used to make backup copies of .ini files

Parameters: file (str) – The file path to check
Returns: Whether the passed in file is a DISABLED_RemapBackup.txt file
Return type: bool

classmethod isBlend(file: str) → bool

Determines whether the file is a Blend.buf file which is the original blend file provided in the mod

Parameters: file (str) – The file path to check
Returns: Whether the passed in file is a Blend.buf file
Return type: bool

classmethod isIni(file: str) → bool

Determines whether the file is a .ini file which is the file used to control how a mod behaves

Parameters: file (str) – The file path to check
Returns: Whether the passed in file is a .ini file
Return type: bool

classmethod isRemapBlend(file: str) → bool

Determines whether the file is a RemapBlend.buf file which is the fixed Blend.buf file created by this fix

Parameters: file (str) – The file path to check
Returns: Whether the passed in file is a RemapBlend.buf file
Return type: bool

classmethod isRemapCopyIni(file: str) → bool

Determines whether the file is RemapFix.ini file which are .ini files generated by this fix to remap specific type of mods

*eg. mods such as Keqing or Jean that are fixed by GIMIObjMergeFixer *

Parameters: file (str) – The file path to check
Returns: Whether the passed in file is a RemapFix.ini file
Return type: bool

classmethod isSrcIni(file: str) → bool

Determines whether the file is a .ini file that is not created by this fix

Parameters: file (str) – The file path to check
Returns: Whether the passed in file is a .ini file not created by this fix
Return type: bool

print(funcName: str, *args, **kwargs)

Prints out output

Parameters

funcName (str) – The name of the function in the logger for printing out the output
*args (List[str]) – Arguments to pass to the function in the logger
**kwargs (Dict[str, Any]) – Keyword arguments to pass to the function in the logger

Returns

The return value from running the corresponding function in the logger

Return type

Any

removeBackupInis(): Removes all DISABLED_RemapBackup.txt contained in the mod

removeFix(fixedBlends: Set[str], fixedInis: Set[str], visitedRemapBlendsAtRemoval: Set[str], inisSkipped: Dict[str, Exception], keepBackups: bool = True, fixOnly: bool = False, readAllInis: bool = False) → List[Set[str]]

Removes any previous changes done by this module’s fix

Parameters

fixedBlend (Set[str]) – The file paths to the RemapBlend.buf files that we do not want to remove
fixedInis (Set[str]) – The file paths to the .ini files that we do not want to remove
visitedRemapBlendsAtRemoval (Set[str]) – The file paths to the RemapBlend.buf that have already been attempted to be removed
inisSkipped (Dict[str, Exception]) – The file paths to the .ini files that are skipped due to errors
keepBackups (bool) –
Whether to create or keep DISABLED_RemapBackup.txt files in the mod

Default: True
fixOnly (bool) –
Whether to not undo any changes created in the .ini files

Default: False
readAllInis (bool) –
Whether to remove the .ini fix from all the .ini files encountered

Default: False

Returns

The removed files that have their fix removed, where the types of files for the return value is based on the list below:

.ini files with their fix removed
RemapBlend.buf files that got deleted

Return type

[Set[str], Set[str]]

removeRemapCopies(): Removes all RemapFix.ini files contained in the mod

ModType

Attributes

aliases
check
hashes
indices
iniFixBuilder
iniParseBuilder
iniRemoveBuilder
name
vgRemaps

Methods

deffixIni
defgetModsToFix
defgetVGRemap
defisName
defisType

class ModType(name: str, check: Union[str, Pattern, Callable[[str], bool]], hashes: Optional[Hashes], indices: Optional[Indices] = None, aliases: Optional[List[str]] = None, vgRemaps: Optional[VGRemaps] = None, iniParseBuilder: Optional[IniParseBuilder] = None, iniFixBuilder: Optional[IniFixBuilder] = None, iniRemoveBuilder: Optional[IniRemoveBuilder] = None)

Class for defining a generic type of mod

Parameters

name (str) – The default name for the type of mod
check (Union[str, Pattern, Callable[[str], bool]]) –
The specific check used to identify the .ini file belongs to the specific type of mod when checking arbitrary line in a .ini file
1. If this argument is a string, then will check if a line in the .ini file equals to this argument
2. If this argument is a regex pattern, then will check if a line in the .ini file matches this regex pattern
3. If this argument is a function, then will check if a line in the .ini file will make the function for this argument return True
hashes (Optional[Hashes]) –
The hashes related to the mod and its fix

If this value is None, then will create a new, empty Hashes

Default: None
indices (Optional[Indices]) –
The indices related to the mod and its fix

If this None, then will create a new, emtpy Indices

Default: None
aliases (Optional[List[str]]) –
Other alternative names for the type of mod

Default: None
vgRemaps (Optional[VGRemaps]) –
Maps the blend indices from the vertex group of one mod to another mod

If this value is None, then will create a new, empty VGRemaps

Default: None
iniParseBuilder (Optional[IniParseBuilder]) –
The builder to build the parser used for .ini files

If this value is None, then by default this attribute will be set to IniParseBuilder(:class:`GIMIParser`)

Default: None
iniFixBuilder (Optional[IniFixBuilder]) –
The builder to build the fixer used for .ini files

If this value is None, then by default this attribute will be set to IniFixBuilder(:class:`GIMIFixer`)

Default: None
iniRemoveBuilder (Optional[IniRemoveBuilder]) –
The builder to build the remover used for .ini files

If this value is None, then by default this attribute will be set to IniRemoveBuilder(:class:`IniRemover`)

Default: None

name

The default name for the type of mod

Type: str

check

The specific check used to identify the .ini file belongs to the specific type of mod when checking arbitrary line in a .ini file

Type: Union[str, Pattern, Callable[[str], bool]]

hashes

The hashes related to the mod and its fix

Type: Hashes

indices

The indices related to the mod and its fix

Type: Indices

vgRemaps

The repository that stores the mapping for remapping vertex group blend indices of the mod to the vertex group blend indices of another mod

Type: VGRemaps

aliases

Other alternative names for the type of mod

Type: Optional[List[str]]

iniParseBuilder

The builder to build the parser used for .ini files

Type: IniParseBuilder

iniFixBuilder

the builder to build the fixer used for .ini files

Type: IniFixBuilder

iniRemoveBuilder

the builder to build the remover used for .ini files

Type: IniRemoveBuilder

fixIni(iniFile: IniFile, keepBackup: bool = True, fixOnly: bool = False)

Fixes the .ini file associated to this type of mod

Parameters

iniFile (IniFile) – The .ini file to fix
keepBackup (bool) –
Whether to keep backups for the .ini file

Default: True
fixOnly (bool) –
Whether to only fix the .ini file without undoing any fixes

Default: False

getModsToFix() → Set[str]

Retrieves the names of the mods this mod type will fix to

Returns: The names of the mods to fix to
Return type: Set[str]

getVGRemap(modName: str, version: Optional[float] = None) → VGRemap

Retrieves the corresponding Vertex Group Remap

Attention

This function assumes that the specified map ModType.vgRemaps (VGRemaps.map) contains ModType.name (the name of this mod type) as a mod to map from

Parameters

modName (str) – The name of the mod to map to
version (Optional[float]) –
The specific game version we want for the remap

If this value is None, then will get the latest version of the remap

Default: None

Returns

The corresponding remap

Return type

VGRemap

isName(name: str) → bool

Determines whether a certain name matches with the names defined for this type of mod

Parameters: name (str) – The name being searched
Returns: Whether the searched name matches with the names for this type of mod
Return type: bool

isType(iniLine: str) → bool

Determines whether a line in the .ini file correponds with this mod type

Parameters: iniLine (str) – An arbitrary line in a .ini file
Returns: Whether the line in the .ini file corresponds with this type of mod
Return type: bool

ModTypeBuilder

class ModTypeBuilder: Class to create a new ModType for different mods

GIBuilder

class GIBuilder

This Class inherits from ModTypeBuilder

Creates new ModType objects for some anime game

classmethod amber() → ModType

Creates the ModType for Amber

Returns: The resultant ModType
Return type: ModType

classmethod amberCN() → ModType

Creates the ModType for AmberCN

Returns: The resultant ModType
Return type: ModType

classmethod arlecchino() → ModType

Creates the ModType for Arlecchino

Returns: The resultant ModType
Return type: ModType

classmethod barbara() → ModType

Creates the ModType for Barbara

Returns: The resultant ModType
Return type: ModType

classmethod barbaraSummerTime() → ModType

Creates the ModType for BarbaraSummerTime

Returns: The resultant ModType
Return type: ModType

classmethod ganyu() → ModType

Creates the ModType for Ganyu

Returns: The resultant ModType
Return type: ModType

classmethod ganyuTwilight() → ModType

Creates the ModType for GanyuTwilight

Returns: The resultant ModType
Return type: ModType

classmethod jean() → ModType

Creates the ModType for Jean

Returns: The resultant ModType
Return type: ModType

classmethod jeanCN() → ModType

Creates the ModType for JeanCN

Returns: The resultant ModType
Return type: ModType

classmethod jeanSea() → ModType

Creates the ModType for JeanSea

Returns: The resultant ModType
Return type: ModType

classmethod keqing() → ModType

Creates the ModType for Keqing

Returns: The resultant ModType
Return type: ModType

classmethod keqingOpulent() → ModType

Creates the ModType for KeqingOpulent

Returns: The resultant ModType
Return type: ModType

classmethod mona() → ModType

Creates the ModType for Mona

Returns: The resultant ModType
Return type: ModType

classmethod monaCN() → ModType

Creates the ModType for MonaCN

Returns: The resultant ModType
Return type: ModType

classmethod ningguang() → ModType

Creates the ModType for Ningguang

Returns: The resultant ModType
Return type: ModType

classmethod ningguangOrchid() → ModType

Creates the ModType for Ningguang

Returns: The resultant ModType
Return type: ModType

classmethod raiden() → ModType

Creates the ModType for Ei

Returns: The resultant ModType
Return type: ModType

classmethod rosaria() → ModType

Creates the ModType for Rosaria

Returns: The resultant ModType
Return type: ModType

classmethod rosariaCN() → ModType

Creates the ModType for RosariaCN

Returns: The resultant ModType
Return type: ModType

classmethod shenhe() → ModType

Creates the ModType for Shenhe

Returns: The resultant ModType
Return type: ModType

classmethod shenheFrostFlower() → ModType

Creates the ModType for ShenheFrostFlower

Returns: The resultant ModType
Return type: ModType

ModAssets

Attributes

fixFrom
fixTo
map
repo
versions

Methods

clsModAssets.updateMap
def_addVersion
def_partition
def_updateAssetContent
def_updateVersions
defaddMap
defaddMapping
defclear
deffindClosestVersion
defloadFromPreset
defupdateRepo

class ModAssets(repo: Dict[float, Dict[str, T]], map: Optional[Dict[str, Set[str]]] = None)

Class to handle assets of any type for a mod

Note

This is a bipartite graph that maps assets to fix from to assets to fix to

Parameters

repo (Dict[str, Dict[str, T]]) –
The original source for any preset assets
- The outer key is the game version number for the assets
- The inner key is the name of the asset
- The inner value is the content for the asset
map (Optional[Dict[str, Set[str]]]) –
The adjacency list that maps the assets to fix from to the assets to fix to using the predefined mods

Default: None

repo

The original source for any preset assets

The outer key is the game version number for the assets
The inner key is the name of the asset
The inner value is the content for the asset

Type: Dict[float, Dict[str, T]]

_addVersion(name: str, version: float)

Adds a new version for a particular asset

Parameters

name (str) – The name of the asset
version (float) – The game version

_partition(map: Dict[str, Set[str]], assets: Dict[float, Dict[str, Any]]) → Tuple[Dict[str, Set[str]], Set[str], Set[str]]

Creates the bipartition for the assets to fix from vs the assets to fix to
Filters the mapping such that all the asset names in the new mapping exist in assets

Parameters

map (Dict[str, Set[str]]) – The desired mapping for the assets for fixing
assets (Dict[float, Dict[str, Any]]) –
The source for all the assets
- The outer key is the game version number for the assets
- The first inner key is the name of the asset
- The second inner key is the type of asset
- The most inner value is the id for the asset (must be unique)

Returns

The following output is in the same order as listed below:

The new mapping with all asset names being in assets
The names of the assets to fix from
The names of the assets to fix to

Return type

Tuple[Dict[str, Set[str]], Set[str], Set[str]]

_updateAssetContent(srcAsset: T, newAsset: T) → T

Combines the content of 2 assets

Parameters

srcAsset (T) – The content of the asset to be updates
newAsset (T) – The new asset to update into srcAsset

Returns

The updated asset

Return type

T

_updateVersions(assets: Dict[float, Dict[str, T]])

Updates the versioning of the assets

Parameters: assets (T) – The assets for checking the versioning

addMap(assetMap: Dict[str, Set[str]], assets: Optional[Dict[float, Dict[str, T]]] = None)

Adds a new map to the existing map on how to retrieve the assets

Parameters

assetMap (Dict[str, Set[str]]) – The new adjacency list used to map assets to fix from to assets to fix to
assets (Optional[T]) –
Any new assets that needs to be added/updated to the existing assets to support the given map

Default: None

addMapping(fromAsset: str, toAssets: Set[str], assets: Any)

Adds a new mapping of how to fix the assets

Parameters

fromAsset (str) – The name of the asset to fix from
toAssets (Set[str]) – The names of the assets to fix to
assets (Any) – Any new assets that needs to be added/updated to the existing assets to support the new mapping

clear(flush: bool = True, clearMap: bool = False)

Clears all the assets

Parameters

flush (bool) –
Whether to flush out (reload) any cached data

Default: False
clearMap (bool) –
Whether to clear out the mapping for the assets

Default: False

findClosestVersion(name: str, version: Optional[float] = None, fromCache: bool = True) → float

Finds the closest available game version from ModStrAssets._toAssets for a particular asset

Parameters

name (str) – The name of the asset to search
version (Optional[float]) –
The game version to be searched

If This value is None, then will assume we want the latest version

Default: None
fromCache (bool) –
Whether to use the result from the cache

Default: None

Raises

KeyError – The name for the particular asset is not found

Returns

The latest game version from the assets that corresponds to the desired version

Return type

float

property fixFrom: Set[str]

The names of the assets to fix from using the predefined mods

Getter: Retrieves the names of assets used to fix from
Type: Set[str]

property fixTo: Set[str]

The names of the assets to fix to using the predefined mods

Getter: Retrives the names of assets to fix to
Type: Set[str]

loadFromPreset(): Reinitializes to load the predefined mods

property map: Dict[str, Set[str]]

The adjacency list used to map assets to fix from to assets to fix to

Getter: Retrieves the adjacency list
Setter: Sets a new adjacency list
Type: Dict[str, Set[str]]

classmethod updateMap(srcMap: Dict[str, Set[str]], newMap: Dict[str, Set[str]]) → Dict[str, Set[str]]

Combines 2 maps together

Parameters

srcMap (Dict[str, Set[str]]) – The map to be updates
newMap (Dict[str, Set[str]]) – The new map to update srcMap

Returns

The updated map

Return type

Dict[str, Set[str]]

updateRepo(srcRepo: Dict[float, Dict[str, Any]], newRepo: Dict[float, Dict[str, Any]]) → Dict[float, Dict[str, Any]]

Updates the values in srcRepo

Parameters

srcRepo (Dict[float, Dict[str, Any]]) – The first repo to be combined
newRepo (Dict[float, Dict[str, Any]]) – The second repo to be combined

Returns

The combined repo

Return type

Dict[float, Dict[str, Any]]

property versions: Dict[str, Version]

The game versions available for the assets

The keys are the names of the assets
The values are versions for the asset

Getter: Returns all the available game versions for the assets
Type: Dict[str, Version]

ModIdAssets

Attributes

fixFrom
fixTo
fromAssets
map
toAssets
versions

Methods

clsModIdAssets._getFromAssets
clsModIdAssets.updateMap
def_addVersion
def_getToAssets
def_partition
def_updateAssetContent
def_updateVersions
defaddMap
defaddMapping
defclear
deffindClosestVersion
defget
defloadFromPreset
defreplace
defupdateRepo

class ModIdAssets(repo: Dict[float, Dict[str, Dict[str, str]]], map: Optional[Dict[str, Set[str]]] = None)

This class inherits from ModAssets

Class to handle hashes, indices, and other string id type assets for a mod

Parameters

repo (Dict[float, Dict[str, Dict[str, str]]]) –
The original source for any preset assets
- The outer key is the game version of the assets
- The first inner key is the name of the asset
- The second inner key is the type of asset
- The most inner value is the id for the asset
Note

The id value for each asset should be unique
map (Optional[Dict[str, Set[str]]]) –
The adjacency list that maps the assets to fix from to the assets to fix to using the predefined mods

Default: None

_addVersion(name: str, version: float)

Adds a new version for a particular asset

Parameters

name (str) – The name of the asset
version (float) – The game version

classmethod _getFromAssets(map: Dict[str, Set[str]], assets: Dict[float, Dict[str, Dict[str, str]]]) → Dict[str, Tuple[Set[str], str]]

Retrieves the assets to fix from

Parameters

map (Dict[str, Set[str]]) – The mapping for fixing the assets
assets (Dict[float, Dict[str, Dict[str, str]]]) –
The source for all the assets
- The outer key is the game version number for the assets
- The first inner key is the name of the asset
- The second inner key is the type of asset
- The most inner value is the id for the asset (must be unique)

Returns

The assets to fix from

The keys are the ids for the asset
The values contains metadata about the assets to fix to where each tuple contains:

# The names of the assets # The type of asset

Return type

Dict[str, Tuple[Set[str], str]]

_getToAssets(assetNames: Set[str], assets: Dict[float, Dict[str, Dict[str, str]]]) → Dict[float, Dict[str, Dict[str, str]]]

Retrieves the assets to fix to

Parameters

assetNames (Set[str]) – The names of the assets to fix to
assets (Dict[float, Dict[str, Dict[str, str]]]) –
The source for all the assets
- The outer key is the game version number for the assets
- The first inner key is the name of the asset
- The second inner key is the type of asset
- The most inner value is the id for the asset (must be unique)

Returns

The assets to fix to

The outer key is the game version number for the assets
The first inner key is the name of the asset
The second inner key is the type of asset
The most inner value is the id for the asset (must be unique)

Return type

Dict[float, Dict[str, Dict[str, str]]]

_partition(map: Dict[str, Set[str]], assets: Dict[float, Dict[str, Any]]) → Tuple[Dict[str, Set[str]], Set[str], Set[str]]

Creates the bipartition for the assets to fix from vs the assets to fix to
Filters the mapping such that all the asset names in the new mapping exist in assets

Parameters

map (Dict[str, Set[str]]) – The desired mapping for the assets for fixing
assets (Dict[float, Dict[str, Any]]) –
The source for all the assets
- The outer key is the game version number for the assets
- The first inner key is the name of the asset
- The second inner key is the type of asset
- The most inner value is the id for the asset (must be unique)

Returns

The following output is in the same order as listed below:

The new mapping with all asset names being in assets
The names of the assets to fix from
The names of the assets to fix to

Return type

Tuple[Dict[str, Set[str]], Set[str], Set[str]]

_updateAssetContent(srcAsset: Dict[str, str], newAsset: Dict[str, str]) → Dict[str, str]

Combines the content of 2 assets

Parameters

srcAsset (T) – The content of the asset to be updates
newAsset (T) – The new asset to update into srcAsset

Returns

The updated asset

Return type

T

_updateVersions(assets: Dict[float, Dict[str, T]])

Updates the versioning of the assets

Parameters: assets (T) – The assets for checking the versioning

addMap(assetMap: Dict[str, Set[str]], assets: Optional[Dict[float, Dict[str, Dict[str, str]]]] = None)

Adds a new map to the existing map on how to retrieve the assets

Parameters

assetMap (Dict[str, Set[str]]) – The new adjacency list used to map assets to fix from to assets to fix to
assets (Optional[T]) –
Any new assets that needs to be added/updated to the existing assets to support the given map

Default: None

addMapping(fromAsset: str, toAssets: Set[str], assets: Any)

Adds a new mapping of how to fix the assets

Parameters

fromAsset (str) – The name of the asset to fix from
toAssets (Set[str]) – The names of the assets to fix to
assets (Any) – Any new assets that needs to be added/updated to the existing assets to support the new mapping

clear(flush: bool = True, clearMap: bool = False)

Clears all the assets

Parameters

flush (bool) –
Whether to flush out (reload) any cached data

Default: False
clearMap (bool) –
Whether to clear out the mapping for the assets

Default: False

findClosestVersion(name: str, version: Optional[float] = None, fromCache: bool = True) → float

Finds the closest available game version from ModStrAssets._toAssets for a particular asset

Parameters

name (str) – The name of the asset to search
version (Optional[float]) –
The game version to be searched

If This value is None, then will assume we want the latest version

Default: None
fromCache (bool) –
Whether to use the result from the cache

Default: None

Raises

KeyError – The name for the particular asset is not found

Returns

The latest game version from the assets that corresponds to the desired version

Return type

float

property fixFrom: Set[str]

The names of the assets to fix from using the predefined mods

Getter: Retrieves the names of assets used to fix from
Type: Set[str]

property fixTo: Set[str]

The names of the assets to fix to using the predefined mods

Getter: Retrives the names of assets to fix to
Type: Set[str]

property fromAssets: Dict[str, Tuple[Set[str], str]]

The assets to fix from

The keys are the ids for the asset
The values contains metadata about the assets to fix to where each tuple contains:

# The names of the assets # The type of asset

Getter: Returns the assets needed to be fixed
Type: Dict[str, Tuple[Set[str], str]]

get(assetName: str, assetType: str, version: Optional[float] = None) → str

Retrieves the corresponding id asset from ModStrAssets._toAssets

Parameters

assetName (str) – The name of the assets we want
assetType (str) – The name of the type of asset we want.
version (Optional[float]) –
The game version we want the asset to come from

If This value is None, then will retrieve the asset of the latest version.

Default: None

Raises

KeyError – If the corresponding asset based on the search parameters is not found

Returns

The found asset

Return type

str

loadFromPreset(): Reinitializes to load the predefined mods

property map: Dict[str, Set[str]]

The adjacency list used to map assets to fix from to assets to fix to

Getter: Retrieves the adjacency list
Setter: Sets a new adjacency list
Type: Dict[str, Set[str]]

replace(fromAsset: str, version: Optional[float] = None, toAssets: Optional[Union[str, Set[str]]] = None) → Union[str, None, Dict[str, str]]

Retrieves the corresponding asset to replace ‘fromAsset’

Parameters

fromAsset (str) – The asset to be replaced
version (Optional[float]) –
The game version we want the asset to come from

If This value is None, then will retrieve the asset of the latest version.

Default: None
toAssets (Optional[Union[str, Set[str]]]) – The assets to used for replacement

Returns

The corresponding assets for the fix to replace, if available

The result is a string if the passed in parameter ‘toAssets’ is also a string

Otherwise, the result is a dictionary such that:

The keys are the names of the assets
The values are the corresponding asset ids to replace

Return type

Union[str, Dict[str, str]]

property toAssets: Dict[float, Dict[str, Dict[str, str]]]

The outer key is the game version number for the assets
The first inner key is the name of the assets
The most inner key is the type of asset
The most inner value is the id for the asset

Getter: Returns the new assets that will replace the old assets
Type: Dict[float, Dict[str, Dict[str, str]]]
Type: The assets to fix to

classmethod updateMap(srcMap: Dict[str, Set[str]], newMap: Dict[str, Set[str]]) → Dict[str, Set[str]]

Combines 2 maps together

Parameters

srcMap (Dict[str, Set[str]]) – The map to be updates
newMap (Dict[str, Set[str]]) – The new map to update srcMap

Returns

The updated map

Return type

Dict[str, Set[str]]

updateRepo(srcRepo: Dict[float, Dict[str, Any]], newRepo: Dict[float, Dict[str, Any]]) → Dict[float, Dict[str, Any]]

Updates the values in srcRepo

Parameters

srcRepo (Dict[float, Dict[str, Any]]) – The first repo to be combined
newRepo (Dict[float, Dict[str, Any]]) – The second repo to be combined

Returns

The combined repo

Return type

Dict[float, Dict[str, Any]]

property versions: Dict[str, Version]

The game versions available for the assets

The keys are the names of the assets
The values are versions for the asset

Getter: Returns all the available game versions for the assets
Type: Dict[str, Version]

VGRemap

Attributes

maxIndex
remap

class VGRemap(vgRemap: Dict[int, int])

Class for handling the vertex group remaps for mods

Parameters: vgRemap (Dict[int, int]) – The vertex group remap from one type of mod to another

property maxIndex

The maximum index in the vertex group remap

Getter: Retrieves the max index
Type: int

property remap

The vertex group remap

Getter: Retrieves the remap
Setter: Sets a new remap
Type: Dict[int, int]

VGRemaps

Attributes

fixFrom
fixTo
map
versions

Methods

clsVGRemaps.updateMap
def_addVersion
def_partition
def_updateAssetContent
def_updateVersions
defaddMap
defaddMapping
defclear
deffindClosestVersion
defget
defloadFromPreset
defupdateRepo

class VGRemaps(map: Optional[Dict[str, Set[str]]] = None)

This class inherits from ModAssets

Class to handle Vertex Group Remaps fsor a mod

Parameters

map (Optional[Dict[str, Set[str]]]) –

The adjacency list that maps the assets to fix from to the assets to fix to using the predefined mods

Default: None

_addVersion(fromAsset: str, toAsset: str, version: float)

Adds a new version for a particular asset

Parameters

name (str) – The name of the asset
version (float) – The game version

_partition(map: Dict[str, Set[str]], assets: Dict[float, Dict[str, Any]]) → Tuple[Dict[str, Set[str]], Set[str], Set[str]]

Creates the bipartition for the assets to fix from vs the assets to fix to
Filters the mapping such that all the asset names in the new mapping exist in assets

Parameters

map (Dict[str, Set[str]]) – The desired mapping for the assets for fixing
assets (Dict[float, Dict[str, Any]]) –
The source for all the assets
- The outer key is the game version number for the assets
- The first inner key is the name of the asset
- The second inner key is the type of asset
- The most inner value is the id for the asset (must be unique)

Returns

The following output is in the same order as listed below:

The new mapping with all asset names being in assets
The names of the assets to fix from
The names of the assets to fix to

Return type

Tuple[Dict[str, Set[str]], Set[str], Set[str]]

_updateAssetContent(asset1: Dict[str, VGRemap], asset2: Dict[str, VGRemap]) → T

Combines the content of 2 assets

Parameters

srcAsset (T) – The content of the asset to be updates
newAsset (T) – The new asset to update into srcAsset

Returns

The updated asset

Return type

T

_updateVersions(assets: Dict[float, Dict[str, Dict[str, VGRemap]]])

Updates the versioning of the assets

Parameters: assets (T) – The assets for checking the versioning

addMap(assetMap: Dict[str, Set[str]], assets: Optional[Dict[float, Dict[str, T]]] = None)

Adds a new map to the existing map on how to retrieve the assets

Parameters

assetMap (Dict[str, Set[str]]) – The new adjacency list used to map assets to fix from to assets to fix to
assets (Optional[T]) –
Any new assets that needs to be added/updated to the existing assets to support the given map

Default: None

addMapping(fromAsset: str, toAssets: Set[str], assets: Any)

Adds a new mapping of how to fix the assets

Parameters

fromAsset (str) – The name of the asset to fix from
toAssets (Set[str]) – The names of the assets to fix to
assets (Any) – Any new assets that needs to be added/updated to the existing assets to support the new mapping

clear(flush: bool = True, clearMap: bool = False)

Clears all the assets

Parameters

flush (bool) –
Whether to flush out (reload) any cached data

Default: False
clearMap (bool) –
Whether to clear out the mapping for the assets

Default: False

findClosestVersion(fromAsset: str, toAsset: str, version: Optional[float] = None, fromCache: bool = True) → float

Finds the closest available game version from ModStrAssets._toAssets for a particular asset

Parameters

fromAsset (str) – The name of the asset to map from
toAsset (str) – The name of the asset to map to
version (Optional[float]) –
The game version to be searched

If This value is None, then will assume we want the latest version

Default: None
fromCache (bool) –
Whether to use the result from the cache

Default: None

Raises

KeyError – The name for the particular asset is not found

Returns

The latest game version from the assets that corresponds to the desired version

Return type

float

property fixFrom: Set[str]

The names of the assets to fix from using the predefined mods

Getter: Retrieves the names of assets used to fix from
Type: Set[str]

property fixTo: Set[str]

The names of the assets to fix to using the predefined mods

Getter: Retrives the names of assets to fix to
Type: Set[str]

get(fromAsset: str, toAsset: str, version: Optional[float] = None) → str

Retrieves the corresponding vertex group remap

Parameters

fromAsset (str) – The name of the asset to map from
toAsset (str) – The name of the asset to map to
version (Optional[float]) –
The game version we want the remap to come from

If This value is None, then will retrieve the asset of the latest version.

Default: None

Raises

KeyError – If the corresponding asset based on the search parameters is not found

Returns

The found asset

Return type

str

loadFromPreset(): Reinitializes to load the predefined mods

property map: Dict[str, Set[str]]

The adjacency list used to map assets to fix from to assets to fix to

Getter: Retrieves the adjacency list
Setter: Sets a new adjacency list
Type: Dict[str, Set[str]]

classmethod updateMap(srcMap: Dict[str, Set[str]], newMap: Dict[str, Set[str]]) → Dict[str, Set[str]]

Combines 2 maps together

Parameters

srcMap (Dict[str, Set[str]]) – The map to be updates
newMap (Dict[str, Set[str]]) – The new map to update srcMap

Returns

The updated map

Return type

Dict[str, Set[str]]

updateRepo(srcRepo: Dict[float, Dict[str, Any]], newRepo: Dict[float, Dict[str, Any]]) → Dict[float, Dict[str, Any]]

Updates the values in srcRepo

Parameters

srcRepo (Dict[float, Dict[str, Any]]) – The first repo to be combined
newRepo (Dict[float, Dict[str, Any]]) – The second repo to be combined

Returns

The combined repo

Return type

Dict[float, Dict[str, Any]]

property versions: Dict[str, Version]

The game versions available for the assets

The outer keys are the names of the assets to map from
The inner keys are the names of the assets to map to
The inner values are versions for the assets

Getter: Returns all the available game versions for the assets
Type: Dict[str, Dict[str, Version]]

Hashes

Attributes

fixFrom
fixTo
fromAssets
map
toAssets
versions

Methods

clsHashes._getFromAssets
clsHashes.updateMap
def_addVersion
def_getToAssets
def_partition
def_updateAssetContent
def_updateVersions
defaddMap
defaddMapping
defclear
deffindClosestVersion
defget
defloadFromPreset
defreplace
defupdateRepo

class Hashes(map: Optional[Dict[str, Set[str]]] = None)

This class inherits from ModDictStrAssets

Class for managing hashes for a mod

Parameters

map (Optional[Dict[str, Set[str]]]) –

The adjacency list that maps the hashes to fix from to the hashes to fix to using the predefined mods

Default: None

_addVersion(name: str, version: float)

Adds a new version for a particular asset

Parameters

name (str) – The name of the asset
version (float) – The game version

classmethod _getFromAssets(map: Dict[str, Set[str]], assets: Dict[float, Dict[str, Dict[str, str]]]) → Dict[str, Tuple[Set[str], str]]

Retrieves the assets to fix from

Parameters

map (Dict[str, Set[str]]) – The mapping for fixing the assets
assets (Dict[float, Dict[str, Dict[str, str]]]) –
The source for all the assets
- The outer key is the game version number for the assets
- The first inner key is the name of the asset
- The second inner key is the type of asset
- The most inner value is the id for the asset (must be unique)

Returns

The assets to fix from

The keys are the ids for the asset
The values contains metadata about the assets to fix to where each tuple contains:

# The names of the assets # The type of asset

Return type

Dict[str, Tuple[Set[str], str]]

_getToAssets(assetNames: Set[str], assets: Dict[float, Dict[str, Dict[str, str]]]) → Dict[float, Dict[str, Dict[str, str]]]

Retrieves the assets to fix to

Parameters

assetNames (Set[str]) – The names of the assets to fix to
assets (Dict[float, Dict[str, Dict[str, str]]]) –
The source for all the assets
- The outer key is the game version number for the assets
- The first inner key is the name of the asset
- The second inner key is the type of asset
- The most inner value is the id for the asset (must be unique)

Returns

The assets to fix to

The outer key is the game version number for the assets
The first inner key is the name of the asset
The second inner key is the type of asset
The most inner value is the id for the asset (must be unique)

Return type

Dict[float, Dict[str, Dict[str, str]]]

_partition(map: Dict[str, Set[str]], assets: Dict[float, Dict[str, Any]]) → Tuple[Dict[str, Set[str]], Set[str], Set[str]]

Creates the bipartition for the assets to fix from vs the assets to fix to
Filters the mapping such that all the asset names in the new mapping exist in assets

Parameters

map (Dict[str, Set[str]]) – The desired mapping for the assets for fixing
assets (Dict[float, Dict[str, Any]]) –
The source for all the assets
- The outer key is the game version number for the assets
- The first inner key is the name of the asset
- The second inner key is the type of asset
- The most inner value is the id for the asset (must be unique)

Returns

The following output is in the same order as listed below:

The new mapping with all asset names being in assets
The names of the assets to fix from
The names of the assets to fix to

Return type

Tuple[Dict[str, Set[str]], Set[str], Set[str]]

_updateAssetContent(srcAsset: Dict[str, str], newAsset: Dict[str, str]) → Dict[str, str]

Combines the content of 2 assets

Parameters

srcAsset (T) – The content of the asset to be updates
newAsset (T) – The new asset to update into srcAsset

Returns

The updated asset

Return type

T

_updateVersions(assets: Dict[float, Dict[str, T]])

Updates the versioning of the assets

Parameters: assets (T) – The assets for checking the versioning

addMap(assetMap: Dict[str, Set[str]], assets: Optional[Dict[float, Dict[str, Dict[str, str]]]] = None)

Adds a new map to the existing map on how to retrieve the assets

Parameters

assetMap (Dict[str, Set[str]]) – The new adjacency list used to map assets to fix from to assets to fix to
assets (Optional[T]) –
Any new assets that needs to be added/updated to the existing assets to support the given map

Default: None

addMapping(fromAsset: str, toAssets: Set[str], assets: Any)

Adds a new mapping of how to fix the assets

Parameters

fromAsset (str) – The name of the asset to fix from
toAssets (Set[str]) – The names of the assets to fix to
assets (Any) – Any new assets that needs to be added/updated to the existing assets to support the new mapping

clear(flush: bool = True, clearMap: bool = False)

Clears all the assets

Parameters

flush (bool) –
Whether to flush out (reload) any cached data

Default: False
clearMap (bool) –
Whether to clear out the mapping for the assets

Default: False

findClosestVersion(name: str, version: Optional[float] = None, fromCache: bool = True) → float

Finds the closest available game version from ModStrAssets._toAssets for a particular asset

Parameters

name (str) – The name of the asset to search
version (Optional[float]) –
The game version to be searched

If This value is None, then will assume we want the latest version

Default: None
fromCache (bool) –
Whether to use the result from the cache

Default: None

Raises

KeyError – The name for the particular asset is not found

Returns

The latest game version from the assets that corresponds to the desired version

Return type

float

property fixFrom: Set[str]

The names of the assets to fix from using the predefined mods

Getter: Retrieves the names of assets used to fix from
Type: Set[str]

property fixTo: Set[str]

The names of the assets to fix to using the predefined mods

Getter: Retrives the names of assets to fix to
Type: Set[str]

property fromAssets: Dict[str, Tuple[Set[str], str]]

The assets to fix from

The keys are the ids for the asset
The values contains metadata about the assets to fix to where each tuple contains:

# The names of the assets # The type of asset

Getter: Returns the assets needed to be fixed
Type: Dict[str, Tuple[Set[str], str]]

get(assetName: str, assetType: str, version: Optional[float] = None) → str

Retrieves the corresponding id asset from ModStrAssets._toAssets

Parameters

assetName (str) – The name of the assets we want
assetType (str) – The name of the type of asset we want.
version (Optional[float]) –
The game version we want the asset to come from

If This value is None, then will retrieve the asset of the latest version.

Default: None

Raises

KeyError – If the corresponding asset based on the search parameters is not found

Returns

The found asset

Return type

str

loadFromPreset(): Reinitializes to load the predefined mods

property map: Dict[str, Set[str]]

The adjacency list used to map assets to fix from to assets to fix to

Getter: Retrieves the adjacency list
Setter: Sets a new adjacency list
Type: Dict[str, Set[str]]

replace(fromAsset: str, version: Optional[float] = None, toAssets: Optional[Union[str, Set[str]]] = None) → Union[str, None, Dict[str, str]]

Retrieves the corresponding asset to replace ‘fromAsset’

Parameters

fromAsset (str) – The asset to be replaced
version (Optional[float]) –
The game version we want the asset to come from

If This value is None, then will retrieve the asset of the latest version.

Default: None
toAssets (Optional[Union[str, Set[str]]]) – The assets to used for replacement

Returns

The corresponding assets for the fix to replace, if available

The result is a string if the passed in parameter ‘toAssets’ is also a string

Otherwise, the result is a dictionary such that:

The keys are the names of the assets
The values are the corresponding asset ids to replace

Return type

Union[str, Dict[str, str]]

property toAssets: Dict[float, Dict[str, Dict[str, str]]]

The outer key is the game version number for the assets
The first inner key is the name of the assets
The most inner key is the type of asset
The most inner value is the id for the asset

Getter: Returns the new assets that will replace the old assets
Type: Dict[float, Dict[str, Dict[str, str]]]
Type: The assets to fix to

classmethod updateMap(srcMap: Dict[str, Set[str]], newMap: Dict[str, Set[str]]) → Dict[str, Set[str]]

Combines 2 maps together

Parameters

srcMap (Dict[str, Set[str]]) – The map to be updates
newMap (Dict[str, Set[str]]) – The new map to update srcMap

Returns

The updated map

Return type

Dict[str, Set[str]]

updateRepo(srcRepo: Dict[float, Dict[str, Any]], newRepo: Dict[float, Dict[str, Any]]) → Dict[float, Dict[str, Any]]

Updates the values in srcRepo

Parameters

srcRepo (Dict[float, Dict[str, Any]]) – The first repo to be combined
newRepo (Dict[float, Dict[str, Any]]) – The second repo to be combined

Returns

The combined repo

Return type

Dict[float, Dict[str, Any]]

property versions: Dict[str, Version]

The game versions available for the assets

The keys are the names of the assets
The values are versions for the asset

Getter: Returns all the available game versions for the assets
Type: Dict[str, Version]

Indices

Attributes

fixFrom
fixTo
fromAssets
map
toAssets
versions

Methods

clsIndices._getFromAssets
clsIndices.updateMap
def_addVersion
def_getToAssets
def_partition
def_updateAssetContent
def_updateVersions
defaddMap
defaddMapping
defclear
deffindClosestVersion
defget
defloadFromPreset
defreplace
defupdateRepo

class Indices(map: Optional[Dict[str, Set[str]]] = None)

This class inherits from ModDictStrAssets

Class for managing indices for a mod

Parameters

map (Optional[Dict[str, Set[str]]]) –

The adjacency list that maps the indices to fix from to the indices to fix to using the predefined mods

Default: None

_addVersion(name: str, version: float)

Adds a new version for a particular asset

Parameters

name (str) – The name of the asset
version (float) – The game version

classmethod _getFromAssets(map: Dict[str, Set[str]], assets: Dict[float, Dict[str, Dict[str, str]]]) → Dict[str, Tuple[Set[str], str]]

Retrieves the assets to fix from

Parameters

map (Dict[str, Set[str]]) – The mapping for fixing the assets
assets (Dict[float, Dict[str, Dict[str, str]]]) –
The source for all the assets
- The outer key is the game version number for the assets
- The first inner key is the name of the asset
- The second inner key is the type of asset
- The most inner value is the id for the asset (must be unique)

Returns

The assets to fix from

The keys are the ids for the asset
The values contains metadata about the assets to fix to where each tuple contains:

# The names of the assets # The type of asset

Return type

Dict[str, Tuple[Set[str], str]]

_getToAssets(assetNames: Set[str], assets: Dict[float, Dict[str, Dict[str, str]]]) → Dict[float, Dict[str, Dict[str, str]]]

Retrieves the assets to fix to

Parameters

assetNames (Set[str]) – The names of the assets to fix to
assets (Dict[float, Dict[str, Dict[str, str]]]) –
The source for all the assets
- The outer key is the game version number for the assets
- The first inner key is the name of the asset
- The second inner key is the type of asset
- The most inner value is the id for the asset (must be unique)

Returns

The assets to fix to

The outer key is the game version number for the assets
The first inner key is the name of the asset
The second inner key is the type of asset
The most inner value is the id for the asset (must be unique)

Return type

Dict[float, Dict[str, Dict[str, str]]]

_partition(map: Dict[str, Set[str]], assets: Dict[float, Dict[str, Any]]) → Tuple[Dict[str, Set[str]], Set[str], Set[str]]

Creates the bipartition for the assets to fix from vs the assets to fix to
Filters the mapping such that all the asset names in the new mapping exist in assets

Parameters

map (Dict[str, Set[str]]) – The desired mapping for the assets for fixing
assets (Dict[float, Dict[str, Any]]) –
The source for all the assets
- The outer key is the game version number for the assets
- The first inner key is the name of the asset
- The second inner key is the type of asset
- The most inner value is the id for the asset (must be unique)

Returns

The following output is in the same order as listed below:

The new mapping with all asset names being in assets
The names of the assets to fix from
The names of the assets to fix to

Return type

Tuple[Dict[str, Set[str]], Set[str], Set[str]]

_updateAssetContent(srcAsset: Dict[str, str], newAsset: Dict[str, str]) → Dict[str, str]

Combines the content of 2 assets

Parameters

srcAsset (T) – The content of the asset to be updates
newAsset (T) – The new asset to update into srcAsset

Returns

The updated asset

Return type

T

_updateVersions(assets: Dict[float, Dict[str, T]])

Updates the versioning of the assets

Parameters: assets (T) – The assets for checking the versioning

addMap(assetMap: Dict[str, Set[str]], assets: Optional[Dict[float, Dict[str, Dict[str, str]]]] = None)

Adds a new map to the existing map on how to retrieve the assets

Parameters

assetMap (Dict[str, Set[str]]) – The new adjacency list used to map assets to fix from to assets to fix to
assets (Optional[T]) –
Any new assets that needs to be added/updated to the existing assets to support the given map

Default: None

addMapping(fromAsset: str, toAssets: Set[str], assets: Any)

Adds a new mapping of how to fix the assets

Parameters

fromAsset (str) – The name of the asset to fix from
toAssets (Set[str]) – The names of the assets to fix to
assets (Any) – Any new assets that needs to be added/updated to the existing assets to support the new mapping

clear(flush: bool = True, clearMap: bool = False)

Clears all the assets

Parameters

flush (bool) –
Whether to flush out (reload) any cached data

Default: False
clearMap (bool) –
Whether to clear out the mapping for the assets

Default: False

findClosestVersion(name: str, version: Optional[float] = None, fromCache: bool = True) → float

Finds the closest available game version from ModStrAssets._toAssets for a particular asset

Parameters

name (str) – The name of the asset to search
version (Optional[float]) –
The game version to be searched

If This value is None, then will assume we want the latest version

Default: None
fromCache (bool) –
Whether to use the result from the cache

Default: None

Raises

KeyError – The name for the particular asset is not found

Returns

The latest game version from the assets that corresponds to the desired version

Return type

float

property fixFrom: Set[str]

The names of the assets to fix from using the predefined mods

Getter: Retrieves the names of assets used to fix from
Type: Set[str]

property fixTo: Set[str]

The names of the assets to fix to using the predefined mods

Getter: Retrives the names of assets to fix to
Type: Set[str]

property fromAssets: Dict[str, Tuple[Set[str], str]]

The assets to fix from

The keys are the ids for the asset
The values contains metadata about the assets to fix to where each tuple contains:

# The names of the assets # The type of asset

Getter: Returns the assets needed to be fixed
Type: Dict[str, Tuple[Set[str], str]]

get(assetName: str, assetType: str, version: Optional[float] = None) → str

Retrieves the corresponding id asset from ModStrAssets._toAssets

Parameters

assetName (str) – The name of the assets we want
assetType (str) – The name of the type of asset we want.
version (Optional[float]) –
The game version we want the asset to come from

If This value is None, then will retrieve the asset of the latest version.

Default: None

Raises

KeyError – If the corresponding asset based on the search parameters is not found

Returns

The found asset

Return type

str

loadFromPreset(): Reinitializes to load the predefined mods

property map: Dict[str, Set[str]]

The adjacency list used to map assets to fix from to assets to fix to

Getter: Retrieves the adjacency list
Setter: Sets a new adjacency list
Type: Dict[str, Set[str]]

replace(fromAsset: str, version: Optional[float] = None, toAssets: Optional[Union[str, Set[str]]] = None) → Union[str, None, Dict[str, str]]

Retrieves the corresponding asset to replace ‘fromAsset’

Parameters

fromAsset (str) – The asset to be replaced
version (Optional[float]) –
The game version we want the asset to come from

If This value is None, then will retrieve the asset of the latest version.

Default: None
toAssets (Optional[Union[str, Set[str]]]) – The assets to used for replacement

Returns

The corresponding assets for the fix to replace, if available

The result is a string if the passed in parameter ‘toAssets’ is also a string

Otherwise, the result is a dictionary such that:

The keys are the names of the assets
The values are the corresponding asset ids to replace

Return type

Union[str, Dict[str, str]]

property toAssets: Dict[float, Dict[str, Dict[str, str]]]

The outer key is the game version number for the assets
The first inner key is the name of the assets
The most inner key is the type of asset
The most inner value is the id for the asset

Getter: Returns the new assets that will replace the old assets
Type: Dict[float, Dict[str, Dict[str, str]]]
Type: The assets to fix to

classmethod updateMap(srcMap: Dict[str, Set[str]], newMap: Dict[str, Set[str]]) → Dict[str, Set[str]]

Combines 2 maps together

Parameters

srcMap (Dict[str, Set[str]]) – The map to be updates
newMap (Dict[str, Set[str]]) – The new map to update srcMap

Returns

The updated map

Return type

Dict[str, Set[str]]

updateRepo(srcRepo: Dict[float, Dict[str, Any]], newRepo: Dict[float, Dict[str, Any]]) → Dict[float, Dict[str, Any]]

Updates the values in srcRepo

Parameters

srcRepo (Dict[float, Dict[str, Any]]) – The first repo to be combined
newRepo (Dict[float, Dict[str, Any]]) – The second repo to be combined

Returns

The combined repo

Return type

Dict[float, Dict[str, Any]]

property versions: Dict[str, Version]

The game versions available for the assets

The keys are the names of the assets
The values are versions for the asset

Getter: Returns all the available game versions for the assets
Type: Dict[str, Version]

Mod Files

IniFile

Attributes

_parser
_resourceBlends
_textureOverrideBlendRoot
availableType
defaultModType
file
fileLines
fileLinesRead
filePath
fileTxt
folder
isFixed
isModIni
modTypes
modsToFix
remapBlendModels
sectionIfTemplates
type
version

Methods

clsIniFile.compareResources
clsIniFile.getBlendResources
clsIniFile.getFixedBlendFile
clsIniFile.getMergedResourceIndex
clsIniFile.getRemapBlendName
clsIniFile.getRemapFixName
clsIniFile.getRemapResourceName
clsIniFile.getResourceName
clsIniFile.removeResourceName
def_checkFixed
def_checkModType
def_createIfTemplate
def_getCommandIfTemplate
def_getCommands
def_getFixer
def_getIfTemplateHash
def_getIfTemplateMatchFirstIndex
def_getIfTemplateResourceName
def_getIfTemplateSubCommand
def_getParser
def_getRemover
def_isIfTemplateDraw
def_isIfTemplateHash
def_isIfTemplateMatchFirstIndex
def_isIfTemplateResource
def_isIfTemplateSubCommand
def_parseSection
def_processIfTemplate
def_readLines
def_removeFix
def_removeSection
def_setToFix
def_setupIfTemplateAtts
defaddFixBoilerPlate
defcheckIsMod
defclear
defclearRead
defdisIni
deffillIfTemplate
deffix
deffixBoilerPlate
defgetFixCredit
defgetFixFooter
defgetFixHeader
defgetFixModTypeHeadingname
defgetFixModTypeName
defgetFixStr
defgetHeadingName
defgetIfTemplates
defmakeRemapModel
defparse
defread
defreadFileLines
defreadIfTemplates
defremoveSectionOptions
defwrite

class IniFile(file: Optional[str] = None, logger: Optional[Logger] = None, txt: str = '', modTypes: Optional[Set[ModType]] = None, defaultModType: Optional[ModType] = None, version: Optional[float] = None, modsToFix: Optional[Set[str]] = None)

This class inherits from Model

Class for handling .ini files

Note

We analyse the .ini file using Regex which is NOT the right way to do things since the modified .ini language that GIMI interprets is a CFG (context free grammer) and NOT a regular language.

But since we are lazy and don’t want make our own compiler with tokenizers, parsing algorithms (eg. SLR(1)), type checking, etc… this module should handle regular cases of .ini files generated using existing scripts (assuming the user does not do anything funny…)

Parameters

file (Optional[str]) –
The file path to the .ini file

Default: None
logger (Optional[Logger]) – The logger to print messages if necessary
txt (str) –
Used as the text content of the .ini file if IniFile.file is set to None

Default: “”
modTypes (Optional[Set[ModType]]) –
The types of mods that the .ini file should belong to

Default: None
modsToFix (Optional[Set[str]]) –
The names of the mods we want to fix to

Default: None
defaultModType (Optional[ModType]) –
The type of mod to use if the .ini file has an unidentified mod type

If this value is None, then will skip the .ini file with an unidentified mod type

Default: None
version (Optional[float]) –
The game version we want the .ini file to be compatible with

If This value is None, then will retrieve the hashes/indices of the latest version.

Default: None

version

The game version we want the .ini file to be compatible with

If This value is None, then will retrieve the hashes/indices of the latest version.

Type: Optional[float]

_parser

Parser used to parse very basic cases in a .ini file

Type: ConfigParser

modTypes

The types of mods that the .ini file should belong to

Type: Set[ModType]

modsToFix

The names of the mods that we want to fix to

Type: Set[str]

defaultModType

The type of mod to use if the .ini file has an unidentified mod type

Type: Optional[ModType]

_textureOverrideBlendRoot

The name for the section containing the keywords: [.*TextureOverride.*Blend.*]

Type: Optional[str]

sectionIfTemplates

All the sections in the .ini file that can be parsed into an IfTemplate

For more info see IfTemplate

Attention

The modified .ini language that GIMI uses introduces keywords that can be used before the key of a key-value pair

eg. defining constants

[Constants]
global persist $swapvar = 0
global persist $swapscarf = 0
global $active
global $creditinfo = 0

Sections containing this type of pattern will not be parsed. But generally, these sections are irrelevant to fixing the Raiden Boss

Type: Dict[str, IfTemplate]

_resourceBlends

Sections that are linked to 1 or more Blend.buf files.

The keys are the name of the sections.

Type: Dict[str, IfTemplate]

remapBlendModels

The data for the [Resource.*RemapBlend.*] sections used in the fix

The keys are the original names of the resource with the pattern [Resource.*Blend.*]

Type: Dict[str, RemapBlendModel]

_checkFixed(line: str)

Checks if a line of text matches the regex, [.*TextureOverride.*RemapBlend.*] ,to identify whether the .ini file has been fixed

Parameters: line (str) – The line of text to check

_checkModType(line: str)

Checks if a line of text contains the keywords to identify whether the .ini file belongs to the types of mods in IniFile.modTypes

If IniFile.modTypes is not empty, then will find the first ModType that where the line makes ModType.isType() return True
Otherwise, will see if the line matches with the regex, [.*TextureOverride.*Blend.*]

Parameters: line (str) – The text to check

_createIfTemplate(ifTemplateParts: List[Union[str, Dict[str, Any]]], name: str = '') → IfTemplate

Creates an IfTemplate

Parameters

ifTemplateParts (List[Union[str, Dict[str, Any]]]) – The parts in the IfTemplate
name (str) – The name of the section for the IfTemplate

Returns

The created IfTemplate based off the imaginary

Return type

IfTemplate

_getCommandIfTemplate(sectionName: str, raiseException: bool = True) → Optional[IfTemplate]

Retrieves the IfTemplate for a certain section from IniFile._sectionIfTemplate

Parameters

sectionName (str) – The name of the section
raiseException (bool) – Whether to raise an exception when the section’s IfTemplate is not found

Raises

KeyError – If the IfTemplate for the section is not found and raiseException is set to True

Returns

The corresponding IfTemplate for the section

Return type

Optional[IfTemplate]

_getCommands(sectionName: str, subCommands: Set[str], subCommandLst: List[str])

Low level function for retrieving all the commands/sections that are called from a certain section in the .ini file

Parameters

sectionName (str) – The name of the section we are starting from
subCommands (Set[str]) – The result for all of the sections that were called
subCommandLst (List[str]) – The result for all of the sections that were called while maintaining the order the sections are called in the call stack

Raises

KeyError – If the IfTemplate is not found for some section

_getFixer()

Retrieves the fixer for fixing the .ini file

Returns: The resultant fixer
Return type: Optional[BaseIniFixer]

_getIfTemplateHash(ifTemplatePart: Dict[str, Any]) → Any

Retrieves the value from the key, ‘hash’, for some part of a section

Parameters: ifTemplatePart (Dict[str, Any]) – The key-value pairs for some part in a section
Returns: The corresponding value for the key ‘hash’
Return type: Any

_getIfTemplateMatchFirstIndex(ifTemplatePart: Dict[str, Any]) → Any

Retrieves the value from the key, ‘match_first_index’, for some part of a section

Parameters: ifTemplatePart (Dict[str, Any]) – The key-value pairs for some part in a section
Returns: The corresponding value for the key ‘match_first_index’
Return type: Any

_getIfTemplateResourceName(ifTemplatePart: Dict[str, Any]) → Any

Retrieves the value from the key, ‘vb1’, for some part of a section

Parameters: ifTemplatePart (Dict[str, Any]) – The key-value pairs for some part in a section
Returns: The corresponding value for the key ‘vb1’
Return type: Any

_getIfTemplateSubCommand(ifTemplatePart: Dict[str, Any]) → Any

Retrieves the value from the key, ‘run’, for some part of a section

Parameters: ifTemplatePart (Dict[str, Any]) – The key-value pairs for some part in a section
Returns: The corresponding value for the key ‘run’
Return type: Any

_getParser() → Optional[BaseIniParser]

Retrieves the parser for parsing the .ini file

Returns: The resultant parser
Return type: Optional[BaseIniParser]

_getRemover() → BaseIniRemover

Retrieves the remover for removing fixes from the .ini file

Returns: The resultant parser
Return type: BaseIniRemover

_isIfTemplateDraw(ifTemplatePart: Dict[str, Any]) → bool

Whether the content for some part of a section contains the key ‘draw’

Parameters: ifTemplatePart (Dict[str, Any]) – The key-value pairs for some part in a section
Returns: Whether ‘draw’ is contained in the part
Return type: bool

_isIfTemplateHash(ifTemplatePart: Dict[str, Any]) → bool

Whether the content for some part of a section contains the key ‘hash’

Parameters: ifTemplatePart (Dict[str, Any]) – The key-value pairs for some part in a section
Returns: Whether ‘hash’ is contained in the part
Return type: bool

_isIfTemplateMatchFirstIndex(ifTemplatePart: Dict[str, Any]) → bool

Whether the content for some part of a section contains the key ‘match_first_index’

Parameters: ifTemplatePart (Dict[str, Any]) – The key-value pairs for some part in a section
Returns: Whether ‘match_first_index’ is contained in the part
Return type: bool

_isIfTemplateResource(ifTemplatePart: Dict[str, Any]) → bool

Whether the content for some part of a section contains the key ‘vb1’

Parameters: ifTemplatePart (Dict[str, Any]) – The key-value pairs for some part in a section
Returns: Whether ‘vb1’ is contained in the part
Return type: bool

_isIfTemplateSubCommand(ifTemplatePart: Dict[str, Any]) → bool

Whether the content for some part of a section contains the key ‘run’

Parameters: ifTemplatePart (Dict[str, Any]) – The key-value pairs for some part in a section
Returns: Whether ‘run’ is contained in the part
Return type: bool

_parseSection(sectionName: str, srcTxt: str, save: Optional[Dict[str, Any]] = None) → Optional[Dict[str, str]]

Regularly parses the key-value pairs of a certain section

The function parses uses ConfigParser to parse the section.

Parameters

sectionName (str) – The name of the section
srcTxt (str) – The text containing the entire section
save (Optional[Dict[str, Any]]) –
Place to save the parsed result for the section

The result for the parsed section will be saved as a value in the dictionary while section’s name will be used in the key for the dictionary

Default: None

Returns

The result from parsing the section

Note

If ConfigParser is unable to parse the section, then None is returned

Return type

Optional[Dict[str, str]]

_processIfTemplate(startInd: int, endInd: int, fileLines: List[str], sectionName: str, srcTxt: str) → IfTemplate

Parses a section in the .ini file as an IfTemplate

Note

See IfTemplate to see how we define an ‘IfTemplate’

Parameters

startInd (int) – The starting line index of the section
endInd (int) – The ending line index of the section
fileLines (List[str]) – All the file lines read from the .ini file
sectionName (str) – The name of the section
srcTxt (str) – The text content of the section

Returns

The generated IfTemplate from the section

Return type

IfTemplate

_readLines()

Decorator to read all the lines in the .ini file first before running a certain function

All the file lines will be saved in IniFile._fileLines

Examples

@_readLines
def printLines(self):
    for line in self._fileLines:
        print(f"LINE: {line}")

_removeFix(parse: bool = False) → str

Removes any previous changes that were probably made by this script

For the .ini file will remove:

All code surrounded by the ‘—…— . Fix —…—-’* header/footer
All sections containing the keywords RemapBlend

Parameters

parse (bool) –

Whether to keep track of the Blend.buf files that also need to be removed

Default: False

Returns

The new text content of the .ini file with the changes removed

Return type

str

_removeSection(startInd: int, endInd: int, fileLines: List[str], sectionName: str, srcTxt: str) → Tuple[int, int]

Retrieves the starting line index and ending line index of where to remove a certain section from the read lines of the .ini file

Parameters

startInd (int) – The starting line index of the section
endInd (int) – The ending line index of the section
fileLines (List[str]) – All the file lines read from the .ini file
sectionName (str) – The name of the section
srcTxt (str) – The text content of the section

Returns

The starting line index and the ending line index of the section to remove

Return type

Tuple[int, int]

_setToFix() → Set[str]

Sets the names for the types of mods that will used in the fix

Returns: The names of the mods that will be used in the fix
Return type: Set[str]

_setupIfTemplateAtts(ifTemplate: IfTemplate, partIndex: int, part: Union[str, Dict[str, Any]])

Setup the attributes for the IfTemplate

Parameters

ifTemplate (IfTemplate) – The IfTemplate we are working with
partIndex (int) – The index for the part of the IfTemplate we are working with
part (Union[str, Dict[str, Any]]) – The part of the IfTemplate we are working with

addFixBoilerPlate(fix: str = '') → str

Adds the boilerplate code to identify the .ini sections have been changed by this fix

Parameters

fix (str) –

The content for the fix

Default: ""

Returns

The fix with the boilerplate code included

Return type

str

property availableType: Optional[ModType]

Retrieves the type of mod identified for this .ini file

Note

This function is the same as IniFile.type(), but will return IniFile.defaultModType if IniFile.type() is None

Returns: The type of mod identified
Return type: Optional[ModType]

checkIsMod() → bool

Reads the entire .ini file and checks whether the .ini file belongs to a mod

Note

If the .ini file has already been parsed (eg. calling IniFile.checkModType() or IniFile.parse()), then

you only need to read IniFile.isModIni()

Returns: Whether the .ini file is a .ini file that belongs to some mod
Return type: bool

clear(eraseSourceTxt: bool = False)

Clears all the saved data for the .ini file

Note

Please see the note at IniFile.clearRead()

Parameters

eraseSourceTxt (bool) –

Whether to erase the only data source for this class if IniFile.file is set to None, see the note at IniFile.clearRead() for more info

Default: False

clearRead(eraseSourceTxt: bool = False)

Clears the saved text read in from the .ini file

Note

If IniFile.file is set to None, then the default run of this function with the argument eraseSourceTxt set to False will have no effect since the provided text from IniFile._fileTxt is the only source of data for the IniFile

If you also want to clear the above source text data, then run this function with the eraseSourceTxt argument set to True

Parameters

eraseSourceTxt (bool) –

Whether to erase the only data source for this class if IniFile.file is set to None, see the note above for more info

Default: False

classmethod compareResources(resourceTuple1: Tuple[str, Optional[int]], resourceTuple2: Tuple[str, Optional[int]]) → int

Compare function used for sorting resources

The order for sorting is the resources is:

Resources that do are not suffixed by an index number
Resource that are suffixed by an index number (see IniFile.getMergedResourceIndex() for more info)

Parameters

resourceTuple1 (Tuple[str, Optional[int]]) –
Data for the first resource in the compare function, contains:
- Name of the resource
- The index for the resource
resourceTuple2 (Tuple[str, Optional[int]]) –
Data for the second resource in the compare function, contains:
- Name of the resource
- The index for the resource

Returns

The result for a typical compare function used in sorting

returns -1 if resourceTuple1 should come before resourceTuple2
returns 1 if resourceTuple1 should come after resourceTuple2
returns 0 if resourceTuple1 is equal to resourceTuple2

Return type

int

disIni(makeCopy: bool = False)

Disables the .ini file

Note

For more info, see FileService.disableFile()

Parameters

makeCopy (bool) –

Whether to make a copy of the disabled .ini file

Default: False

property file: Optional[str]

The file path to the .ini file

Getter: Returns the path to the file
Setter: Sets the new path for the file
Type: Optional[str]

property fileLines: List[str]

The text lines of the .ini file

Note

For the setter, each line must end with a newline character (same behaviour as readLines)

Getter: Returns the text lines of the .ini file
Setter: Reads the new value for both the text lines of the .ini file and the text content of the .ini file
Type: List[str]

property fileLinesRead: bool

Whether the .ini file has been read

Getter: Determines whether the .ini file has been read
Type: bool

property filePath: Optional[FilePath]

The path to the .ini file

Getter: Returns the path to the file
Type: Optional[FilePath]

property fileTxt: str

The text content of the .ini file

Getter: Returns the content of the .ini file
Setter: Reads the new value for both the text content of the .ini file and the text lines of the .ini file
Type: str

fillIfTemplate(modName: str, sectionName: str, ifTemplate: IfTemplate, fillFunc: Callable[[str, str, Union[str, Dict[str, Any]], int, int, str], str], origSectionName: Optional[str] = None) → str

Creates a new IfTemplate for an existing section in the .ini file

Parameters

modName (str) – The name for the type of mod to fix to
sectionName (str) – The new name of the section
ifTemplate (IfTemplate) – The IfTemplate of the orginal section
fillFunc (Callable[[str, str, Union[str, Dict[str, Any], int, str, str], str]]) –
The function to create a new content part for the new IfTemplate

Tip

For more info about an ‘IfTemplate’, see IfTemplate

The parameter order for the function is:
1. The name for the type of mod to fix to
2. The new section name
3. The corresponding content part in the original IfTemplate
4. The index for the content part in the original IfTemplate
5. The string to prefix every line in the content part of the IfTemplate
6. The original name of the section
origSectionName (Optional[str]) –
The original name of the section.

If this argument is set to None, then will assume this argument has the same value as the argument for sectionName

Default: None

Returns

The text for the newly created IfTemplate

Return type

str

fix(keepBackup: bool = True, fixOnly: bool = False, update: bool = False) → Union[str, List[str]]

Fixes the .ini file

Parameters

keepBackup (bool) –
Whether we want to make a backup copy of the .ini file

Default: True
fixOnly (bool) –
Whether we are only fixing the .ini file without removing any previous changes

Default: False
update (bool) –
Whether to also update the source text of this classs with the fix

Default: False

Returns

The new content of the .ini file which includes the fix and the new content of any other newly created .ini files related to fixing the particular .ini file

Return type

Union[str, List[str]]

fixBoilerPlate()

Decorator used to add the boilerplate code to identify a code section has been changed by this fix in the .ini file

Examples

@fixBoilerPlate
def helloWorld(self) -> str:
    return "Hello World"

property folder: str

The folder where this .ini file resides

If IniFile.file is set to None, then will return the folder where this script is ran

Getter: Retrieves the folder
Type: str

classmethod getBlendResources(blendResources: Set[str], blendCommandsGraph: IniSectionGraph, isIfTemplateResource: Callable[[Dict[str, Any]], bool], getIfTemplateResource: Callable[[Dict[str, Any]], bool])

Retrieves all the referenced resources that were called by sections related to the [TextureOverride.*Blend.*] sections

Parameters

blendResources (Set[str]) – The result for all the resource sections that were referenced
blendCommandsGraph (IniSectionGraph) – The subgraph for all the sections related to the [TextureOverride.*Blend.*] sections
isIfTemplateResource (Callable[[Dict[str, Any]], bool]) – Checks whether a part in the IfTemplate of a section contains the key that reference the target resource
getIfTemplateResource (Callable[[Dict[str, Any]], str]) – Function to retrieve the target resource from a part in the IfTemplate of a section

getFixCredit() → str

Retrieves the credit text for the code generated in the .ini file

Returns: The credits to be displayed in the .ini file
Return type: str

getFixFooter() → str

Retrieves the footer text used to identify a code section has been changed by this fix in the .ini file

Returns: The footer section comment to be used in the .ini file
Return type: str

getFixHeader() → str

Retrieves the header text used to identify a code section has been changed by this fix in the .ini file

Returns: The header section comment to be used in the .ini file
Return type: str

getFixModTypeHeadingname()

Retrieves the name of the type of mod corresponding to the .ini file to be used in the header/footer divider comment of the fix

Returns: The name for the type of mod to be displayed in the header/footer divider comment
Return type: Optional[str]

getFixModTypeName() → Optional[str]

Retrieves the name of the type of mod corresponding to the .ini file to be used for the comment of the fix

Returns: The name for the type of mod corresponding to the .ini file
Return type: Optional[str]

getFixStr(fix: str = '') → str

Generates the newly added code in the .ini file for the fix

Parameters

fix (str) –

Any existing text we want the result of the fix to add onto

Default: “”

Returns

The text for the newly generated code in the .ini file

Return type

str

classmethod getFixedBlendFile(blendFile: str, modName: str = '') → str

Retrieves the file path for the fixed RemapBlend.buf file

Parameters

blendFile (str) – The file path to the original Blend.buf file
modName (str) – The name of the mod to fix to

Returns

The file path of the fixed RemapBlend.buf file

Return type

str

getHeadingName()

Retrieves the title for the header of the divider comment of the fix

Returns: The title for the header of the divider comment
Return type: str

getIfTemplates(flush: bool = False) → Dict[str, IfTemplate]

Retrieves all the :class:`IfTemplate`s for the .ini file

Note

This is the same as IniFile.readIfTemplates(), but uses caching

Parameters

flush (bool) – Whether to re-parse the :class:`IfTemplates`s instead of using the saved cached values

Returns

The parsed IfTemplate`s :raw-html:`

The keys are the name of the IfTemplate
The values are the corresponding IfTemplate

Return type

Dict[str, IfTempalte]

classmethod getMergedResourceIndex(mergedResourceName: str) → Optional[int]

Retrieves the index number of a resource created by GIMI’s genshin_merge_mods.py script

Examples

>>> IniFile.getMergedResourceIndex("ResourceCuteLittleEiBlend.8")
8

>>> IniFile.getMergedResourceIndex("ResourceCuteLittleEiBlend.Score.-100")
-100

>>> IniFile.getMergedResourceIndex("ResourceCuteLittleEiBlend.UnitTests")
None

>>> IniFile.getMergedResourceIndex("ResourceCuteLittleEiBlend")
None

Parameters: mergedResourceName (str) – The name of the section
Returns: The index for the resource section, if found and the index is an integer
Return type: Optional[int]

classmethod getRemapBlendName(name: str, modName: str = '') → str

Changes a section name to have the keyword ‘RemapBlend’ to identify that the section is created by this fix

Examples

>>> IniFile.getRemapBlendName("EiTriesToUseBlenderAndFails", "Raiden")
"EiTriesToUseRaidenRemapBlenderAndFails"

>>> IniFile.getRemapBlendName("EiBlendsTheBlender", "Yae")
"EiBlendsTheYaeRemapBlender"

>>> IniFile.getRemapBlendName("ResourceCuteLittleEi", "Raiden")
"ResourceCuteLittleEiRaidenRemapBlend"

>>> IniFile.getRemapBlendName("ResourceCuteLittleEiRemapBlend", "Raiden")
"ResourceCuteLittleEiRemapRaidenRemapBlend"

Parameters

name (str) – The name of the section
modName (str) –
The name of the mod to fix

Default: ""

Returns

The name of the section with the added ‘RemapBlend’ keyword

Return type

str

classmethod getRemapFixName(name: str, modName: str = '') → str

Changes a section name to have the suffix RemapFix to identify that the section is created by this fix

Examples

>>> IniFile.getRemapFixName("EiIsDoneWithRemapFix", "Raiden")
"EiIsDoneWithRaidenRemapFix"

>>> IniFile.getRemapFixName("EiIsHappy", "Raiden")
"EiIsHappyRaidenRemapFix"

Parameters

name (str) – The name of the section
modName (str) –
The name of the mod to fix

Default: ""

Returns

The name of the section with the added ‘RemapFix’ keyword

Return type

str

classmethod getRemapResourceName(name: str, modName: str = '') → str

Changes the name of a section to be a new resource that this fix will create

Note

See IniFile.getResourceName() and IniFile.getRemapBlendName() for more info

Parameters

name (str) – The name of the section
modName (str) –
The name of the mod to fix

Default: ""

Returns

The name of the section with the prefix ‘Resource’ and the keyword ‘Remap’ added

Return type

str

classmethod getResourceName(name: str) → str

Makes the name of a section to be used for the resource sections of a .ini file

Examples

>>> IniFile.getResourceName("CuteLittleEi")
"ResourceCuteLittleEi"

>>> IniFile.getResourceName("ResourceCuteLittleEi")
"ResourceCuteLittleEi"

Parameters: name (str) – The name of the section
Returns: The name of the section as a resource in a .ini file
Return type: str

property isFixed: bool

Whether the .ini file has already been fixed

Getter: Returns whether the .ini file has already been fixed
Type: bool

property isModIni: bool

Whether the .ini file belongs to a mod

Getter: Returns whether the .ini file belongs to a mod
Type: bool

makeRemapModel(ifTemplate: IfTemplate, toFix: Set[str], getFixedFile: Optional[Callable[[str], str]] = None) → RemapBlendModel

Creates the data needed for fixing a particular [Resource.*Blend.*] section in the .ini file

Parameters

ifTemplate (IfTemplate) – The particular section to extract data
toFix (Set[str]) – The names of the mods to fix
getFixedFile (Optional[Callable[[str, str], str]]) –
The function for transforming the file path of a found .*Blend.buf file into a .*RemapBlend.buf file

If this value is None, then will use IniFile.getFixedBlendFile()

The parameters for the function are:

# The path to the original file # The type of mod to fix to

Default: None

Returns

The data for fixing the particular

Return type

RemapBlendModel

parse()

Parses the .ini file

Raises: KeyError – If a certain resource section is not found

(either the name of the section is not found in the .ini file or the section was skipped due to some error when parsing the section)

read() → str

Reads the .ini file

If IniFile.file is set to None, then will read the existing value from IniFile.fileTxt

Returns: The text content of the .ini file
Return type: str

readFileLines() → List[str]

Reads each line in the .ini file

If IniFile.file is set to None, then will read the existing value from IniFile.fileLines

Returns: All the lines read from the .ini file
Return type: List[str]

readIfTemplates() → Dict[str, IfTemplate]

Parses all the :class:`IfTemplate`s for the .ini file

Returns

The parsed IfTemplate`s :raw-html:`

The keys are the name of the IfTemplate
The values are the corresponding IfTemplate

Return type

Dict[str, IfTempalte]

classmethod removeResourceName(name: str) → str

Removes the ‘Resource’ prefix from a section’s name

Examples

>>> IniFile.removeResourceName("ResourceCuteLittleEi")
"CuteLittleEi"

>>> IniFile.removeResourceName("LittleMissGanyu")
"LittleMissGanyu"

Parameters: name (str) – The name of the section
Returns: The name of the section with the ‘Resource’ prefix removed
Return type: str

removeSectionOptions(section: Union[str, Pattern, Callable[[str], bool]])

Removes a certain type of section from the .ini file

Parameters: section (Union[str, Pattern, Callable[[str], bool]]) – The type of section to remove

property type: Optional[ModType]

The type of mod the .ini file belongs to

Getter: Returns the type of mod the .ini file belongs to
Type: Optional[ModType]

write(txt: Optional[str] = None) → str

Writes back into the .ini files based off the content in IniFile._fileLines

Parameters

txt (Optional[str]) –

The text to write back into the .ini file

If this argument is None, then will use the IniFile.fileTxt

Default: none

Returns

The text that is written to the .ini file

Return type

str

IfTemplate

Attributes

calledSubCommands
hashes
indices
parts

Methods

defadd
deffind
defgetMods

class IfTemplate(parts: List[Union[str, Dict[str, Any]]], calledSubCommands: Optional[Dict[int, str]] = None, hashes: Optional[Set[str]] = None, indices: Optional[Set[str]] = None, name: str = '')

Data for storing information about a section in a .ini file

Note

Assuming every if/else clause must be on its own line, we have that an IfTemplate have a form looking similar to this:

...(does stuff)...
...(does stuff)...
if ...(bool)...
    if ...(bool)...
        ...(does stuff)...
    else if ...(bool)...
        ...(does stuff)...
    endif
else ...(bool)...
    if ...(bool)...
        if ...(bool)...
            ...(does stuff)...
        endif
    endif
endif
...(does stuff)...
...(does stuff)...

We split the above structure into parts where each part is either:

An If Part: a single line containing the keywords “if”, “else” or “endif”
OR
A Content Part: a group of lines that “does stuff”

Note that: an ifTemplate does not need to contain any parts containing the keywords “if”, “else” or “endif”. This case covers the scenario when the user does not use if..else statements for a particular section

Based on the above assumptions, we can assume that every [section] in a .ini file contains this IfTemplate

Supported Operations:

for element in x: Iterates over all the parts of the IfTemplate, x

x[num]: Retrieves the part from the IfTemplate, x, at index num

x[num] = newPart: Sets the part at index num of the IfTemplate, x, to have the value of newPart

Parameters

parts (List[Union[str, Dict[str, Any]]]) – The individual parts of how we divided an IfTemplate described above
calledSubCommands (Optional[Dict[int, str]]) –
Any other sections that this IfTemplate references

The keys are the indices to the part in the IfTemplate that the section is called

Default: None
hashes (Optional[Set[str]]) –
The hashes this IfTemplate references

Default: None
indices (Optional[Set[str]]) –
The indices this IfTemplate references

Default: None
name (str) –
The name of the section for this IfTemplate

Default: ""

parts

The individual parts of how we divided an IfTemplate described above

Type: List[Union[str, Dict[str, Any]]]

calledSubCommands

Any other sections that this IfTemplate references

The keys are the indices to the part in the IfTemplate that the section is called

Type: Dict[int, str]

hashes

The hashes this IfTemplate references

Type: Set[str]

indices

The indices this IfTemplate references

Type: Set[str]

add(part: Union[str, Dict[str, Any]])

Adds a part to the ifTemplate

Parameters: part (Union[str, Dict[str, Any]]) – The part to add to the IfTemplate

find(pred: Optional[Callable[[int, Union[str, Dict[str, Any]]], bool]] = None, postProcessor: Optional[Callable[[int, Union[str, Dict[str, Any]]], Any]] = None) → Dict[int, Any]

Searches the IfTemplate for parts that meet a certain condition

Parameters

pred (Optional[Callable[[IfTemplate, int, Union[str, Dict[str, Any]]], bool]]) –
The predicate used to filter the parts

If this value is None, then this function will return all the parts

The order of arguments passed into the predicate will be:
1. The IfTemplate that this method is calling from
2. The index for the part in the IfTemplate
3. The current part of the IfTemplate
Default: None
postProcessor (Optional[Callable[[IfTemplate, int, Union[str, Dict[str, Any]]], Any]]) –
A function that performs any post-processing on the found part that meets the required condition

The order of arguments passed into the post-processor will be:
1. The IfTemplate that this method is calling from
2. The index for the part in the IfTemplate
3. The current part of the IfTemplate
Default: None

Returns

The filtered parts that meet the search condition

The keys are the index locations of the parts and the values are the found parts

Return type

Dict[int, Any]

getMods(hashRepo: Hashes, indexRepo: Indices, version: Optional[float] = None) → Set[str]

Retrieves the corresponding mods the IfTemplate will fix to

Parameters

hashRepo (Hashes) – The data source for the hashes
indexRepo (Indices) – The data source for the indices
version (Optional[float]) –
What version we want to fix

If this value is None, will assume we want to fix to the latest version

Default: None

Returns

Names of all the types of mods the IfTemplate will fix to

Return type

Set[str]

IniSectionGraph

Attributes

allSections
modsToFix
remapNameFunc
remapNames
runSequence
sections
targetSections

Methods

def_dfsExplore
defbuild
defconstruct
defgetCommonMods
defgetRemapBlendNames
defgetSection

class IniSectionGraph(targetSections: Union[Set[str], List[str]], allSections: Dict[str, IfTemplate], remapNameFunc: Optional[Callable[[str], str]] = None, modsToFix: Optional[Set[str]] = None)

Class for constructing a directed subgraph for how the sections in the .ini file are ran

Note

The nodes are the sections of the .ini file
The directed edges are the command calls from the sections , where the source of the edge is the caller and the sink of the edge is the callee

Parameters

sections (Set[str]) – Names of the desired sections we want our subgraph to have from the sections of the .ini file
allSections (Dict[str, IfTemplate]) –
All the sections for the .ini file

Note

You can think of this as the adjacency list for the directed graph of all sections in the .ini file
remapNameFunc (Optional[Callable[[str, str], str]]) –
Function to get the corresponding remap names for the section names

If this value is None, then will not get the remap names for the sections

The parameters for the function are:
1. Name of the section
2. Name fo the type of mod to fix
Default: False
modsToFix (Optional[Set[str]]) –
The names of the mods that will be fixed by the .ini file

Default: None

remapNameFunc

Function to get the corresponding remap names for the section names

The parameters for the function are:

Name of the section

Name fo the type of mod to fix

Type: Optional[Callable[[str], str]]

_dfsExplore(section: IfTemplate, visited: Dict[str, IfTemplate], runSequence: List[Tuple[str, IfTemplate]])

The typical recursive implementation of DFS for exploring a particular section (node)

Parameters

section (IfTemplate) – The section that is currently being explored
visited (Dict[str, ifTemplate]) – The sections that have already been visited
runSequence (List[Tuple[str, IfTemplate]]) – The order the sections will be ran

property allSections

All the sections of the .ini file

Note

You can think of this as the adjacency list for the directed graph of all sections in the .ini file

Getter: All the sections for the .ini file
Setter: Constructs a new subgraph based on the new sections for the .ini file
Type: Dict[str, IfTemplate]

build(newTargetSections: Optional[Union[Set[str], List[str]]] = None, newAllSections: Optional[Dict[str, IfTemplate]] = None, newModsToFix: Optional[Set[str]] = None)

Performs the initialization for rebuilding the subgraph

Parameters

newTargetSections (Optional[Set[str], List[str]]) –
The new desired sections we want in our subgraph

Default: None
newAllSections (Optional[Dict[str, IfTemplate]]) –
The new sections for the .ini file

Default: None
newModsToFix (Optional[Set[str]]) –
The new desired names of the mods that we want to fix for the .ini file

Default: None

construct() → Dict[str, IfTemplate]

Constructs the subgraph for the sections using DFS

Returns: The sections that are part of the subgraph
Return type: Dict[str, IfTemplate]

getCommonMods(hashRepo: Hashes, indexRepo: Indices, version: Optional[float] = None) → Set[str]

Retrieves the common mods to fix to based off all the :class:`IfTemplate`s in the graph

Parameters

hashRepo (Hashes) – The data source for all the hashes
indexRepo (Indices) – The data source for all the indices
version (Optional[float]) –
The version we want to fix to

If this value is None, then will assume we want to fix to the latest version

Default: None

Returns

The common mods to fix to

Return type

Set[str]

getRemapBlendNames(newModsToFix: Optional[Set[str]] = None) → Dict[str, Dict[str, str]]

Retrieves the corresponding remap names of the sections made by this fix

Parameters

newModsToFix (Optional[Set[str]]) –

The new desired names of the mods that we want to fix for the .ini file

Default: None

Returns

The new names for the sections with the ‘FixRemap’ keyword added

Return type

Dict[str, str]

getSection(sectionName: str, raiseException: bool = True) → Optional[IfTemplate]

Retrieves the IfTemplate for a certain section

Parameters

sectionName (str) – The name of the section
raiseException (bool) – Whether to raise an exception when the section’s IfTemplate is not found

Raises

KeyError – If the IfTemplate for the section is not found and raiseException is set to True

Returns

The corresponding IfTemplate for the section

Return type

Optional[IfTemplate]

property modsToFix

The names of the mods that will be fixed by the .ini file

Getter: Retrieves the names of the mods to fix
Type: Set[str]

property remapNames

The corresponding names for the sections that the fix will make

The outer key is the name of the original section
The inner key is the name for the type of mod to fix
The inner value is the corresponding name for the section and mod type

Getter: All the corresponding names for the sections
Type: Dict[str, Dict[str, str]]

property runSequence

The order the sections will be ran

Getter: Retrieves the order the sections will be ran
Type: List[Tuple[str, IfTemplate]]

property sections

The sections that are part of the contructed subgraph based on the desired sections specified at IniSectionGraph.targetSections

Note

You can think of this as the adjacency list for the subgraph

Getter: All the sections for the subgraph
Type: Dict[str, IfTemplate]

property targetSections

Names of the desired sections we want our subgraph to have from the sections of the .ini file

Getter: The names of the desired sections we want in the subgraph
Setter: Constructs a new subgraph based on the new desired sections we want
Type: List[str]

BlendFile

Attributes

_data
src

Methods

defcorrect
defprint
defread

class BlendFile(src: Union[str, bytes])

This Class inherits from Model

Used for handling blend.buf files

Note

We observe that a Blend.buf file is a binary file defined as:

each line contains 32 bytes (256 bits)
each line uses little-endian mode (MSB is to the right while LSB is to the left)
the first 16 bytes of a line are for the blend weights, each weight is 4 bytes or 32 bits (4 weights/line)
the last 16 bytes of a line are for the corresponding indices for the blend weights, each index is 4 bytes or 32 bits (4 indices/line)
the blend weights are floating points while the blend indices are unsigned integers

Parameters: src (Union[str, bytes]) – The source file or bytes for the blend file

src

The source file or bytes for the blend file

Type: Union[str, bytes]

_data

The bytes read from the source

Type: bytes

correct(vgRemap: VGRemap, fixedBlendFile: Optional[str] = None) → Union[str, None, bytearray]

Fixes a Blend.buf file

Parameters

vgRemap (VGRemap) – The vertex group remap for correcting the Blend.buf file
fixedBlendFile (Optional[str]) –
The file path for the fixed Blend.buf file

Default: None

Raises

BlendFileNotRecognized – If the original Blend.buf file provided by the parameter blendFile cannot be read
BadBlendData – If the bytes passed into this function do not correspond to the format defined for a Blend.buf file

Returns

If the argument fixedBlendFile is None, then will return an array of bytes for the fixed Blend.buf file

Otherwise will return the filename to the fixed RemapBlend.buf file if the provided Blend.buf file got corrected

Return type

Union[Optional[str], bytearray]

print(funcName: str, *args, **kwargs)

Prints out output

Parameters

funcName (str) – The name of the function in the logger for printing out the output
*args (List[str]) – Arguments to pass to the function in the logger
**kwargs (Dict[str, Any]) – Keyword arguments to pass to the function in the logger

Returns

The return value from running the corresponding function in the logger

Return type

Any

read() → bytes

Reads the bytes in the blend.buf file

Returns: The read bytes
Return type: bytes

Ini Parsers

BaseIniParser

Attributes

_iniFile
_modsToFix

Methods

defclear
defparse

class BaseIniParser(iniFile: IniFile)

Base class to parse a .ini file

Parameters: iniFile (IniFile) – The .ini file to parse

_modsToFix

The name of the mods that will be fixed to

Type: Set[str]

_iniFile

The .ini file that will be parsed

Type: IniFile

clear(): Clears any saved data

parse(): Parses the .ini file

IniParseBuilder

Methods

defbuild

class IniParseBuilder(cls: Type[BaseIniParser], args: Optional[List[Any]] = None, kwargs: Optional[Dict[str, Any]] = None)

This class inherits from Builder

A class to help dynamically build a BaseIniParser

Parameters

cls (Type[BaseIniParser]) – The class to construct a BaseIniFixer
args (Optional[List[Any]]) –
The constant arguments used to build the object

Default: None
kwargs (Optional[Dict[str, Any]]) –
The constant keyword arguments used to build the object

Default: None

build(iniFile: IniFile) → BaseIniParser

Builds the parser

Parameters: iniFile (IniFile) – The .ini file to parse
Returns: The built parser
Return type: BaseIniParser

GIMIParser

Attributes

blendCommandsGraph
nonBlendHashIndexCommandsGraph
resourceCommandsGraph

Methods

def_makeRemapModels
def_setToFix
defclear
defparse

class GIMIParser(iniFile: IniFile)

This class inherits from BaseIniParser

Parses a .ini file used by a GIMI related importer

Parameters: iniFile (IniFile) – The .ini file to parse

blendCommandsGraph

All the sections that use some [Resource.*Blend.*] section.

Type: IniSectionGraph

nonBlendHashIndexCommandsGraph

All the sections that are not used by the [Resource.*Blend.*] sections and contains the target hashes/indices that need to be replaced

Type: IniSectionGraph

resourceCommandsGraph

All the related sections to the [Resource.*Blend.*] sections that are used by sections related to the [TextureOverride.*Blend.*] sections. The keys are the name of the sections.

Type: IniSectionGraph

_makeRemapModels(resourceGraph: IniSectionGraph, getFixedFile: Optional[Callable[[str], str]] = None) → Dict[str, RemapBlendModel]

Creates all the data needed for fixing the [Resource.*Blend.*] sections in the .ini file

Parameters

resourceGraph (IniSectionGraph) – The graph of sections for the resources
getFixedFile (Optional[Callable[[str], str]]) –
The function for transforming the file path of a found .*Blend.buf file into a .*RemapBlend.buf file

If this value is None, then will use IniFile.getFixedBlendFile()

Default: None

Returns

The data for fixing the resource sections

The keys are the original names for the resource sections and the values are the required data for fixing the sections

Return type

Dict[str, RemapBlendModel]

_setToFix() → Set[str]

Sets the names for the types of mods that will used in the fix

Returns: The names of the mods that will be used in the fix
Return type: Set[str]

clear(): Clears any saved data

parse(): Parses the .ini file

GIMIObjParser

Attributes

_objRootSections
_objSearchPatterns
objGraphs
objs

Methods

def_makeRemapModels
def_setToFix
defclear
defparse

class GIMIObjParser(iniFile: IniFile, objs: Set[str])

This class inherits from GIMIParser

Parses a .ini file used by a GIMI related importer and parses section’s related to a specific mod object (head, body, dress, etc…)

Note

For the specific names of the objects for a particular mod, please refer to GIMI Assets

Parameters

iniFile (IniFile) – The .ini file to parse
objs (Set[str]) – The specific mod objects to keep track of

objGraphs

The different sections related to each mod object

The keys are the names of the objects and the values are the graphs related to each object

Type: Dict[str, IniSectionGraph]

_objSearchPatterns

The Regex patterns used to find the roots of the sections related to each mod object

The keys are the names of the objects and the values are the Regex patterns

Type: Dict[str, Pattern]

_objRootSections

The root sections for each mod object

The keys are the names of the objects and the values are the names of the sections

Type: Dict[str, Set[str]]

_makeRemapModels(resourceGraph: IniSectionGraph, getFixedFile: Optional[Callable[[str], str]] = None) → Dict[str, RemapBlendModel]

Creates all the data needed for fixing the [Resource.*Blend.*] sections in the .ini file

Parameters

resourceGraph (IniSectionGraph) – The graph of sections for the resources
getFixedFile (Optional[Callable[[str], str]]) –
The function for transforming the file path of a found .*Blend.buf file into a .*RemapBlend.buf file

If this value is None, then will use IniFile.getFixedBlendFile()

Default: None

Returns

The data for fixing the resource sections

The keys are the original names for the resource sections and the values are the required data for fixing the sections

Return type

Dict[str, RemapBlendModel]

_setToFix() → Set[str]

Sets the names for the types of mods that will used in the fix

Returns: The names of the mods that will be used in the fix
Return type: Set[str]

clear(): Clears any saved data

property objs

The specific mod objects to keep track of

Getter: Returns the names of the mod objects
Setter: Sets the new names for the mod objects to keep track of
Type: Set[str]

parse(): Parses the .ini file

Ini Fixers

BaseIniFixer

Attributes

_iniFile
_parser

Methods

def_getAsset
def_getAssetReplacement
def_getHash
def_getHashReplacement
def_getIndex
def_getIndexReplacement
deffillIfTemplate
deffix
defgetFix

class BaseIniFixer(parser: BaseIniParser)

Base class to fix a .ini file

Parameters: parser (BaseIniParser) – The associated parser to retrieve data for the fix

_parser

The associated parser to retrieve data for the fix

Type: BaseIniParser

_iniFile

The .ini file that will be fixed

Type: IniFile

_getAsset(assetType: str, assetRepoAttName: str, modName: str, notFoundVal: Optional[Any] = None) → Union[str, Any]

Retrieves the corresponding asset

Parameters

assetType (str) – The name for the type of asset to retrieve
assetRepoAttName (str) – The name of the ModIdAssets repo in IniFile.availableType()
modName (str) – The name of the mod we want the asset for
notFoundVal (Any) –
The value to be returned if the replacement is not found

Default: None

Returns

The found asset or the value from ‘notFoundVal’ if the asset was not found

Return type

Union[str, Any]

_getAssetReplacement(asset: str, assetRepoAttName: str, modName: str, notFoundVal: Optional[Any] = None) → Union[str, Any]

Retrieves the replacement for ‘asset’

Parameters

asset (str) – The asset to be replaced
assetRepoAttName (str) – The name of the ModIdAssets repo in IniFile.availableType()
modName (str) – The name of the mod we want the replacement for
notFoundVal (Any) –
The value to be returns if the replacement is not found

Default: None

Returns

The found replacement asset or the value from ‘notFoundVal’ if the replacement was not found

Return type

Union[str, Any]

_getHash(hashType: str, modName: str) → str

Retrieves the corresponding hash

Parameters

hashType (str) – The name for the type of hash to retrieve
modName (str) – The name for the type of mod to get the hash from

Returns

The found hash or “HashNotFound” if the corresponding hash is not found

Return type

str

_getHashReplacement(hash: str, modName: str) → str

Retrieves the replacement for ‘hash’

Parameters

hash (str) – The hash to be replaced
modName (str) – The name of the mod we want the replacement for

Returns

The corresponding replacement for the hash or “HashNotFound” if there are not replacements

Return type

str

_getIndex(indexType: str, modName: str) → str

Retrieves the corresponding index

Parameters

indexType (str) – The name for the type of index to retrieve
modName (str) – The name for the type of mod to get the index from

Returns

The found index or “IndexNotFound” if the corresponding index is not found

Return type

str

_getIndexReplacement(index: str, modName: str) → str

Retrieves the replacement for ‘index’

Parameters

index (str) – The index to be replaced
modName (str) – The name of the mod we want the replacement for

Returns

The corresponding replacement for the index or “IndexNotFound” if there are not replacements

Return type

str

fillIfTemplate(modName: str, sectionName: str, ifTemplate: IfTemplate, fillFunc: Callable[[str, str, Union[str, Dict[str, Any]], int, int, str], str], origSectionName: Optional[str] = None) → str

Creates a new IfTemplate for an existing section in the .ini file

Parameters

modName (str) – The name for the type of mod to fix to
sectionName (str) – The new name of the section
ifTemplate (IfTemplate) – The IfTemplate of the orginal section
fillFunc (Callable[[str, str, Union[str, Dict[str, Any], int, str, str], str]]) –
The function to create a new content part for the new IfTemplate

Tip

For more info about an ‘IfTemplate’, see IfTemplate

The parameter order for the function is:
1. The name for the type of mod to fix to
2. The new section name
3. The corresponding content part in the original IfTemplate
4. The index for the content part in the original IfTemplate
5. The string to prefix every line in the content part of the IfTemplate
6. The original name of the section
origSectionName (Optional[str]) –
The original name of the section.

If this argument is set to None, then will assume this argument has the same value as the argument for sectionName

Default: None

Returns

The text for the newly created IfTemplate

Return type

str

fix(keepBackup: bool = True, fixOnly: bool = False, update: bool = False) → Union[str, List[str]]

Fixes the .ini file

Parameters

keepBackup (bool) –
Whether to keep backups for the .ini file

Default: True
fixOnly (bool) –
Whether to only fix the .ini file without undoing any fixes

Default: False
update (bool) –
Whether to also update the source text in the IniFile object with the latest fix

Default: False

Returns

The new content of the .ini file which includes the fix and the new content of any other newly created .ini files related to fixing the particular .ini file

Return type

Union[str, List[str]]

getFix(fixStr: str = '') → str: Retrieves the text to fix the .ini file

IniFixBuilder

Methods

defbuild

class IniFixBuilder(cls: Type[BaseIniFixer], args: Optional[List[Any]] = None, kwargs: Optional[Dict[str, Any]] = None)

This class inherits from Builder

Class to dynamically build a BaseIniFixer to fix .ini files

Parameters

cls (Type[BaseIniFixer]) – The class to construct a BaseIniFixer
args (Optional[List[Any]]) –
The constant arguments used to build the object

Default: None
kwargs (Optional[Dict[str, Any]]) –
The constant keyword arguments used to build the object

Default: None

build(parser: BaseIniParser) → BaseIniFixer

Builds the fixer

Parameters: parser (BaseIniParser) – The corresponding parser for the .ini file
Returns: The built fixer
Return type: BaseIniFixer

GIMIFixer

Methods

def_fillNonBlendSections
def_fillRemapResource
def_fillTextureOverrideRemapBlend
def_getAsset
def_getAssetReplacement
def_getHash
def_getHashReplacement
def_getIndex
def_getIndexReplacement
deffillIfTemplate
deffix
deffixMod
defgetFix

class GIMIFixer(parser: GIMIParser)

This class inherits from BaseIniFixer

Fixes a .ini file used by a GIMI related importer

Parameters: parser (GIMIParser) – The associated parser to retrieve data for the fix

_fillNonBlendSections(modName: str, sectionName: str, part: Dict[str, Any], partIndex: int, linePrefix: str, origSectionName: str) → str

Creates the content part of an IfTemplate for the new sections created by this fix that are not related to the [TextureOverride.*Blend.*] sections

Tip

For more info about an ‘IfTemplate’, see IfTemplate

Parameters

modName (str) – The name for the type of mod to fix to
sectionName (str) – The new name for the section
part (Dict[str, Any]) – The content part of the IfTemplate of the original [TextureOverrideBlend] section
partIndex (int) – The index of where the content part appears in the IfTemplate of the original section
linePrefix (str) – The text to prefix every line of the created content part
origSectionName (str) – The name of the original section

Returns

The created content part

Return type

str

_fillRemapResource(modName: str, sectionName: str, part: Dict[str, Any], partIndex: int, linePrefix: str, origSectionName: str)

Creates the content part of an IfTemplate for the new sections created by this fix related to the [Resource.*Blend.*] sections

Tip

For more info about an ‘IfTemplate’, see IfTemplate

Parameters

modName (str) – The name for the type of mod to fix to
sectionName (str) – The new name for the section
part (Dict[str, Any]) – The content part of the IfTemplate of the original [Resource.*Blend.*] section
partIndex (int) – The index of where the content part appears in the IfTemplate of the original section
linePrefix (str) – The text to prefix every line of the created content part
origSectionName (str) – The name of the original section

Returns

The created content part

Return type

str

_fillTextureOverrideRemapBlend(modName: str, sectionName: str, part: Dict[str, Any], partIndex: int, linePrefix: str, origSectionName: str) → str

Creates the content part of an IfTemplate for the new sections created by this fix related to the [TextureOverride.*Blend.*] sections

Tip

For more info about an ‘IfTemplate’, see IfTemplate

Parameters

modName (str) – The name for the type of mod to fix to
sectionName (str) – The new name for the section
part (Dict[str, Any]) – The content part of the IfTemplate of the original [TextureOverrideBlend] section
partIndex (int) – The index of where the content part appears in the IfTemplate of the original section
linePrefix (str) – The text to prefix every line of the created content part
origSectionName (str) – The name of the original section

Returns

The created content part

Return type

str

_getAsset(assetType: str, assetRepoAttName: str, modName: str, notFoundVal: Optional[Any] = None) → Union[str, Any]

Retrieves the corresponding asset

Parameters

assetType (str) – The name for the type of asset to retrieve
assetRepoAttName (str) – The name of the ModIdAssets repo in IniFile.availableType()
modName (str) – The name of the mod we want the asset for
notFoundVal (Any) –
The value to be returned if the replacement is not found

Default: None

Returns

The found asset or the value from ‘notFoundVal’ if the asset was not found

Return type

Union[str, Any]

_getAssetReplacement(asset: str, assetRepoAttName: str, modName: str, notFoundVal: Optional[Any] = None) → Union[str, Any]

Retrieves the replacement for ‘asset’

Parameters

asset (str) – The asset to be replaced
assetRepoAttName (str) – The name of the ModIdAssets repo in IniFile.availableType()
modName (str) – The name of the mod we want the replacement for
notFoundVal (Any) –
The value to be returns if the replacement is not found

Default: None

Returns

The found replacement asset or the value from ‘notFoundVal’ if the replacement was not found

Return type

Union[str, Any]

_getHash(hashType: str, modName: str) → str

Retrieves the corresponding hash

Parameters

hashType (str) – The name for the type of hash to retrieve
modName (str) – The name for the type of mod to get the hash from

Returns

The found hash or “HashNotFound” if the corresponding hash is not found

Return type

str

_getHashReplacement(hash: str, modName: str) → str

Retrieves the replacement for ‘hash’

Parameters

hash (str) – The hash to be replaced
modName (str) – The name of the mod we want the replacement for

Returns

The corresponding replacement for the hash or “HashNotFound” if there are not replacements

Return type

str

_getIndex(indexType: str, modName: str) → str

Retrieves the corresponding index

Parameters

indexType (str) – The name for the type of index to retrieve
modName (str) – The name for the type of mod to get the index from

Returns

The found index or “IndexNotFound” if the corresponding index is not found

Return type

str

_getIndexReplacement(index: str, modName: str) → str

Retrieves the replacement for ‘index’

Parameters

index (str) – The index to be replaced
modName (str) – The name of the mod we want the replacement for

Returns

The corresponding replacement for the index or “IndexNotFound” if there are not replacements

Return type

str

fillIfTemplate(modName: str, sectionName: str, ifTemplate: IfTemplate, fillFunc: Callable[[str, str, Union[str, Dict[str, Any]], int, int, str], str], origSectionName: Optional[str] = None) → str

Creates a new IfTemplate for an existing section in the .ini file

Parameters

modName (str) – The name for the type of mod to fix to
sectionName (str) – The new name of the section
ifTemplate (IfTemplate) – The IfTemplate of the orginal section
fillFunc (Callable[[str, str, Union[str, Dict[str, Any], int, str, str], str]]) –
The function to create a new content part for the new IfTemplate

Tip

For more info about an ‘IfTemplate’, see IfTemplate

The parameter order for the function is:
1. The name for the type of mod to fix to
2. The new section name
3. The corresponding content part in the original IfTemplate
4. The index for the content part in the original IfTemplate
5. The string to prefix every line in the content part of the IfTemplate
6. The original name of the section
origSectionName (Optional[str]) –
The original name of the section.

If this argument is set to None, then will assume this argument has the same value as the argument for sectionName

Default: None

Returns

The text for the newly created IfTemplate

Return type

str

fix(keepBackup: bool = True, fixOnly: bool = False, update: bool = False) → Union[str, List[str]]

Fixes the .ini file

Parameters

keepBackup (bool) –
Whether to keep backups for the .ini file

Default: True
fixOnly (bool) –
Whether to only fix the .ini file without undoing any fixes

Default: False
update (bool) –
Whether to also update the source text in the IniFile object with the latest fix

Default: False

Returns

The new content of the .ini file which includes the fix and the new content of any other newly created .ini files related to fixing the particular .ini file

Return type

Union[str, List[str]]

fixMod(modName: str, fix: str = '')

Generates the newly added code in the .ini file for the fix of a single type of mod

Note

eg.: If we are making the fix from Jean -> JeanCN and JeanSeaBreeze, The code below will only make the fix for JeanCN

fixMod("JeanCN")

Parameters

modName (str) – The name of the mod to fix
fix (str) –
Any existing text we want the result of the fix to add onto

Default: “”

Returns

The text for the newly generated code in the .ini file

Return type

str

getFix(fixStr: str = ''): Retrieves the text to fix the .ini file

GIMIObjReplaceFixer

Attributes

regEditOldObj
regRemap
regRemove

Methods

def_fillNonBlendSections
def_fillRemapResource
def_fillTextureOverrideRemapBlend
def_getAsset
def_getAssetReplacement
def_getHash
def_getHashReplacement
def_getIndex
def_getIndexReplacement
deffillIfTemplate
deffillObjNonBlendSection
deffix
deffixMod
defgetFix
defgetObjRemapFixName
defremapReg

class GIMIObjReplaceFixer(parser: GIMIObjParser, regRemap: Optional[Dict[str, Dict[str, str]]] = None, regRemove: Optional[Dict[str, Set[str]]] = None, regEditOldObj: bool = True)

This class inherits from GIMIFixer

Base class to fix a .ini file used by a GIMI related importer where particular mod objects (head, body, dress, etc…) in the mod to remap are replaced by other mod objects

Parameters

parser (GIMIObjParser) – The associated parser to retrieve data for the fix
regRemap (Optional[Dict[str, Dict[str, List[str]]]]) –
Defines how the register values in the parts of an IfTemplate are mapped to a new register in the remapped mod for particular mod objects
- The outer keys are the name of the mod object to have their registers remapped
- The inner keys are the names of the registers that hold the register values to be remapped
- The inner values are the new names of the registers that will hold the register values
eg.
{"head": {"ps-t1": ["new_ps-t2", "new_ps-t3"]}, "body": {"ps-t3": [ps-t0"], "ps-t0": [], "ps-t1": ["ps-t8"]}}

Note

See GIMIObjReplaceFixer.regEditOldObj for whether the mod objects refer to the mod to be fixed or the fixed mods

Note

This parameter is preceded by GIMIObjSplitFixer.regRemove()

Default: None
regRemove (Optional[Dict[str, Set[str]]]) –
Defines whether some register assignments should be removed from the sections from the mod objects

The keys are the names of the objects to have their registers removed and the values are the names of the register to be removed

eg.
{"head": {"ps-t1", "ps-t2"}, "body": {"ps-t3", "ps-t0"}}

Note

See GIMIObjReplaceFixer.regEditOldObj for whether the mod objects refer to the mod to be fixed or the fixed mod

Note

This parameter takes precedence over GIMIObjSplitFixer.regRemap()

Default: None
regEditOldObj (bool) –
Whether the register editting attributes such as GIMIObjReplaceFixer.regRemap() or GIMIObjReplaceFixer.regRemove() have their mod objects reference the original mod objects of the mod to be fixed or the new mod objects of the fixed mods

Default: true

regEditOldObj

Whether the register editting attributes such as GIMIObjReplaceFixer.regRemap() or GIMIObjReplaceFixer.regRemove() have their mod objects reference the original mod objects of the mod to be fixed or the new mod objects of the fixed mods

Type: bool

_fillNonBlendSections(modName: str, sectionName: str, part: Dict[str, Any], partIndex: int, linePrefix: str, origSectionName: str) → str

Creates the content part of an IfTemplate for the new sections created by this fix that are not related to the [TextureOverride.*Blend.*] sections

Tip

For more info about an ‘IfTemplate’, see IfTemplate

Parameters

modName (str) – The name for the type of mod to fix to
sectionName (str) – The new name for the section
part (Dict[str, Any]) – The content part of the IfTemplate of the original [TextureOverrideBlend] section
partIndex (int) – The index of where the content part appears in the IfTemplate of the original section
linePrefix (str) – The text to prefix every line of the created content part
origSectionName (str) – The name of the original section

Returns

The created content part

Return type

str

_fillRemapResource(modName: str, sectionName: str, part: Dict[str, Any], partIndex: int, linePrefix: str, origSectionName: str)

Creates the content part of an IfTemplate for the new sections created by this fix related to the [Resource.*Blend.*] sections

Tip

For more info about an ‘IfTemplate’, see IfTemplate

Parameters

modName (str) – The name for the type of mod to fix to
sectionName (str) – The new name for the section
part (Dict[str, Any]) – The content part of the IfTemplate of the original [Resource.*Blend.*] section
partIndex (int) – The index of where the content part appears in the IfTemplate of the original section
linePrefix (str) – The text to prefix every line of the created content part
origSectionName (str) – The name of the original section

Returns

The created content part

Return type

str

_fillTextureOverrideRemapBlend(modName: str, sectionName: str, part: Dict[str, Any], partIndex: int, linePrefix: str, origSectionName: str) → str

Creates the content part of an IfTemplate for the new sections created by this fix related to the [TextureOverride.*Blend.*] sections

Tip

For more info about an ‘IfTemplate’, see IfTemplate

Parameters

modName (str) – The name for the type of mod to fix to
sectionName (str) – The new name for the section
part (Dict[str, Any]) – The content part of the IfTemplate of the original [TextureOverrideBlend] section
partIndex (int) – The index of where the content part appears in the IfTemplate of the original section
linePrefix (str) – The text to prefix every line of the created content part
origSectionName (str) – The name of the original section

Returns

The created content part

Return type

str

_getAsset(assetType: str, assetRepoAttName: str, modName: str, notFoundVal: Optional[Any] = None) → Union[str, Any]

Retrieves the corresponding asset

Parameters

assetType (str) – The name for the type of asset to retrieve
assetRepoAttName (str) – The name of the ModIdAssets repo in IniFile.availableType()
modName (str) – The name of the mod we want the asset for
notFoundVal (Any) –
The value to be returned if the replacement is not found

Default: None

Returns

The found asset or the value from ‘notFoundVal’ if the asset was not found

Return type

Union[str, Any]

_getAssetReplacement(asset: str, assetRepoAttName: str, modName: str, notFoundVal: Optional[Any] = None) → Union[str, Any]

Retrieves the replacement for ‘asset’

Parameters

asset (str) – The asset to be replaced
assetRepoAttName (str) – The name of the ModIdAssets repo in IniFile.availableType()
modName (str) – The name of the mod we want the replacement for
notFoundVal (Any) –
The value to be returns if the replacement is not found

Default: None

Returns

The found replacement asset or the value from ‘notFoundVal’ if the replacement was not found

Return type

Union[str, Any]

_getHash(hashType: str, modName: str) → str

Retrieves the corresponding hash

Parameters

hashType (str) – The name for the type of hash to retrieve
modName (str) – The name for the type of mod to get the hash from

Returns

The found hash or “HashNotFound” if the corresponding hash is not found

Return type

str

_getHashReplacement(hash: str, modName: str) → str

Retrieves the replacement for ‘hash’

Parameters

hash (str) – The hash to be replaced
modName (str) – The name of the mod we want the replacement for

Returns

The corresponding replacement for the hash or “HashNotFound” if there are not replacements

Return type

str

_getIndex(indexType: str, modName: str) → str

Retrieves the corresponding index

Parameters

indexType (str) – The name for the type of index to retrieve
modName (str) – The name for the type of mod to get the index from

Returns

The found index or “IndexNotFound” if the corresponding index is not found

Return type

str

_getIndexReplacement(index: str, modName: str) → str

Retrieves the replacement for ‘index’

Parameters

index (str) – The index to be replaced
modName (str) – The name of the mod we want the replacement for

Returns

The corresponding replacement for the index or “IndexNotFound” if there are not replacements

Return type

str

fillIfTemplate(modName: str, sectionName: str, ifTemplate: IfTemplate, fillFunc: Callable[[str, str, Union[str, Dict[str, Any]], int, int, str], str], origSectionName: Optional[str] = None) → str

Creates a new IfTemplate for an existing section in the .ini file

Parameters

modName (str) – The name for the type of mod to fix to
sectionName (str) – The new name of the section
ifTemplate (IfTemplate) – The IfTemplate of the orginal section
fillFunc (Callable[[str, str, Union[str, Dict[str, Any], int, str, str], str]]) –
The function to create a new content part for the new IfTemplate

Tip

For more info about an ‘IfTemplate’, see IfTemplate

The parameter order for the function is:
1. The name for the type of mod to fix to
2. The new section name
3. The corresponding content part in the original IfTemplate
4. The index for the content part in the original IfTemplate
5. The string to prefix every line in the content part of the IfTemplate
6. The original name of the section
origSectionName (Optional[str]) –
The original name of the section.

If this argument is set to None, then will assume this argument has the same value as the argument for sectionName

Default: None

Returns

The text for the newly created IfTemplate

Return type

str

fillObjNonBlendSection(modName: str, sectionName: str, part: Dict[str, Any], partIndex: int, linePrefix: str, origSectionName: str, objName: str, newObjName: str)

Creates the content part of an IfTemplate for the new sections created by this fix that are not related to the [TextureOverride.*Blend.*] sections of some mod object, where the original section comes from a different mod object

Tip

For more info about an ‘IfTemplate’, see IfTemplate

Parameters

modName (str) – The name for the type of mod to fix to
sectionName (str) – The new name for the section
part (Dict[str, Any]) – The content part of the IfTemplate of the original [TextureOverrideBlend] section
partIndex (int) – The index of where the content part appears in the IfTemplate of the original section
linePrefix (str) – The text to prefix every line of the created content part
origSectionName (str) – The name of the original section
objName (str) – The name of the original mod object
newObjName (str) – The name of the mod object to fix to

Returns

The created content part

Return type

str

fix(keepBackup: bool = True, fixOnly: bool = False, update: bool = False) → Union[str, List[str]]

Fixes the .ini file

Parameters

keepBackup (bool) –
Whether to keep backups for the .ini file

Default: True
fixOnly (bool) –
Whether to only fix the .ini file without undoing any fixes

Default: False
update (bool) –
Whether to also update the source text in the IniFile object with the latest fix

Default: False

Returns

The new content of the .ini file which includes the fix and the new content of any other newly created .ini files related to fixing the particular .ini file

Return type

Union[str, List[str]]

fixMod(modName: str, fix: str = '')

Generates the newly added code in the .ini file for the fix of a single type of mod

Note

eg.: If we are making the fix from Jean -> JeanCN and JeanSeaBreeze, The code below will only make the fix for JeanCN

fixMod("JeanCN")

Parameters

modName (str) – The name of the mod to fix
fix (str) –
Any existing text we want the result of the fix to add onto

Default: “”

Returns

The text for the newly generated code in the .ini file

Return type

str

getFix(fixStr: str = ''): Retrieves the text to fix the .ini file

getObjRemapFixName(name: str, modName: str, objName: str, newObjName: str) → str

Retrieves the new name of the section for a new mod object

Parameters

name (str) – The name of the section
modName (str) – The name of the mod to be fixed
objName (str) – The name of the original mod object for the section
newObjName (str) – The name of the new mod object for the section

property regRemap

Defines how the register values in the parts of an IfTemplate are mapped to a new register in the remapped mod for particular mod objects

The outer keys are the name of the mod objects to have its registers remapped
The inner keys are the names of the registers that hold the register values to be remapped
The inner values are the new names of the registers that will hold the register values

eg.
{"head": {"ps-t1": ["new_ps-t2", "new_ps-t3"]}, "body": {"ps-t3": [ps-t0"], "ps-t0": [], "ps-t1": ["ps-t8"]}}

Note

See GIMIObjReplaceFixer.regEditOldObj for whether the mod objects refer to the mod to be fixed or the fixed mod

Note

This attribute is preceded by GIMIObjSplitFixer.regRemove()

Getter: Retrieves the remap of the registers for the mod objects
Setter: Sets the new remap of the registers
Type: Dict[str, Dict[str, Set[str]]]

property regRemove

Defines whether some register assignments should be removed from the sections of the remapped mod object

The keys are the names of the objects to have their registers removed and the values are the names of the register to be removed

eg.
{"head": {"ps-t1", "ps-t2"}, "body": {"ps-t3", "ps-t0"}}

Note

See GIMIObjReplaceFixer.regEditOldObj for whether the mod objects refer to the mod to be fixed or the fixed mod

Note

This attribute takes precedence over GIMIObjSplitFixer.regRemap()

Getter: Retrieves the registers to be removed for the mod objects
Setter: Sets the new registers to be removed
Type: Dict[str, Set[str]]

remapReg(regName: str, regVal: str, objName: str, linePrefix: str = '') → str

Retrieves the new text with ‘regVal’ remapped to a new register

Parameters

regName (str) – The old name of the register to be remapped
regVal (str) – The value that corresponds to the old name of the register
objName (str) – The name of the mod object where this remap will happend
linePrefix (str) –
Any text to prefix the new text created

Default: ""

Returns

The new text with the register value remapped to a new register

Return type

str

GIMIObjSplitFixer

Attributes

objs
regRemap
regRemove

Methods

def_fillNonBlendSections
def_fillRemapResource
def_fillTextureOverrideRemapBlend
def_getAsset
def_getAssetReplacement
def_getHash
def_getHashReplacement
def_getIndex
def_getIndexReplacement
deffillIfTemplate
deffillObjNonBlendSection
deffix
deffixMod
defgetFix
defgetObjRemapFixName
defremapReg

class GIMIObjSplitFixer(parser: GIMIObjParser, objs: Dict[str, List[str]], regRemap: Optional[Dict[str, Dict[str, str]]] = None, regRemove: Optional[Dict[str, Set[str]]] = None)

This class inherits from GIMIObjReplaceFixer

Fixes a .ini file used by a GIMI related importer where particular mod objects (head, body, dress, etc…) in the mod to remap are split into multiple mod objects in remapped mod

eg.

 KeqingOpulent's "body" is split into Keqing's "body" and "dress"

 KeqingOpulent             Keqing
===============       =================
*** objects ***       **** objects ****
    body  -------+------>   body
    head         |          head
                 +------>   dress

Parameters

parser (GIMIObjParser) – The associated parser to retrieve data for the fix
objs (Dict[str, List[str]]) –
The mod objects that will be split into multiple new mod objects

The keys are the names of the mod objects to be split and the values are the names of the new mod objects the original mod object will be split into

Note

The dictionary keys should align with the defined object names at GIMIObjParser.objs() for your parser

Warning

If multiple mod objects split into the same object, then the resultant .ini file will contain duplicate sections for that particular mod object

eg.
{"body": ["dress", "extra"], "head": ["face", "extra"]}
regRemap (Optional[Dict[str, Dict[str, List[str]]]]) –
Defines how the register values in the parts of an IfTemplate are mapped to a new register in the remapped mod for particular mod objects
- The outer keys is the name of the mod object to have its registers remapped for the fixed mod
- The inner keys are the names of the registers that hold the register values to be remapped
- The inner values are the new names of the registers that will hold the register values
eg.
{"head": {"ps-t1": ["new_ps-t2", "new_ps-t3"]}, "body": {"ps-t3": [ps-t0"], "ps-t0": [], "ps-t1": ["ps-t8"]}}

Note

For this class, GIMIObjReplaceFixer.regEditOldObj is set to False

Note

This parameter is preceded by GIMIObjSplitFixer.regRemove()

Default: None
regRemove (Optional[Dict[str, Set[str]]]) –
Defines whether some register assignments should be removed from the sections of some mod object

The keys are the names of the objects to have their registers removed and the values are the names of the register to be removed

eg.
{"head": {"ps-t1", "ps-t2"}, "body": {"ps-t3", "ps-t0"}}

Note

For this class, GIMIObjReplaceFixer.regEditOldObj is set to False

Note

This parameter takes precedence over GIMIObjSplitFixer.regRemap()

Default: None

_fillNonBlendSections(modName: str, sectionName: str, part: Dict[str, Any], partIndex: int, linePrefix: str, origSectionName: str) → str

Creates the content part of an IfTemplate for the new sections created by this fix that are not related to the [TextureOverride.*Blend.*] sections

Tip

For more info about an ‘IfTemplate’, see IfTemplate

Parameters

modName (str) – The name for the type of mod to fix to
sectionName (str) – The new name for the section
part (Dict[str, Any]) – The content part of the IfTemplate of the original [TextureOverrideBlend] section
partIndex (int) – The index of where the content part appears in the IfTemplate of the original section
linePrefix (str) – The text to prefix every line of the created content part
origSectionName (str) – The name of the original section

Returns

The created content part

Return type

str

_fillRemapResource(modName: str, sectionName: str, part: Dict[str, Any], partIndex: int, linePrefix: str, origSectionName: str)

Creates the content part of an IfTemplate for the new sections created by this fix related to the [Resource.*Blend.*] sections

Tip

For more info about an ‘IfTemplate’, see IfTemplate

Parameters

modName (str) – The name for the type of mod to fix to
sectionName (str) – The new name for the section
part (Dict[str, Any]) – The content part of the IfTemplate of the original [Resource.*Blend.*] section
partIndex (int) – The index of where the content part appears in the IfTemplate of the original section
linePrefix (str) – The text to prefix every line of the created content part
origSectionName (str) – The name of the original section

Returns

The created content part

Return type

str

_fillTextureOverrideRemapBlend(modName: str, sectionName: str, part: Dict[str, Any], partIndex: int, linePrefix: str, origSectionName: str) → str

Creates the content part of an IfTemplate for the new sections created by this fix related to the [TextureOverride.*Blend.*] sections

Tip

For more info about an ‘IfTemplate’, see IfTemplate

Parameters

modName (str) – The name for the type of mod to fix to
sectionName (str) – The new name for the section
part (Dict[str, Any]) – The content part of the IfTemplate of the original [TextureOverrideBlend] section
partIndex (int) – The index of where the content part appears in the IfTemplate of the original section
linePrefix (str) – The text to prefix every line of the created content part
origSectionName (str) – The name of the original section

Returns

The created content part

Return type

str

_getAsset(assetType: str, assetRepoAttName: str, modName: str, notFoundVal: Optional[Any] = None) → Union[str, Any]

Retrieves the corresponding asset

Parameters

assetType (str) – The name for the type of asset to retrieve
assetRepoAttName (str) – The name of the ModIdAssets repo in IniFile.availableType()
modName (str) – The name of the mod we want the asset for
notFoundVal (Any) –
The value to be returned if the replacement is not found

Default: None

Returns

The found asset or the value from ‘notFoundVal’ if the asset was not found

Return type

Union[str, Any]

_getAssetReplacement(asset: str, assetRepoAttName: str, modName: str, notFoundVal: Optional[Any] = None) → Union[str, Any]

Retrieves the replacement for ‘asset’

Parameters

asset (str) – The asset to be replaced
assetRepoAttName (str) – The name of the ModIdAssets repo in IniFile.availableType()
modName (str) – The name of the mod we want the replacement for
notFoundVal (Any) –
The value to be returns if the replacement is not found

Default: None

Returns

The found replacement asset or the value from ‘notFoundVal’ if the replacement was not found

Return type

Union[str, Any]

_getHash(hashType: str, modName: str) → str

Retrieves the corresponding hash

Parameters

hashType (str) – The name for the type of hash to retrieve
modName (str) – The name for the type of mod to get the hash from

Returns

The found hash or “HashNotFound” if the corresponding hash is not found

Return type

str

_getHashReplacement(hash: str, modName: str) → str

Retrieves the replacement for ‘hash’

Parameters

hash (str) – The hash to be replaced
modName (str) – The name of the mod we want the replacement for

Returns

The corresponding replacement for the hash or “HashNotFound” if there are not replacements

Return type

str

_getIndex(indexType: str, modName: str) → str

Retrieves the corresponding index

Parameters

indexType (str) – The name for the type of index to retrieve
modName (str) – The name for the type of mod to get the index from

Returns

The found index or “IndexNotFound” if the corresponding index is not found

Return type

str

_getIndexReplacement(index: str, modName: str) → str

Retrieves the replacement for ‘index’

Parameters

index (str) – The index to be replaced
modName (str) – The name of the mod we want the replacement for

Returns

The corresponding replacement for the index or “IndexNotFound” if there are not replacements

Return type

str

fillIfTemplate(modName: str, sectionName: str, ifTemplate: IfTemplate, fillFunc: Callable[[str, str, Union[str, Dict[str, Any]], int, int, str], str], origSectionName: Optional[str] = None) → str

Creates a new IfTemplate for an existing section in the .ini file

Parameters

modName (str) – The name for the type of mod to fix to
sectionName (str) – The new name of the section
ifTemplate (IfTemplate) – The IfTemplate of the orginal section
fillFunc (Callable[[str, str, Union[str, Dict[str, Any], int, str, str], str]]) –
The function to create a new content part for the new IfTemplate

Tip

For more info about an ‘IfTemplate’, see IfTemplate

The parameter order for the function is:
1. The name for the type of mod to fix to
2. The new section name
3. The corresponding content part in the original IfTemplate
4. The index for the content part in the original IfTemplate
5. The string to prefix every line in the content part of the IfTemplate
6. The original name of the section
origSectionName (Optional[str]) –
The original name of the section.

If this argument is set to None, then will assume this argument has the same value as the argument for sectionName

Default: None

Returns

The text for the newly created IfTemplate

Return type

str

fillObjNonBlendSection(modName: str, sectionName: str, part: Dict[str, Any], partIndex: int, linePrefix: str, origSectionName: str, objName: str, newObjName: str)

Creates the content part of an IfTemplate for the new sections created by this fix that are not related to the [TextureOverride.*Blend.*] sections of some mod object, where the original section comes from a different mod object

Tip

For more info about an ‘IfTemplate’, see IfTemplate

Parameters

modName (str) – The name for the type of mod to fix to
sectionName (str) – The new name for the section
part (Dict[str, Any]) – The content part of the IfTemplate of the original [TextureOverrideBlend] section
partIndex (int) – The index of where the content part appears in the IfTemplate of the original section
linePrefix (str) – The text to prefix every line of the created content part
origSectionName (str) – The name of the original section
objName (str) – The name of the original mod object
newObjName (str) – The name of the mod object to fix to

Returns

The created content part

Return type

str

fix(keepBackup: bool = True, fixOnly: bool = False, update: bool = False) → Union[str, List[str]]

Fixes the .ini file

Parameters

keepBackup (bool) –
Whether to keep backups for the .ini file

Default: True
fixOnly (bool) –
Whether to only fix the .ini file without undoing any fixes

Default: False
update (bool) –
Whether to also update the source text in the IniFile object with the latest fix

Default: False

Returns

The new content of the .ini file which includes the fix and the new content of any other newly created .ini files related to fixing the particular .ini file

Return type

Union[str, List[str]]

fixMod(modName: str, fix: str = '')

Generates the newly added code in the .ini file for the fix of a single type of mod

Note

eg.: If we are making the fix from Jean -> JeanCN and JeanSeaBreeze, The code below will only make the fix for JeanCN

fixMod("JeanCN")

Parameters

modName (str) – The name of the mod to fix
fix (str) –
Any existing text we want the result of the fix to add onto

Default: “”

Returns

The text for the newly generated code in the .ini file

Return type

str

getFix(fixStr: str = ''): Retrieves the text to fix the .ini file

getObjRemapFixName(name: str, modName: str, objName: str, newObjName: str) → str

Retrieves the new name of the section for a new mod object

Parameters

name (str) – The name of the section
modName (str) – The name of the mod to be fixed
objName (str) – The name of the original mod object for the section
newObjName (str) – The name of the new mod object for the section

property objs: Dict[str, List[str]]

The mods objects that will be split to multiple other mod objects

The keys are the names of the objects in the mod to be remapped and the values are the split objects of the remapped mod

Getter: Retrieves the mods objects
Setter: Sets the new objects
Type: Dict[str, List[str]]

property regRemap

Defines how the register values in the parts of an IfTemplate are mapped to a new register in the remapped mod for particular mod objects

The outer keys are the name of the mod objects to have its registers remapped
The inner keys are the names of the registers that hold the register values to be remapped
The inner values are the new names of the registers that will hold the register values

eg.
{"head": {"ps-t1": ["new_ps-t2", "new_ps-t3"]}, "body": {"ps-t3": [ps-t0"], "ps-t0": [], "ps-t1": ["ps-t8"]}}

Note

See GIMIObjReplaceFixer.regEditOldObj for whether the mod objects refer to the mod to be fixed or the fixed mod

Note

This attribute is preceded by GIMIObjSplitFixer.regRemove()

Getter: Retrieves the remap of the registers for the mod objects
Setter: Sets the new remap of the registers
Type: Dict[str, Dict[str, Set[str]]]

property regRemove

Defines whether some register assignments should be removed from the sections of the remapped mod object

The keys are the names of the objects to have their registers removed and the values are the names of the register to be removed

eg.
{"head": {"ps-t1", "ps-t2"}, "body": {"ps-t3", "ps-t0"}}

Note

See GIMIObjReplaceFixer.regEditOldObj for whether the mod objects refer to the mod to be fixed or the fixed mod

Note

This attribute takes precedence over GIMIObjSplitFixer.regRemap()

Getter: Retrieves the registers to be removed for the mod objects
Setter: Sets the new registers to be removed
Type: Dict[str, Set[str]]

remapReg(regName: str, regVal: str, objName: str, linePrefix: str = '') → str

Retrieves the new text with ‘regVal’ remapped to a new register

Parameters

regName (str) – The old name of the register to be remapped
regVal (str) – The value that corresponds to the old name of the register
objName (str) – The name of the mod object where this remap will happend
linePrefix (str) –
Any text to prefix the new text created

Default: ""

Returns

The new text with the register value remapped to a new register

Return type

str

GIMIObjMergeFixer

Attributes

_targetObjs
copyPreamble
objs
regRemap
regRemove

Methods

def_fillNonBlendSections
def_fillRemapResource
def_fillTextureOverrideRemapBlend
def_getAsset
def_getAssetReplacement
def_getHash
def_getHashReplacement
def_getIndex
def_getIndexReplacement
deffillIfTemplate
deffillObjNonBlendSection
deffix
deffixMod
defgetFix
defgetObjRemapFixName
defremapReg

class GIMIObjMergeFixer(parser: GIMIObjParser, objs: Dict[str, List[str]], copyPreamble: str = '')

This class inherits from GIMIObjReplaceFixer

Fixes a .ini file used by a GIMI related importer where particular mod objects (head, body, dress, etc…) in the mod to remap are merged to a single mod object

eg.

 Keqing's "body" and "dress" are merged into KeqingOpulent's "body"

    Keqing             KeqingOpulent
===============       =================
*** objects ***       **** objects ****
    body      -----+---->   body
    head           |        head
    dress     -----+

Note

This class takes advantage of GIMI’s bug/feature of overlapping mods from loading multiple mods of the same character by creating different variations of the original .ini file

Parameters

parser (GIMIObjParser) – The associated parser to retrieve data for the fix
objs (Dict[str, List[str]]) –
The mod objects to be merged to a single mod object

The keys are the names of the merged objects and the values are the names of the mod objects to be merged

Note

The dictionary values should align with the defined object names at GIMIObjParser.objs() for your parser
copyPreamble (str) –
Any text we want to put before the text of the newly generated .ini file variations

Default: ""

_targetObjs

Which original mod objects to show for each merged mod object in the current .ini file

The keys are the names of the original mod objects to display on the current .ini file and the values are the names of the merged objects.

Type: Dict[str, str]

copyPreamble

Any text we want to put before the text of the newly generated .ini file variations

Type: str

_fillNonBlendSections(modName: str, sectionName: str, part: Dict[str, Any], partIndex: int, linePrefix: str, origSectionName: str) → str

Creates the content part of an IfTemplate for the new sections created by this fix that are not related to the [TextureOverride.*Blend.*] sections

Tip

For more info about an ‘IfTemplate’, see IfTemplate

Parameters

modName (str) – The name for the type of mod to fix to
sectionName (str) – The new name for the section
part (Dict[str, Any]) – The content part of the IfTemplate of the original [TextureOverrideBlend] section
partIndex (int) – The index of where the content part appears in the IfTemplate of the original section
linePrefix (str) – The text to prefix every line of the created content part
origSectionName (str) – The name of the original section

Returns

The created content part

Return type

str

_fillRemapResource(modName: str, sectionName: str, part: Dict[str, Any], partIndex: int, linePrefix: str, origSectionName: str)

Creates the content part of an IfTemplate for the new sections created by this fix related to the [Resource.*Blend.*] sections

Tip

For more info about an ‘IfTemplate’, see IfTemplate

Parameters

modName (str) – The name for the type of mod to fix to
sectionName (str) – The new name for the section
part (Dict[str, Any]) – The content part of the IfTemplate of the original [Resource.*Blend.*] section
partIndex (int) – The index of where the content part appears in the IfTemplate of the original section
linePrefix (str) – The text to prefix every line of the created content part
origSectionName (str) – The name of the original section

Returns

The created content part

Return type

str

_fillTextureOverrideRemapBlend(modName: str, sectionName: str, part: Dict[str, Any], partIndex: int, linePrefix: str, origSectionName: str) → str

Creates the content part of an IfTemplate for the new sections created by this fix related to the [TextureOverride.*Blend.*] sections

Tip

For more info about an ‘IfTemplate’, see IfTemplate

Parameters

modName (str) – The name for the type of mod to fix to
sectionName (str) – The new name for the section
part (Dict[str, Any]) – The content part of the IfTemplate of the original [TextureOverrideBlend] section
partIndex (int) – The index of where the content part appears in the IfTemplate of the original section
linePrefix (str) – The text to prefix every line of the created content part
origSectionName (str) – The name of the original section

Returns

The created content part

Return type

str

_getAsset(assetType: str, assetRepoAttName: str, modName: str, notFoundVal: Optional[Any] = None) → Union[str, Any]

Retrieves the corresponding asset

Parameters

assetType (str) – The name for the type of asset to retrieve
assetRepoAttName (str) – The name of the ModIdAssets repo in IniFile.availableType()
modName (str) – The name of the mod we want the asset for
notFoundVal (Any) –
The value to be returned if the replacement is not found

Default: None

Returns

The found asset or the value from ‘notFoundVal’ if the asset was not found

Return type

Union[str, Any]

_getAssetReplacement(asset: str, assetRepoAttName: str, modName: str, notFoundVal: Optional[Any] = None) → Union[str, Any]

Retrieves the replacement for ‘asset’

Parameters

asset (str) – The asset to be replaced
assetRepoAttName (str) – The name of the ModIdAssets repo in IniFile.availableType()
modName (str) – The name of the mod we want the replacement for
notFoundVal (Any) –
The value to be returns if the replacement is not found

Default: None

Returns

The found replacement asset or the value from ‘notFoundVal’ if the replacement was not found

Return type

Union[str, Any]

_getHash(hashType: str, modName: str) → str

Retrieves the corresponding hash

Parameters

hashType (str) – The name for the type of hash to retrieve
modName (str) – The name for the type of mod to get the hash from

Returns

The found hash or “HashNotFound” if the corresponding hash is not found

Return type

str

_getHashReplacement(hash: str, modName: str) → str

Retrieves the replacement for ‘hash’

Parameters

hash (str) – The hash to be replaced
modName (str) – The name of the mod we want the replacement for

Returns

The corresponding replacement for the hash or “HashNotFound” if there are not replacements

Return type

str

_getIndex(indexType: str, modName: str) → str

Retrieves the corresponding index

Parameters

indexType (str) – The name for the type of index to retrieve
modName (str) – The name for the type of mod to get the index from

Returns

The found index or “IndexNotFound” if the corresponding index is not found

Return type

str

_getIndexReplacement(index: str, modName: str) → str

Retrieves the replacement for ‘index’

Parameters

index (str) – The index to be replaced
modName (str) – The name of the mod we want the replacement for

Returns

The corresponding replacement for the index or “IndexNotFound” if there are not replacements

Return type

str

fillIfTemplate(modName: str, sectionName: str, ifTemplate: IfTemplate, fillFunc: Callable[[str, str, Union[str, Dict[str, Any]], int, int, str], str], origSectionName: Optional[str] = None) → str

Creates a new IfTemplate for an existing section in the .ini file

Parameters

modName (str) – The name for the type of mod to fix to
sectionName (str) – The new name of the section
ifTemplate (IfTemplate) – The IfTemplate of the orginal section
fillFunc (Callable[[str, str, Union[str, Dict[str, Any], int, str, str], str]]) –
The function to create a new content part for the new IfTemplate

Tip

For more info about an ‘IfTemplate’, see IfTemplate

The parameter order for the function is:
1. The name for the type of mod to fix to
2. The new section name
3. The corresponding content part in the original IfTemplate
4. The index for the content part in the original IfTemplate
5. The string to prefix every line in the content part of the IfTemplate
6. The original name of the section
origSectionName (Optional[str]) –
The original name of the section.

If this argument is set to None, then will assume this argument has the same value as the argument for sectionName

Default: None

Returns

The text for the newly created IfTemplate

Return type

str

fillObjNonBlendSection(modName: str, sectionName: str, part: Dict[str, Any], partIndex: int, linePrefix: str, origSectionName: str, objName: str, newObjName: str)

Creates the content part of an IfTemplate for the new sections created by this fix that are not related to the [TextureOverride.*Blend.*] sections of some mod object, where the original section comes from a different mod object

Tip

For more info about an ‘IfTemplate’, see IfTemplate

Parameters

modName (str) – The name for the type of mod to fix to
sectionName (str) – The new name for the section
part (Dict[str, Any]) – The content part of the IfTemplate of the original [TextureOverrideBlend] section
partIndex (int) – The index of where the content part appears in the IfTemplate of the original section
linePrefix (str) – The text to prefix every line of the created content part
origSectionName (str) – The name of the original section
objName (str) – The name of the original mod object
newObjName (str) – The name of the mod object to fix to

Returns

The created content part

Return type

str

fix(keepBackup: bool = True, fixOnly: bool = False, update: bool = False) → Union[str, List[str]]

Fixes the .ini file

Parameters

keepBackup (bool) –
Whether to keep backups for the .ini file

Default: True
fixOnly (bool) –
Whether to only fix the .ini file without undoing any fixes

Default: False
update (bool) –
Whether to also update the source text in the IniFile object with the latest fix

Default: False

Returns

The new content of the .ini file which includes the fix and the new content of any other newly created .ini files related to fixing the particular .ini file

Return type

Union[str, List[str]]

fixMod(modName: str, fix: str = '')

Generates the newly added code in the .ini file for the fix of a single type of mod

Note

eg.: If we are making the fix from Jean -> JeanCN and JeanSeaBreeze, The code below will only make the fix for JeanCN

fixMod("JeanCN")

Parameters

modName (str) – The name of the mod to fix
fix (str) –
Any existing text we want the result of the fix to add onto

Default: “”

Returns

The text for the newly generated code in the .ini file

Return type

str

getFix(fixStr: str = ''): Retrieves the text to fix the .ini file

getObjRemapFixName(name: str, modName: str, objName: str, newObjName: str) → str

Retrieves the new name of the section for a new mod object

Parameters

name (str) – The name of the section
modName (str) – The name of the mod to be fixed
objName (str) – The name of the original mod object for the section
newObjName (str) – The name of the new mod object for the section

property objs

The mod objects to be merged to a single mod object

The keys are the names of the merged objects and the values are the names of the mod objects to be merged

Getter: Retrieves the mod objects to be merged
Setter: Set the new mod objects to be merged
Type: Dict[str, List[str]]

property regRemap

Defines how the register values in the parts of an IfTemplate are mapped to a new register in the remapped mod for particular mod objects

The outer keys are the name of the mod objects to have its registers remapped
The inner keys are the names of the registers that hold the register values to be remapped
The inner values are the new names of the registers that will hold the register values

eg.
{"head": {"ps-t1": ["new_ps-t2", "new_ps-t3"]}, "body": {"ps-t3": [ps-t0"], "ps-t0": [], "ps-t1": ["ps-t8"]}}

Note

See GIMIObjReplaceFixer.regEditOldObj for whether the mod objects refer to the mod to be fixed or the fixed mod

Note

This attribute is preceded by GIMIObjSplitFixer.regRemove()

Getter: Retrieves the remap of the registers for the mod objects
Setter: Sets the new remap of the registers
Type: Dict[str, Dict[str, Set[str]]]

property regRemove

Defines whether some register assignments should be removed from the sections of the remapped mod object

The keys are the names of the objects to have their registers removed and the values are the names of the register to be removed

eg.
{"head": {"ps-t1", "ps-t2"}, "body": {"ps-t3", "ps-t0"}}

Note

See GIMIObjReplaceFixer.regEditOldObj for whether the mod objects refer to the mod to be fixed or the fixed mod

Note

This attribute takes precedence over GIMIObjSplitFixer.regRemap()

Getter: Retrieves the registers to be removed for the mod objects
Setter: Sets the new registers to be removed
Type: Dict[str, Set[str]]

remapReg(regName: str, regVal: str, objName: str, linePrefix: str = '') → str

Retrieves the new text with ‘regVal’ remapped to a new register

Parameters

regName (str) – The old name of the register to be remapped
regVal (str) – The value that corresponds to the old name of the register
objName (str) – The name of the mod object where this remap will happend
linePrefix (str) –
Any text to prefix the new text created

Default: ""

Returns

The new text with the register value remapped to a new register

Return type

str

GIMIObjRegEditFixer

Attributes

objs
regRemap
regRemove

Methods

def_fillNonBlendSections
def_fillRemapResource
def_fillTextureOverrideRemapBlend
def_getAsset
def_getAssetReplacement
def_getHash
def_getHashReplacement
def_getIndex
def_getIndexReplacement
deffillIfTemplate
deffillObjNonBlendSection
deffix
deffixMod
defgetFix
defgetObjRemapFixName
defremapReg

class GIMIObjRegEditFixer(parser: GIMIObjParser, regRemap: Optional[Dict[str, Dict[str, str]]] = None, regRemove: Optional[Dict[str, Set[str]]] = None)

This class inherits from GIMIObjSplitFixer

Fixes a .ini file used by a GIMI related importer where particular mod objects (head, body, dress, etc…) in the mod to remap needs to have their registers remapped or removed

Parameters

regRemap (Optional[Dict[str, Dict[str, List[str]]]]) –
Defines how the register values in the parts of an IfTemplate are mapped to a new register in the remapped mod for particular mod objects
- The outer keys is the name of the mod object to have its registers remapped for the fixed mod
- The inner keys are the names of the registers that hold the register values to be remapped
- The inner values are the new names of the registers that will hold the register values
eg.
{"head": {"ps-t1": ["new_ps-t2", "new_ps-t3"]}, "body": {"ps-t3": [ps-t0"], "ps-t0": [], "ps-t1": ["ps-t8"]}}

Note

For this class, GIMIObjReplaceFixer.regEditOldObj is set to False

Note

This parameter is preceded by GIMIObjSplitFixer.regRemove()

Default: None
regRemove (Optional[Dict[str, Set[str]]]) –
Defines whether some register assignments should be removed from the sections of some mod object

The keys are the names of the objects to have their registers removed and the values are the names of the register to be removed

eg.
{"head": {"ps-t1", "ps-t2"}, "body": {"ps-t3", "ps-t0"}}

Note

For this class, GIMIObjReplaceFixer.regEditOldObj is set to False

Note

This parameter takes precedence over GIMIObjSplitFixer.regRemap()

Default: None

_fillNonBlendSections(modName: str, sectionName: str, part: Dict[str, Any], partIndex: int, linePrefix: str, origSectionName: str) → str

Creates the content part of an IfTemplate for the new sections created by this fix that are not related to the [TextureOverride.*Blend.*] sections

Tip

For more info about an ‘IfTemplate’, see IfTemplate

Parameters

modName (str) – The name for the type of mod to fix to
sectionName (str) – The new name for the section
part (Dict[str, Any]) – The content part of the IfTemplate of the original [TextureOverrideBlend] section
partIndex (int) – The index of where the content part appears in the IfTemplate of the original section
linePrefix (str) – The text to prefix every line of the created content part
origSectionName (str) – The name of the original section

Returns

The created content part

Return type

str

_fillRemapResource(modName: str, sectionName: str, part: Dict[str, Any], partIndex: int, linePrefix: str, origSectionName: str)

Creates the content part of an IfTemplate for the new sections created by this fix related to the [Resource.*Blend.*] sections

Tip

For more info about an ‘IfTemplate’, see IfTemplate

Parameters

modName (str) – The name for the type of mod to fix to
sectionName (str) – The new name for the section
part (Dict[str, Any]) – The content part of the IfTemplate of the original [Resource.*Blend.*] section
partIndex (int) – The index of where the content part appears in the IfTemplate of the original section
linePrefix (str) – The text to prefix every line of the created content part
origSectionName (str) – The name of the original section

Returns

The created content part

Return type

str

_fillTextureOverrideRemapBlend(modName: str, sectionName: str, part: Dict[str, Any], partIndex: int, linePrefix: str, origSectionName: str) → str

Creates the content part of an IfTemplate for the new sections created by this fix related to the [TextureOverride.*Blend.*] sections

Tip

For more info about an ‘IfTemplate’, see IfTemplate

Parameters

modName (str) – The name for the type of mod to fix to
sectionName (str) – The new name for the section
part (Dict[str, Any]) – The content part of the IfTemplate of the original [TextureOverrideBlend] section
partIndex (int) – The index of where the content part appears in the IfTemplate of the original section
linePrefix (str) – The text to prefix every line of the created content part
origSectionName (str) – The name of the original section

Returns

The created content part

Return type

str

_getAsset(assetType: str, assetRepoAttName: str, modName: str, notFoundVal: Optional[Any] = None) → Union[str, Any]

Retrieves the corresponding asset

Parameters

assetType (str) – The name for the type of asset to retrieve
assetRepoAttName (str) – The name of the ModIdAssets repo in IniFile.availableType()
modName (str) – The name of the mod we want the asset for
notFoundVal (Any) –
The value to be returned if the replacement is not found

Default: None

Returns

The found asset or the value from ‘notFoundVal’ if the asset was not found

Return type

Union[str, Any]

_getAssetReplacement(asset: str, assetRepoAttName: str, modName: str, notFoundVal: Optional[Any] = None) → Union[str, Any]

Retrieves the replacement for ‘asset’

Parameters

asset (str) – The asset to be replaced
assetRepoAttName (str) – The name of the ModIdAssets repo in IniFile.availableType()
modName (str) – The name of the mod we want the replacement for
notFoundVal (Any) –
The value to be returns if the replacement is not found

Default: None

Returns

The found replacement asset or the value from ‘notFoundVal’ if the replacement was not found

Return type

Union[str, Any]

_getHash(hashType: str, modName: str) → str

Retrieves the corresponding hash

Parameters

hashType (str) – The name for the type of hash to retrieve
modName (str) – The name for the type of mod to get the hash from

Returns

The found hash or “HashNotFound” if the corresponding hash is not found

Return type

str

_getHashReplacement(hash: str, modName: str) → str

Retrieves the replacement for ‘hash’

Parameters

hash (str) – The hash to be replaced
modName (str) – The name of the mod we want the replacement for

Returns

The corresponding replacement for the hash or “HashNotFound” if there are not replacements

Return type

str

_getIndex(indexType: str, modName: str) → str

Retrieves the corresponding index

Parameters

indexType (str) – The name for the type of index to retrieve
modName (str) – The name for the type of mod to get the index from

Returns

The found index or “IndexNotFound” if the corresponding index is not found

Return type

str

_getIndexReplacement(index: str, modName: str) → str

Retrieves the replacement for ‘index’

Parameters

index (str) – The index to be replaced
modName (str) – The name of the mod we want the replacement for

Returns

The corresponding replacement for the index or “IndexNotFound” if there are not replacements

Return type

str

fillIfTemplate(modName: str, sectionName: str, ifTemplate: IfTemplate, fillFunc: Callable[[str, str, Union[str, Dict[str, Any]], int, int, str], str], origSectionName: Optional[str] = None) → str

Creates a new IfTemplate for an existing section in the .ini file

Parameters

modName (str) – The name for the type of mod to fix to
sectionName (str) – The new name of the section
ifTemplate (IfTemplate) – The IfTemplate of the orginal section
fillFunc (Callable[[str, str, Union[str, Dict[str, Any], int, str, str], str]]) –
The function to create a new content part for the new IfTemplate

Tip

For more info about an ‘IfTemplate’, see IfTemplate

The parameter order for the function is:
1. The name for the type of mod to fix to
2. The new section name
3. The corresponding content part in the original IfTemplate
4. The index for the content part in the original IfTemplate
5. The string to prefix every line in the content part of the IfTemplate
6. The original name of the section
origSectionName (Optional[str]) –
The original name of the section.

If this argument is set to None, then will assume this argument has the same value as the argument for sectionName

Default: None

Returns

The text for the newly created IfTemplate

Return type

str

fillObjNonBlendSection(modName: str, sectionName: str, part: Dict[str, Any], partIndex: int, linePrefix: str, origSectionName: str, objName: str, newObjName: str)

Creates the content part of an IfTemplate for the new sections created by this fix that are not related to the [TextureOverride.*Blend.*] sections of some mod object, where the original section comes from a different mod object

Tip

For more info about an ‘IfTemplate’, see IfTemplate

Parameters

modName (str) – The name for the type of mod to fix to
sectionName (str) – The new name for the section
part (Dict[str, Any]) – The content part of the IfTemplate of the original [TextureOverrideBlend] section
partIndex (int) – The index of where the content part appears in the IfTemplate of the original section
linePrefix (str) – The text to prefix every line of the created content part
origSectionName (str) – The name of the original section
objName (str) – The name of the original mod object
newObjName (str) – The name of the mod object to fix to

Returns

The created content part

Return type

str

fix(keepBackup: bool = True, fixOnly: bool = False, update: bool = False) → Union[str, List[str]]

Fixes the .ini file

Parameters

keepBackup (bool) –
Whether to keep backups for the .ini file

Default: True
fixOnly (bool) –
Whether to only fix the .ini file without undoing any fixes

Default: False
update (bool) –
Whether to also update the source text in the IniFile object with the latest fix

Default: False

Returns

The new content of the .ini file which includes the fix and the new content of any other newly created .ini files related to fixing the particular .ini file

Return type

Union[str, List[str]]

fixMod(modName: str, fix: str = '')

Generates the newly added code in the .ini file for the fix of a single type of mod

Note

eg.: If we are making the fix from Jean -> JeanCN and JeanSeaBreeze, The code below will only make the fix for JeanCN

fixMod("JeanCN")

Parameters

modName (str) – The name of the mod to fix
fix (str) –
Any existing text we want the result of the fix to add onto

Default: “”

Returns

The text for the newly generated code in the .ini file

Return type

str

getFix(fixStr: str = ''): Retrieves the text to fix the .ini file

getObjRemapFixName(name: str, modName: str, objName: str, newObjName: str) → str

Retrieves the new name of the section for a new mod object

Parameters

name (str) – The name of the section
modName (str) – The name of the mod to be fixed
objName (str) – The name of the original mod object for the section
newObjName (str) – The name of the new mod object for the section

property objs: Dict[str, List[str]]

The mods objects that will be split to multiple other mod objects

The keys are the names of the objects in the mod to be remapped and the values are the split objects of the remapped mod

Getter: Retrieves the mods objects
Setter: Sets the new objects
Type: Dict[str, List[str]]

property regRemap

Defines how the register values in the parts of an IfTemplate are mapped to a new register in the remapped mod for particular mod objects

The outer keys are the name of the mod objects to have its registers remapped
The inner keys are the names of the registers that hold the register values to be remapped
The inner values are the new names of the registers that will hold the register values

eg.
{"head": {"ps-t1": ["new_ps-t2", "new_ps-t3"]}, "body": {"ps-t3": [ps-t0"], "ps-t0": [], "ps-t1": ["ps-t8"]}}

Note

See GIMIObjReplaceFixer.regEditOldObj for whether the mod objects refer to the mod to be fixed or the fixed mod

Note

This attribute is preceded by GIMIObjSplitFixer.regRemove()

Getter: Retrieves the remap of the registers for the mod objects
Setter: Sets the new remap of the registers
Type: Dict[str, Dict[str, Set[str]]]

property regRemove

Defines whether some register assignments should be removed from the sections of the remapped mod object

The keys are the names of the objects to have their registers removed and the values are the names of the register to be removed

eg.
{"head": {"ps-t1", "ps-t2"}, "body": {"ps-t3", "ps-t0"}}

Note

See GIMIObjReplaceFixer.regEditOldObj for whether the mod objects refer to the mod to be fixed or the fixed mod

Note

This attribute takes precedence over GIMIObjSplitFixer.regRemap()

Getter: Retrieves the registers to be removed for the mod objects
Setter: Sets the new registers to be removed
Type: Dict[str, Set[str]]

remapReg(regName: str, regVal: str, objName: str, linePrefix: str = '') → str

Retrieves the new text with ‘regVal’ remapped to a new register

Parameters

regName (str) – The old name of the register to be remapped
regVal (str) – The value that corresponds to the old name of the register
objName (str) – The name of the mod object where this remap will happend
linePrefix (str) –
Any text to prefix the new text created

Default: ""

Returns

The new text with the register value remapped to a new register

Return type

str

MultiModFixer

Attributes

_fixBuilders
_fixers

Methods

def_getAsset
def_getAssetReplacement
def_getHash
def_getHashReplacement
def_getIndex
def_getIndexReplacement
defbuildFixers
deffillIfTemplate
deffix
defgetFix

class MultiModFixer(parser: BaseIniParser, fixBuilders: Dict[str, IniFixBuilder])

This class inherits from BaseIniFixer

Fixes a .ini file where each mod to fix requires a different BaseIniFixer strategy

Parameters

parser (BaseIniParser) – The associated parser to retrieve data for the fix
fixBuilders (Dict[str, IniFixBuilder]) –
The different builders to dynamcally construct the BaseIniFixer used for each mod to fix

The keys are the names of the mods to fix and the values are the different IniFixBuilder used to construct the BaseIniFixer to fix the mod

_fixBuilders

The different builders to dynamcally construct the BaseIniFixer used for each mod to fix

The keys are the names of the mods to fix and the values are the different IniFixBuilder used to construct the BaseIniFixer to fix the mod

Type: Dict[str, IniFixBuilder]

_fixers

The different fixers to fix each type of mod

The keys are the names of the mods to fix and the values are the fixers to fix the mod

Type: Dict[str, BaseIniFixer]

_getAsset(assetType: str, assetRepoAttName: str, modName: str, notFoundVal: Optional[Any] = None) → Union[str, Any]

Retrieves the corresponding asset

Parameters

assetType (str) – The name for the type of asset to retrieve
assetRepoAttName (str) – The name of the ModIdAssets repo in IniFile.availableType()
modName (str) – The name of the mod we want the asset for
notFoundVal (Any) –
The value to be returned if the replacement is not found

Default: None

Returns

The found asset or the value from ‘notFoundVal’ if the asset was not found

Return type

Union[str, Any]

_getAssetReplacement(asset: str, assetRepoAttName: str, modName: str, notFoundVal: Optional[Any] = None) → Union[str, Any]

Retrieves the replacement for ‘asset’

Parameters

asset (str) – The asset to be replaced
assetRepoAttName (str) – The name of the ModIdAssets repo in IniFile.availableType()
modName (str) – The name of the mod we want the replacement for
notFoundVal (Any) –
The value to be returns if the replacement is not found

Default: None

Returns

The found replacement asset or the value from ‘notFoundVal’ if the replacement was not found

Return type

Union[str, Any]

_getHash(hashType: str, modName: str) → str

Retrieves the corresponding hash

Parameters

hashType (str) – The name for the type of hash to retrieve
modName (str) – The name for the type of mod to get the hash from

Returns

The found hash or “HashNotFound” if the corresponding hash is not found

Return type

str

_getHashReplacement(hash: str, modName: str) → str

Retrieves the replacement for ‘hash’

Parameters

hash (str) – The hash to be replaced
modName (str) – The name of the mod we want the replacement for

Returns

The corresponding replacement for the hash or “HashNotFound” if there are not replacements

Return type

str

_getIndex(indexType: str, modName: str) → str

Retrieves the corresponding index

Parameters

indexType (str) – The name for the type of index to retrieve
modName (str) – The name for the type of mod to get the index from

Returns

The found index or “IndexNotFound” if the corresponding index is not found

Return type

str

_getIndexReplacement(index: str, modName: str) → str

Retrieves the replacement for ‘index’

Parameters

index (str) – The index to be replaced
modName (str) – The name of the mod we want the replacement for

Returns

The corresponding replacement for the index or “IndexNotFound” if there are not replacements

Return type

str

buildFixers(): Rebuilds the BaseIniFixer used for each mod

fillIfTemplate(modName: str, sectionName: str, ifTemplate: IfTemplate, fillFunc: Callable[[str, str, Union[str, Dict[str, Any]], int, int, str], str], origSectionName: Optional[str] = None) → str

Creates a new IfTemplate for an existing section in the .ini file

Parameters

modName (str) – The name for the type of mod to fix to
sectionName (str) – The new name of the section
ifTemplate (IfTemplate) – The IfTemplate of the orginal section
fillFunc (Callable[[str, str, Union[str, Dict[str, Any], int, str, str], str]]) –
The function to create a new content part for the new IfTemplate

Tip

For more info about an ‘IfTemplate’, see IfTemplate

The parameter order for the function is:
1. The name for the type of mod to fix to
2. The new section name
3. The corresponding content part in the original IfTemplate
4. The index for the content part in the original IfTemplate
5. The string to prefix every line in the content part of the IfTemplate
6. The original name of the section
origSectionName (Optional[str]) –
The original name of the section.

If this argument is set to None, then will assume this argument has the same value as the argument for sectionName

Default: None

Returns

The text for the newly created IfTemplate

Return type

str

fix(keepBackup: bool = True, fixOnly: bool = False, update: bool = False) → Union[str, List[str]]

Fixes the .ini file

Parameters

keepBackup (bool) –
Whether to keep backups for the .ini file

Default: True
fixOnly (bool) –
Whether to only fix the .ini file without undoing any fixes

Default: False
update (bool) –
Whether to also update the source text in the IniFile object with the latest fix

Default: False

Returns

The new content of the .ini file which includes the fix and the new content of any other newly created .ini files related to fixing the particular .ini file

Return type

Union[str, List[str]]

getFix(fixStr: str = '') → str: Retrieves the text to fix the .ini file

Ini Removers

BaseIniRemover

Attributes

_readLines
iniFile

Methods

defremove

class BaseIniRemover(iniFile: IniFile)

Base class to remove fixes from a .ini file

Parameters: iniFile (IniFile) – The .ini file to remove the fix from

iniFile

The .ini file that will be parsed

Type: IniFile

static _readLines(func)

Decorator to read all the lines in the .ini file first before running a certain function

All the file lines will be saved in IniFile._fileLines

Examples

@_readLines
def printLines(self):
    for line in self.iniFile.fileLines:
        print(f"LINE: {line}")

remove(parse: bool = False) → str

Removes the fix from the .ini file

Parameters

parse (bool) –

Whether to also parse for the .*RemapBlend.buf files that need to be removed

Default: False

Returns

The new content of the .ini file

Return type

str

IniRemoveBuilder

Attributes

cache

Methods

defbuild

class IniRemoveBuilder(cls: Type[BaseIniRemover], args: Optional[List[Any]] = None, kwargs: Optional[Dict[str, Any]] = None, cache: bool = True)

This class inherits from FlyweightBuilder

A class to help dynamically build a BaseIniRemover

Parameters

cls (Type[BaseIniRemover]) – The class to construct a BaseIniRemover
args (Optional[List[Any]]) –
The constant arguments used to build the object

Default: None
kwargs (Optional[Dict[str, Any]]) –
The constant keyword arguments used to build the object

Default: None
cache (bool) –
Whether to cache the built object

Default: True

cache

Whether to cache the built object

Type: bool

build(iniFile: IniFile) → BaseIniRemover

Builds the remover

Parameters: iniFile (IniFile) – The .ini file to parse
Returns: The built remover
Return type: BaseIniRemover

IniRemover

Attributes

_readLines

Methods

defremove

class IniRemover(iniFile: IniFile)

This class inherits from BaseIniRemover

Class for the basic removal of the fixes from .ini files

Parameters: iniFile (IniFile) – The .ini file to remove the fix from

static _readLines(func)

Decorator to read all the lines in the .ini file first before running a certain function

All the file lines will be saved in IniFile._fileLines

Examples

@_readLines
def printLines(self):
    for line in self.iniFile.fileLines:
        print(f"LINE: {line}")

remove(parse: bool = False) → str

Removes the fix from the .ini file

Parameters

parse (bool) –

Whether to also parse for the .*RemapBlend.buf files that need to be removed

Default: False

Returns

The new content of the .ini file

Return type

str

Models

Model

Attributes

logger

Methods

defprint

class Model(logger: Optional[Logger] = None)

Generic class used for any data models in the fix

Parameters

logger (Optional[Logger]) –

The logger used to print messages to the console

Default: None

logger

The logger used to print messages to the console

Type: Optional[Logger]

print(funcName: str, *args, **kwargs)

Prints out output

Parameters

funcName (str) – The name of the function in the logger for printing out the output
*args (List[str]) – Arguments to pass to the function in the logger
**kwargs (Dict[str, Any]) – Keyword arguments to pass to the function in the logger

Returns

The return value from running the corresponding function in the logger

Return type

Any

RemapBlendModel

Attributes

fixedBlendPaths
fullPaths
iniFolderPath
origBlendPaths
origFullPaths

class RemapBlendModel(iniFolderPath: str, fixedBlendPaths: Dict[int, Dict[str, str]], origBlendPaths: Optional[Dict[int, str]] = None)

Contains data for fixing a particular resource in a .ini file

Parameters

iniFolderPath (str) – The folder path to where the .ini file of the resource is located
fixedBlendPaths (Dict[int, Dict[str, str]]) –
The file paths to the fixed RemapBlend.buf files for the resource
- The outer keys are the indices that the Blend.buf file appears in the IfTemplate for some resource
- The inner keys are the names for the type of mod to fix to
- The inner values are the file paths
origBlendPaths (Optional[Dict[int, str]]) –
The file paths to the Blend.buf files for the resource

The keys are the indices that the Blend.buf file appears in the IfTemplate for some resource

Default: None

iniFolderPath

The folder path to where the .ini file of the resource is located

Type: str

fixedBlendPaths

The file paths to the fixed RemapBlend.buf files for the resource

The outer keys are the indices that the Blend.buf file appears in the IfTemplate for some resource
The inner keys are the names for the type of mod to fix to
The inner values are the file paths

Type: Dict[int, Dict[str, str]]

origBlendPaths

The file paths to the Blend.buf files for the resource

The keys are the indices that the Blend.buf file appears in the IfTemplate for the resource

Type: Optional[Dict[int, str]]

fullPaths

The absolute paths to the fixed RemapBlend.buf files for the resource

The outer keys are the indices that the Blend.buf file appears in the IfTemplate for some resource
The inner keys are the names for the type of mod to fix to
The inner values are the file paths

Type: Dict[int, Dict[str, str]]

origFullPaths

The absolute paths to the Blend.buf files for the resource

The keys are the indices that the Blend.buf file appears in the IfTemplate for the resource

Type: Dict[int, str]

Views

Logger

Attributes

_headings
_loggedTxt
_prefix
includePrefix
logTxt
loggedTxt
prefix
verbose

Methods

clsLogger.getBulletStr
clsLogger.getNumberedStr
def_addLogTxt
def_setDefaultHeadingAtts
defbox
defbulletPoint
defclear
defcloseHeading
deferror
defgetStr
defhandleException
definput
deflist
deflog
defopenHeading
defspace
defsplit
defwaitExit

class Logger(prefix: str = '', logTxt: bool = False, verbose: bool = True)

Class for pretty printing output to display on the console

Parameters

prefix (str) –
line that is printed before any message is printed out

Default: “”
logTxt (bool) –
Whether to log all the printed messages into a .txt file once the fix is done

Default: False
verbose (bool) –
Whether to print out output

Default: True

includePrefix

Whether to include the prefix string when printing out a message

Type: bool

verbose

Whether to print out output

Type: bool

logTxt

Whether to log all the printed messages into a .txt file once the fix is done

Type: bool

_prefix

line that is printed before any message is printed out

Type: str

_headings

A stack of headings that have been opened (by calling Heading.open()), but have not been closed yet (have not called Heading.close() yet)

Type: Deque[Heading]

_loggedTxt

The text that will be logged into a .txt file

Type: str

_addLogTxt(txt: str)

Appends the text to the logged output to be printed to a .txt file

Parameters: txt (str) – The text to be added onto the logged output

_setDefaultHeadingAtts(): Sets the default attributes for printing out a header line

box(message: str, header: str)

Prints the message to be sandwiched by the text defined in the argument, header

Parameters

message (str) – The message we want to print out
header (str) – The string that we want to sandwich our message against

bulletPoint(txt: str)

Prints out an item in an unordered list

Parameters: txt (str) – The message we want to print out

clear(): Clears out any saved text from the logger

closeHeading(): Prints out a closing heading that corresponds to a previous opening heading printed (see line 3 of the example at Heading)

error(message: str)

Prints an error message

Parameters: message (str) – The message we want to print out

classmethod getBulletStr(txt: str) → str

Creates the string for an item in an unordered list

Parameters: txt (str) – The message we want to print out
Returns: The text formatted as an item in an unordered list
Return type: str

classmethod getNumberedStr(txt: str, num: int) → str

Creates the string for an ordered list

Parameters

txt (str) – The message we want to print out
num (str) – The number we want to print out before the text for the ordered list

Returns

The text formatted as an item in an ordered list

Return type

str

getStr(message: str)

Retrieves the string to be printed out by the logger

Parameters: message (str) – The message we want to print out
Returns: The transformed text that the logger prints out
Return type: str

handleException(exception: Exception)

Prints the message for an error

Parameters: exception (Exception) – The error we want to handle

input(desc: str) → str

Handles user input from the console

Parameters: desc (str) – The question/description being asked to the user for input
Returns: The resultant input the user entered
Return type: str

list(lst: List[str], transform: Optional[Callable[[str], str]] = None)

Prints out an ordered list

Parameters

lst (List[str]) – The list of messages we want to print out
transform (Optional[Callable[[str], str]]) –
A function used to do any processing on each message in the list of messages

If this parameter is None, then the list of message will not go through any type of processing

Default: None

log(message: str)

Regularly prints text onto the console

Parameters: message (str) – The message we want to print out

property loggedTxt

The text to be logged into a .txt file

Getter: Returns such a prefix
Type: str

openHeading(txt: str, sideLen: int = 2, headingChar='=')

Prints out an opening heading

Parameters

txt (str) – The message we want to print out
sideLen (int) –
How many characters we want for the side border of the heading
(see line 1 of the example at Heading)

Default: 2
headingChar (str) –
The type of character used to print the side border of the heading
(see line 3 of the example at Heading)

Default: “=”

property prefix

The line of text that is printed before any message is printed out

Getter: Returns such a prefix
Setter: Sets up such a prefix for the logger
Type: str

space(): Prints out a space

split(): Prints out a new line

waitExit(): Prints the message used when the script finishes running

Heading

Attributes

sideChar
sideLen
title

Methods

defclose
defcopy
defopen

class Heading(title: str = '', sideLen: int = 0, sideChar: str = '=')

Class for handling information about a heading for pretty printing

Examples

======= Title: Fix Raiden Boss 2 =======
...
========================================

Parameters

title (str) –
The title for the heading

Default: “”
sideLen (int) –
The number of characters we want one side for the border of the opening heading to have

Default: 0
sideChar (str) –
The type of character we want the border for the heading to have

Default: “=”

title

The title for the heading

Type: str

sideLen

The number of characters we want one side for the border of the opening heading to have

Type: int

sideChar

The type of character we want the border for the heading to have

Type: str

close() → str

Makes the closing heading (see line 3 of the example at Heading)

Returns: The closing heading created
Return type: str

copy()

Makes a new copy of a heading

Returns: The new copy of the heading
Return type: Heading

open() → str

Makes the opening heading (see line 1 of the example at Heading)

Returns: The opening heading created
Return type: str

Enums

ModTypes

class ModTypes(value)

The supported types of mods that can be fixed

Amber

Amber mods

Checks if the .ini file contains a section with the regex ^\s*\[\s*TextureOverride.*(Amber)((?!(RemapBlend|CN)).)*Blend.*\s*\]

Type: ModType

AmberCN

Amber Chinese mods

Checks if the .ini file contains a section with the regex ^\s*\[\s*TextureOverride.*(AmberCN)((?!RemapBlend).)*Blend.*\s*\]

Type: ModType

Arlecchino

Arlecchino mods

Checks if the .ini file contains a section with the regex ^\s*\[\s*TextureOverride.*(Arlecchino)((?!RemapBlend).)*Blend.*\s*\]

Type: ModType

Barbara

Barabara mods

Checks if the .ini file contains a section with the regex ^\s*\[\s*TextureOverride.*(Barbara)((?!RemapBlend|Summertime).)*Blend.*\s*\]

Type: ModType

BarbaraSummertime

Barabara Summertime mods

Checks if the .ini file contains a section with the regex ^\s*\[\s*TextureOverride.*(BarbaraSummertime)((?!RemapBlend).)*Blend.*\s*\]

Type: ModType

Ganyu

Ganyu mods

Checks if the .ini file contains a section with the regex ^\s*\[\s*TextureOverride.*(Ganyu)((?!(RemapBlend|Twilight)).)*Blend.*\s*\]

Type: ModType

GanyuTwilight

Ganyu Latern Rite mods

Checks if the .ini file contains a section with the regex ^\s*\[\s*TextureOverride.*(GanyuTwilight)((?!(RemapBlend)).)*Blend.*\s*\]

Type: ModType

Jean

Jean mods

Checks if the .ini file contains a section with the regex ^\s*\[\s*TextureOverride.*(Jean)((?!(RemapBlend|CN|Sea)).)*Blend.*\s*\]

Type: ModType

JeanCN

Jean Chinese mods

Checks if the .ini file contains a section with the regex ^\s*\[\s*TextureOverride.*(JeanCN)((?!RemapBlend|Sea).)*Blend.*\s*\]

Type: ModType

JeanSea

Jean Summertime mods

Checks if the .ini file contains a section with the regex ^\s*\[\s*TextureOverride.*(JeanSea)((?!RemapBlend|CN).)*Blend.*\s*\]

Type: ModType

Keqing

Keqing mods

Checks if the .ini file contains a section with the regex ^\s*\[\s*TextureOverride.*(Keqing)((?!(RemapBlend|Opulent)).)*Blend.*\s*\]

Type: ModType

KeqingOpulent

Keqing Lantern Rite mods

Checks if the .ini file contains a section with the regex ^\s*\[\s*TextureOverride.*(KeqingOpulent)((?!RemapBlend).)*Blend.*\s*\]

Type: ModType

Mona

Mona mods

Checks if the .ini file contains a section with the regex ^\s*\[\s*TextureOverride.*(Mona)((?!(RemapBlend|CN)).)*Blend.*\s*\]

Type: ModType

MonaCN

Mona Chinese mods

Checks if the .ini file contains a section with the regex ^\s*\[\s*TextureOverride.*(MonaCN)((?!RemapBlend).)*Blend.*\s*\]

Type: ModType

Ningguang

Ningguang Chinese mods

Checks if the .ini file contains a section with the regex ^\s*\[\s*TextureOverride.*(Ningguang)((?!(RemapBlend|Orchid)).)*Blend.*\s*\]

Type: ModType

NingguangOrchid

Ningguang Lantern Rite mods

Checks if the .ini file contains a section with the regex ^\s*\[\s*TextureOverride.*(NingguangOrchid)((?!RemapBlend).)*Blend.*\s*\]

Type: ModType

Raiden

Raiden mods

Checks if the .ini file contains a section with the regex ^\s*\[\s*TextureOverride.*(Raiden|Shogun)((?!RemapBlend).)*Blend.*\s*\]

Type: ModType

Rosaria

Rosaria mods

Checks if the .ini file contains a section with the regex ^\s*\[\s*TextureOverride.*(Rosaria)((?!(RemapBlend|CN)).)*Blend.*\s*\]

Type: ModType

RosariaCN

Rosaria Chinese mods

Checks if the .ini file contains a section with the regex ^\s*\[\s*TextureOverride.*(RosariaCN)((?!RemapBlend).)*Blend.*\s*\]

Type: ModType

Shenhe

Shenhe mods

Checks if the .ini file contains a section with the regex ^\s*\[\s*TextureOverride.*(Shenhe)((?!RemapBlend|FrostFlower).)*Blend.*\s*\]

Type: ModType

ShenheFrostFlower

Shenhe Lantern Rite mods

Checks if the .ini file contains a section with the regex ^\s*\[\s*TextureOverride.*(ShenheFrostFlower)((?!RemapBlend).)*Blend.*\s*\]

Type: ModType

classmethod getAll() → Set[ModType]

Retrieves a set of all the mod types available

Returns: All the available mod types
Return type: Set[ModType]

classmethod search(name: str)

Searches a mod type based off the provided name

Parameters: name (str) – The name of the mod to search for
Returns: The found mod type based off the provided name
Return type: Optional[ModType]

IniKeywords

Attributes

Blend
Draw
Filename
Handling
Hash
HashNotFound
IndexNotFound
MatchFirstIndex
RemapBlend
RemapFix
Resource
Run
Vb1

class IniKeywords(value)

Common keywords used in the .ini file

Blend = 'Blend': The substring that usually occurse in the name of section to indicate that the section will call some *.Blend.buf file

Draw = 'draw': Location to draw a resource

Filename = 'filename': The filename for some resource

Handling = 'handling': Handling

Hash = 'hash': The unique id for a part in the mod

HashNotFound = 'HashNotFound': The hash for a mod has not been found

IndexNotFound = 'IndexNotFound': The index for a mod has not been found

MatchFirstIndex = 'match_first_index': The index location to map some resource

RemapBlend = 'RemapBlend': The substring used to indicate that the section references some *.RemapBlend.buf file

RemapFix = 'RemapFix': The substring used to indicate that the section was created by this program

Resource = 'Resource': The starting prefix used for any sections that reference some file

Run = 'run': The subsection that will be called from a certain section

Vb1 = 'vb1': Vertex buffer #1

Utilities

FileService

Methods

clsFileService.absPathOfRelPath
clsFileService.changeExt
clsFileService.copyFile
clsFileService.disableFile
clsFileService.getFiles
clsFileService.getFilesAndDirs
clsFileService.getRelPath
clsFileService.getSingleFiles
clsFileService.ntPathToPosix
clsFileService.parseOSPath
clsFileService.read
clsFileService.readBinary
clsFileService.rename
clsFileService.writeBinary

class FileService

Tools for handling with files and folders

classmethod absPathOfRelPath(dstPath: str, relFolder: str) → str

Retrieves the absolute path of the relative path of a file with respect to a certain folder

Parameters

dstPath (str) – The target file path we are working with
relFolder (str) – The folder that the target file path is relative to

Returns

The absolute path for the target file

Return type

str

classmethod changeExt(file: str, newExt: str) → str

Changes the extension for a file

Parameters

file (str) – The file path to the file we are working with
newExt (str) – The name of the new extension for the file (without the dot at front)

Returns

the new file path with the extension changed

Return type

str

classmethod copyFile(src: str, dest: str)

Copies a file from src to dest

Parameters

src (str) – The file path to the file to be copied
dest (str) – The new file path for the copied file

classmethod disableFile(file: str, filePrefix: str = 'DISABLED_RemapBackup_') → str

Marks a file as ‘DISABLED’ and changes the file to a .txt file

Parameters

file (str) – The file path to the file we are working with
filePrefix (str) –
Prefix name we want to add in front of the file name

Default: “DISABLED_BossFixBackup_”

Returns

The new name of the file

Return type

str

classmethod getFiles(path: Optional[str] = None, filters: Optional[List[Callable[[str], bool]]] = None, files: Optional[List[str]] = None) → Union[List[str], List[List[str]]]

Retrieves many different types of files within a folder

Note

Only retrieves files that are the direct children of the folder (will not retrieve files nested in a folder within the folder we are searching)

Parameters

path (Optional[str]) –
The path to the target folder we are working with. If this value is set to None, then will use the current directory of where this module is loaded

Default: None
filters (Optional[List[Callable[[str], bool]]]) –
Different filter functions for each type of file we are trying to get. If this values is either None or [], then will default to a filter to get all the files

Default: None
files (Optional[List[str]]) –
The files contained in the target folder

If this value is set to None, then the function will search for the files

Default: None

Returns

The files partitioned into the different types specified by the filters

If ‘filters’ only has 1 element, then the function returns List[str] Otherwise, will return List[List[str]]

Return type

Union[List[str], List[List[str]]]

classmethod getFilesAndDirs(path: Optional[str] = None, recursive: bool = False) → List[List[str]]

Retrieves the files and folders contained in a certain folder

Parameters

path (Optional[str]) –
The path to the target folder we are working with. If this argument is None, then will use the current directory of where this module is loaded

Default: None
recursive (bool) –
Whether to recursively check all the folders from our target folder

Default: False

Returns

The files and directories within the folder. The order for the result is:

files
folders

Return type

[List[str], List[str]]

classmethod getRelPath(path: str, start: str) → str

Tries to get the relative path of a file/folder relative to another folder, if possible.

If it is not possible to get the relative path, will return back the original file path

Note

An example where it would not be possible to get the relative path would be:

If the file is located in one mount (eg. C:/ drive) and the folder is located in another mount (eg. D:/ drive)

Parameters

path (str) – The path to the target file/folder we are working with
start (str) – The path that the target file/folder is relative to

Returns

Either the relative path or the original path if not possible to get the relative paths

Return type

str

classmethod getSingleFiles(path: Optional[str] = None, filters: Optional[Dict[str, Callable[[str], bool]]] = None, files: Optional[List[str]] = None, optional: bool = False) → Union[str, None, List[str], List[Optional[str]]]

Retrieves exactly 1 of each type of file in a folder

Parameters

path (Optional[str]) –
The path to the target folder we are searching.

If this value is set to None, then will use the current directory of where this module is loaded

Default: None
filters (Optional[Dict[str, Callable[[str], bool]]]) –
Different filter functions for each type of file we are trying to get. If this value is None or {}, then will default to use a filter to get all files

The keys are the names for the file type

Default: None
files (Optional[List[str]]) –
The files contained in the target folder

If this value is set to None, then the function will search for the files

Default: None
optional (bool) –
Whether we want to send an exception if there is not exactly 1 file for a certain type of file
1. If this value is False and there are no files for a certain type of file, then will raise a MissingFileException
2. If this value is False and there are more than 1 file for a certain type of file, then will raise a DuplicateFileException
3. If this value is True and there are no files for a certain type of file, then the file for that type of file will be None
4. If this value is True and there are more than 1 file for a certain type of file, then will retrieve the first file for that type of file
Default: False

Raises

MissingFileException – if optional is set to False and there are not files for a certain type of file
DuplicateFileException – if optional is set to False and there are more than 1 file for a certain type of file

Returns

The files partitioned for each type of file

If filters only contains 1 element and optional is False, then will return str
If filters contains more than 1 element and optional is ``False`, then will return List[str]
If filters only contains 1 element and optional is True, then will return Optional[str]
Otherwise, returns List[Optional[str]]

Return type

Union[Optional[str], List[str], List[Optional[str]]]

classmethod ntPathToPosix(path: str) → str

Converts a file path from the ntpath library to a file path for the os library

Note

The character for the folder paths (/ or \) used in both libraries may be different depending on the OS

Parameters: path (str) – The file path we are working that is generated from the ‘ntpath’ library
Returns: The file path generated by the ‘os’ library
Return type: str

classmethod parseOSPath(path: str)

Retrieves a normalized file path from a string

Parameters: path (str) – The string containing some sort of file path

classmethod read(file: str, fileCode: str, postProcessor: Callable[[TextIoWrapper], Any]) → Any

Tries to read a file using different file encodings

Will interact with the file using the following order of encodings:

utf-8
latin1

Parameters

file (str) – The file we are trying to read from
fileCode (str) – What file mode to interact with the file (eg. r, rb, r+, etc…)
postProcessor (Callable[[TextIoWrapper], Any]) – A function used to process the file pointer of the opened file

Returns

The result after processing the file pointer of the opened file

Return type

Any

classmethod readBinary(src: Union[str, bytes]) → bytes

Reads a binary file

Parameters: src (Union[str, bytes]) – The source to read from
Returns: The read bytes
Return type: bytes

classmethod rename(oldFile: str, newFile: str)

Renames a file

Warning

If the new name for the file already exists, then the function deletes the file with the new name and renames the target file with the new name

Parameters

oldFile (str) – file path to the target file we are working with
newFile (str) – new file path for the target file

classmethod writeBinary(file: str, data: bytes)

Writes data into a binary file

Parameters

file (str) – The file to write into
data (bytes) – The data to write

DictTools

Methods

clsDictTools.combine
clsDictTools.getFirstKey
clsDictTools.getFirstValue
clsDictTools.invert
clsDictTools.update

class DictTools

Tools for handling with Dictionaries

classmethod combine(dict1: Dict[Hashable, Any], dict2: Dict[Hashable, Any], combineDuplicate: Optional[Callable[[Any, Any], Any]] = None) → Dict[Hashable, Any]

Creates a new dictionary from combining 2 dictionaries

Parameters

dict1 (Dict[Hashable, Any]) – The destination of where we want the combined dictionaries to be stored
dict2 (Dict[Hashable, Any]) – The dictionary we want to combine with
combineDuplicate (Optional[Callable[[Any, Any], Any]]) –
Function for handling cases where there contains the same key in both dictionaries

If this value is set to None, then will use the key from ‘dict2’

Default: None
makeNewCopy (bool) – Whether we want the resultant dictionary to be newly created or to be updated into dict1

Returns

The new combined dictionary

Return type

Dict[Hashable, Any]

classmethod getFirstKey(dict: Dict[Any, Any]) → Any

Retrieves the first key in a dictionary

Parameters

dict (Dict[Any, Any]) –

The dictionary we are working with

Note

The dictionary must not be empty

Returns

The first key of the dictionary

Return type

Any

classmethod getFirstValue(dict: Dict[Any, Any]) → Any

Retrieves the first value in a dictionary

Parameters: dict (Dict[Any, Any]) – The dictionary we are working with
Returns: The first value of the dictionary
Return type: Any

classmethod invert(dict: Dict[Hashable, Hashable]) → Dict[Hashable, Hashable]

Inverts a dictionary by making the keys the values and the values the keys

Parameters: dict (Dict[Hashable, Hashable]) – The dictionary to invert
Returns: The inverted dictionary
Return type: Dict[Hashable, Hashable]

classmethod update(srcDict: Dict[Hashable, Any], newDict: Dict[Hashable, Any], combineDuplicate: Optional[Callable[[Any, Any], Any]] = None) → Dict[Hashable, Any]

Updates srcDict based off the new values from newDict

Parameters

srcDict (Dict[Hashable, Any]) – The dictionary to be updated
newDict (Dict[Hashable, Any]) – The dictionary to help with updating srcDict
combineDuplicate (Optional[Callable[[Any, Any], Any]]) –
Function for handling cases where there contains the same key in both dictionaries
- The first parameter comes from srcDict
- The second parameter comes from newDict
If this value is set to None, then will use the key from newDict

Default: None

Returns

Reference to the updated dictionary

Return type

Dict[Hashable, Any]

TextTools

Methods

clsTextTools.capitalize
clsTextTools.getTextLines
clsTextTools.removeLines
clsTextTools.removeParts

class TextTools

classmethod capitalize(txt: str) → str

Capitalize only the beginning letter of ‘txt’

Parameters: txt (str) – The text to be capitalized
Returns: The new text with its first letter capitalized
Return type: str

classmethod getTextLines(txt: str) → List[str]

Retrieves the lines of text, split by the newline character, similar to how python’s readlines function works

Parameters: txt (str) – The target text to be split
Returns: The lines of text that were split
Return type: List[str]

classmethod removeLines(txtLines: List[str], partIndices: List[Tuple[int, int]]) → List[str]

Removes multiple sub-lists of lines from a list of text lines

Parameters

txtLines (List[str]) – The lines of text to have its lines removed
partIndices (List[Tuple[int, int]]) –
The indices for the list of lines to be removed

The tuples contain the following data:
1. The start index for the list of lines
2. The ending index for the list of lines

Returns

The new lines of text with the removed lines

Return type

List[str]

classmethod removeParts(txt: str, partIndices: List[Tuple[int, int]]) → str

Remove multiple substrings from a text based off the indices of the substrings

Parameters

txt (str) – The target txt to have the substrings removed
partIndices (List[Tuple[int, int]]) –
The indices for the substrings to be removed

The tuples contain the following data:
1. The start index for the substring
2. The ending index for the substring

Returns

The new string with the substrings removed

Return type

str

FilePath

Attributes

base
baseName
folder
path

class FilePath(path: str)

Class for storing info about a file path

Parameters: path (str) – The file path

property base

The base for the file path (includes file extension)

Getter: Retrieves the base
Setter: Sets the new base for the file path
Type: str

property baseName

The basename for the file path without any file extensions

Getter: Retrieves the basename
Setter: Sets the new basename for the file path
Type: str

property folder

The parent folder for the path

Getter: Retrieves the parent folder name
Setter: Sets the new parent folder name
Type: str

property path

The file path

Getter: Retrieves the path
Setter: Sets a new path
Type: str

Cache

Attributes

cacheStorage
capacity

Methods

defclear

class Cache(capacity: int = 128, cacheStorage: Optional[Any] = None)

Class for a generic cache

Supported Operations:

len(x): Retrieves the size of the Cache, x

x[key]: Retrieves the value from the Cache, x, from the key key

x[key] = newValue: Sets the key key of the Cache, x, to have the value of newValue

Parameters

capacity (int) –
The maximum capacity of the cache

Default: 128
cacheStorage (Optional[Any]) –
The type of KVP (Key-value pair) data structure to use for the cache. If this parameter is None, then will use a dictionary

Default: None

capacity

The maximum capacity of the cache

Type: int

cacheStorage

The type of KVP (Key-value pair) data structure to use for the cache.

Type: Any

clear() → None: Clears the cache

LruCache

Methods

defclear

class LruCache(capacity: int = 128)

This class inherits from Cache

Class for an LRU cache

Supported Operations:

len(x): Retrieves the size of the LruCache, x

x[key]: Retrieves the value from the LruCache, x, from the key key

x[key] = newValue: Sets the key key of the LruCache, x, to have the value of newValue

Parameters

capacity (int) –

The maximum capacity of the cache

Default: 128

clear() → None: Clears the cache

Algo

Methods

clsAlgo.binaryInsert
clsAlgo.binarySearch

class Algo

Tools for some basic algorithms

classmethod binaryInsert(lst: List[T], target: T, compare: Callable[[T, T], bool], optionalInsert: bool = False) → bool

Insert’s ‘target’ into ‘lst’ using binary search

Parameters

lst (List[T]) – The sorted list we want to insert the target element
target (T) – The target element to insert
compare (Callable[[T, T], bool]) – The compare function for comparing elements in the list with the target element
optionalInsert (bool) –
Whether to still insert the target element into the list if the element target element is found in the list

Default: False

Returns

Whether the target element has been inserted into the list

Return type

bool

classmethod binarySearch(lst: List[T], target: T, compare: Callable[[T, T], bool]) → List[Union[int, bool]]

Performs binary search to search for ‘target’ in ‘lst’

Parameters

lst (List[T]) – The sorted list we are searching from
target (T) – The target element to search for in the list
compare (Callable[[T, T], bool]) – The compare function for comparing elements in the list with the target element

Returns

The first element is whether the target element is found in the list
The second element is the found index or the index that we expect the target element to be in the list

Return type

[int, bool]

Builder

Attributes

args
cls
kwargs

Methods

defbuild

class Builder(cls: Type[BuildCls], args: Optional[List[Any]] = None, kwargs: Optional[Dict[str, Any]] = None)

Class to dynamically create a new object

Parameters

cls (Type[T]) – The class for the objects to be built from
args (Optional[List[Any]]) –
The constant arguments used to build the object

Default: None
kwargs (Optional[Dict[str, Any]]) –
The constant keyword arguments used to build the object

Default: None

cls

The class for the objects to be built from

Type: Type[T]

args

The constant arguments used to build the object

Type: List[Any]

kwargs

The constant keyword arguments used to build the object

Type: Dict[str, Any]

build(*args, **kwargs) → BuildCls

Builds the object

Parameters

*args – arguments to build the object
**kwargs – keyword arguments to build the object

Returns

The built objects

Return type

T

FlyweightBuilder

Methods

defbuild

class FlyweightBuilder(cls: Type[BuildCls], args: Optional[List[Any]] = None, kwargs: Optional[Dict[str, Any]] = None)

This class inherits from Builder

A flyweight factory for building the same reusable objects (based off flyweight design pattern)

build(args: Optional[List[Any]] = None, kwargs: Optional[Dict[str, Any]] = None, id: Optional[Hashable] = None, cache: bool = True) → BuildCls

Builds the object

Parameters

args (Optional[List[Any]]) –
arguments to build the object

Default: None
kwargs (Optional[Dict[str, Any]]) –
keyword arguments to build the object

Default: None
id (Optional[Hashable]) –
The id for the repeating states to be built by the object

If this value is None, then will auto-generate an id

Default: None
cache (bool) –
Whether to cache the built object

Note

If this value is set to False, then this function behaves the same as Builder.build()

Default: True

Returns

The built objects

Return type

T

Exceptions

Error

class Error(message: str)

The base exception used by this module

Parameters: message (str) – the error message to print out

FileException

Attributes

with_traceback

class FileException(message: str, path: Optional[str] = None)

This Class inherits from Error

Exceptions relating to files

Parameters

message (str) – The error message to print out
path (Optional[str]) –
The path where the error for the file occured. If this value is None, then the path will be the current directory where this module is loaded

Default: None

with_traceback(): Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

DuplicateFileException

Attributes

fileType
files
with_traceback

class DuplicateFileException(files: List[str], fileType: str = 'file', path: Optional[str] = None)

This Class inherits from FileException

Exception when there are multiple files of the same type in a folder

Parameters

files (List[str]) – The files that triggered the exception
fileType (str) –
The name for the type of files

Default: “file”
path (Optional[str]) –
The path to the folder where the files are located If this value is None, then the path will be the current directory where this module is loaded

Default: None

files

The files that triggered the exception

Type: List[str]

fileType

The name for the type of files

Default: None

Type: str

with_traceback(): Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

MissingFileException

Attributes

fileType
with_traceback

class MissingFileException(fileType: str = 'file', path: Optional[str] = None)

This Class inherits from FileException

Exception when a certain type of file is missing from a folder

Parameters

fileType (str) –
The type of file searching in the folder

Default: “file”
path (str) –
The path to the folder that is being searched. If this value is None, then the path will be the current directory where this module is loaded

Default: None

fileType

The type of file searching in the folder

Type: str

with_traceback(): Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

RemapMissingBlendFile

Attributes

with_traceback

class RemapMissingBlendFile(remapBlend: str)

This Class inherits from FileException

Exception when a RemapBlend.buf file is missing its corresponding Blend.buf file

Parameters: remapBlend (str) – The path to the RemapBlend.buf file

with_traceback(): Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

BlendFileNotRecognized

Attributes

with_traceback

class BlendFileNotRecognized(blendFile: str)

This Class inherits from FileException

Exception when a Blend.buf file cannot be read

Parameters: blendFile (str) – The file path to the Blend.buf file

with_traceback(): Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

BadBlendData

Attributes

with_traceback

class BadBlendData

This Class inherits fsrom Error

Exception when certain bytes do not correspond to the format defined for a Blend.buf file

with_traceback(): Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

ConflictingOptions

Attributes

with_traceback

class ConflictingOptions(options: List[str])

This Class inherits from Error

Exception when the script or RemapService is ran with options that cannot be used together

Parameters: options (List[str]) – The options that cannot be used together

with_traceback(): Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

InvalidModType

Attributes

with_traceback

class InvalidModType(type: str)

This Class inherits from Error

Exception when the type of mod specified to fix is not found

Parameters: type (str) – The name for the type of mod specified

with_traceback(): Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

NoModType

Attributes

with_traceback

class NoModType

This Class inherits from Error

Exception when trying to fix a mod of some unidentified mod type

Parameters: type (str) – The name for the type of mod specified

with_traceback(): Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.