From 4fa7e9bc249ee8ee350e1ffa572bf3e90a360faa Mon Sep 17 00:00:00 2001 From: Lilaa3 <87947656+Lilaa3@users.noreply.github.com> Date: Sun, 14 Jan 2024 09:16:21 +0000 Subject: [PATCH] Lots of clean up left, but its been like 3 days bruhh --- fast64_internal/oot/cutscene/properties.py | 6 +- fast64_internal/sm64/animation/c_parser.py | 295 + fast64_internal/sm64/animation/classes.py | 141 +- fast64_internal/sm64/animation/exporting.py | 75 +- fast64_internal/sm64/animation/importing.py | 278 +- fast64_internal/sm64/animation/operators.py | 33 +- fast64_internal/sm64/animation/properties.py | 263 +- .../animation/pylint_delete_before_pr.json | 7178 +++++++++++++++++ fast64_internal/sm64/animation/utility.py | 395 +- 9 files changed, 7962 insertions(+), 702 deletions(-) create mode 100644 fast64_internal/sm64/animation/c_parser.py create mode 100644 fast64_internal/sm64/animation/pylint_delete_before_pr.json diff --git a/fast64_internal/oot/cutscene/properties.py b/fast64_internal/oot/cutscene/properties.py index f2f6c3c58..1f4707633 100644 --- a/fast64_internal/oot/cutscene/properties.py +++ b/fast64_internal/oot/cutscene/properties.py @@ -204,13 +204,13 @@ class OOTCSListProperty(PropertyGroup): def draw_props(self, layout: UILayout, listIndex: int, objName: str, collectionType: str): box = layout.box().column() - enumName = getEnumName(ootEnumCSListType, self.listType) + enum_name = getEnumName(ootEnumCSListType, self.listType) # Draw current command tab box.prop( self, "expandTab", - text=enumName, + text=enum_name, icon="TRIA_DOWN" if self.expandTab else "TRIA_RIGHT", ) @@ -274,7 +274,7 @@ def draw_props(self, layout: UILayout, listIndex: int, objName: str, collectionT # ``p`` type: # OOTCSTextProperty | OOTCSLightSettingsProperty | OOTCSTimeProperty | # OOTCSSeqProperty | OOTCSMiscProperty | OOTCSRumbleProperty - p.draw_props(box, self, listIndex, i, objName, collectionType, enumName.removesuffix(" List")) + p.draw_props(box, self, listIndex, i, objName, collectionType, enum_name.removesuffix(" List")) if len(data) == 0: box.label(text="No items in " + getEnumName(ootEnumCSListType, self.listType)) diff --git a/fast64_internal/sm64/animation/c_parser.py b/fast64_internal/sm64/animation/c_parser.py new file mode 100644 index 000000000..be7aa4489 --- /dev/null +++ b/fast64_internal/sm64/animation/c_parser.py @@ -0,0 +1,295 @@ +from dataclasses import dataclass, field +import re +from typing import List, Union + +from ...utility import PluginError + + +@dataclass +class IfDefMacro: + type: str = "" + value: str = "" + + +@dataclass +class ParsedValue: + value: Union[str, int, float] + if_def: IfDefMacro + + def set_or_add(self, value): + if isinstance(self.value, list): + self.value.append(value) + else: + self.value = value + + +@dataclass +class MacroCall(ParsedValue): + name: str = "" + + +@dataclass +class DesignatedValue(ParsedValue): + name: str = "" + + +@dataclass +class Include: + path: str = "" + + +@dataclass +class Initialization(ParsedValue): + keywords: List[str] = field(default_factory=list) + is_extern: bool = False + is_static: bool = False + is_const: bool = False + is_enum: bool = False + is_struct: bool = False + pointer_depth: int = 0 + + origin_path: str = "" + + def array_to_struct_dict(self, struct_definition: list[str]): + if not isinstance(self.value, ParsedValue) or not isinstance(self.value.value, list): + raise PluginError("Assumed struct is not a list.") + struct_dict = {} + for i, element in enumerate(self.value.value): + if isinstance(element, DesignatedValue): + struct_dict[element.name] = element.value + else: + struct_dict[struct_definition[i]] = element.value + return struct_dict + + +delimiters = ( + "->", + ">>", + "<<", + "/*", + "\n", + "=", + ";", + "{", + "}", + "(", + ")", + "[", + "]", + ",", + "&", + "^", + "#", + ":", + '"', + "'", + "|", + "\\" "/", + "%", + "*", + ".", + "+", + "-", + ">", + "<", +) + +delimiters_pattern = "|".join(map(re.escape, delimiters)) + +token_pattern = re.compile( + r""" + (?: # Non-capturing group for alternatives + [^{delimiters_pattern}\s"']+ # Match characters that are not delimiters or whitespace or quotes + | + "[^"]*" # Match double-quoted strings + | + '[^']*' # Match single-quoted strings + ) + | + [{delimiters_pattern}] # Match any of the delimiters + """.format( + delimiters_pattern=re.escape(delimiters_pattern) + ), + re.VERBOSE, +) + +comment_pattern = re.compile(r"/\*.*?\*/|//.*?$", re.DOTALL | re.MULTILINE) + + +class CParser: + def get_tabs(self): + return "\t" * len(self.stack) + + def handle_accumulated_tokens(self): + if not self.accumulated_tokens: + return + joined = " ".join(self.accumulated_tokens) + joined_stripped = joined.replace(" ", "").replace("\n", "").replace("\t", "") + if not joined_stripped: + return + + if joined_stripped.startswith(('"', "'")): + value = joined + elif joined_stripped.startswith("0x"): + value = int(joined_stripped, 16) + else: + try: + value = float(joined_stripped) + if value.is_integer(): + value = int(value) + except ValueError: + value = joined_stripped + + self.stack[-1].set_or_add(ParsedValue(value, self.if_defs.copy())) + if isinstance(self.stack[-1], DesignatedValue): + self.stack.pop() + + self.accumulated_tokens.clear() + + def read_macro(self, prev_token: str, cur_token: str): + if cur_token == "\n" and not prev_token == "\\": + macro_type = self.accumulated_macro_tokens[0] + if macro_type == "include": + if self.stack: + self.stack[-1].set_or_add(Include(self.accumulated_macro_tokens[1])) + elif macro_type in {"ifdef", "if", "ifndef"}: + self.if_defs.append(IfDefMacro(macro_type, " ".join(self.accumulated_macro_tokens[1:]))) + pass + elif macro_type in {"elif", "else"}: + self.if_defs.pop() + self.if_defs.append(IfDefMacro(macro_type, " ".join(self.accumulated_macro_tokens[1:]))) + elif macro_type == "endif": + self.if_defs.pop() + else: + raise PluginError(f"Unimplemented macro. {macro_type}") + + self.accumulated_macro_tokens.clear() + self.reading_macro = False + return + + self.accumulated_macro_tokens.append(cur_token) + + def read_values(self, prev_token: str, cur_token: str): + if cur_token == "=": + designated_value = DesignatedValue( + None, self.if_defs.copy(), "".join(self.accumulated_tokens).strip().replace(".", "", 1) + ) + self.accumulated_tokens.clear() + + self.stack[-1].set_or_add(designated_value) + self.stack.append(designated_value) + elif cur_token == "(": + macro = MacroCall([], self.if_defs.copy(), "".join(self.accumulated_tokens).strip()) + self.accumulated_tokens.clear() + self.stack[-1].set_or_add(macro) + self.stack.append(macro) + elif cur_token == "{": + self.handle_accumulated_tokens() + + array = ParsedValue([], self.if_defs.copy()) + + if cur_token == "(": + array.name = prev_token + + self.stack[-1].set_or_add(array) + self.stack.append(array) + elif cur_token in {"}", ")"} or (cur_token == ";" and not self.reading_function): + self.handle_accumulated_tokens() + + self.stack.pop() + if len(self.stack) == 1 and self.reading_function: + # Exiting stack because of function + self.stack.pop() + if len(self.stack) == 0: + self.reading_function = False + self.reading_keywords = True + self.cur_initializer = Initialization(None, IfDefMacro()) + elif isinstance(self.stack[-1], DesignatedValue): + self.stack.pop() + elif cur_token == ";" or cur_token == ",": + self.handle_accumulated_tokens() + else: + self.accumulated_tokens.append(cur_token) + + def read_keywords(self, prev_token: str, cur_token: str): + if self.reading_array_size: + if cur_token == "]": + self.reading_array_size = False + return + else: + if cur_token == "[": + self.reading_array_size = True + return + + add_token = False + if cur_token == "static": + self.cur_initializer.is_static = True + elif cur_token == "const": + self.cur_initializer.is_const = True + elif cur_token == "extern": + self.cur_initializer.is_extern = True + elif cur_token == "enum": + self.cur_initializer.is_enum = True + elif cur_token == "struct": + self.cur_initializer.is_struct = True + elif cur_token == "*": + self.cur_initializer.pointer_depth += 1 + else: + add_token = True + + if not add_token: + return + + if cur_token in {"=", "{", ";"}: + self.values.append(self.cur_initializer) + if prev_token == ")" and cur_token == "{": + self.reading_function = True + + self.stack.append(self.cur_initializer) + + self.cur_initializer.name = self.cur_initializer.keywords[-1] + self.values_by_name[self.cur_initializer.name] = self.cur_initializer + self.cur_initializer.origin_path = self.origin_path + self.cur_initializer.if_def = self.if_defs.copy() + self.reading_keywords = False + + elif not cur_token in {"\n"}: + self.cur_initializer.keywords.append(cur_token) + + def read_c_text(self, text: str, origin_path: str = ""): + self.cur_initializer = Initialization(None, IfDefMacro()) + self.reading_array_size = False + self.reading_keywords = True + self.reading_function = False # Used for stack stuff, functions are not supported + self.reading_macro = False + + self.stack: list[ParsedValue] = [] + self.accumulated_tokens: list[str] = [] + self.accumulated_macro_tokens: list[str] = [] + self.if_defs: list[IfDefMacro] = [] + + self.origin_path = origin_path + + tokens = re.findall(token_pattern, re.sub(comment_pattern, "", text)) + + prev_token = "" + for i, cur_token in enumerate(tokens): + prev_token = tokens[i - 1] if i > 0 else "" + # next_token = tokens[i + 1] + if cur_token == "#": + self.reading_macro = True + continue + if self.reading_macro: + self.read_macro(prev_token, cur_token) + continue + + if self.reading_keywords: + self.read_keywords(prev_token, cur_token) + if cur_token == "=": + continue # HACK!!! + if not self.reading_keywords: + self.read_values(prev_token, cur_token) + + def __init__(self) -> None: + self.values: list[Initialization] = [] + self.values_by_name: dict[str, Initialization] = {} diff --git a/fast64_internal/sm64/animation/classes.py b/fast64_internal/sm64/animation/classes.py index ccb45317e..9185c64f2 100644 --- a/fast64_internal/sm64/animation/classes.py +++ b/fast64_internal/sm64/animation/classes.py @@ -1,11 +1,16 @@ +import bpy +from bpy.types import bpy_prop_collection + import dataclasses from io import StringIO import os from typing import BinaryIO +from .c_parser import CParser, Initialization + from ..sm64_constants import MAX_U16 -from .utility import RomReading, readArrayToStructDict, updateHeaderVariantNumbers +from .utility import RomReading from ...utility import PluginError, decodeSegmentedAddr, is_bit_active, toAlnum @@ -13,12 +18,13 @@ class SM64_AnimHeader: name: str = None address: int = None - headerVariant: int = 0 + origin_path: str = "" + header_variant: int = 0 flags: str | int = None yDivisor: int = 0 startFrame: int = 0 loopStart: int = 0 - loopEnd: int = 1 + loop_end: int = 1 boneCount: int = None values: str = "" indices: str = "" @@ -30,7 +36,7 @@ def toC(self, designated: bool, asArray: bool) -> str: ("animYTransDivisor", self.yDivisor), ("startFrame", self.startFrame), ("loopStart", self.loopStart), - ("loopEnd", self.loopEnd), + ("loop_end", self.loop_end), ("unusedBoneCount", f"ANIMINDEX_NUMPARTS({self.data.indicesReference})"), # Unused but potentially useful ("values", self.data.valuesReference), ("index", self.data.indicesReference), @@ -50,7 +56,7 @@ def toBinary(self, indicesReference, valuesReference): data.extend(self.yDivisor.to_bytes(2, byteorder="big", signed=True)) # 0x02 data.extend(self.startFrame.to_bytes(2, byteorder="big", signed=True)) # 0x04 data.extend(self.loopStart.to_bytes(2, byteorder="big", signed=True)) # 0x06 - data.extend(self.loopEnd.to_bytes(2, byteorder="big", signed=True)) # 0x08 + data.extend(self.loop_end.to_bytes(2, byteorder="big", signed=True)) # 0x08 data.extend(self.boneCount.to_bytes(2, byteorder="big", signed=True)) # 0x0A data.extend(valuesReference.to_bytes(4, byteorder="big", signed=False)) # 0x0C data.extend(indicesReference.to_bytes(4, byteorder="big", signed=False)) # 0x10 @@ -83,8 +89,8 @@ def toHeaderProps(self, action, header): header.overrideName = True header.customName = self.name - correctFrameRange = self.startFrame, self.loopStart, self.loopEnd - header.startFrame, header.loopStart, header.loopEnd = correctFrameRange + correctFrameRange = self.startFrame, self.loopStart, self.loop_end + header.startFrame, header.loopStart, header.loop_end = correctFrameRange if correctFrameRange != header.getFrameRange(action): # If auto frame range is wrong header.manualFrameRange = True @@ -103,20 +109,20 @@ def toHeaderProps(self, action, header): header.setCustomFlags = True header.customFlags = self.flags - def readBinary(self, romfile: BinaryIO, address: int, segmentData, isDMA: bool = False): + def read_binary(self, romfile: BinaryIO, address: int, segmentData, isDMA: bool = False): headerReader = RomReading(romfile, address) self.address = address - self.flags = headerReader.readValue(2, signed=False) # /*0x00*/ s16 flags; - self.yDivisor = headerReader.readValue(2) # /*0x02*/ s16 animYTransDivisor; - self.startFrame = headerReader.readValue(2) # /*0x04*/ s16 startFrame; - self.loopStart = headerReader.readValue(2) # /*0x06*/ s16 loopStart; - self.loopEnd = headerReader.readValue(2) # /*0x08*/ s16 loopEnd; + self.flags = headerReader.read_value(2, signed=False) # /*0x00*/ s16 flags; + self.yDivisor = headerReader.read_value(2) # /*0x02*/ s16 animYTransDivisor; + self.startFrame = headerReader.read_value(2) # /*0x04*/ s16 startFrame; + self.loopStart = headerReader.read_value(2) # /*0x06*/ s16 loopStart; + self.loop_end = headerReader.read_value(2) # /*0x08*/ s16 loopEnd; # Unused in engine but makes it easy to read animation data - self.boneCount = headerReader.readValue(2) # /*0x0A*/ s16 unusedBoneCount; + self.boneCount = headerReader.read_value(2) # /*0x0A*/ s16 unusedBoneCount; - valuesOffset = headerReader.readValue(4) # /*0x0C*/ const s16 *values; - indicesOffset = headerReader.readValue(4) # /*0x10*/ const u16 *index; + valuesOffset = headerReader.read_value(4) # /*0x0C*/ const s16 *values; + indicesOffset = headerReader.read_value(4) # /*0x10*/ const u16 *index; if isDMA: self.values = address + valuesOffset @@ -125,11 +131,10 @@ def readBinary(self, romfile: BinaryIO, address: int, segmentData, isDMA: bool = self.values = decodeSegmentedAddr(valuesOffset.to_bytes(4, byteorder="big"), segmentData) self.indices = decodeSegmentedAddr(indicesOffset.to_bytes(4, byteorder="big"), segmentData) - def readC(self, array: "ReadArray"): - self.name = toAlnum(array.name) + def readC(self, value: Initialization): + self.name = toAlnum(value.name) - structDict = readArrayToStructDict( - array, + structDict = value.array_to_struct_dict( [ "flags", "animYTransDivisor", @@ -147,11 +152,36 @@ def readC(self, array: "ReadArray"): self.yDivisor = structDict["animYTransDivisor"] self.startFrame = structDict["startFrame"] self.loopStart = structDict["loopStart"] - self.loopEnd = structDict["loopEnd"] + self.loop_end = structDict["loopEnd"] self.values = structDict["values"] self.indices = structDict["index"] - return + + self.origin_path = value.origin_path + + +@dataclasses.dataclass +class SM64_AnimTable: + name: str = "" + elements: list[SM64_AnimHeader] = dataclasses.field(default_factory=list) + + def to_blender(self, table_elements: bpy_prop_collection): + for header in self.elements: + table_elements.add() + table_elements[-1].action = bpy.data.actions[header.data.actionName] + table_elements[-1].header_variant = header.header_variant + + def toBinary(self): + pass + + def toC(self): + pass + + def read_binary(self): + pass + + def readC(self): + pass @dataclasses.dataclass @@ -171,21 +201,21 @@ def appendFrame(self, value: int): def getFrame(self, frame: int): if frame < len(self.values): return self.values[frame] - return self.values[len(self.values) - 1] + return self.values[-1] # Importing - def readBinary(self, indicesReader: RomReading, romfile: BinaryIO, valuesAdress: int): - maxFrame = indicesReader.readValue(2) - valueOffset = indicesReader.readValue(2) * 2 + def read_binary(self, indicesReader: RomReading, romfile: BinaryIO, valuesAdress: int): + maxFrame = indicesReader.read_value(2) + valueOffset = indicesReader.read_value(2) * 2 valueReader = RomReading(romfile, valuesAdress + valueOffset) for frame in range(maxFrame): - value = valueReader.readValue(2, signed=True) + value = valueReader.read_value(2, signed=True) self.values.append(value) def readC(self, maxFrame, offset, values: list[int]): for frame in range(maxFrame): - value = values[offset + frame] + value = values[offset + frame].value if value >= 0: # Cast any positive to signed. value = int.from_bytes( value.to_bytes(length=2, byteorder="big", signed=False), signed=True, byteorder="big" @@ -208,19 +238,16 @@ class SM64_Anim: fileName: str = None def createTables(self, merge: bool) -> tuple[list[int], list[int]]: - def findOffset(addedIndexes, pairValues) -> int | None: + def findOffset(addedIndexes: list, pairValues) -> int | None: offset: int | None = None for addedIndex in addedIndexes: - # TODO: If the added index values are less than the values of the current pair - # but the values that it does have are all equal to the pair´s, add the rest of - # the values to the added index values. - if len(addedIndex.values) < len(pairValues): - continue - for i, j in zip(pairValues, addedIndex.values[0 : len(pairValues)]): + for i, j in zip(pairValues[0 : len(addedIndex.values)], addedIndex.values[0 : len(pairValues)]): offset = addedIndex.offset - if abs(i - j) > 2: # 2 is a good max difference, basically invisible in game. + if abs(i - j) > 1: offset = None break + if len(addedIndex.values) < len(pairValues): + addedIndex.extend(pairValues[len(pairValues) - 1 :]) return offset print("Merging values and creating tables.") @@ -318,8 +345,8 @@ def toC(self, mergeValues: bool, useHexValues: bool) -> str: return cData.getvalue() # Importing - def toAction(self, action): - actionProps = action.fast64.sm64 + def to_action(self, action): + action_props = action.fast64.sm64 if self.actionName: action.name = self.actionName @@ -331,51 +358,51 @@ def toAction(self, action): self.actionName = action.name if self.fileName: - actionProps.customFileName = self.fileName - actionProps.overrideFileName = True + action_props.customFileName = self.fileName + action_props.overrideFileName = True - actionProps.indicesTable, actionProps.indicesAddress = self.indicesReference, self.indicesReference - actionProps.valuesTable, actionProps.valueAddress = self.valuesReference, self.valuesReference + action_props.indicesTable, action_props.indicesAddress = self.indicesReference, self.indicesReference + action_props.valuesTable, action_props.valueAddress = self.valuesReference, self.valuesReference self.referenceTables = self.reference - actionProps.customMaxFrame = max([1] + [len(x.values) for x in self.pairs]) + action_props.customMaxFrame = max([1] + [len(x.values) for x in self.pairs]) for i in range(len(self.headers) - 1): - actionProps.header_variants.add() + action_props.header_variants.add() - for header, header_props in zip(self.headers, actionProps.get_headers()): + for header, header_props in zip(self.headers, action_props.get_headers()): header.toHeaderProps(action, header_props) - updateHeaderVariantNumbers(actionProps.header_variants) + action_props.update_header_variant_numbers() - def readBinary(self, romfile: BinaryIO, header: SM64_AnimHeader): + def read_binary(self, romfile: BinaryIO, header: SM64_AnimHeader): self.indicesReference = hex(header.indices) self.valuesReference = hex(header.values) indicesReader = RomReading(romfile, header.indices) for i in range((header.boneCount + 1) * 3): pair = SM64_AnimPair(True) - pair.readBinary(indicesReader, romfile, header.values) + pair.read_binary(indicesReader, romfile, header.values) self.pairs.append(pair) - def readC(self, header: SM64_AnimHeader, arrays: dict["ReadArray"]): + def readC(self, header: SM64_AnimHeader, c_parser: CParser): self.indicesReference = header.indices self.valuesReference = header.values - if self.indicesReference in arrays and self.valuesReference in arrays: - indicesArray: "ReadArray" = arrays[self.indicesReference] - valuesArray: "ReadArray" = arrays[self.valuesReference] - self.fileName = os.path.basename(indicesArray.originPath) + if self.indicesReference in c_parser.values_by_name and self.valuesReference in c_parser.values_by_name: + indicesArray = c_parser.values_by_name[self.indicesReference] + valuesArray = c_parser.values_by_name[self.valuesReference] + self.fileName = os.path.basename(indicesArray.origin_path) else: - # self.fileName = os.path.basename(header.originPath) + self.fileName = os.path.basename(header.origin_path) self.reference = True return - indices = indicesArray.values - values = valuesArray.values + indices = indicesArray.value.value + values = valuesArray.value.value for i in range(0, len(indices), 2): - maxFrame, offset = indices[i], indices[i + 1] + maxFrame, offset = indices[i].value, indices[i + 1].value pair = SM64_AnimPair(True) pair.readC(maxFrame, offset, values) self.pairs.append(pair) diff --git a/fast64_internal/sm64/animation/exporting.py b/fast64_internal/sm64/animation/exporting.py index 06bf50a85..8b0a35f91 100644 --- a/fast64_internal/sm64/animation/exporting.py +++ b/fast64_internal/sm64/animation/exporting.py @@ -1,30 +1,26 @@ import bpy, mathutils, os from .utility import ( - CArrayReader, - animNameToEnum, + anim_name_to_enum, get_anim_pose_bones, - getAnimName, - getAnimFileName, - getActionsInTable, - getEnumListName, - getHeadersInTable, - getMaxFrame, + get_anim_name, + get_max_frame, ) from ..sm64_utility import radian_to_sm64_degree -from .classes import SM64_AnimHeader, SM64_Anim, SM64_AnimPair from ...utility import ( getPathAndLevel, toAlnum, writeIfNotFound, writeInsertableFile, - applyBasicTweaks, getExportDir, ) from ...utility_anim import stashActionInArmature from ..sm64_constants import NULL +from .classes import SM64_AnimHeader, SM64_Anim, SM64_AnimPair +from .c_parser import CParser + def getAnimationPairs( scene: bpy.types.Scene, @@ -33,10 +29,9 @@ def getAnimationPairs( animBonesInfo: list[bpy.types.PoseBone], ) -> tuple[list[int], list[int]]: sm64Props = scene.fast64.sm64 - exportProps = sm64Props.anim_export blender_to_sm64_scale = sm64Props.blender_to_sm64_scale - maxFrame = getMaxFrame(scene, action) + maxFrame = get_max_frame(scene, action) pairs = [ SM64_AnimPair(), @@ -150,10 +145,10 @@ def updateTableFile(tablePath: str, tableName: str, headers: list["SM64_AnimHead text = readable_file.read() tableProps = exportProps.table - headerPointers = [f"&{getAnimName(sm64ExportProps, header, action)}" for header in headers] - tableName, enumListName = exportProps.table.getAnimTableName(exportProps), getEnumListName(exportProps) + headerPointers = [f"&{get_anim_name(sm64ExportProps, header, action)}" for header in headers] + tableName, enumListName = exportProps.table.getAnimTableName(exportProps), exportProps.get_enum_list_name() - arrayReader = CArrayReader() + arrayReader = CParser() arrays = arrayReader.findAllCArraysInFile(text) tableOriginArray, readTable = None, headerPointers @@ -174,20 +169,20 @@ def updateTableFile(tablePath: str, tableName: str, headers: list["SM64_AnimHead enum = element[0] pointer = element[1] else: - enum = animNameToEnum(element[1:]) + enum = anim_name_to_enum(element[1:]) pointer = element tableArray[enum] = pointer for headerPointer in headerPointers: - headerEnum = animNameToEnum(headerPointer[1:]) + headerEnum = anim_name_to_enum(headerPointer[1:]) tableArray[headerEnum] = headerPointer for tableEnumName in tableArray.keys(): - for enumName in enumsList: - if isinstance(enumName, tuple): - enumName = enumListName[0] - if enumName == tableEnumName: + for enum_name in enumsList: + if isinstance(enum_name, tuple): + enum_name = enumListName[0] + if enum_name == tableEnumName: break else: enumsList.append(tableEnumName) @@ -230,12 +225,12 @@ def updateTableFile(tablePath: str, tableName: str, headers: list["SM64_AnimHead def createTableFile(exportProps, tableFilePath, tableName, headerNames): tableProps = exportProps.table - tableName, enumListName = tableProps.getAnimTableName(exportProps), getEnumListName(exportProps) + tableName, enumListName = tableProps.getAnimTableName(exportProps), exportProps.get_enum_list_name() if tableProps.generateEnums: tableArray = {} for headerName in headerNames: - tableArray[animNameToEnum(headerName)] = f"&{headerName}" + tableArray[anim_name_to_enum(headerName)] = f"&{headerName}" enumsList = set() for tableEnumName in tableArray.keys(): @@ -264,8 +259,8 @@ def createTableFile(exportProps, tableFilePath, tableName, headerNames): def createDataFile(sm64Props, dataFilePath, table=None): print(f"Creating new animation data file at {dataFilePath}") open(dataFilePath, "w", newline="\n") - for action in getActionsInTable(table): - writeIfNotFound(dataFilePath, '#include "' + getAnimFileName(action) + '"\n', "") + for action in table.get_actions(): + writeIfNotFound(dataFilePath, '#include "' + action.fast64.sm64.get_anim_file_name(action) + '"\n', "") def updateDataFile(sm64Props, dataFilePath, animFileName): @@ -342,18 +337,18 @@ def getAnimationPaths(exportProps): def getAnimationData(armatureObj: bpy.types.Object, scene: bpy.types.Scene, action: bpy.types.Action, headers): sm64Props = scene.fast64.sm64 exportProps = sm64Props.anim_export - actionProps = action.fast64.sm64 + action_props = action.fast64.sm64 stashActionInArmature(armatureObj, action) animBonesInfo = get_anim_pose_bones(armatureObj) sm64Anim = SM64_Anim() - if actionProps.referenceTables: + if action_props.referenceTables: sm64Anim.reference = True if sm64Props.is_binary_export(): - sm64Anim.valuesReference, sm64Anim.indicesReference = int(actionProps.valuesAddress, 16), int( - actionProps.indicesAddress, 16 + sm64Anim.valuesReference, sm64Anim.indicesReference = int(action_props.valuesAddress, 16), int( + action_props.indicesAddress, 16 ) else: sm64Anim.pairs = getAnimationPairs(scene, action, armatureObj, animBonesInfo) @@ -365,18 +360,18 @@ def getAnimationData(armatureObj: bpy.types.Object, scene: bpy.types.Scene, acti sm64AnimHeader.data = sm64Anim sm64Anim.headers.append(sm64AnimHeader) - sm64AnimHeader.name = getAnimName(exportProps.actor_name, action, header) + sm64AnimHeader.name = get_anim_name(exportProps.actor_name, action, header) if sm64Anim.isDmaStructure or sm64Props.is_binary_export(): sm64AnimHeader.flags = getIntFlags(header) else: sm64AnimHeader.flags = getCFlags(header) - startFrame, loopStart, loopEnd = header.getFrameRange(action) + startFrame, loopStart, loop_end = header.getFrameRange(action) sm64AnimHeader.yDivisor = header.yDivisor sm64AnimHeader.startFrame = startFrame sm64AnimHeader.loopStart = loopStart - sm64AnimHeader.loopEnd = loopEnd + sm64AnimHeader.loop_end = loop_end sm64AnimHeader.boneCount = len(animBonesInfo) return sm64Anim @@ -407,7 +402,7 @@ def exportAnimTableInsertableBinary( data.extend(NULL.to_bytes(4, byteorder="big", signed=False)) # NULL represents the end of a table - for action in getActionsInTable(tableProps): # Iterates through all actions in table + for action in tableProps.get_actions(): # Iterates through all actions in table offset = len(data) actionHeaders = [] # Get all headers needed for table export in order @@ -451,17 +446,17 @@ def exportAnimC( ) -> str: sm64Props = scene.fast64.sm64 exportProps = sm64Props.anim_export - actionProps = action.fast64.sm64 + action_props = action.fast64.sm64 - if actionProps.referenceTables: - sm64Anim.valuesReference, sm64Anim.indicesReference = actionProps.valuesTable, actionProps.indicesTable + if action_props.referenceTables: + sm64Anim.valuesReference, sm64Anim.indicesReference = action_props.valuesTable, action_props.indicesTable else: dataName: str = toAlnum(f"anim_{action.name}") sm64Anim.valuesReference, sm64Anim.indicesReference = f"{dataName}_values", f"{dataName}_indices" animDirPath, dirPath, geoDirPath, levelName = getAnimationPaths(exportProps) - animFileName = getAnimFileName(action) + animFileName = action_props.get_anim_file_name(action) isDmaStructure = False if exportProps.export_type == "DMA": @@ -522,11 +517,11 @@ def exportAnimationTable(context: bpy.types.Context, armatureObj: bpy.types.Obje exportProps = sm64Props.anim_export tableProps = exportProps.table - tableHeaders = getHeadersInTable(tableProps) - headerNames = [getAnimName(exportProps, header) for header in tableHeaders] + tableHeaders = tableProps.get_headers() + headerNames = [get_anim_name(exportProps, header) for header in tableHeaders] if sm64Props.export_type == "C": - for action in getActionsInTable(tableProps): + for action in tableProps.get_actions(): exportAnimation(context, scene, action, tableProps.overrideFiles) elif sm64Props.export_type == "Insertable Binary": return exportAnimTableInsertableBinary(armatureObj, scene, tableHeaders, sm64Props) diff --git a/fast64_internal/sm64/animation/importing.py b/fast64_internal/sm64/animation/importing.py index b593c6dfe..d70990b8d 100644 --- a/fast64_internal/sm64/animation/importing.py +++ b/fast64_internal/sm64/animation/importing.py @@ -1,25 +1,26 @@ +from collections import OrderedDict +import bpy +from bpy.types import Object, bpy_prop_collection + import dataclasses from io import BufferedReader import math import os -from typing import BinaryIO, Optional +from typing import Optional from mathutils import Euler, Vector, Quaternion -import bpy -from bpy.types import Object - from ...utility import PluginError, decodeSegmentedAddr, path_checks from ...utility_anim import stashActionInArmature from ..sm64_utility import import_rom_checks -from .utility import CArrayReader, RomReading, get_anim_pose_bones, sm64ToRadian - -from .classes import SM64_Anim, SM64_AnimHeader, SM64_AnimPair - from ..sm64_level_parser import parseLevelAtPointer from ..sm64_constants import ( level_pointers, ) +from .utility import RomReading, get_anim_pose_bones, sm64_to_radian +from .classes import SM64_Anim, SM64_AnimHeader, SM64_AnimPair, SM64_AnimTable +from .c_parser import CParser, Initialization + def value_distance(e1: Euler, e2: Euler) -> float: result = 0 @@ -60,19 +61,19 @@ def read_pairs(self, pairs: list[SM64_AnimPair]): return array def read_translation(self, pairs: list[SM64_AnimPair], scale: float): - translationFrames = self.read_pairs(pairs) + translation_frames = self.read_pairs(pairs) - for translationFrame in translationFrames: - scaledTrans = [(1.0 / scale) * x for x in translationFrame] + for translation_frame in translation_frames: + scaledTrans = [(1.0 / scale) * x for x in translation_frame] self.translation.append(scaledTrans) def read_rotation(self, pairs: list[SM64_AnimPair]): - rotationFrames: list[Vector] = self.read_pairs(pairs) + rotation_frames: list[Vector] = self.read_pairs(pairs) prev = Euler([0, 0, 0]) - for rotationFrame in rotationFrames: - e = Euler([sm64ToRadian(x) for x in rotationFrame]) + for rotation_frame in rotation_frames: + e = Euler([sm64_to_radian(x) for x in rotation_frame]) e[0] = naive_flip_diff(prev[0], e[0]) e[1] = naive_flip_diff(prev[1], e[1]) e[2] = naive_flip_diff(prev[2], e[2]) @@ -91,20 +92,13 @@ def read_rotation(self, pairs: list[SM64_AnimPair]): self.rotation.append(e.to_quaternion()) -def animation_table_to_blender(table_elements, table_list: list[SM64_AnimHeader]): - for header in table_list: - table_elements.add() - table_elements[-1].action = bpy.data.actions[header.data.actionName] - table_elements[-1].headerVariant = header.headerVariant - - def animation_data_to_blender(armature_obj: Object, blender_to_sm64_scale: float, anim_import: SM64_Anim): anim_bones = get_anim_pose_bones(armature_obj) for pose_bone in anim_bones: pose_bone.rotation_mode = "QUATERNION" action = bpy.data.actions.new("") - anim_import.toAction(action) + anim_import.to_action(action) if armature_obj.animation_data is None: armature_obj.animation_data_create() @@ -116,118 +110,125 @@ def animation_data_to_blender(armature_obj: Object, blender_to_sm64_scale: float # TODO: Duplicate keyframe filter pairs = anim_import.pairs - for pairNum in range(3, len(pairs), 3): + for pair_num in range(3, len(pairs), 3): bone = SM64_AnimBone() - if pairNum == 3: + if pair_num == 3: bone.read_translation(pairs[0:3], blender_to_sm64_scale) - bone.read_rotation(pairs[pairNum : pairNum + 3]) + bone.read_rotation(pairs[pair_num : pair_num + 3]) bone_anim_data.append(bone) - is_root_translation = True - for pose_bone, boneData in zip(anim_bones, bone_anim_data): - if is_root_translation: + is_root = True + for pose_bone, bone_data in zip(anim_bones, bone_anim_data): + if is_root: for property_index in range(3): - fcurve = action.fcurves.new( + f_curve = action.fcurves.new( data_path='pose.bones["' + pose_bone.name + '"].location', index=property_index, action_group=pose_bone.name, ) - for frame in range(len(boneData.translation)): - fcurve.keyframe_points.insert(frame, boneData.translation[frame][property_index]) - is_root_translation = False + for frame in range(len(bone_data.translation)): + f_curve.keyframe_points.insert(frame, bone_data.translation[frame][property_index]) + is_root = False for property_index in range(4): - fcurve = action.fcurves.new( + f_curve = action.fcurves.new( data_path='pose.bones["' + pose_bone.name + '"].rotation_quaternion', index=property_index, action_group=pose_bone.name, ) - for frame in range(len(boneData.rotation)): - fcurve.keyframe_points.insert(frame, boneData.rotation[frame][property_index]) - return action + for frame in range(len(bone_data.rotation)): + f_curve.keyframe_points.insert(frame, bone_data.rotation[frame][property_index]) + +def import_animation_from_c_header( + animations: dict[str, SM64_Anim], header_initialization: Initialization, c_parser: CParser +): + print(f"Reading animation {header_initialization.name}") -def import_animation(dataDict, array: "ReadArray", arrays: list["ReadArray"]): - print(f"Reading animation {array.name}") header = SM64_AnimHeader() - header.readC(array) - print(header) + header.readC(header_initialization) + + data_key = f"{header.indices}-{header.values}" - dataKey: str = f"{header.indices}-{header.values}" - if dataKey in dataDict: - data: SM64_Anim = dataDict[dataKey] + if data_key in animations: + data = animations[data_key] else: data = SM64_Anim() - data.readC(header, arrays) - dataDict[dataKey] = data + data.readC(header, c_parser) + animations[data_key] = data - header.headerVariant = len(data.headers) + header.header_variant = len(data.headers) header.data = data data.headers.append(header) return header -def import_c_animations( - path: str, - dataDict: dict[str, SM64_Anim], - tableList: list[SM64_Anim], -): +def import_c_animations(path: str, animations: dict[str, SM64_Anim], table: SM64_AnimTable): path_checks(path) if os.path.isfile(path): - filePaths: list[str] = [path] + file_paths: list[str] = [path] elif os.path.isdir(path): - fileNames = os.listdir(path) - filePaths: list[str] = [os.path.join(path, fileName) for fileName in fileNames] - else: - raise PluginError(f"Path ({path}) is not a file or a directory.") + file_names = sorted(os.listdir(path)) + file_paths: list[str] = [os.path.join(path, fileName) for fileName in file_names] - filePaths.sort() + c_parser = CParser() - print("Reading arrays in path") + for filepath in file_paths: + print(f"Reading file {filepath}") + try: + with open(filepath, "r") as file: + c_parser.read_c_text(file.read(), filepath) + except Exception as e: + print(f"Exception while attempting to parse file {filepath}: {str(e)}") + # Should I raise here? - arrays: dict[ReadArray] = {} - for filePath in filePaths: - if not filePath.endswith(".c"): - continue + print(f"All files have been parsed") - print(f"Reading file {filePath}") - with open(filePath, "r") as file: - arrayReader = CArrayReader() - arrays.update(arrayReader.findAllCArraysInFile(file.read(), filePath)) + table_initialization: None | Initialization = None + all_headers: OrderedDict[SM64_AnimHeader] = OrderedDict() - header = None - for array in arrays.values(): - if "*const" in array.keywords or "Animation*" in array.keywords: # Table + for value in c_parser.values: + if not "Animation" in value.keywords: continue - elif not "Animation" in array.keywords: - continue - header = import_animation(dataDict, array, arrays) - tableList.append(header) - return header + if value.pointer_depth == 1: # Table + table_initialization = value + else: + header = import_animation_from_c_header(animations, value, c_parser) + all_headers[header.name] = header + + if table_initialization: # If a table was found + for element in table_initialization.value.value: + # TODO: Add suport for enum indexed tables + name = element.value[1:] + if name in all_headers: + table.elements.append(all_headers[name]) + table.name = table_initialization.name + else: + table.elements.extend(all_headers.values()) def import_binary_header( - ROMData: BinaryIO, - headerAddress: int, - isDMA: bool, - segmentData: dict[int, tuple[int, int]], - dataDict: dict[str, SM64_Anim], + rom_data: BufferedReader, + address: int, + is_dma: bool, + segment_data: dict[int, tuple[int, int]], + animations: dict[str, SM64_Anim], ): header = SM64_AnimHeader() - header.readBinary(ROMData, headerAddress, segmentData, isDMA) + header.read_binary(rom_data, address, segment_data, is_dma) - dataKey: str = f"{header.indices}-{header.values}" - if dataKey in dataDict: - data = dataDict[dataKey] + data_key = f"{header.indices}-{header.values}" + if data_key in animations: + data = animations[data_key] else: data = SM64_Anim() - data.readBinary(ROMData, header) - dataDict[dataKey] = data + data.read_binary(rom_data, header) + animations[data_key] = data - header.headerVariant = len(data.headers) + header.header_variant = len(data.headers) header.data = data data.headers.append(header) return header @@ -241,22 +242,25 @@ class DMATableEntrie: def read_binary_dma_table_entries(rom_data: BufferedReader, address: int) -> list[DMATableEntrie]: + dma_entries: list[DMATableEntrie] = [] dma_table_reader = RomReading(rom_data, address) - numEntries = dma_table_reader.readValue(4) - addrPlaceholder = dma_table_reader.readValue(4) + numEntries = dma_table_reader.read_value(4) + addrPlaceholder = dma_table_reader.read_value(4) for i in range(numEntries): - offset = dma_table_reader.readValue(4) - size = dma_table_reader.readValue(4) - yield DMATableEntrie(offset, address + offset, size) + offset = dma_table_reader.read_value(4) + size = dma_table_reader.read_value(4) + dma_entries.append(DMATableEntrie(offset, address + offset, size)) + + return dma_entries def import_binary_dma_animation( rom_data: BufferedReader, address: int, animations: dict[str, SM64_Anim], - table: list[SM64_AnimHeader], + table: SM64_AnimTable, read_entire_table: bool, table_index: Optional[int] = None, ): @@ -264,54 +268,52 @@ def import_binary_dma_animation( if read_entire_table: for entrie in entries: header = import_binary_header(rom_data, entrie.address, True, None, animations) - table.append(header) + table.elements.append(header) else: if not (0 <= table_index < len(entries)): raise PluginError("Entrie outside of defined table.") entrie: DMATableEntrie = entries[table_index] header = import_binary_header(rom_data, entrie.address, True, None, animations) - table.append(header) + table.elements.append(header) return header def import_binary_table( - ROMData: BinaryIO, + rom_data: BufferedReader, address: int, + segment_data: dict[int, tuple[int, int]], + animations: dict[str, SM64_Anim], read_entire_table: bool, - tableIndex: int, - segmentData: dict[int, tuple[int, int]], - dataDict: dict[str, SM64_Anim], - tableList: list[SM64_Anim], + table_index: int, + ignore_null: bool, + table: SM64_AnimTable, ): for i in range(255): - ROMData.seek(address + (4 * i)) - ptr = int.from_bytes(ROMData.read(4), "big", signed=False) - if ptr == 0: + element_address = address + (4 * i) + rom_data.seek(element_address) + ptr = int.from_bytes(rom_data.read(4), "big", signed=False) + if ptr == 0 and not ignore_null: if not read_entire_table: raise PluginError("Table Index not in table.") break - isCorrectIndex = not read_entire_table and i == tableIndex - if read_entire_table or isCorrectIndex: - ptrInBytes: bytes = ptr.to_bytes(4, "big") - if ptrInBytes[0] not in segmentData: + is_correct_index = i == table_index + if read_entire_table or is_correct_index: + ptr_in_bytes: bytes = ptr.to_bytes(4, "big") + if ptr_in_bytes[0] not in segment_data: raise PluginError( - f"\ -Header at table index {i} located at {ptr} does not belong to the current segment." + f"Header at table index {i} located at {hex(element_address)} does not belong to the current segment." ) - headerAddress = decodeSegmentedAddr(ptrInBytes, segmentData) + header_address = decodeSegmentedAddr(ptr_in_bytes, segment_data) - header = import_binary_header(ROMData, headerAddress, False, segmentData, dataDict) - tableList.append(header) + header = import_binary_header(rom_data, header_address, False, segment_data, animations) + table.elements.append(header) - if isCorrectIndex: + if not read_entire_table and is_correct_index: break else: - raise PluginError( - "\ -Table address is invalid, iterated through 255 indices and no NULL was found." - ) + raise PluginError("Table address is invalid, iterated through 255 indices and no NULL was found.") def import_binary_animations( @@ -321,25 +323,21 @@ def import_binary_animations( address: int, level: str, animations: dict[str, SM64_Anim], - read_entire_table: Optional[bool] = None, - table_index: Optional[int] = None, - table: Optional[list[SM64_AnimHeader]] = None, + read_entire_table: bool = False, + table_index: int = 0, + ignore_null: bool = False, + table: SM64_AnimTable = SM64_AnimTable(), ): segment_data: dict[int, tuple[int, int]] = parseLevelAtPointer(rom_data, level_pointers[level]).segmentData if is_segmented_pointer: address = decodeSegmentedAddr(address.to_bytes(4, "big"), segment_data) if import_type == "Table": - import_binary_table(rom_data, address, read_entire_table, table_index, segment_data, animations, table) - elif import_type == "DMA": - import_binary_dma_animation( - rom_data, - address, - animations, - table, - read_entire_table, - table_index, + import_binary_table( + rom_data, address, segment_data, animations, read_entire_table, table_index, ignore_null, table ) + elif import_type == "DMA": + import_binary_dma_animation(rom_data, address, animations, table, read_entire_table, table_index) elif import_type == "Animation": import_binary_header(rom_data, address, False, segment_data, animations) else: @@ -350,18 +348,19 @@ def import_animation_to_blender( armature_obj: Object, import_type: str, sm64_to_blender_scale: float, - table_elements, - c_path: Optional[str] = None, - import_rom_path: Optional[str] = None, - address: Optional[int] = None, - is_segmented_pointer: Optional[bool] = None, - level: Optional[str] = None, - binary_import_type: Optional[str] = None, - read_entire_table: Optional[bool] = None, - table_index: Optional[int] = None, + table_elements: bpy_prop_collection, + c_path: str = "", + import_rom_path: str = "", + address: int = 0, + is_segmented_pointer: bool = True, + level: str = "IC", + binary_import_type: str = "Animation", + read_entire_table: bool = False, + table_index: int = 0, + ignore_null: bool = False, ): animations: dict[str, SM64_Anim] = {} - table: list[SM64_AnimHeader] = [] + table = SM64_AnimTable() if import_type == "Binary": import_rom_checks(import_rom_path) @@ -375,6 +374,7 @@ def import_animation_to_blender( animations, read_entire_table, table_index, + ignore_null, table, ) elif import_type == "C": @@ -385,4 +385,4 @@ def import_animation_to_blender( for data in animations.values(): animation_data_to_blender(armature_obj, sm64_to_blender_scale, data) - animation_table_to_blender(table_elements, table) + table.to_blender(table_elements) diff --git a/fast64_internal/sm64/animation/operators.py b/fast64_internal/sm64/animation/operators.py index 97249d78e..2567c92ae 100644 --- a/fast64_internal/sm64/animation/operators.py +++ b/fast64_internal/sm64/animation/operators.py @@ -12,7 +12,6 @@ from .importing import ( import_binary_dma_animation, animation_data_to_blender, - animation_table_to_blender, import_animation_to_blender, ) @@ -21,9 +20,8 @@ exportAnimationTable, ) from .utility import ( - animationOperatorChecks, - getAction, - updateHeaderVariantNumbers, + animation_operator_checks, + get_action, ) from .constants import marioAnimationNames @@ -82,14 +80,14 @@ class SM64_PreviewAnimOperator(bpy.types.Operator): played_action: StringProperty(name="Action") def executeOperation(self, context): - animationOperatorChecks(context) + animation_operator_checks(context) scene = context.scene exportProps: "SM64_AnimExportProps" = scene.fast64.sm64.anim_export armatureObj: bpy.types.Object = context.selected_objects[0] if self.played_action: - played_action = getAction(self.played_action) + played_action = get_action(self.played_action) else: played_action = exportProps.selectedAction header = played_action.fast64.sm64.headerFromIndex(self.played_header) @@ -132,7 +130,7 @@ class SM64_TableOperations(bpy.types.Operator): type: StringProperty() actionName: StringProperty(name="Action") - headerVariant: IntProperty() + header_variant: IntProperty() def execute_operator(self, context): exportProps = context.scene.fast64.sm64.anim_export @@ -147,7 +145,7 @@ def execute_operator(self, context): tableElements.add() tableElements.move(len(tableElements) - 1, self.arrayIndex) tableElements[-1].action = bpy.data.actions[self.actionName] - tableElements[-1].headerVariant = self.headerVariant + tableElements[-1].header_variant = self.header_variant elif self.type == "REMOVE": tableElements.remove(self.arrayIndex) if self.type == "CLEAR": @@ -175,9 +173,9 @@ class SM64_AnimVariantOperations(bpy.types.Operator): def execute_operator(self, context): action = bpy.data.actions[self.actionName] - actionProps = action.fast64.sm64 + action_props = action.fast64.sm64 - variants = actionProps.header_variants + variants = action_props.header_variants if self.type == "MOVE_UP": variants.move(self.arrayIndex, self.arrayIndex - 1) @@ -192,7 +190,7 @@ def execute_operator(self, context): for i in range(len(variants)): variants.remove(0) - updateHeaderVariantNumbers(variants) + action_props.update_header_variant_numbers() if self.type == "ADD": variants[-1].action = action @@ -200,7 +198,7 @@ def execute_operator(self, context): if len(variants) > 1: arrayIndex += 1 variants[-1].copyHeader( - context.scene.fast64.sm64.anim_export.actor_name, action, actionProps.get_headers()[arrayIndex] + context.scene.fast64.sm64.anim_export.actor_name, action, action_props.get_headers()[arrayIndex] ) return {"FINISHED"} @@ -221,7 +219,7 @@ class SM64_ExportAnimTable(bpy.types.Operator): def execute(self, context): try: - animationOperatorChecks(context) + animation_operator_checks(context) except Exception as e: raisePluginError(self, e) return {"CANCELLED"} @@ -260,7 +258,7 @@ def execute(self, context): romfileOutput, tempROM = None, None try: - animationOperatorChecks(context) + animation_operator_checks(context) except Exception as e: raisePluginError(self, e) return {"CANCELLED"} @@ -301,7 +299,7 @@ class SM64_ImportAllMarioAnims(bpy.types.Operator): bl_options = {"REGISTER", "UNDO", "PRESET"} def execute_operator(self, context): - animationOperatorChecks(context, False) + animation_operator_checks(context, False) sm64Props = context.scene.fast64.sm64 importProps = sm64Props.anim_import @@ -329,7 +327,7 @@ def execute_operator(self, context): for dataKey, data in dataDict.items(): animation_data_to_blender(armatureObj, sm64Props.blender_to_sm64_scale, data) - animation_table_to_blender(context, tableList) + tableList.to_blender(sm64Props.table.elements) return {"FINISHED"} @@ -351,7 +349,7 @@ def execute(self, context): sm64_props = context.scene.fast64.sm64 anim_import_props = sm64_props.anim_import - animationOperatorChecks(context, False) + animation_operator_checks(context, False) import_animation_to_blender( context.selected_objects[0], @@ -368,6 +366,7 @@ def execute(self, context): anim_import_props.binary_import_type, anim_import_props.read_entire_table, anim_import_props.tableIndex, + anim_import_props.ignore_null, ) self.report({"INFO"}, "Success!") return {"FINISHED"} diff --git a/fast64_internal/sm64/animation/properties.py b/fast64_internal/sm64/animation/properties.py index 414dcb8b9..7384579d3 100644 --- a/fast64_internal/sm64/animation/properties.py +++ b/fast64_internal/sm64/animation/properties.py @@ -1,5 +1,5 @@ import bpy -from bpy.types import PropertyGroup, Action, Context, Material, UILayout +from bpy.types import PropertyGroup, Action, Context, UILayout from bpy.utils import register_class, unregister_class from bpy.props import ( BoolProperty, @@ -34,10 +34,9 @@ enumLevelNames, ) from .utility import ( - getAnimName, - getAnimFileName, - getAnimEnum, - getMaxFrame, + anim_name_to_enum, + get_anim_name, + get_max_frame, ) from ...utility_anim import getFrameInterval from ...utility import ( @@ -46,6 +45,7 @@ customExportWarning, decompFolderMessage, makeWriteInfoBox, + multilineLabel, path_ui_warnings, prop_split, writeBoxExportType, @@ -53,7 +53,7 @@ class SM64_HeaderOverwrites(PropertyGroup): - expandTab: BoolProperty(name="Overwrites") + expand_tab: BoolProperty(name="Overwrites") overwrite0x28: BoolProperty(name="Overwrite 0x28 behaviour command", default=True) setListIndex: BoolProperty(name="Set List Entry", default=True) addr0x27: StringProperty(name="0x27 Command Address", default=hex(2215168)) @@ -68,10 +68,10 @@ def draw_props(self, layout: UILayout, binaryExportProps: "SM64_AnimBinaryExport col.prop( self, - "expandTab", - icon="TRIA_DOWN" if self.expandTab else "TRIA_RIGHT", + "expand_tab", + icon="TRIA_DOWN" if self.expand_tab else "TRIA_RIGHT", ) - if not self.expandTab: + if not self.expand_tab: return col.box().label(text="These values will not be used when exporting an entire table.") @@ -86,9 +86,9 @@ def draw_props(self, layout: UILayout, binaryExportProps: "SM64_AnimBinaryExport class SM64_AnimHeaderProps(bpy.types.PropertyGroup): - expandTab: BoolProperty(name="Header Properties", default=True) + expand_tab: BoolProperty(name="Header Properties", default=True) - headerVariant: IntProperty(name="Header Variant Number", default=0) + header_variant: IntProperty(name="Header Variant Number", default=0) overrideName: BoolProperty(name="Override Name") customName: StringProperty(name="Name", default="anim_00") @@ -97,7 +97,7 @@ class SM64_AnimHeaderProps(bpy.types.PropertyGroup): manualFrameRange: BoolProperty(name="Manual Frame Range") startFrame: IntProperty(name="Start Frame", min=0, max=MAX_S16) loopStart: IntProperty(name="Loop Start", min=0, max=MAX_S16) - loopEnd: IntProperty(name="Loop End", min=0, max=MAX_S16) + loop_end: IntProperty(name="Loop End", min=0, max=MAX_S16) yDivisor: IntProperty( name="Y Divisor", @@ -125,41 +125,43 @@ class SM64_AnimHeaderProps(bpy.types.PropertyGroup): ) customFlags: StringProperty(name="Flags", default="ANIM_FLAG_NOLOOP") - customIntFlags: StringProperty(name="Flags", default=hex(1)) def getFrameRange(self, action: Action): if self.manualFrameRange: - return self.startFrame, self.loopStart, self.loopEnd + return self.startFrame, self.loopStart, self.loop_end - loopStart, loopEnd = getFrameInterval(action) - return 0, loopStart, loopEnd + loopStart, loop_end = getFrameInterval(action) + return 0, loopStart, loop_end + + def get_anim_enum(self, actor_name: str, action: bpy.types.Action): + return anim_name_to_enum(get_anim_name(actor_name, action, self)) def copyHeader(self, actor_name, action, header: "SM64_AnimHeaderProps"): - # ["customName", "headerVariant", "expandTab"] + # TODO: FIX + # ["customName", "header_variant", "expand_tab"] copyPropertyGroup(header, self) - self.customName = f"\ -{getAnimName(actor_name, action, header)}_variant{self.headerVariant}" + self.customName = f"{get_anim_name(actor_name, action, header)}_variant{self.header_variant}" def draw_flag_props(self, layout: UILayout, sm64Props): exportProps: SM64_AnimExportProps = sm64Props.anim_export col = layout.column() - col.prop(self, "setCustomFlags") - if self.setCustomFlags: - if sm64Props.is_binary_export() or exportProps.is_dma_structure(sm64Props): - col.prop(self, "customIntFlags") - else: + if not sm64Props.is_binary_export() and not exportProps.is_dma_structure(sm64Props): + col.prop(self, "setCustomFlags") + + if self.setCustomFlags: col.prop(self, "customFlags") - else: - row = col.row() - row.prop(self, "noAcceleration") - row.prop(self, "noLoop") + return - row = col.row() - row.prop(self, "disabled") - row.prop(self, "backward") + row = col.row() + row.prop(self, "noAcceleration") + row.prop(self, "noLoop") + + row = col.row() + row.prop(self, "disabled") + row.prop(self, "backward") def draw_frame_range(self, layout: UILayout): col = layout.column() @@ -168,7 +170,7 @@ def draw_frame_range(self, layout: UILayout): prop_split(col, self, "startFrame", "Start Frame") row = col.row() prop_split(row, self, "loopStart", "Loop Start") - prop_split(row, self, "loopEnd", "Loop End") + prop_split(row, self, "loop_end", "Loop End") def drawNameSettings(self, layout: UILayout, sm64_props): anim_export_props = sm64_props.anim_export @@ -181,12 +183,12 @@ def drawNameSettings(self, layout: UILayout, sm64_props): nameSplit.prop(self, "customName", text="") else: nameSplit.box().label( - text=f"Name: {getAnimName(anim_export_props.actor_name, anim_export_props.selected_action, self)}" + text=f"Name: {get_anim_name(anim_export_props.actor_name, anim_export_props.selected_action, self)}" ) if anim_export_props.table.generateEnums: layout.box().label( - text=f"Enum: {getAnimEnum(anim_export_props.actor_name, anim_export_props.selected_action, self)}" + text=f"Enum: {self.get_anim_enum(anim_export_props.actor_name, anim_export_props.selected_action)}" ) def draw_props(self, context: bpy.types.Context, action: bpy.types.Action, layout: UILayout): @@ -195,12 +197,12 @@ def draw_props(self, context: bpy.types.Context, action: bpy.types.Action, layou col = layout.column() previewOp = col.operator(SM64_PreviewAnimOperator.bl_idname) - previewOp.played_header = self.headerVariant + previewOp.played_header = self.header_variant previewOp.played_action = action.name addOp = col.row().operator(SM64_TableOperations.bl_idname, text="Add Header to Table", icon="ADD") addOp.arrayIndex, addOp.type = len(exportProps.table.elements), "ADD" - addOp.actionName, addOp.headerVariant = action.name, self.headerVariant + addOp.actionName, addOp.header_variant = action.name, self.header_variant if sm64Props.export_type == "Binary": self.overwrites.draw_props(col.box(), exportProps.binary) @@ -238,12 +240,22 @@ class SM64_ActionProps(bpy.types.PropertyGroup): def get_headers(self) -> list[SM64_AnimHeaderProps]: return [self.header] + list(self.header_variants) - def headerFromIndex(self, headerVariant=0) -> SM64_AnimHeaderProps: + def headerFromIndex(self, header_variant=0) -> SM64_AnimHeaderProps: try: - return self.get_headers()[headerVariant] + return self.get_headers()[header_variant] except IndexError: raise PluginError("Header variant does not exist.") + def update_header_variant_numbers(self): + for i, variant in enumerate(self.get_headers()): + variant.header_variant = i + + def get_anim_file_name(self, action: Action): + if self.overrideFileName: + return self.customFileName + + return f"anim_{action.name}.inc.c" + def drawHeaderVariant( self, context, @@ -273,11 +285,11 @@ def drawHeaderVariant( col.prop( header, - "expandTab", + "expand_tab", text=f"Variation {arrayIndex + 1}", - icon="TRIA_DOWN" if header.expandTab else "TRIA_RIGHT", + icon="TRIA_DOWN" if header.expand_tab else "TRIA_RIGHT", ) - if not header.expandTab: + if not header.expand_tab: return header.draw_props(context, action, col) @@ -347,17 +359,17 @@ def draw_props(self, layout: UILayout, context: Context, action: Action): if self.overrideFileName: nameSplit.prop(self, "customFileName", text="") else: - nameSplit.box().label(text=f"{getAnimFileName(action)}") + nameSplit.box().label(text=f"{self.get_anim_file_name(action)}") self.drawReferences(col, sm64Props) if not self.referenceTables: - maxFrameSplit = col.split(factor=0.4) - maxFrameSplit.prop(self, "overrideMaxFrame") + max_frame_split = col.split(factor=0.4) + max_frame_split.prop(self, "overrideMaxFrame") if self.overrideMaxFrame: - maxFrameSplit.prop(self, "customMaxFrame", text="") + max_frame_split.prop(self, "customMaxFrame", text="") else: - maxFrameSplit.box().label(text=f"{getMaxFrame(scene, action)}") + max_frame_split.box().label(text=f"{get_max_frame(action)}") self.header.draw_props(context, action, col) self.drawVariants(col, context, action) @@ -365,13 +377,14 @@ def draw_props(self, layout: UILayout, context: Context, action: Action): class SM64_TableElement(bpy.types.PropertyGroup): action: PointerProperty(name="Action", type=bpy.types.Action) - headerVariant: bpy.props.IntProperty() + header_variant: bpy.props.IntProperty() class SM64_AnimTable(bpy.types.PropertyGroup): """Scene SM64 animation import properties found under scene.fast64.sm64.anim_export.table""" - expandTab: BoolProperty(name="Animation Table", default=True) + expand_tab: BoolProperty(name="Table", default=True) + expand_headers_tab: BoolProperty(name="Headers", default=True) elements: CollectionProperty(type=SM64_TableElement) overrideFiles: BoolProperty(name="Override Table and Data Files", default=False) @@ -393,6 +406,28 @@ def getAnimTableFileName(self, sm64Props): else: return "table.inc.c" + def get_headers(self): + headers = [] + for table_element in self.elements: + try: + action_props = table_element.action.fast64.sm64 + headers.append(action_props.headerFromIndex(table_element.header_variant)) + except: + raise PluginError(f'Action "{table_element.action.name}" in table is not in this file´s action data') + + return headers + + def get_actions(self): + actions = [] + for table_element in self.elements: + try: + if table_element.action not in actions: + actions.append(table_element.action) + except: + raise PluginError(f'Action "{table_element.action.name}" in table is not in this file´s action data') + + return actions + def drawTableNameSettings(self, layout: UILayout, context: Context): sm64Props = context.scene.fast64.sm64 col = layout.column() @@ -410,43 +445,52 @@ def drawTableNameSettings(self, layout: UILayout, context: Context): else: nameSplit.box().label(text=self.getAnimTableName(sm64Props.anim_export.actor_name)) - def drawTableElement(self, layout: UILayout, sm64Props, tableIndex: int, tableElement): + def drawTableElement(self, layout: UILayout, sm64Props, tableIndex: int, table_element): exportProps: "SM64_AnimExportProps" = sm64Props.anim_export - actionBox = layout.box().column() - row = actionBox.row() + row = layout.box().row() + + left_row = row.row() + left_row.alignment = "LEFT" - action, headerVariant = tableElement.action, tableElement.headerVariant + right_row = row.row() + right_row.alignment = "RIGHT" + + action, header_variant = table_element.action, table_element.header_variant if action: - actionProps: SM64_ActionProps = action.fast64.sm64 + action_props: SM64_ActionProps = action.fast64.sm64 - row.label(text=f"Index {tableIndex}") - if headerVariant == 0: - actionBox.label(text=f'Action "{action.name}"') - else: - actionBox.label(text=f'Action "{action.name}", Variant {headerVariant}') - if headerVariant < len(actionProps.get_headers()): - header = actionProps.headerFromIndex(headerVariant) + element_text = "" + + if header_variant < len(action_props.get_headers()): + header = action_props.headerFromIndex(header_variant) if not sm64Props.is_binary_export(): - actionBox.separator() if exportProps.table.generateEnums: - actionBox.label(text=f"Enum {getAnimEnum(exportProps.actor_name, action, header)}") - actionBox.label(text=f'Header Name "{getAnimName(exportProps.actor_name, action, header)}') + element_text += f"Enum {header.get_anim_enum(exportProps.actor_name, action)}\n" + element_text += f'Header Name "{get_anim_name(exportProps.actor_name, action, header)}\n' + else: + left_row.box().label(text=f"Header variant does not exist. Please remove.", icon="ERROR") + + if header_variant == 0: + element_text += f'Action "{action.name}"\n' else: - actionBox.box().label(text=f"Header variant does not exist. Please remove.", icon="ERROR") + element_text += f'Action "{action.name}", Variant {header_variant}\n' + + multilineLabel(left_row, element_text.rstrip("\n")) else: - actionBox.label(text=f"Header´s action does not exist. Please remove.", icon="ERROR") + left_row.label(text=f"Header´s action does not exist. Please remove.", icon="ERROR") - removeOp = row.operator(SM64_TableOperations.bl_idname, icon="REMOVE") + right_row.label(text=str(tableIndex)) + removeOp = right_row.operator(SM64_TableOperations.bl_idname, icon="REMOVE") removeOp.arrayIndex, removeOp.type = tableIndex, "REMOVE" - moveUpCol = row.column() + moveUpCol = right_row.column() moveUpCol.enabled = tableIndex != 0 moveUp = moveUpCol.operator(SM64_TableOperations.bl_idname, icon="TRIA_UP") moveUp.arrayIndex, moveUp.type = tableIndex, "MOVE_UP" - moveDownCol = row.column() + moveDownCol = right_row.column() moveDownCol.enabled = tableIndex != len(self.elements) - 1 moveDown = moveDownCol.operator(SM64_TableOperations.bl_idname, icon="TRIA_DOWN") moveDown.arrayIndex, moveDown.type = tableIndex, "MOVE_DOWN" @@ -457,10 +501,10 @@ def draw_props(self, layout: bpy.types.UILayout, context: bpy.types.Context): col = layout.column() col.prop( self, - "expandTab", - icon="TRIA_DOWN" if self.expandTab else "TRIA_RIGHT", + "expand_tab", + icon="TRIA_DOWN" if self.expand_tab else "TRIA_RIGHT", ) - if not self.expandTab: + if not self.expand_tab: return if not sm64Props.is_binary_export(): @@ -472,21 +516,28 @@ def draw_props(self, layout: bpy.types.UILayout, context: bpy.types.Context): if self.elements: col.operator(SM64_ExportAnimTable.bl_idname) + col.separator() + # TODO: Add selected action button should add all variations in action. # addOp = col.row().operator(SM64_TableOperations.bl_idname, text="Add Selected Action", icon="ADD") # addOp.arrayIndex, addOp.type = len(self.elements), "ADD" - # addOp.actionName, addOp.headerVariant = getSelectedAction(exportProps, False).name, 0 - - box = col.box().column() + # addOp.actionName, addOp.header_variant = getSelectedAction(exportProps, False).name, 0 if self.elements: - clearOp = box.row().operator(SM64_TableOperations.bl_idname, icon="TRASH") + col.prop( + self, + "expand_headers_tab", + icon="TRIA_DOWN" if self.expand_headers_tab else "TRIA_RIGHT", + ) + if not self.expand_headers_tab: + return + clearOp = col.row().operator(SM64_TableOperations.bl_idname, icon="TRASH") clearOp.type = "CLEAR" - for tableIndex, tableElement in enumerate(self.elements): - self.drawTableElement(box, sm64Props, tableIndex, tableElement) + for tableIndex, table_element in enumerate(self.elements): + self.drawTableElement(col, sm64Props, tableIndex, table_element) else: - box.label(text="Empty table, add headers from actions.") + col.label(text="Empty table, add headers from actions.") class SM64_AnimBinaryExportProps(bpy.types.PropertyGroup): @@ -518,7 +569,6 @@ def draw_props(self, layout: UILayout, export_type: str): class SM64_AnimExportProps(bpy.types.PropertyGroup): """Scene SM64 animation export properties found under scene.fast64.sm64.anim_export""" - export_settings_tab: BoolProperty(name="Export Settings", default=True) action_settings_tab: BoolProperty(name="Action Properties", default=True) played_header: IntProperty(min=0, default=0) @@ -547,6 +597,9 @@ class SM64_AnimExportProps(bpy.types.PropertyGroup): level_name: StringProperty(name="Level", default="bob") level_option: EnumProperty(items=enumLevelNames, name="Level", default="bob") + def get_enum_list_name(self): + return f"{self.actorName.title()}Anims" + def is_dma_structure(self, sm64Props): if sm64Props.is_binary_export(): return self.binary.isDMA @@ -573,7 +626,7 @@ def draw_action_properties(self, layout, context: Context): def canUseDMAStructure(self): return self.header_type == "Custom" or self.header_type == "DMA" - def drawCSettings(self, layout: bpy.types.UILayout): + def draw_c_settings(self, layout: bpy.types.UILayout): col = layout.column() prop_split(col, self, "header_type", "Export Type") @@ -589,9 +642,7 @@ def drawCSettings(self, layout: bpy.types.UILayout): customExportWarning(col) elif self.header_type == "DMA": col.prop(self, "dma_folder") - write_box = col.box().column() - write_box.label(text="This will write to:") - write_box.label(text=self.dma_folder) + col.box().label(text=f"This will write to: {self.dma_folder}") else: if self.header_type == "Actor": prop_split(col, self, "group_name", "Group Name") @@ -601,7 +652,7 @@ def drawCSettings(self, layout: bpy.types.UILayout): prop_split(col, self, "level_name", "Level Name") decompFolderMessage(col) - write_box = makeWriteInfoBox(col) + write_box = makeWriteInfoBox(col).column() writeBoxExportType( write_box, self.header_type, @@ -610,27 +661,18 @@ def drawCSettings(self, layout: bpy.types.UILayout): self.level_option, ) - def draw_export_settings(self, export_type, layout: bpy.types.UILayout): + def draw_props(self, context: bpy.types.Context, layout: bpy.types.UILayout): col = layout.column() - col.prop( - self, - "export_settings_tab", - icon="TRIA_DOWN" if self.export_settings_tab else "TRIA_RIGHT", - ) - if not self.export_settings_tab: - return - - if export_type in ["C"]: - self.drawCSettings(col) + export_type = context.scene.fast64.sm64.export_type + if export_type == "C": + self.draw_c_settings(col) else: self.binary.draw_props(col, export_type) + col.separator() - def draw_props(self, context: bpy.types.Context, layout: bpy.types.UILayout): - col = layout.column() - - self.draw_export_settings(context.scene.fast64.sm64.export_type, col.box()) self.draw_action_properties(col.box(), context) + col.separator() self.table.draw_props(col.box(), context) @@ -644,16 +686,19 @@ class SM64_AnimImportProps(bpy.types.PropertyGroup): binary_import_type: EnumProperty(items=enumAnimBinaryImportTypes, name="Type", default="Animation") - address: StringProperty(name="Address", default="4EC690") + address: StringProperty(name="Address", default="0600FC48") isSegPtr: BoolProperty(name="Is Segmented Address") level: EnumProperty(items=level_enums, name="Level", default="IC") # Table - read_entire_table: BoolProperty(name="Read All Animations", default=False) + read_entire_table: BoolProperty( + name="Read All Animations", + ) tableIndex: IntProperty(name="Table Index", min=0) + ignore_null: BoolProperty(name="Ignore NULL Delimiter") # DMA - DMATableAddress: StringProperty(name="DMA Table Address", default=hex(0x4EC000)) + DMATableAddress: StringProperty(name="DMA Table Address", default="0x4EC000") marioAnimation: IntProperty(name="Selected Preset Mario Animation", default=0) path: StringProperty(name="Path", subtype="FILE_PATH", default="U:/home/user/sm64/assets/anims/") @@ -672,8 +717,6 @@ def drawBinaryAddress(self, layout: bpy.types.UILayout): def drawBinary(self, layout: bpy.types.UILayout): col = layout.column() - col.operator(SM64_ImportAllMarioAnims.bl_idname) - prop_split(col, self, "binary_import_type", "Type") if self.binary_import_type == "DMA": @@ -694,6 +737,7 @@ def drawBinary(self, layout: bpy.types.UILayout): col.prop(self, "read_entire_table") if not self.read_entire_table: prop_split(col, self, "tableIndex", "List Index") + col.prop(self, "ignore_null") def drawC(self, layout: bpy.types.UILayout): col = layout.column() @@ -704,12 +748,15 @@ def draw_props(self, layout: bpy.types.UILayout): col = layout.column() col.prop(self, "import_type") - box = col.box().column() if self.isBinaryImport(): - self.drawBinary(box) + self.drawBinary(col) else: - self.drawC(box) - box.operator(SM64_ImportAnim.bl_idname) + self.drawC(col) + + col.operator(SM64_ImportAnim.bl_idname) + if self.isBinaryImport(): + col.separator() + col.operator(SM64_ImportAllMarioAnims.bl_idname) sm64_anim_properties = ( diff --git a/fast64_internal/sm64/animation/pylint_delete_before_pr.json b/fast64_internal/sm64/animation/pylint_delete_before_pr.json new file mode 100644 index 000000000..762ff20b3 --- /dev/null +++ b/fast64_internal/sm64/animation/pylint_delete_before_pr.json @@ -0,0 +1,7178 @@ +[ + { + "type": "error", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "", + "line": 1, + "column": 0, + "endLine": 1, + "endColumn": 10, + "path": "classes.py", + "symbol": "import-error", + "message": "Unable to import 'bpy'", + "message-id": "E0401" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_AnimHeader", + "line": 18, + "column": 0, + "endLine": 18, + "endColumn": 21, + "path": "classes.py", + "symbol": "missing-class-docstring", + "message": "Missing class docstring", + "message-id": "C0115" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_AnimHeader", + "line": 18, + "column": 0, + "endLine": 18, + "endColumn": 21, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Class name \"SM64_AnimHeader\" doesn't conform to PascalCase naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_AnimHeader", + "line": 24, + "column": 4, + "endLine": null, + "endColumn": null, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Attribute name \"yDivisor\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_AnimHeader", + "line": 25, + "column": 4, + "endLine": null, + "endColumn": null, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Attribute name \"startFrame\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_AnimHeader", + "line": 26, + "column": 4, + "endLine": null, + "endColumn": null, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Attribute name \"loopStart\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_AnimHeader", + "line": 28, + "column": 4, + "endLine": null, + "endColumn": null, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Attribute name \"boneCount\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "refactor", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_AnimHeader", + "line": 18, + "column": 0, + "endLine": 18, + "endColumn": 21, + "path": "classes.py", + "symbol": "too-many-instance-attributes", + "message": "Too many instance attributes (13/7)", + "message-id": "R0902" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_AnimHeader.toC", + "line": 33, + "column": 4, + "endLine": 33, + "endColumn": 11, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Method name \"toC\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_AnimHeader.toC", + "line": 33, + "column": 36, + "endLine": 33, + "endColumn": 49, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Argument name \"asArray\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_AnimHeader.toC", + "line": 34, + "column": 8, + "endLine": 34, + "endColumn": 18, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Variable name \"headerData\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "error", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_AnimHeader.toC", + "line": 45, + "column": 15, + "endLine": 45, + "endColumn": 24, + "path": "classes.py", + "symbol": "undefined-variable", + "message": "Undefined variable 'structToC'", + "message-id": "E0602" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_AnimHeader.toBinary", + "line": 53, + "column": 4, + "endLine": 53, + "endColumn": 16, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Method name \"toBinary\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_AnimHeader.toBinary", + "line": 53, + "column": 23, + "endLine": 53, + "endColumn": 39, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Argument name \"indicesReference\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_AnimHeader.toBinary", + "line": 53, + "column": 41, + "endLine": 53, + "endColumn": 56, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Argument name \"valuesReference\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_AnimHeader.toHeaderProps", + "line": 68, + "column": 4, + "endLine": 68, + "endColumn": 21, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Method name \"toHeaderProps\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_AnimHeader.toHeaderProps", + "line": 69, + "column": 8, + "endLine": 69, + "endColumn": 23, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Variable name \"intFlagsToProps\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_AnimHeader.toHeaderProps", + "line": 75, + "column": 8, + "endLine": 75, + "endColumn": 24, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Variable name \"intFlagsToString\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_AnimHeader.toHeaderProps", + "line": 92, + "column": 8, + "endLine": 92, + "endColumn": 25, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Variable name \"correctFrameRange\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_AnimHeader.toHeaderProps", + "line": 101, + "column": 12, + "endLine": 101, + "endColumn": 18, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Variable name \"cFlags\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_AnimHeader.toHeaderProps", + "line": 103, + "column": 16, + "endLine": 103, + "endColumn": 21, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Variable name \"cFlag\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_AnimHeader.read_binary", + "line": 112, + "column": 59, + "endLine": 112, + "endColumn": 70, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Argument name \"segmentData\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_AnimHeader.read_binary", + "line": 112, + "column": 72, + "endLine": 112, + "endColumn": 83, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Argument name \"isDMA\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_AnimHeader.read_binary", + "line": 113, + "column": 8, + "endLine": 113, + "endColumn": 20, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Variable name \"headerReader\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_AnimHeader.read_binary", + "line": 124, + "column": 8, + "endLine": 124, + "endColumn": 20, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Variable name \"valuesOffset\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_AnimHeader.read_binary", + "line": 125, + "column": 8, + "endLine": 125, + "endColumn": 21, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Variable name \"indicesOffset\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_AnimHeader.readC", + "line": 134, + "column": 4, + "endLine": 134, + "endColumn": 13, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Method name \"readC\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_AnimHeader.readC", + "line": 137, + "column": 8, + "endLine": 137, + "endColumn": 18, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Variable name \"structDict\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_AnimTable", + "line": 164, + "column": 0, + "endLine": 164, + "endColumn": 20, + "path": "classes.py", + "symbol": "missing-class-docstring", + "message": "Missing class docstring", + "message-id": "C0115" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_AnimTable", + "line": 164, + "column": 0, + "endLine": 164, + "endColumn": 20, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Class name \"SM64_AnimTable\" doesn't conform to PascalCase naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_AnimTable.toBinary", + "line": 174, + "column": 4, + "endLine": 174, + "endColumn": 16, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Method name \"toBinary\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_AnimTable.toC", + "line": 177, + "column": 4, + "endLine": 177, + "endColumn": 11, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Method name \"toC\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_AnimTable.readC", + "line": 183, + "column": 4, + "endLine": 183, + "endColumn": 13, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Method name \"readC\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_AnimPair", + "line": 188, + "column": 0, + "endLine": 188, + "endColumn": 19, + "path": "classes.py", + "symbol": "missing-class-docstring", + "message": "Missing class docstring", + "message-id": "C0115" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_AnimPair", + "line": 188, + "column": 0, + "endLine": 188, + "endColumn": 19, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Class name \"SM64_AnimPair\" doesn't conform to PascalCase naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_AnimPair", + "line": 189, + "column": 4, + "endLine": null, + "endColumn": null, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Attribute name \"maxFrame\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_AnimPair.appendFrame", + "line": 192, + "column": 4, + "endLine": 192, + "endColumn": 19, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Method name \"appendFrame\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_AnimPair.appendFrame", + "line": 194, + "column": 12, + "endLine": 194, + "endColumn": 21, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Variable name \"lastValue\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_AnimPair.getFrame", + "line": 201, + "column": 4, + "endLine": 201, + "endColumn": 16, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Method name \"getFrame\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_AnimPair.read_binary", + "line": 207, + "column": 26, + "endLine": 207, + "endColumn": 51, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Argument name \"indicesReader\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_AnimPair.read_binary", + "line": 207, + "column": 72, + "endLine": 207, + "endColumn": 89, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Argument name \"valuesAdress\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_AnimPair.read_binary", + "line": 208, + "column": 8, + "endLine": 208, + "endColumn": 16, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Variable name \"maxFrame\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_AnimPair.read_binary", + "line": 209, + "column": 8, + "endLine": 209, + "endColumn": 19, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Variable name \"valueOffset\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_AnimPair.read_binary", + "line": 211, + "column": 8, + "endLine": 211, + "endColumn": 19, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Variable name \"valueReader\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_AnimPair.read_binary", + "line": 212, + "column": 12, + "endLine": 212, + "endColumn": 17, + "path": "classes.py", + "symbol": "unused-variable", + "message": "Unused variable 'frame'", + "message-id": "W0612" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_AnimPair.readC", + "line": 216, + "column": 4, + "endLine": 216, + "endColumn": 13, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Method name \"readC\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_AnimPair.readC", + "line": 216, + "column": 20, + "endLine": 216, + "endColumn": 28, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Argument name \"maxFrame\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "", + "line": 226, + "column": 0, + "endLine": 226, + "endColumn": 10, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Constant name \"headerSize\" doesn't conform to UPPER_CASE naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_Anim", + "line": 230, + "column": 0, + "endLine": 230, + "endColumn": 15, + "path": "classes.py", + "symbol": "missing-class-docstring", + "message": "Missing class docstring", + "message-id": "C0115" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_Anim", + "line": 230, + "column": 0, + "endLine": 230, + "endColumn": 15, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Class name \"SM64_Anim\" doesn't conform to PascalCase naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_Anim", + "line": 237, + "column": 4, + "endLine": null, + "endColumn": null, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Attribute name \"actionName\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_Anim.to_action", + "line": 367, + "column": 8, + "endLine": 367, + "endColumn": 28, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Attribute name \"referenceTables\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_Anim", + "line": 231, + "column": 4, + "endLine": null, + "endColumn": null, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Attribute name \"indicesReference\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_Anim", + "line": 232, + "column": 4, + "endLine": null, + "endColumn": null, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Attribute name \"valuesReference\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_Anim", + "line": 238, + "column": 4, + "endLine": null, + "endColumn": null, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Attribute name \"fileName\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_Anim", + "line": 234, + "column": 4, + "endLine": null, + "endColumn": null, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Attribute name \"isDmaStructure\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "refactor", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_Anim", + "line": 230, + "column": 0, + "endLine": 230, + "endColumn": 15, + "path": "classes.py", + "symbol": "too-many-instance-attributes", + "message": "Too many instance attributes (9/7)", + "message-id": "R0902" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_Anim.createTables", + "line": 240, + "column": 4, + "endLine": 240, + "endColumn": 20, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Method name \"createTables\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_Anim.createTables.findOffset", + "line": 241, + "column": 8, + "endLine": 241, + "endColumn": 22, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Function name \"findOffset\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_Anim.createTables.findOffset", + "line": 241, + "column": 23, + "endLine": 241, + "endColumn": 41, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Argument name \"addedIndexes\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_Anim.createTables.findOffset", + "line": 241, + "column": 43, + "endLine": 241, + "endColumn": 53, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Argument name \"pairValues\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_Anim.createTables.findOffset", + "line": 243, + "column": 16, + "endLine": 243, + "endColumn": 26, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Variable name \"addedIndex\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_Anim.createTables", + "line": 255, + "column": 8, + "endLine": 255, + "endColumn": 18, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Variable name \"valueTable\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_Anim.createTables", + "line": 255, + "column": 20, + "endLine": 255, + "endColumn": 32, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Variable name \"indicesTable\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_Anim.createTables", + "line": 255, + "column": 34, + "endLine": 255, + "endColumn": 46, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Variable name \"addedIndexes\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_Anim.createTables", + "line": 258, + "column": 12, + "endLine": 258, + "endColumn": 20, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Variable name \"maxFrame\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_Anim.createTables", + "line": 259, + "column": 12, + "endLine": 259, + "endColumn": 22, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Variable name \"pairValues\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_Anim.createTables", + "line": 261, + "column": 12, + "endLine": 261, + "endColumn": 26, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Variable name \"existingOffset\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_Anim.createTables", + "line": 263, + "column": 16, + "endLine": 263, + "endColumn": 30, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Variable name \"existingOffset\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_Anim.headersToC", + "line": 281, + "column": 4, + "endLine": 281, + "endColumn": 18, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Method name \"headersToC\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_Anim.headersToC", + "line": 281, + "column": 43, + "endLine": 281, + "endColumn": 56, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Argument name \"asArray\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_Anim.headersToC", + "line": 282, + "column": 8, + "endLine": 282, + "endColumn": 13, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Variable name \"cData\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_Anim.toBinary", + "line": 287, + "column": 4, + "endLine": 287, + "endColumn": 16, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Method name \"toBinary\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_Anim.toBinary", + "line": 287, + "column": 23, + "endLine": 287, + "endColumn": 40, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Argument name \"mergeValues\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_Anim.toBinary", + "line": 287, + "column": 42, + "endLine": 287, + "endColumn": 53, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Argument name \"isDMA\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_Anim.toBinary", + "line": 287, + "column": 55, + "endLine": 287, + "endColumn": 72, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Argument name \"startAddress\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_Anim.toBinary", + "line": 293, + "column": 16, + "endLine": 293, + "endColumn": 26, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Variable name \"headerData\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_Anim.toBinary", + "line": 297, + "column": 8, + "endLine": 297, + "endColumn": 18, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Variable name \"valueTable\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_Anim.toBinary", + "line": 297, + "column": 20, + "endLine": 297, + "endColumn": 32, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Variable name \"indicesTable\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_Anim.toBinary", + "line": 299, + "column": 8, + "endLine": 299, + "endColumn": 21, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Variable name \"indicesOffset\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_Anim.toBinary", + "line": 300, + "column": 8, + "endLine": 300, + "endColumn": 20, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Variable name \"valuesOffset\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_Anim.toBinary", + "line": 301, + "column": 8, + "endLine": 301, + "endColumn": 24, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Variable name \"indicesReference\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_Anim.toBinary", + "line": 301, + "column": 26, + "endLine": 301, + "endColumn": 41, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Variable name \"valuesReference\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_Anim.toBinary", + "line": 305, + "column": 12, + "endLine": 305, + "endColumn": 22, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Variable name \"headerData\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_Anim.toC", + "line": 317, + "column": 4, + "endLine": 317, + "endColumn": 11, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Method name \"toC\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_Anim.toC", + "line": 317, + "column": 18, + "endLine": 317, + "endColumn": 35, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Argument name \"mergeValues\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_Anim.toC", + "line": 317, + "column": 37, + "endLine": 317, + "endColumn": 55, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Argument name \"useHexValues\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_Anim.toC", + "line": 321, + "column": 8, + "endLine": 321, + "endColumn": 18, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Variable name \"valueTable\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_Anim.toC", + "line": 321, + "column": 20, + "endLine": 321, + "endColumn": 32, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Variable name \"indicesTable\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_Anim.toC", + "line": 323, + "column": 8, + "endLine": 323, + "endColumn": 13, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Variable name \"cData\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "error", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_Anim.toC", + "line": 325, + "column": 12, + "endLine": 325, + "endColumn": 20, + "path": "classes.py", + "symbol": "undefined-variable", + "message": "Undefined variable 'arrayToC'", + "message-id": "E0602" + }, + { + "type": "error", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_Anim.toC", + "line": 336, + "column": 12, + "endLine": 336, + "endColumn": 20, + "path": "classes.py", + "symbol": "undefined-variable", + "message": "Undefined variable 'arrayToC'", + "message-id": "E0602" + }, + { + "type": "refactor", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_Anim.toC", + "line": 317, + "column": 4, + "endLine": 317, + "endColumn": 11, + "path": "classes.py", + "symbol": "inconsistent-return-statements", + "message": "Either all return statements in a function should return an expression, or none of them should.", + "message-id": "R1710" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_Anim.to_action", + "line": 371, + "column": 12, + "endLine": 371, + "endColumn": 13, + "path": "classes.py", + "symbol": "unused-variable", + "message": "Unused variable 'i'", + "message-id": "W0612" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_Anim.read_binary", + "line": 383, + "column": 8, + "endLine": 383, + "endColumn": 21, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Variable name \"indicesReader\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_Anim.read_binary", + "line": 384, + "column": 12, + "endLine": 384, + "endColumn": 13, + "path": "classes.py", + "symbol": "unused-variable", + "message": "Unused variable 'i'", + "message-id": "W0612" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_Anim.readC", + "line": 389, + "column": 4, + "endLine": 389, + "endColumn": 13, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Method name \"readC\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_Anim.readC", + "line": 394, + "column": 12, + "endLine": 394, + "endColumn": 24, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Variable name \"indicesArray\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_Anim.readC", + "line": 395, + "column": 12, + "endLine": 395, + "endColumn": 23, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Variable name \"valuesArray\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_Anim.readC", + "line": 405, + "column": 12, + "endLine": 405, + "endColumn": 20, + "path": "classes.py", + "symbol": "invalid-name", + "message": "Variable name \"maxFrame\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "SM64_Anim.to_action", + "line": 367, + "column": 8, + "endLine": 367, + "endColumn": 28, + "path": "classes.py", + "symbol": "attribute-defined-outside-init", + "message": "Attribute 'referenceTables' defined outside __init__", + "message-id": "W0201" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "", + "line": 4, + "column": 0, + "endLine": 4, + "endColumn": 18, + "path": "classes.py", + "symbol": "wrong-import-order", + "message": "standard import \"import dataclasses\" should be placed before \"import bpy\"", + "message-id": "C0411" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "", + "line": 5, + "column": 0, + "endLine": 5, + "endColumn": 23, + "path": "classes.py", + "symbol": "wrong-import-order", + "message": "standard import \"from io import StringIO\" should be placed before \"import bpy\"", + "message-id": "C0411" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "", + "line": 6, + "column": 0, + "endLine": 6, + "endColumn": 9, + "path": "classes.py", + "symbol": "wrong-import-order", + "message": "standard import \"import os\" should be placed before \"import bpy\"", + "message-id": "C0411" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.classes", + "obj": "", + "line": 7, + "column": 0, + "endLine": 7, + "endColumn": 27, + "path": "classes.py", + "symbol": "wrong-import-order", + "message": "standard import \"from typing import BinaryIO\" should be placed before \"import bpy\"", + "message-id": "C0411" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "", + "line": 140, + "column": 9, + "endLine": null, + "endColumn": null, + "path": "properties.py", + "symbol": "fixme", + "message": "TODO: FIX", + "message-id": "W0511" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "", + "line": 520, + "column": 9, + "endLine": null, + "endColumn": null, + "path": "properties.py", + "symbol": "fixme", + "message": "TODO: Add selected action button should add all variations in action.", + "message-id": "W0511" + }, + { + "type": "error", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "", + "line": 1, + "column": 0, + "endLine": 1, + "endColumn": 10, + "path": "properties.py", + "symbol": "import-error", + "message": "Unable to import 'bpy'", + "message-id": "E0401" + }, + { + "type": "error", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "", + "line": 3, + "column": 0, + "endLine": 3, + "endColumn": 54, + "path": "properties.py", + "symbol": "import-error", + "message": "Unable to import 'bpy.utils'", + "message-id": "E0401" + }, + { + "type": "error", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "", + "line": 4, + "column": 0, + "endLine": 11, + "endColumn": 1, + "path": "properties.py", + "symbol": "import-error", + "message": "Unable to import 'bpy.props'", + "message-id": "E0401" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_HeaderOverwrites", + "line": 55, + "column": 0, + "endLine": 55, + "endColumn": 27, + "path": "properties.py", + "symbol": "missing-class-docstring", + "message": "Missing class docstring", + "message-id": "C0115" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_HeaderOverwrites", + "line": 55, + "column": 0, + "endLine": 55, + "endColumn": 27, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Class name \"SM64_HeaderOverwrites\" doesn't conform to PascalCase naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_HeaderOverwrites.draw_props", + "line": 63, + "column": 43, + "endLine": 63, + "endColumn": 90, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Argument name \"binaryExportProps\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "refactor", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_HeaderOverwrites", + "line": 55, + "column": 0, + "endLine": 55, + "endColumn": 27, + "path": "properties.py", + "symbol": "too-few-public-methods", + "message": "Too few public methods (1/2)", + "message-id": "R0903" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_AnimHeaderProps", + "line": 88, + "column": 0, + "endLine": 88, + "endColumn": 26, + "path": "properties.py", + "symbol": "missing-class-docstring", + "message": "Missing class docstring", + "message-id": "C0115" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_AnimHeaderProps", + "line": 88, + "column": 0, + "endLine": 88, + "endColumn": 26, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Class name \"SM64_AnimHeaderProps\" doesn't conform to PascalCase naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_AnimHeaderProps.copyHeader", + "line": 144, + "column": 8, + "endLine": 144, + "endColumn": 23, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Attribute name \"customName\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_AnimHeaderProps.getFrameRange", + "line": 129, + "column": 4, + "endLine": 129, + "endColumn": 21, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Method name \"getFrameRange\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_AnimHeaderProps.getFrameRange", + "line": 133, + "column": 8, + "endLine": 133, + "endColumn": 17, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Variable name \"loopStart\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_AnimHeaderProps.copyHeader", + "line": 139, + "column": 4, + "endLine": 139, + "endColumn": 18, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Method name \"copyHeader\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_AnimHeaderProps.draw_flag_props", + "line": 146, + "column": 48, + "endLine": 146, + "endColumn": 57, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Argument name \"sm64Props\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_AnimHeaderProps.draw_flag_props", + "line": 147, + "column": 8, + "endLine": 147, + "endColumn": 19, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Variable name \"exportProps\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_AnimHeaderProps.drawNameSettings", + "line": 175, + "column": 4, + "endLine": 175, + "endColumn": 24, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Method name \"drawNameSettings\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_AnimHeaderProps.drawNameSettings", + "line": 180, + "column": 8, + "endLine": 180, + "endColumn": 17, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Variable name \"nameSplit\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_AnimHeaderProps.draw_props", + "line": 195, + "column": 8, + "endLine": 195, + "endColumn": 17, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Variable name \"sm64Props\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_AnimHeaderProps.draw_props", + "line": 196, + "column": 8, + "endLine": 196, + "endColumn": 19, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Variable name \"exportProps\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_AnimHeaderProps.draw_props", + "line": 199, + "column": 8, + "endLine": 199, + "endColumn": 17, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Variable name \"previewOp\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_AnimHeaderProps.draw_props", + "line": 203, + "column": 8, + "endLine": 203, + "endColumn": 13, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Variable name \"addOp\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_ActionProps", + "line": 218, + "column": 0, + "endLine": 218, + "endColumn": 22, + "path": "properties.py", + "symbol": "missing-class-docstring", + "message": "Missing class docstring", + "message-id": "C0115" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_ActionProps", + "line": 218, + "column": 0, + "endLine": 218, + "endColumn": 22, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Class name \"SM64_ActionProps\" doesn't conform to PascalCase naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_ActionProps.headerFromIndex", + "line": 243, + "column": 4, + "endLine": 243, + "endColumn": 23, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Method name \"headerFromIndex\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_ActionProps.headerFromIndex", + "line": 247, + "column": 12, + "endLine": 247, + "endColumn": 63, + "path": "properties.py", + "symbol": "raise-missing-from", + "message": "Consider explicitly re-raising using 'except IndexError as exc' and 'raise PluginError('Header variant does not exist.') from exc'", + "message-id": "W0707" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_ActionProps.drawHeaderVariant", + "line": 259, + "column": 4, + "endLine": 259, + "endColumn": 25, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Method name \"drawHeaderVariant\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_ActionProps.drawHeaderVariant", + "line": 265, + "column": 8, + "endLine": 265, + "endColumn": 23, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Argument name \"arrayIndex\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "refactor", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_ActionProps.drawHeaderVariant", + "line": 259, + "column": 4, + "endLine": 259, + "endColumn": 25, + "path": "properties.py", + "symbol": "too-many-arguments", + "message": "Too many arguments (6/5)", + "message-id": "R0913" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_ActionProps.drawHeaderVariant", + "line": 269, + "column": 8, + "endLine": 269, + "endColumn": 13, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Variable name \"opRow\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_ActionProps.drawHeaderVariant", + "line": 270, + "column": 8, + "endLine": 270, + "endColumn": 16, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Variable name \"removeOp\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_ActionProps.drawHeaderVariant", + "line": 273, + "column": 8, + "endLine": 273, + "endColumn": 13, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Variable name \"addOp\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_ActionProps.drawHeaderVariant", + "line": 276, + "column": 8, + "endLine": 276, + "endColumn": 17, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Variable name \"moveUpCol\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_ActionProps.drawHeaderVariant", + "line": 278, + "column": 8, + "endLine": 278, + "endColumn": 14, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Variable name \"moveUp\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_ActionProps.drawHeaderVariant", + "line": 281, + "column": 8, + "endLine": 281, + "endColumn": 19, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Variable name \"moveDownCol\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_ActionProps.drawHeaderVariant", + "line": 283, + "column": 8, + "endLine": 283, + "endColumn": 16, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Variable name \"moveDown\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_ActionProps.drawVariants", + "line": 297, + "column": 4, + "endLine": 297, + "endColumn": 20, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Method name \"drawVariants\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_ActionProps.drawVariants", + "line": 308, + "column": 8, + "endLine": 308, + "endColumn": 13, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Variable name \"opRow\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_ActionProps.drawVariants", + "line": 309, + "column": 8, + "endLine": 309, + "endColumn": 13, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Variable name \"addOp\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_ActionProps.drawVariants", + "line": 313, + "column": 12, + "endLine": 313, + "endColumn": 19, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Variable name \"clearOp\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_ActionProps.drawReferences", + "line": 323, + "column": 4, + "endLine": 323, + "endColumn": 22, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Method name \"drawReferences\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_ActionProps.drawReferences", + "line": 323, + "column": 47, + "endLine": 323, + "endColumn": 56, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Argument name \"sm64Props\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_ActionProps.drawReferences", + "line": 325, + "column": 8, + "endLine": 325, + "endColumn": 18, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Variable name \"shouldShow\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_ActionProps.draw_props", + "line": 342, + "column": 8, + "endLine": 342, + "endColumn": 17, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Variable name \"sm64Props\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_ActionProps.draw_props", + "line": 343, + "column": 8, + "endLine": 343, + "endColumn": 19, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Variable name \"exportProps\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_ActionProps.draw_props", + "line": 344, + "column": 8, + "endLine": 344, + "endColumn": 25, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Variable name \"binaryExportProps\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_ActionProps.draw_props", + "line": 357, + "column": 12, + "endLine": 357, + "endColumn": 21, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Variable name \"nameSplit\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_TableElement", + "line": 378, + "column": 0, + "endLine": 378, + "endColumn": 23, + "path": "properties.py", + "symbol": "missing-class-docstring", + "message": "Missing class docstring", + "message-id": "C0115" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_TableElement", + "line": 378, + "column": 0, + "endLine": 378, + "endColumn": 23, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Class name \"SM64_TableElement\" doesn't conform to PascalCase naming style", + "message-id": "C0103" + }, + { + "type": "refactor", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_TableElement", + "line": 378, + "column": 0, + "endLine": 378, + "endColumn": 23, + "path": "properties.py", + "symbol": "too-few-public-methods", + "message": "Too few public methods (0/2)", + "message-id": "R0903" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_AnimTable", + "line": 383, + "column": 0, + "endLine": 383, + "endColumn": 20, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Class name \"SM64_AnimTable\" doesn't conform to PascalCase naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_AnimTable.getAnimTableName", + "line": 397, + "column": 4, + "endLine": 397, + "endColumn": 24, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Method name \"getAnimTableName\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_AnimTable.getAnimTableFileName", + "line": 402, + "column": 4, + "endLine": 402, + "endColumn": 28, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Method name \"getAnimTableFileName\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_AnimTable.getAnimTableFileName", + "line": 402, + "column": 35, + "endLine": 402, + "endColumn": 44, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Argument name \"sm64Props\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "refactor", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_AnimTable.getAnimTableFileName", + "line": 403, + "column": 8, + "endLine": 406, + "endColumn": 32, + "path": "properties.py", + "symbol": "no-else-return", + "message": "Unnecessary \"else\" after \"return\", remove the \"else\" and de-indent the code inside it", + "message-id": "R1705" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_AnimTable.get_headers", + "line": 415, + "column": 16, + "endLine": 415, + "endColumn": 118, + "path": "properties.py", + "symbol": "raise-missing-from", + "message": "Consider explicitly re-raising using 'except Exception as exc' and 'raise PluginError(f'Action \"{table_element.action.name}\" in table is not in this file\u00b4s action data') from exc'", + "message-id": "W0707" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_AnimTable.get_actions", + "line": 426, + "column": 16, + "endLine": 426, + "endColumn": 118, + "path": "properties.py", + "symbol": "raise-missing-from", + "message": "Consider explicitly re-raising using 'except Exception as exc' and 'raise PluginError(f'Action \"{table_element.action.name}\" in table is not in this file\u00b4s action data') from exc'", + "message-id": "W0707" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_AnimTable.drawTableNameSettings", + "line": 430, + "column": 4, + "endLine": 430, + "endColumn": 29, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Method name \"drawTableNameSettings\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_AnimTable.drawTableNameSettings", + "line": 431, + "column": 8, + "endLine": 431, + "endColumn": 17, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Variable name \"sm64Props\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "refactor", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_AnimTable.drawTableNameSettings", + "line": 434, + "column": 8, + "endLine": 439, + "endColumn": 18, + "path": "properties.py", + "symbol": "no-else-return", + "message": "Unnecessary \"elif\" after \"return\", remove the leading \"el\" from \"elif\"", + "message-id": "R1705" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_AnimTable.drawTableNameSettings", + "line": 440, + "column": 8, + "endLine": 440, + "endColumn": 17, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Variable name \"nameSplit\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_AnimTable.drawTableElement", + "line": 447, + "column": 4, + "endLine": 447, + "endColumn": 24, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Method name \"drawTableElement\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_AnimTable.drawTableElement", + "line": 447, + "column": 49, + "endLine": 447, + "endColumn": 58, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Argument name \"sm64Props\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_AnimTable.drawTableElement", + "line": 447, + "column": 60, + "endLine": 447, + "endColumn": 75, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Argument name \"tableIndex\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "refactor", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_AnimTable.drawTableElement", + "line": 447, + "column": 4, + "endLine": 447, + "endColumn": 24, + "path": "properties.py", + "symbol": "too-many-locals", + "message": "Too many local variables (19/15)", + "message-id": "R0914" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_AnimTable.drawTableElement", + "line": 448, + "column": 8, + "endLine": 448, + "endColumn": 19, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Variable name \"exportProps\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_AnimTable.drawTableElement", + "line": 472, + "column": 42, + "endLine": 472, + "endColumn": 90, + "path": "properties.py", + "symbol": "f-string-without-interpolation", + "message": "Using an f-string that does not have any interpolated variables", + "message-id": "W1309" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_AnimTable.drawTableElement", + "line": 481, + "column": 32, + "endLine": 481, + "endColumn": 82, + "path": "properties.py", + "symbol": "f-string-without-interpolation", + "message": "Using an f-string that does not have any interpolated variables", + "message-id": "W1309" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_AnimTable.drawTableElement", + "line": 484, + "column": 8, + "endLine": 484, + "endColumn": 16, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Variable name \"removeOp\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_AnimTable.drawTableElement", + "line": 487, + "column": 8, + "endLine": 487, + "endColumn": 17, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Variable name \"moveUpCol\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_AnimTable.drawTableElement", + "line": 489, + "column": 8, + "endLine": 489, + "endColumn": 14, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Variable name \"moveUp\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_AnimTable.drawTableElement", + "line": 492, + "column": 8, + "endLine": 492, + "endColumn": 19, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Variable name \"moveDownCol\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_AnimTable.drawTableElement", + "line": 494, + "column": 8, + "endLine": 494, + "endColumn": 16, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Variable name \"moveDown\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_AnimTable.draw_props", + "line": 498, + "column": 8, + "endLine": 498, + "endColumn": 17, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Variable name \"sm64Props\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_AnimTable.draw_props", + "line": 526, + "column": 12, + "endLine": 526, + "endColumn": 19, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Variable name \"clearOp\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_AnimTable.draw_props", + "line": 529, + "column": 16, + "endLine": 529, + "endColumn": 26, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Variable name \"tableIndex\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_AnimBinaryExportProps", + "line": 535, + "column": 0, + "endLine": 535, + "endColumn": 32, + "path": "properties.py", + "symbol": "missing-class-docstring", + "message": "Missing class docstring", + "message-id": "C0115" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_AnimBinaryExportProps", + "line": 535, + "column": 0, + "endLine": 535, + "endColumn": 32, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Class name \"SM64_AnimBinaryExportProps\" doesn't conform to PascalCase naming style", + "message-id": "C0103" + }, + { + "type": "refactor", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_AnimBinaryExportProps", + "line": 535, + "column": 0, + "endLine": 535, + "endColumn": 32, + "path": "properties.py", + "symbol": "too-few-public-methods", + "message": "Too few public methods (1/2)", + "message-id": "R0903" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_AnimExportProps", + "line": 561, + "column": 0, + "endLine": 561, + "endColumn": 26, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Class name \"SM64_AnimExportProps\" doesn't conform to PascalCase naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_AnimExportProps.is_dma_structure", + "line": 595, + "column": 31, + "endLine": 595, + "endColumn": 40, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Argument name \"sm64Props\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "refactor", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_AnimExportProps.is_dma_structure", + "line": 596, + "column": 8, + "endLine": 600, + "endColumn": 45, + "path": "properties.py", + "symbol": "no-else-return", + "message": "Unnecessary \"else\" after \"return\", remove the \"else\" and de-indent the code inside it", + "message-id": "R1705" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_AnimExportProps.canUseDMAStructure", + "line": 618, + "column": 4, + "endLine": 618, + "endColumn": 26, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Method name \"canUseDMAStructure\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "refactor", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_AnimExportProps.canUseDMAStructure", + "line": 619, + "column": 15, + "endLine": 619, + "endColumn": 72, + "path": "properties.py", + "symbol": "consider-using-in", + "message": "Consider merging these comparisons with 'in' by using 'self.header_type in ('Custom', 'DMA')'. Use a set instead if elements are hashable.", + "message-id": "R1714" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_AnimImportProps", + "line": 672, + "column": 0, + "endLine": 672, + "endColumn": 26, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Class name \"SM64_AnimImportProps\" doesn't conform to PascalCase naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_AnimImportProps.isBinaryImport", + "line": 696, + "column": 4, + "endLine": 696, + "endColumn": 22, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Method name \"isBinaryImport\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_AnimImportProps.isSegmentedPointer", + "line": 699, + "column": 4, + "endLine": 699, + "endColumn": 26, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Method name \"isSegmentedPointer\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_AnimImportProps.drawBinaryAddress", + "line": 702, + "column": 4, + "endLine": 702, + "endColumn": 25, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Method name \"drawBinaryAddress\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_AnimImportProps.drawBinary", + "line": 707, + "column": 4, + "endLine": 707, + "endColumn": 18, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Method name \"drawBinary\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.properties", + "obj": "SM64_AnimImportProps.drawC", + "line": 732, + "column": 4, + "endLine": 732, + "endColumn": 13, + "path": "properties.py", + "symbol": "invalid-name", + "message": "Method name \"drawC\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "error", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "", + "line": 3, + "column": 0, + "endLine": 3, + "endColumn": 10, + "path": "operators.py", + "symbol": "import-error", + "message": "Unable to import 'bpy'", + "message-id": "E0401" + }, + { + "type": "error", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "", + "line": 4, + "column": 0, + "endLine": 4, + "endColumn": 54, + "path": "operators.py", + "symbol": "import-error", + "message": "Unable to import 'bpy.utils'", + "message-id": "E0401" + }, + { + "type": "error", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "", + "line": 5, + "column": 0, + "endLine": 5, + "endColumn": 28, + "path": "operators.py", + "symbol": "import-error", + "message": "Unable to import 'bpy.path'", + "message-id": "E0401" + }, + { + "type": "error", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "", + "line": 6, + "column": 0, + "endLine": 10, + "endColumn": 1, + "path": "operators.py", + "symbol": "import-error", + "message": "Unable to import 'bpy.props'", + "message-id": "E0401" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "emulateNoLoop", + "line": 38, + "column": 0, + "endLine": 38, + "endColumn": 17, + "path": "operators.py", + "symbol": "invalid-name", + "message": "Function name \"emulateNoLoop\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "emulateNoLoop", + "line": 39, + "column": 4, + "endLine": 39, + "endColumn": 15, + "path": "operators.py", + "symbol": "invalid-name", + "message": "Variable name \"exportProps\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "emulateNoLoop", + "line": 45, + "column": 4, + "endLine": 47, + "endColumn": 14, + "path": "operators.py", + "symbol": "bare-except", + "message": "No exception type(s) specified", + "message-id": "W0702" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "emulateNoLoop", + "line": 54, + "column": 4, + "endLine": 54, + "endColumn": 15, + "path": "operators.py", + "symbol": "unused-variable", + "message": "Unused variable 'start_frame'", + "message-id": "W0612" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "SM64_PreviewAnimOperator", + "line": 74, + "column": 0, + "endLine": 74, + "endColumn": 30, + "path": "operators.py", + "symbol": "missing-class-docstring", + "message": "Missing class docstring", + "message-id": "C0115" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "SM64_PreviewAnimOperator", + "line": 74, + "column": 0, + "endLine": 74, + "endColumn": 30, + "path": "operators.py", + "symbol": "invalid-name", + "message": "Class name \"SM64_PreviewAnimOperator\" doesn't conform to PascalCase naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "SM64_PreviewAnimOperator.executeOperation", + "line": 82, + "column": 4, + "endLine": 82, + "endColumn": 24, + "path": "operators.py", + "symbol": "invalid-name", + "message": "Method name \"executeOperation\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "SM64_PreviewAnimOperator.executeOperation", + "line": 85, + "column": 8, + "endLine": 85, + "endColumn": 19, + "path": "operators.py", + "symbol": "invalid-name", + "message": "Variable name \"exportProps\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "SM64_PreviewAnimOperator.executeOperation", + "line": 87, + "column": 8, + "endLine": 87, + "endColumn": 19, + "path": "operators.py", + "symbol": "invalid-name", + "message": "Variable name \"armatureObj\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "SM64_PreviewAnimOperator.execute", + "line": 120, + "column": 15, + "endLine": 120, + "endColumn": 24, + "path": "operators.py", + "symbol": "broad-exception-caught", + "message": "Catching too general exception Exception", + "message-id": "W0718" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "SM64_TableOperations", + "line": 125, + "column": 0, + "endLine": 125, + "endColumn": 26, + "path": "operators.py", + "symbol": "missing-class-docstring", + "message": "Missing class docstring", + "message-id": "C0115" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "SM64_TableOperations", + "line": 125, + "column": 0, + "endLine": 125, + "endColumn": 26, + "path": "operators.py", + "symbol": "invalid-name", + "message": "Class name \"SM64_TableOperations\" doesn't conform to PascalCase naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "SM64_TableOperations.execute_operator", + "line": 136, + "column": 8, + "endLine": 136, + "endColumn": 19, + "path": "operators.py", + "symbol": "invalid-name", + "message": "Variable name \"exportProps\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "SM64_TableOperations.execute_operator", + "line": 138, + "column": 8, + "endLine": 138, + "endColumn": 21, + "path": "operators.py", + "symbol": "invalid-name", + "message": "Variable name \"tableElements\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "SM64_TableOperations.execute_operator", + "line": 152, + "column": 16, + "endLine": 152, + "endColumn": 17, + "path": "operators.py", + "symbol": "unused-variable", + "message": "Unused variable 'i'", + "message-id": "W0612" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "SM64_TableOperations.execute", + "line": 160, + "column": 15, + "endLine": 160, + "endColumn": 24, + "path": "operators.py", + "symbol": "broad-exception-caught", + "message": "Catching too general exception Exception", + "message-id": "W0718" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "SM64_AnimVariantOperations", + "line": 165, + "column": 0, + "endLine": 165, + "endColumn": 32, + "path": "operators.py", + "symbol": "missing-class-docstring", + "message": "Missing class docstring", + "message-id": "C0115" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "SM64_AnimVariantOperations", + "line": 165, + "column": 0, + "endLine": 165, + "endColumn": 32, + "path": "operators.py", + "symbol": "invalid-name", + "message": "Class name \"SM64_AnimVariantOperations\" doesn't conform to PascalCase naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "SM64_AnimVariantOperations.execute_operator", + "line": 197, + "column": 12, + "endLine": 197, + "endColumn": 22, + "path": "operators.py", + "symbol": "invalid-name", + "message": "Variable name \"arrayIndex\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "SM64_AnimVariantOperations.execute_operator", + "line": 199, + "column": 16, + "endLine": 199, + "endColumn": 26, + "path": "operators.py", + "symbol": "invalid-name", + "message": "Variable name \"arrayIndex\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "SM64_AnimVariantOperations.execute_operator", + "line": 190, + "column": 16, + "endLine": 190, + "endColumn": 17, + "path": "operators.py", + "symbol": "unused-variable", + "message": "Unused variable 'i'", + "message-id": "W0612" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "SM64_AnimVariantOperations.execute", + "line": 209, + "column": 15, + "endLine": 209, + "endColumn": 24, + "path": "operators.py", + "symbol": "broad-exception-caught", + "message": "Catching too general exception Exception", + "message-id": "W0718" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "SM64_ExportAnimTable", + "line": 214, + "column": 0, + "endLine": 214, + "endColumn": 26, + "path": "operators.py", + "symbol": "missing-class-docstring", + "message": "Missing class docstring", + "message-id": "C0115" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "SM64_ExportAnimTable", + "line": 214, + "column": 0, + "endLine": 214, + "endColumn": 26, + "path": "operators.py", + "symbol": "invalid-name", + "message": "Class name \"SM64_ExportAnimTable\" doesn't conform to PascalCase naming style", + "message-id": "C0103" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "SM64_ExportAnimTable.execute", + "line": 223, + "column": 15, + "endLine": 223, + "endColumn": 24, + "path": "operators.py", + "symbol": "broad-exception-caught", + "message": "Catching too general exception Exception", + "message-id": "W0718" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "SM64_ExportAnimTable.execute", + "line": 227, + "column": 8, + "endLine": 227, + "endColumn": 19, + "path": "operators.py", + "symbol": "invalid-name", + "message": "Variable name \"armatureObj\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "SM64_ExportAnimTable.execute", + "line": 228, + "column": 8, + "endLine": 228, + "endColumn": 19, + "path": "operators.py", + "symbol": "invalid-name", + "message": "Variable name \"contextMode\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "SM64_ExportAnimTable.execute", + "line": 229, + "column": 8, + "endLine": 229, + "endColumn": 21, + "path": "operators.py", + "symbol": "invalid-name", + "message": "Variable name \"actionPreRead\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "SM64_ExportAnimTable.execute", + "line": 230, + "column": 8, + "endLine": 230, + "endColumn": 20, + "path": "operators.py", + "symbol": "invalid-name", + "message": "Variable name \"framePreRead\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "SM64_ExportAnimTable.execute", + "line": 238, + "column": 15, + "endLine": 238, + "endColumn": 24, + "path": "operators.py", + "symbol": "broad-exception-caught", + "message": "Catching too general exception Exception", + "message-id": "W0718" + }, + { + "type": "refactor", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "SM64_ExportAnimTable", + "line": 214, + "column": 0, + "endLine": 214, + "endColumn": 26, + "path": "operators.py", + "symbol": "too-few-public-methods", + "message": "Too few public methods (1/2)", + "message-id": "R0903" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "SM64_ExportAnim", + "line": 249, + "column": 0, + "endLine": 249, + "endColumn": 21, + "path": "operators.py", + "symbol": "missing-class-docstring", + "message": "Missing class docstring", + "message-id": "C0115" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "SM64_ExportAnim", + "line": 249, + "column": 0, + "endLine": 249, + "endColumn": 21, + "path": "operators.py", + "symbol": "invalid-name", + "message": "Class name \"SM64_ExportAnim\" doesn't conform to PascalCase naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "SM64_ExportAnim.execute", + "line": 257, + "column": 8, + "endLine": 257, + "endColumn": 19, + "path": "operators.py", + "symbol": "invalid-name", + "message": "Variable name \"exportProps\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "SM64_ExportAnim.execute", + "line": 258, + "column": 8, + "endLine": 258, + "endColumn": 21, + "path": "operators.py", + "symbol": "invalid-name", + "message": "Variable name \"romfileOutput\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "SM64_ExportAnim.execute", + "line": 258, + "column": 23, + "endLine": 258, + "endColumn": 30, + "path": "operators.py", + "symbol": "invalid-name", + "message": "Variable name \"tempROM\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "SM64_ExportAnim.execute", + "line": 262, + "column": 15, + "endLine": 262, + "endColumn": 24, + "path": "operators.py", + "symbol": "broad-exception-caught", + "message": "Catching too general exception Exception", + "message-id": "W0718" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "SM64_ExportAnim.execute", + "line": 266, + "column": 8, + "endLine": 266, + "endColumn": 19, + "path": "operators.py", + "symbol": "invalid-name", + "message": "Variable name \"armatureObj\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "SM64_ExportAnim.execute", + "line": 267, + "column": 8, + "endLine": 267, + "endColumn": 19, + "path": "operators.py", + "symbol": "invalid-name", + "message": "Variable name \"contextMode\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "SM64_ExportAnim.execute", + "line": 268, + "column": 8, + "endLine": 268, + "endColumn": 21, + "path": "operators.py", + "symbol": "invalid-name", + "message": "Variable name \"actionPreRead\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "SM64_ExportAnim.execute", + "line": 269, + "column": 8, + "endLine": 269, + "endColumn": 20, + "path": "operators.py", + "symbol": "invalid-name", + "message": "Variable name \"framePreRead\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "SM64_ExportAnim.execute", + "line": 278, + "column": 15, + "endLine": 278, + "endColumn": 24, + "path": "operators.py", + "symbol": "broad-exception-caught", + "message": "Catching too general exception Exception", + "message-id": "W0718" + }, + { + "type": "refactor", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "SM64_ExportAnim", + "line": 249, + "column": 0, + "endLine": 249, + "endColumn": 21, + "path": "operators.py", + "symbol": "too-few-public-methods", + "message": "Too few public methods (1/2)", + "message-id": "R0903" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "SM64_ImportAllMarioAnims", + "line": 296, + "column": 0, + "endLine": 296, + "endColumn": 30, + "path": "operators.py", + "symbol": "missing-class-docstring", + "message": "Missing class docstring", + "message-id": "C0115" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "SM64_ImportAllMarioAnims", + "line": 296, + "column": 0, + "endLine": 296, + "endColumn": 30, + "path": "operators.py", + "symbol": "invalid-name", + "message": "Class name \"SM64_ImportAllMarioAnims\" doesn't conform to PascalCase naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "SM64_ImportAllMarioAnims.execute_operator", + "line": 304, + "column": 8, + "endLine": 304, + "endColumn": 17, + "path": "operators.py", + "symbol": "invalid-name", + "message": "Variable name \"sm64Props\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "SM64_ImportAllMarioAnims.execute_operator", + "line": 305, + "column": 8, + "endLine": 305, + "endColumn": 19, + "path": "operators.py", + "symbol": "invalid-name", + "message": "Variable name \"importProps\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "SM64_ImportAllMarioAnims.execute_operator", + "line": 307, + "column": 8, + "endLine": 307, + "endColumn": 19, + "path": "operators.py", + "symbol": "invalid-name", + "message": "Variable name \"armatureObj\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "SM64_ImportAllMarioAnims.execute_operator", + "line": 309, + "column": 8, + "endLine": 309, + "endColumn": 16, + "path": "operators.py", + "symbol": "invalid-name", + "message": "Variable name \"dataDict\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "SM64_ImportAllMarioAnims.execute_operator", + "line": 310, + "column": 8, + "endLine": 310, + "endColumn": 17, + "path": "operators.py", + "symbol": "invalid-name", + "message": "Variable name \"tableList\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "SM64_ImportAllMarioAnims.execute_operator", + "line": 313, + "column": 71, + "endLine": 313, + "endColumn": 78, + "path": "operators.py", + "symbol": "invalid-name", + "message": "Variable name \"ROMData\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "SM64_ImportAllMarioAnims.execute_operator", + "line": 314, + "column": 20, + "endLine": 314, + "endColumn": 29, + "path": "operators.py", + "symbol": "invalid-name", + "message": "Variable name \"entrieStr\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "SM64_ImportAllMarioAnims.execute_operator", + "line": 328, + "column": 12, + "endLine": 328, + "endColumn": 19, + "path": "operators.py", + "symbol": "invalid-name", + "message": "Variable name \"dataKey\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "error", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "SM64_ImportAllMarioAnims.execute_operator", + "line": 330, + "column": 8, + "endLine": 330, + "endColumn": 28, + "path": "operators.py", + "symbol": "no-member", + "message": "Instance of 'list' has no 'to_blender' member", + "message-id": "E1101" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "SM64_ImportAllMarioAnims.execute_operator", + "line": 314, + "column": 37, + "endLine": 314, + "endColumn": 48, + "path": "operators.py", + "symbol": "unused-variable", + "message": "Unused variable 'description'", + "message-id": "W0612" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "SM64_ImportAllMarioAnims.execute_operator", + "line": 328, + "column": 12, + "endLine": 328, + "endColumn": 19, + "path": "operators.py", + "symbol": "unused-variable", + "message": "Unused variable 'dataKey'", + "message-id": "W0612" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "SM64_ImportAllMarioAnims.execute", + "line": 337, + "column": 15, + "endLine": 337, + "endColumn": 24, + "path": "operators.py", + "symbol": "broad-exception-caught", + "message": "Catching too general exception Exception", + "message-id": "W0718" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "SM64_ImportAnim", + "line": 342, + "column": 0, + "endLine": 342, + "endColumn": 21, + "path": "operators.py", + "symbol": "missing-class-docstring", + "message": "Missing class docstring", + "message-id": "C0115" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "SM64_ImportAnim", + "line": 342, + "column": 0, + "endLine": 342, + "endColumn": 21, + "path": "operators.py", + "symbol": "invalid-name", + "message": "Class name \"SM64_ImportAnim\" doesn't conform to PascalCase naming style", + "message-id": "C0103" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "SM64_ImportAnim.execute", + "line": 373, + "column": 15, + "endLine": 373, + "endColumn": 24, + "path": "operators.py", + "symbol": "broad-exception-caught", + "message": "Catching too general exception Exception", + "message-id": "W0718" + }, + { + "type": "refactor", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "SM64_ImportAnim", + "line": 342, + "column": 0, + "endLine": 342, + "endColumn": 21, + "path": "operators.py", + "symbol": "too-few-public-methods", + "message": "Too few public methods (1/2)", + "message-id": "R0903" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "SM64_SearchMarioAnimEnum", + "line": 378, + "column": 0, + "endLine": 378, + "endColumn": 30, + "path": "operators.py", + "symbol": "missing-class-docstring", + "message": "Missing class docstring", + "message-id": "C0115" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "SM64_SearchMarioAnimEnum", + "line": 378, + "column": 0, + "endLine": 378, + "endColumn": 30, + "path": "operators.py", + "symbol": "invalid-name", + "message": "Class name \"SM64_SearchMarioAnimEnum\" doesn't conform to PascalCase naming style", + "message-id": "C0103" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.operators", + "obj": "SM64_SearchMarioAnimEnum.invoke", + "line": 395, + "column": 30, + "endLine": 395, + "endColumn": 35, + "path": "operators.py", + "symbol": "unused-argument", + "message": "Unused argument 'event'", + "message-id": "W0613" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "", + "line": 96, + "column": 30, + "endLine": null, + "endColumn": null, + "path": "exporting.py", + "symbol": "fixme", + "message": "TODO: Check for refresh 16 here", + "message-id": "W0511" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "", + "line": 1, + "column": 0, + "endLine": 1, + "endColumn": 25, + "path": "exporting.py", + "symbol": "multiple-imports", + "message": "Multiple imports on one line (bpy, mathutils, os)", + "message-id": "C0410" + }, + { + "type": "error", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "", + "line": 1, + "column": 0, + "endLine": 1, + "endColumn": 25, + "path": "exporting.py", + "symbol": "import-error", + "message": "Unable to import 'bpy'", + "message-id": "E0401" + }, + { + "type": "error", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "", + "line": 1, + "column": 0, + "endLine": 1, + "endColumn": 25, + "path": "exporting.py", + "symbol": "import-error", + "message": "Unable to import 'mathutils'", + "message-id": "E0401" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "getAnimationPairs", + "line": 25, + "column": 0, + "endLine": 25, + "endColumn": 21, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Function name \"getAnimationPairs\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "getAnimationPairs", + "line": 28, + "column": 4, + "endLine": 28, + "endColumn": 33, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Argument name \"armatureObj\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "getAnimationPairs", + "line": 29, + "column": 4, + "endLine": 29, + "endColumn": 43, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Argument name \"animBonesInfo\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "refactor", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "getAnimationPairs", + "line": 25, + "column": 0, + "endLine": 25, + "endColumn": 21, + "path": "exporting.py", + "symbol": "too-many-locals", + "message": "Too many local variables (21/15)", + "message-id": "R0914" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "getAnimationPairs", + "line": 31, + "column": 4, + "endLine": 31, + "endColumn": 13, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"sm64Props\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "getAnimationPairs", + "line": 34, + "column": 4, + "endLine": 34, + "endColumn": 12, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"maxFrame\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "error", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "getAnimationPairs", + "line": 34, + "column": 15, + "endLine": 34, + "endColumn": 43, + "path": "exporting.py", + "symbol": "too-many-function-args", + "message": "Too many positional arguments for function call", + "message-id": "E1121" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "getAnimationPairs", + "line": 41, + "column": 4, + "endLine": 41, + "endColumn": 14, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"transXPair\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "getAnimationPairs", + "line": 41, + "column": 16, + "endLine": 41, + "endColumn": 26, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"transYPair\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "getAnimationPairs", + "line": 41, + "column": 28, + "endLine": 41, + "endColumn": 38, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"transZPair\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "getAnimationPairs", + "line": 43, + "column": 4, + "endLine": 43, + "endColumn": 17, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"rotationPairs\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "getAnimationPairs", + "line": 44, + "column": 8, + "endLine": 44, + "endColumn": 16, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"boneInfo\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "getAnimationPairs", + "line": 45, + "column": 8, + "endLine": 45, + "endColumn": 16, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"xyzPairs\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "getAnimationPairs", + "line": 60, + "column": 12, + "endLine": 60, + "endColumn": 21, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"boneIndex\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "getAnimationPairs", + "line": 60, + "column": 23, + "endLine": 60, + "endColumn": 31, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"poseBone\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "getAnimationPairs", + "line": 44, + "column": 8, + "endLine": 44, + "endColumn": 16, + "path": "exporting.py", + "symbol": "unused-variable", + "message": "Unused variable 'boneInfo'", + "message-id": "W0612" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "getIntFlags", + "line": 73, + "column": 0, + "endLine": 73, + "endColumn": 15, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Function name \"getIntFlags\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "getCFlags", + "line": 89, + "column": 0, + "endLine": 89, + "endColumn": 13, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Function name \"getCFlags\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "getCFlags", + "line": 93, + "column": 8, + "endLine": 93, + "endColumn": 16, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"flagList\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "updateIncludes", + "line": 112, + "column": 0, + "endLine": 112, + "endColumn": 18, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Function name \"updateIncludes\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "updateIncludes", + "line": 112, + "column": 19, + "endLine": 112, + "endColumn": 28, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Argument name \"levelName\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "updateIncludes", + "line": 112, + "column": 30, + "endLine": 112, + "endColumn": 37, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Argument name \"dirName\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "updateIncludes", + "line": 112, + "column": 39, + "endLine": 112, + "endColumn": 46, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Argument name \"dirPath\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "updateIncludes", + "line": 112, + "column": 48, + "endLine": 112, + "endColumn": 59, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Argument name \"exportProps\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "updateIncludes", + "line": 115, + "column": 12, + "endLine": 115, + "endColumn": 22, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"groupPathC\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "updateIncludes", + "line": 116, + "column": 12, + "endLine": 116, + "endColumn": 22, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"groupPathH\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "updateIncludes", + "line": 122, + "column": 12, + "endLine": 122, + "endColumn": 22, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"groupPathC\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "updateIncludes", + "line": 123, + "column": 12, + "endLine": 123, + "endColumn": 22, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"groupPathH\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "writeActorHeader", + "line": 132, + "column": 0, + "endLine": 132, + "endColumn": 20, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Function name \"writeActorHeader\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "writeActorHeader", + "line": 132, + "column": 21, + "endLine": 132, + "endColumn": 31, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Argument name \"geoDirPath\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "writeActorHeader", + "line": 132, + "column": 33, + "endLine": 132, + "endColumn": 42, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Argument name \"animsName\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "writeActorHeader", + "line": 133, + "column": 4, + "endLine": 133, + "endColumn": 14, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"headerPath\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "writeActorHeader", + "line": 134, + "column": 4, + "endLine": 134, + "endColumn": 14, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"headerFile\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "writeActorHeader", + "line": 134, + "column": 17, + "endLine": 134, + "endColumn": 52, + "path": "exporting.py", + "symbol": "unspecified-encoding", + "message": "Using open without explicitly specifying an encoding", + "message-id": "W1514" + }, + { + "type": "refactor", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "writeActorHeader", + "line": 134, + "column": 17, + "endLine": 134, + "endColumn": 52, + "path": "exporting.py", + "symbol": "consider-using-with", + "message": "Consider using 'with' for resource-allocating operations", + "message-id": "R1732" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "updateTableFile", + "line": 139, + "column": 0, + "endLine": 139, + "endColumn": 19, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Function name \"updateTableFile\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "updateTableFile", + "line": 139, + "column": 20, + "endLine": 139, + "endColumn": 34, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Argument name \"tablePath\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "updateTableFile", + "line": 139, + "column": 36, + "endLine": 139, + "endColumn": 50, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Argument name \"tableName\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "updateTableFile", + "line": 139, + "column": 94, + "endLine": 139, + "endColumn": 105, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Argument name \"exportProps\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "refactor", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "updateTableFile", + "line": 139, + "column": 0, + "endLine": 139, + "endColumn": 19, + "path": "exporting.py", + "symbol": "too-many-locals", + "message": "Too many local variables (27/15)", + "message-id": "R0914" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "updateTableFile", + "line": 144, + "column": 9, + "endLine": 144, + "endColumn": 29, + "path": "exporting.py", + "symbol": "unspecified-encoding", + "message": "Using open without explicitly specifying an encoding", + "message-id": "W1514" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "updateTableFile", + "line": 147, + "column": 4, + "endLine": 147, + "endColumn": 14, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"tableProps\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "updateTableFile", + "line": 148, + "column": 4, + "endLine": 148, + "endColumn": 18, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"headerPointers\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "error", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "updateTableFile", + "line": 148, + "column": 40, + "endLine": 148, + "endColumn": 55, + "path": "exporting.py", + "symbol": "undefined-variable", + "message": "Undefined variable 'sm64ExportProps'", + "message-id": "E0602" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "updateTableFile", + "line": 149, + "column": 15, + "endLine": 149, + "endColumn": 27, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"enumListName\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "updateTableFile", + "line": 151, + "column": 4, + "endLine": 151, + "endColumn": 15, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"arrayReader\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "error", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "updateTableFile", + "line": 152, + "column": 13, + "endLine": 152, + "endColumn": 45, + "path": "exporting.py", + "symbol": "no-member", + "message": "Instance of 'CParser' has no 'findAllCArraysInFile' member", + "message-id": "E1101" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "updateTableFile", + "line": 154, + "column": 4, + "endLine": 154, + "endColumn": 20, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"tableOriginArray\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "updateTableFile", + "line": 154, + "column": 22, + "endLine": 154, + "endColumn": 31, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"readTable\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "updateTableFile", + "line": 155, + "column": 4, + "endLine": 155, + "endColumn": 18, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"enumOriginList\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "updateTableFile", + "line": 155, + "column": 20, + "endLine": 155, + "endColumn": 29, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"enumsList\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "updateTableFile", + "line": 158, + "column": 8, + "endLine": 158, + "endColumn": 24, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"tableOriginArray\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "updateTableFile", + "line": 159, + "column": 8, + "endLine": 159, + "endColumn": 17, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"readTable\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "updateTableFile", + "line": 163, + "column": 12, + "endLine": 163, + "endColumn": 26, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"enumOriginList\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "updateTableFile", + "line": 164, + "column": 12, + "endLine": 164, + "endColumn": 21, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"enumsList\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "updateTableFile", + "line": 166, + "column": 8, + "endLine": 166, + "endColumn": 18, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"tableArray\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "updateTableFile", + "line": 177, + "column": 12, + "endLine": 177, + "endColumn": 25, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"headerPointer\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "updateTableFile", + "line": 178, + "column": 12, + "endLine": 178, + "endColumn": 22, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"headerEnum\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "updateTableFile", + "line": 181, + "column": 12, + "endLine": 181, + "endColumn": 25, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"tableEnumName\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "updateTableFile", + "line": 181, + "column": 29, + "endLine": 181, + "endColumn": 46, + "path": "exporting.py", + "symbol": "consider-iterating-dictionary", + "message": "Consider iterating the dictionary directly instead of calling .keys()", + "message-id": "C0201" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "updateTableFile", + "line": 190, + "column": 8, + "endLine": 190, + "endColumn": 15, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"enumInC\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "error", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "updateTableFile", + "line": 190, + "column": 18, + "endLine": 190, + "endColumn": 25, + "path": "exporting.py", + "symbol": "undefined-variable", + "message": "Undefined variable 'enumToC'", + "message-id": "E0602" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "updateTableFile", + "line": 192, + "column": 8, + "endLine": 192, + "endColumn": 18, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"tableArray\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "updateTableFile", + "line": 199, + "column": 12, + "endLine": 199, + "endColumn": 25, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"headerPointer\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "updateTableFile", + "line": 209, + "column": 4, + "endLine": 209, + "endColumn": 12, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"tableInC\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "error", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "updateTableFile", + "line": 209, + "column": 15, + "endLine": 209, + "endColumn": 23, + "path": "exporting.py", + "symbol": "undefined-variable", + "message": "Undefined variable 'arrayToC'", + "message-id": "E0602" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "updateTableFile", + "line": 222, + "column": 9, + "endLine": 222, + "endColumn": 29, + "path": "exporting.py", + "symbol": "unspecified-encoding", + "message": "Using open without explicitly specifying an encoding", + "message-id": "W1514" + }, + { + "type": "refactor", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "updateTableFile", + "line": 139, + "column": 0, + "endLine": 139, + "endColumn": 19, + "path": "exporting.py", + "symbol": "too-many-branches", + "message": "Too many branches (23/12)", + "message-id": "R0912" + }, + { + "type": "refactor", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "updateTableFile", + "line": 139, + "column": 0, + "endLine": 139, + "endColumn": 19, + "path": "exporting.py", + "symbol": "too-many-statements", + "message": "Too many statements (54/50)", + "message-id": "R0915" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "createTableFile", + "line": 226, + "column": 0, + "endLine": 226, + "endColumn": 19, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Function name \"createTableFile\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "createTableFile", + "line": 226, + "column": 20, + "endLine": 226, + "endColumn": 31, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Argument name \"exportProps\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "createTableFile", + "line": 226, + "column": 33, + "endLine": 226, + "endColumn": 46, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Argument name \"tableFilePath\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "createTableFile", + "line": 226, + "column": 48, + "endLine": 226, + "endColumn": 57, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Argument name \"tableName\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "createTableFile", + "line": 226, + "column": 59, + "endLine": 226, + "endColumn": 70, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Argument name \"headerNames\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "createTableFile", + "line": 227, + "column": 4, + "endLine": 227, + "endColumn": 14, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"tableProps\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "createTableFile", + "line": 228, + "column": 15, + "endLine": 228, + "endColumn": 27, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"enumListName\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "createTableFile", + "line": 231, + "column": 8, + "endLine": 231, + "endColumn": 18, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"tableArray\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "createTableFile", + "line": 232, + "column": 12, + "endLine": 232, + "endColumn": 22, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"headerName\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "createTableFile", + "line": 235, + "column": 8, + "endLine": 235, + "endColumn": 17, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"enumsList\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "createTableFile", + "line": 236, + "column": 12, + "endLine": 236, + "endColumn": 25, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"tableEnumName\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "createTableFile", + "line": 236, + "column": 29, + "endLine": 236, + "endColumn": 46, + "path": "exporting.py", + "symbol": "consider-iterating-dictionary", + "message": "Consider iterating the dictionary directly instead of calling .keys()", + "message-id": "C0201" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "createTableFile", + "line": 239, + "column": 8, + "endLine": 239, + "endColumn": 18, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"tableArray\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "createTableFile", + "line": 240, + "column": 12, + "endLine": 240, + "endColumn": 22, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"headerName\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "createTableFile", + "line": 243, + "column": 9, + "endLine": 243, + "endColumn": 47, + "path": "exporting.py", + "symbol": "unspecified-encoding", + "message": "Using open without explicitly specifying an encoding", + "message-id": "W1514" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "createTableFile", + "line": 243, + "column": 51, + "endLine": 243, + "endColumn": 60, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"tableFile\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "error", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "createTableFile", + "line": 245, + "column": 28, + "endLine": 245, + "endColumn": 35, + "path": "exporting.py", + "symbol": "undefined-variable", + "message": "Undefined variable 'enumToC'", + "message-id": "E0602" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "createTableFile", + "line": 248, + "column": 8, + "endLine": 248, + "endColumn": 16, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"tableInC\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "error", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "createTableFile", + "line": 248, + "column": 19, + "endLine": 248, + "endColumn": 27, + "path": "exporting.py", + "symbol": "undefined-variable", + "message": "Undefined variable 'arrayToC'", + "message-id": "E0602" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "createDataFile", + "line": 259, + "column": 0, + "endLine": 259, + "endColumn": 18, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Function name \"createDataFile\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "createDataFile", + "line": 259, + "column": 19, + "endLine": 259, + "endColumn": 28, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Argument name \"sm64Props\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "createDataFile", + "line": 259, + "column": 30, + "endLine": 259, + "endColumn": 42, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Argument name \"dataFilePath\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "refactor", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "createDataFile", + "line": 261, + "column": 4, + "endLine": 261, + "endColumn": 41, + "path": "exporting.py", + "symbol": "consider-using-with", + "message": "Consider using 'with' for resource-allocating operations", + "message-id": "R1732" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "createDataFile", + "line": 261, + "column": 4, + "endLine": 261, + "endColumn": 41, + "path": "exporting.py", + "symbol": "unspecified-encoding", + "message": "Using open without explicitly specifying an encoding", + "message-id": "W1514" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "createDataFile", + "line": 259, + "column": 19, + "endLine": 259, + "endColumn": 28, + "path": "exporting.py", + "symbol": "unused-argument", + "message": "Unused argument 'sm64Props'", + "message-id": "W0613" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "updateDataFile", + "line": 266, + "column": 0, + "endLine": 266, + "endColumn": 18, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Function name \"updateDataFile\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "updateDataFile", + "line": 266, + "column": 19, + "endLine": 266, + "endColumn": 28, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Argument name \"sm64Props\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "updateDataFile", + "line": 266, + "column": 30, + "endLine": 266, + "endColumn": 42, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Argument name \"dataFilePath\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "updateDataFile", + "line": 266, + "column": 44, + "endLine": 266, + "endColumn": 56, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Argument name \"animFileName\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "updateFiles", + "line": 274, + "column": 0, + "endLine": 274, + "endColumn": 15, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Function name \"updateFiles\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "updateFiles", + "line": 275, + "column": 4, + "endLine": 275, + "endColumn": 13, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Argument name \"sm64Props\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "updateFiles", + "line": 276, + "column": 4, + "endLine": 276, + "endColumn": 39, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Argument name \"exportProps\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "updateFiles", + "line": 277, + "column": 4, + "endLine": 277, + "endColumn": 19, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Argument name \"geoDirPath\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "updateFiles", + "line": 278, + "column": 4, + "endLine": 278, + "endColumn": 20, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Argument name \"animDirPath\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "updateFiles", + "line": 279, + "column": 4, + "endLine": 279, + "endColumn": 16, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Argument name \"dirPath\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "updateFiles", + "line": 280, + "column": 4, + "endLine": 280, + "endColumn": 18, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Argument name \"levelName\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "updateFiles", + "line": 281, + "column": 4, + "endLine": 281, + "endColumn": 16, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Argument name \"dirName\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "updateFiles", + "line": 282, + "column": 4, + "endLine": 282, + "endColumn": 21, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Argument name \"animFileName\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "updateFiles", + "line": 284, + "column": 4, + "endLine": 284, + "endColumn": 26, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Argument name \"skipTableAndData\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "refactor", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "updateFiles", + "line": 274, + "column": 0, + "endLine": 274, + "endColumn": 15, + "path": "exporting.py", + "symbol": "too-many-arguments", + "message": "Too many arguments (10/5)", + "message-id": "R0913" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "updateFiles", + "line": 288, + "column": 4, + "endLine": 288, + "endColumn": 14, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"tableProps\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "updateFiles", + "line": 289, + "column": 4, + "endLine": 289, + "endColumn": 13, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"tableName\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "updateFiles", + "line": 290, + "column": 4, + "endLine": 290, + "endColumn": 13, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"tablePath\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "updateFiles", + "line": 291, + "column": 4, + "endLine": 291, + "endColumn": 16, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"dataFilePath\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "error", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "updateFiles", + "line": 294, + "column": 8, + "endLine": 294, + "endColumn": 67, + "path": "exporting.py", + "symbol": "no-value-for-parameter", + "message": "No value for argument 'exportProps' in function call", + "message-id": "E1120" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "getAnimationPaths", + "line": 303, + "column": 0, + "endLine": 303, + "endColumn": 21, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Function name \"getAnimationPaths\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "getAnimationPaths", + "line": 303, + "column": 22, + "endLine": 303, + "endColumn": 33, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Argument name \"exportProps\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "getAnimationPaths", + "line": 304, + "column": 4, + "endLine": 304, + "endColumn": 16, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"customExport\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "getAnimationPaths", + "line": 306, + "column": 4, + "endLine": 306, + "endColumn": 14, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"exportPath\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "getAnimationPaths", + "line": 306, + "column": 16, + "endLine": 306, + "endColumn": 25, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"levelName\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "error", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "getAnimationPaths", + "line": 314, + "column": 8, + "endLine": 314, + "endColumn": 26, + "path": "exporting.py", + "symbol": "undefined-variable", + "message": "Undefined variable 'apply_basic_tweaks'", + "message-id": "E0602" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "getAnimationPaths", + "line": 316, + "column": 4, + "endLine": 316, + "endColumn": 11, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"dirName\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "getAnimationPaths", + "line": 319, + "column": 8, + "endLine": 319, + "endColumn": 19, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"animDirPath\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "getAnimationPaths", + "line": 320, + "column": 8, + "endLine": 320, + "endColumn": 15, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"dirPath\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "getAnimationPaths", + "line": 321, + "column": 8, + "endLine": 321, + "endColumn": 18, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"geoDirPath\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "getAnimationPaths", + "line": 323, + "column": 8, + "endLine": 323, + "endColumn": 15, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"dirPath\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "getAnimationPaths", + "line": 323, + "column": 17, + "endLine": 323, + "endColumn": 23, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"texDir\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "getAnimationPaths", + "line": 324, + "column": 8, + "endLine": 324, + "endColumn": 18, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"geoDirPath\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "getAnimationPaths", + "line": 325, + "column": 8, + "endLine": 325, + "endColumn": 19, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"animDirPath\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "getAnimationPaths", + "line": 323, + "column": 17, + "endLine": 323, + "endColumn": 23, + "path": "exporting.py", + "symbol": "unused-variable", + "message": "Unused variable 'texDir'", + "message-id": "W0612" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "getAnimationData", + "line": 337, + "column": 0, + "endLine": 337, + "endColumn": 20, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Function name \"getAnimationData\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "getAnimationData", + "line": 337, + "column": 21, + "endLine": 337, + "endColumn": 50, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Argument name \"armatureObj\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "getAnimationData", + "line": 338, + "column": 4, + "endLine": 338, + "endColumn": 13, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"sm64Props\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "getAnimationData", + "line": 339, + "column": 4, + "endLine": 339, + "endColumn": 15, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"exportProps\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "getAnimationData", + "line": 343, + "column": 4, + "endLine": 343, + "endColumn": 17, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"animBonesInfo\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "getAnimationData", + "line": 345, + "column": 4, + "endLine": 345, + "endColumn": 12, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"sm64Anim\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "getAnimationData", + "line": 359, + "column": 8, + "endLine": 359, + "endColumn": 22, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"sm64AnimHeader\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "getAnimationData", + "line": 369, + "column": 8, + "endLine": 369, + "endColumn": 18, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"startFrame\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "getAnimationData", + "line": 369, + "column": 20, + "endLine": 369, + "endColumn": 29, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"loopStart\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimTableInsertableBinary", + "line": 379, + "column": 0, + "endLine": 379, + "endColumn": 35, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Function name \"exportAnimTableInsertableBinary\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimTableInsertableBinary", + "line": 380, + "column": 4, + "endLine": 380, + "endColumn": 33, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Argument name \"armatureObj\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimTableInsertableBinary", + "line": 382, + "column": 4, + "endLine": 382, + "endColumn": 46, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Argument name \"tableHeaders\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimTableInsertableBinary", + "line": 383, + "column": 4, + "endLine": 383, + "endColumn": 23, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Argument name \"sm64Anim\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "refactor", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimTableInsertableBinary", + "line": 379, + "column": 0, + "endLine": 379, + "endColumn": 35, + "path": "exporting.py", + "symbol": "too-many-locals", + "message": "Too many local variables (21/15)", + "message-id": "R0914" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimTableInsertableBinary", + "line": 385, + "column": 4, + "endLine": 385, + "endColumn": 13, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"sm64Props\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimTableInsertableBinary", + "line": 386, + "column": 4, + "endLine": 386, + "endColumn": 15, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"exportProps\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimTableInsertableBinary", + "line": 387, + "column": 4, + "endLine": 387, + "endColumn": 14, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"tableProps\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimTableInsertableBinary", + "line": 391, + "column": 4, + "endLine": 391, + "endColumn": 13, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"tableDict\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimTableInsertableBinary", + "line": 395, + "column": 8, + "endLine": 395, + "endColumn": 19, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"tableOffset\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimTableInsertableBinary", + "line": 408, + "column": 8, + "endLine": 408, + "endColumn": 21, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"actionHeaders\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimTableInsertableBinary", + "line": 409, + "column": 12, + "endLine": 409, + "endColumn": 23, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"tableHeader\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimTableInsertableBinary", + "line": 412, + "column": 16, + "endLine": 412, + "endColumn": 27, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"tableOffset\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimTableInsertableBinary", + "line": 413, + "column": 16, + "endLine": 413, + "endColumn": 28, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"headerOffset\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimTableInsertableBinary", + "line": 415, + "column": 33, + "endLine": 415, + "endColumn": 39, + "path": "exporting.py", + "symbol": "undefined-loop-variable", + "message": "Using possibly undefined loop variable 'header'", + "message-id": "W0631" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimTableInsertableBinary", + "line": 418, + "column": 8, + "endLine": 418, + "endColumn": 18, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"animResult\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimTableInsertableBinary", + "line": 424, + "column": 4, + "endLine": 424, + "endColumn": 21, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"animTableFileName\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimInsertableBinary", + "line": 430, + "column": 0, + "endLine": 430, + "endColumn": 30, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Function name \"exportAnimInsertableBinary\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimInsertableBinary", + "line": 430, + "column": 57, + "endLine": 430, + "endColumn": 66, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Argument name \"sm64Props\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimInsertableBinary", + "line": 430, + "column": 68, + "endLine": 430, + "endColumn": 87, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Argument name \"sm64Anim\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimInsertableBinary", + "line": 431, + "column": 4, + "endLine": 431, + "endColumn": 15, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"exportProps\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimInsertableBinary", + "line": 430, + "column": 31, + "endLine": 430, + "endColumn": 55, + "path": "exporting.py", + "symbol": "unused-argument", + "message": "Unused argument 'action'", + "message-id": "W0613" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimC", + "line": 441, + "column": 0, + "endLine": 441, + "endColumn": 15, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Function name \"exportAnimC\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimC", + "line": 444, + "column": 4, + "endLine": 444, + "endColumn": 23, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Argument name \"sm64Anim\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimC", + "line": 445, + "column": 4, + "endLine": 445, + "endColumn": 26, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Argument name \"skipTableAndData\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "refactor", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimC", + "line": 441, + "column": 0, + "endLine": 441, + "endColumn": 15, + "path": "exporting.py", + "symbol": "too-many-locals", + "message": "Too many local variables (18/15)", + "message-id": "R0914" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimC", + "line": 447, + "column": 4, + "endLine": 447, + "endColumn": 13, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"sm64Props\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimC", + "line": 448, + "column": 4, + "endLine": 448, + "endColumn": 15, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"exportProps\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimC", + "line": 454, + "column": 8, + "endLine": 454, + "endColumn": 16, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"dataName\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimC", + "line": 457, + "column": 4, + "endLine": 457, + "endColumn": 15, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"animDirPath\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimC", + "line": 457, + "column": 17, + "endLine": 457, + "endColumn": 24, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"dirPath\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimC", + "line": 457, + "column": 26, + "endLine": 457, + "endColumn": 36, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"geoDirPath\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimC", + "line": 457, + "column": 38, + "endLine": 457, + "endColumn": 47, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"levelName\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimC", + "line": 459, + "column": 4, + "endLine": 459, + "endColumn": 16, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"animFileName\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimC", + "line": 461, + "column": 4, + "endLine": 461, + "endColumn": 18, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"isDmaStructure\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimC", + "line": 463, + "column": 8, + "endLine": 463, + "endColumn": 22, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"isDmaStructure\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimC", + "line": 466, + "column": 12, + "endLine": 466, + "endColumn": 26, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"isDmaStructure\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "error", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimC", + "line": 468, + "column": 12, + "endLine": 478, + "endColumn": 13, + "path": "exporting.py", + "symbol": "no-value-for-parameter", + "message": "No value for argument 'skipTableAndData' in function call", + "message-id": "E1120" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimC", + "line": 480, + "column": 4, + "endLine": 480, + "endColumn": 12, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"animPath\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimC", + "line": 482, + "column": 4, + "endLine": 482, + "endColumn": 12, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"headersC\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimC", + "line": 483, + "column": 4, + "endLine": 483, + "endColumn": 9, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"dataC\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimC", + "line": 485, + "column": 9, + "endLine": 485, + "endColumn": 42, + "path": "exporting.py", + "symbol": "unspecified-encoding", + "message": "Using open without explicitly specifying an encoding", + "message-id": "W1514" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimC", + "line": 485, + "column": 46, + "endLine": 485, + "endColumn": 54, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"animFile\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimation", + "line": 500, + "column": 0, + "endLine": 500, + "endColumn": 19, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Function name \"exportAnimation\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimation", + "line": 501, + "column": 4, + "endLine": 501, + "endColumn": 34, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Argument name \"armatureObj\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimation", + "line": 501, + "column": 86, + "endLine": 501, + "endColumn": 108, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Argument name \"skipTableAndData\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimation", + "line": 503, + "column": 4, + "endLine": 503, + "endColumn": 13, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"sm64Props\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimation", + "line": 505, + "column": 4, + "endLine": 505, + "endColumn": 12, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"sm64Anim\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimationTable", + "line": 514, + "column": 0, + "endLine": 514, + "endColumn": 24, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Function name \"exportAnimationTable\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimationTable", + "line": 514, + "column": 53, + "endLine": 514, + "endColumn": 82, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Argument name \"armatureObj\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "refactor", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimationTable", + "line": 514, + "column": 0, + "endLine": 514, + "endColumn": 24, + "path": "exporting.py", + "symbol": "too-many-locals", + "message": "Too many local variables (16/15)", + "message-id": "R0914" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimationTable", + "line": 516, + "column": 4, + "endLine": 516, + "endColumn": 13, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"sm64Props\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimationTable", + "line": 517, + "column": 4, + "endLine": 517, + "endColumn": 15, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"exportProps\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimationTable", + "line": 518, + "column": 4, + "endLine": 518, + "endColumn": 14, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"tableProps\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimationTable", + "line": 520, + "column": 4, + "endLine": 520, + "endColumn": 16, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"tableHeaders\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimationTable", + "line": 521, + "column": 4, + "endLine": 521, + "endColumn": 15, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"headerNames\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "error", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimationTable", + "line": 521, + "column": 19, + "endLine": 521, + "endColumn": 53, + "path": "exporting.py", + "symbol": "no-value-for-parameter", + "message": "No value for argument 'header' in function call", + "message-id": "E1120" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimationTable", + "line": 532, + "column": 8, + "endLine": 532, + "endColumn": 19, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"animDirPath\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimationTable", + "line": 532, + "column": 21, + "endLine": 532, + "endColumn": 28, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"dirPath\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimationTable", + "line": 532, + "column": 30, + "endLine": 532, + "endColumn": 40, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"geoDirPath\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimationTable", + "line": 532, + "column": 42, + "endLine": 532, + "endColumn": 51, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"levelName\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimationTable", + "line": 534, + "column": 8, + "endLine": 534, + "endColumn": 17, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"tableName\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimationTable", + "line": 535, + "column": 8, + "endLine": 535, + "endColumn": 17, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"tablePath\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimationTable", + "line": 536, + "column": 8, + "endLine": 536, + "endColumn": 20, + "path": "exporting.py", + "symbol": "invalid-name", + "message": "Variable name \"dataFilePath\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "refactor", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimationTable", + "line": 514, + "column": 0, + "endLine": 514, + "endColumn": 24, + "path": "exporting.py", + "symbol": "inconsistent-return-statements", + "message": "Either all return statements in a function should return an expression, or none of them should.", + "message-id": "R1710" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimationTable", + "line": 532, + "column": 21, + "endLine": 532, + "endColumn": 28, + "path": "exporting.py", + "symbol": "unused-variable", + "message": "Unused variable 'dirPath'", + "message-id": "W0612" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimationTable", + "line": 532, + "column": 30, + "endLine": 532, + "endColumn": 40, + "path": "exporting.py", + "symbol": "unused-variable", + "message": "Unused variable 'geoDirPath'", + "message-id": "W0612" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "exportAnimationTable", + "line": 532, + "column": 42, + "endLine": 532, + "endColumn": 51, + "path": "exporting.py", + "symbol": "unused-variable", + "message": "Unused variable 'levelName'", + "message-id": "W0612" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.exporting", + "obj": "", + "line": 1, + "column": 0, + "endLine": 1, + "endColumn": 25, + "path": "exporting.py", + "symbol": "wrong-import-order", + "message": "standard import \"import bpy, mathutils, os\" should be placed before \"import bpy, mathutils, os\"", + "message-id": "C0411" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.c_parser", + "obj": "IfDefMacro", + "line": 9, + "column": 0, + "endLine": 9, + "endColumn": 16, + "path": "c_parser.py", + "symbol": "missing-class-docstring", + "message": "Missing class docstring", + "message-id": "C0115" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.c_parser", + "obj": "ParsedValue", + "line": 15, + "column": 0, + "endLine": 15, + "endColumn": 17, + "path": "c_parser.py", + "symbol": "missing-class-docstring", + "message": "Missing class docstring", + "message-id": "C0115" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.c_parser", + "obj": "CParser.read_values", + "line": 192, + "column": 16, + "endLine": 192, + "endColumn": 26, + "path": "c_parser.py", + "symbol": "attribute-defined-outside-init", + "message": "Attribute 'name' defined outside __init__", + "message-id": "W0201" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.c_parser", + "obj": "MacroCall", + "line": 27, + "column": 0, + "endLine": 27, + "endColumn": 15, + "path": "c_parser.py", + "symbol": "missing-class-docstring", + "message": "Missing class docstring", + "message-id": "C0115" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.c_parser", + "obj": "DesignatedValue", + "line": 32, + "column": 0, + "endLine": 32, + "endColumn": 21, + "path": "c_parser.py", + "symbol": "missing-class-docstring", + "message": "Missing class docstring", + "message-id": "C0115" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.c_parser", + "obj": "Include", + "line": 37, + "column": 0, + "endLine": 37, + "endColumn": 13, + "path": "c_parser.py", + "symbol": "missing-class-docstring", + "message": "Missing class docstring", + "message-id": "C0115" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.c_parser", + "obj": "Initialization", + "line": 42, + "column": 0, + "endLine": 42, + "endColumn": 20, + "path": "c_parser.py", + "symbol": "missing-class-docstring", + "message": "Missing class docstring", + "message-id": "C0115" + }, + { + "type": "refactor", + "module": "fast64-animations.fast64_internal.sm64.animation.c_parser", + "obj": "Initialization", + "line": 42, + "column": 0, + "endLine": 42, + "endColumn": 20, + "path": "c_parser.py", + "symbol": "too-many-instance-attributes", + "message": "Too many instance attributes (10/7)", + "message-id": "R0902" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.c_parser", + "obj": "CParser.read_keywords", + "line": 250, + "column": 12, + "endLine": 250, + "endColumn": 37, + "path": "c_parser.py", + "symbol": "attribute-defined-outside-init", + "message": "Attribute 'name' defined outside __init__", + "message-id": "W0201" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.c_parser", + "obj": "", + "line": 87, + "column": 0, + "endLine": null, + "endColumn": null, + "path": "c_parser.py", + "symbol": "implicit-str-concat", + "message": "Implicit string concatenation found in tuple", + "message-id": "W1404" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.c_parser", + "obj": "", + "line": 97, + "column": 0, + "endLine": 97, + "endColumn": 18, + "path": "c_parser.py", + "symbol": "invalid-name", + "message": "Constant name \"delimiters_pattern\" doesn't conform to UPPER_CASE naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.c_parser", + "obj": "CParser", + "line": 119, + "column": 0, + "endLine": 119, + "endColumn": 13, + "path": "c_parser.py", + "symbol": "missing-class-docstring", + "message": "Missing class docstring", + "message-id": "C0115" + }, + { + "type": "refactor", + "module": "fast64-animations.fast64_internal.sm64.animation.c_parser", + "obj": "CParser", + "line": 119, + "column": 0, + "endLine": 119, + "endColumn": 13, + "path": "c_parser.py", + "symbol": "too-many-instance-attributes", + "message": "Too many instance attributes (12/7)", + "message-id": "R0902" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.c_parser", + "obj": "CParser.read_macro", + "line": 157, + "column": 16, + "endLine": 157, + "endColumn": 20, + "path": "c_parser.py", + "symbol": "unnecessary-pass", + "message": "Unnecessary pass statement", + "message-id": "W0107" + }, + { + "type": "refactor", + "module": "fast64-animations.fast64_internal.sm64.animation.c_parser", + "obj": "CParser.read_values", + "line": 209, + "column": 13, + "endLine": 209, + "endColumn": 49, + "path": "c_parser.py", + "symbol": "consider-using-in", + "message": "Consider merging these comparisons with 'in' by using 'cur_token in (';', ',')'. Use a set instead if elements are hashable.", + "message-id": "R1714" + }, + { + "type": "refactor", + "module": "fast64-animations.fast64_internal.sm64.animation.c_parser", + "obj": "CParser.read_keywords", + "line": 215, + "column": 8, + "endLine": 222, + "endColumn": 22, + "path": "c_parser.py", + "symbol": "no-else-return", + "message": "Unnecessary \"else\" after \"return\", remove the \"else\" and de-indent the code inside it", + "message-id": "R1705" + }, + { + "type": "refactor", + "module": "fast64-animations.fast64_internal.sm64.animation.c_parser", + "obj": "CParser.read_keywords", + "line": 214, + "column": 4, + "endLine": 214, + "endColumn": 21, + "path": "c_parser.py", + "symbol": "too-many-branches", + "message": "Too many branches (14/12)", + "message-id": "R0912" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.c_parser", + "obj": "CParser.read_macro", + "line": 167, + "column": 12, + "endLine": 167, + "endColumn": 30, + "path": "c_parser.py", + "symbol": "attribute-defined-outside-init", + "message": "Attribute 'reading_macro' defined outside __init__", + "message-id": "W0201" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.c_parser", + "obj": "CParser.read_c_text", + "line": 264, + "column": 8, + "endLine": 264, + "endColumn": 26, + "path": "c_parser.py", + "symbol": "attribute-defined-outside-init", + "message": "Attribute 'reading_macro' defined outside __init__", + "message-id": "W0201" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.c_parser", + "obj": "CParser.read_c_text", + "line": 280, + "column": 16, + "endLine": 280, + "endColumn": 34, + "path": "c_parser.py", + "symbol": "attribute-defined-outside-init", + "message": "Attribute 'reading_macro' defined outside __init__", + "message-id": "W0201" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.c_parser", + "obj": "CParser.read_values", + "line": 204, + "column": 16, + "endLine": 204, + "endColumn": 37, + "path": "c_parser.py", + "symbol": "attribute-defined-outside-init", + "message": "Attribute 'reading_function' defined outside __init__", + "message-id": "W0201" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.c_parser", + "obj": "CParser.read_keywords", + "line": 246, + "column": 16, + "endLine": 246, + "endColumn": 37, + "path": "c_parser.py", + "symbol": "attribute-defined-outside-init", + "message": "Attribute 'reading_function' defined outside __init__", + "message-id": "W0201" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.c_parser", + "obj": "CParser.read_c_text", + "line": 263, + "column": 8, + "endLine": 263, + "endColumn": 29, + "path": "c_parser.py", + "symbol": "attribute-defined-outside-init", + "message": "Attribute 'reading_function' defined outside __init__", + "message-id": "W0201" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.c_parser", + "obj": "CParser.read_values", + "line": 205, + "column": 16, + "endLine": 205, + "endColumn": 37, + "path": "c_parser.py", + "symbol": "attribute-defined-outside-init", + "message": "Attribute 'reading_keywords' defined outside __init__", + "message-id": "W0201" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.c_parser", + "obj": "CParser.read_keywords", + "line": 254, + "column": 12, + "endLine": 254, + "endColumn": 33, + "path": "c_parser.py", + "symbol": "attribute-defined-outside-init", + "message": "Attribute 'reading_keywords' defined outside __init__", + "message-id": "W0201" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.c_parser", + "obj": "CParser.read_c_text", + "line": 262, + "column": 8, + "endLine": 262, + "endColumn": 29, + "path": "c_parser.py", + "symbol": "attribute-defined-outside-init", + "message": "Attribute 'reading_keywords' defined outside __init__", + "message-id": "W0201" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.c_parser", + "obj": "CParser.read_values", + "line": 206, + "column": 16, + "endLine": 206, + "endColumn": 36, + "path": "c_parser.py", + "symbol": "attribute-defined-outside-init", + "message": "Attribute 'cur_initializer' defined outside __init__", + "message-id": "W0201" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.c_parser", + "obj": "CParser.read_c_text", + "line": 260, + "column": 8, + "endLine": 260, + "endColumn": 28, + "path": "c_parser.py", + "symbol": "attribute-defined-outside-init", + "message": "Attribute 'cur_initializer' defined outside __init__", + "message-id": "W0201" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.c_parser", + "obj": "CParser.read_keywords", + "line": 217, + "column": 16, + "endLine": 217, + "endColumn": 39, + "path": "c_parser.py", + "symbol": "attribute-defined-outside-init", + "message": "Attribute 'reading_array_size' defined outside __init__", + "message-id": "W0201" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.c_parser", + "obj": "CParser.read_keywords", + "line": 221, + "column": 16, + "endLine": 221, + "endColumn": 39, + "path": "c_parser.py", + "symbol": "attribute-defined-outside-init", + "message": "Attribute 'reading_array_size' defined outside __init__", + "message-id": "W0201" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.c_parser", + "obj": "CParser.read_c_text", + "line": 261, + "column": 8, + "endLine": 261, + "endColumn": 31, + "path": "c_parser.py", + "symbol": "attribute-defined-outside-init", + "message": "Attribute 'reading_array_size' defined outside __init__", + "message-id": "W0201" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.c_parser", + "obj": "CParser.read_c_text", + "line": 266, + "column": 8, + "endLine": 266, + "endColumn": 18, + "path": "c_parser.py", + "symbol": "attribute-defined-outside-init", + "message": "Attribute 'stack' defined outside __init__", + "message-id": "W0201" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.c_parser", + "obj": "CParser.read_c_text", + "line": 267, + "column": 8, + "endLine": 267, + "endColumn": 31, + "path": "c_parser.py", + "symbol": "attribute-defined-outside-init", + "message": "Attribute 'accumulated_tokens' defined outside __init__", + "message-id": "W0201" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.c_parser", + "obj": "CParser.read_c_text", + "line": 268, + "column": 8, + "endLine": 268, + "endColumn": 37, + "path": "c_parser.py", + "symbol": "attribute-defined-outside-init", + "message": "Attribute 'accumulated_macro_tokens' defined outside __init__", + "message-id": "W0201" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.c_parser", + "obj": "CParser.read_c_text", + "line": 269, + "column": 8, + "endLine": 269, + "endColumn": 20, + "path": "c_parser.py", + "symbol": "attribute-defined-outside-init", + "message": "Attribute 'if_defs' defined outside __init__", + "message-id": "W0201" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.c_parser", + "obj": "CParser.read_c_text", + "line": 271, + "column": 8, + "endLine": 271, + "endColumn": 24, + "path": "c_parser.py", + "symbol": "attribute-defined-outside-init", + "message": "Attribute 'origin_path' defined outside __init__", + "message-id": "W0201" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.importing", + "obj": "", + "line": 273, + "column": 0, + "endLine": null, + "endColumn": null, + "path": "importing.py", + "symbol": "superfluous-parens", + "message": "Unnecessary parens after 'not' keyword", + "message-id": "C0325" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.importing", + "obj": "", + "line": 111, + "column": 5, + "endLine": null, + "endColumn": null, + "path": "importing.py", + "symbol": "fixme", + "message": "TODO: Duplicate keyframe filter", + "message-id": "W0511" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.importing", + "obj": "", + "line": 204, + "column": 13, + "endLine": null, + "endColumn": null, + "path": "importing.py", + "symbol": "fixme", + "message": "TODO: Add suport for enum indexed tables", + "message-id": "W0511" + }, + { + "type": "error", + "module": "fast64-animations.fast64_internal.sm64.animation.importing", + "obj": "", + "line": 2, + "column": 0, + "endLine": 2, + "endColumn": 10, + "path": "importing.py", + "symbol": "import-error", + "message": "Unable to import 'bpy'", + "message-id": "E0401" + }, + { + "type": "error", + "module": "fast64-animations.fast64_internal.sm64.animation.importing", + "obj": "", + "line": 10, + "column": 0, + "endLine": 10, + "endColumn": 47, + "path": "importing.py", + "symbol": "import-error", + "message": "Unable to import 'mathutils'", + "message-id": "E0401" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.importing", + "obj": "SM64_AnimBone", + "line": 50, + "column": 0, + "endLine": 50, + "endColumn": 19, + "path": "importing.py", + "symbol": "missing-class-docstring", + "message": "Missing class docstring", + "message-id": "C0115" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.importing", + "obj": "SM64_AnimBone", + "line": 50, + "column": 0, + "endLine": 50, + "endColumn": 19, + "path": "importing.py", + "symbol": "invalid-name", + "message": "Class name \"SM64_AnimBone\" doesn't conform to PascalCase naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.importing", + "obj": "SM64_AnimBone.read_pairs", + "line": 58, + "column": 8, + "endLine": 58, + "endColumn": 16, + "path": "importing.py", + "symbol": "invalid-name", + "message": "Variable name \"maxFrame\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "refactor", + "module": "fast64-animations.fast64_internal.sm64.animation.importing", + "obj": "SM64_AnimBone.read_pairs", + "line": 58, + "column": 19, + "endLine": 58, + "endColumn": 60, + "path": "importing.py", + "symbol": "consider-using-generator", + "message": "Consider using a generator instead 'max(len(pair.values) for pair in pairs)'", + "message-id": "R1728" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.importing", + "obj": "SM64_AnimBone.read_translation", + "line": 67, + "column": 12, + "endLine": 67, + "endColumn": 23, + "path": "importing.py", + "symbol": "invalid-name", + "message": "Variable name \"scaledTrans\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.importing", + "obj": "animation_data_to_blender", + "line": 129, + "column": 16, + "endLine": 130, + "endColumn": 103, + "path": "importing.py", + "symbol": "consider-using-enumerate", + "message": "Consider using enumerate instead of iterating with range and len", + "message-id": "C0200" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.importing", + "obj": "animation_data_to_blender", + "line": 139, + "column": 12, + "endLine": 140, + "endColumn": 96, + "path": "importing.py", + "symbol": "consider-using-enumerate", + "message": "Consider using enumerate instead of iterating with range and len", + "message-id": "C0200" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.importing", + "obj": "import_c_animations", + "line": 183, + "column": 15, + "endLine": 183, + "endColumn": 24, + "path": "importing.py", + "symbol": "broad-exception-caught", + "message": "Catching too general exception Exception", + "message-id": "W0718" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.importing", + "obj": "import_c_animations", + "line": 181, + "column": 17, + "endLine": 181, + "endColumn": 36, + "path": "importing.py", + "symbol": "unspecified-encoding", + "message": "Using open without explicitly specifying an encoding", + "message-id": "W1514" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.importing", + "obj": "import_c_animations", + "line": 187, + "column": 10, + "endLine": 187, + "endColumn": 39, + "path": "importing.py", + "symbol": "f-string-without-interpolation", + "message": "Using an f-string that does not have any interpolated variables", + "message-id": "W1309" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.importing", + "obj": "DMATableEntrie", + "line": 238, + "column": 0, + "endLine": 238, + "endColumn": 20, + "path": "importing.py", + "symbol": "missing-class-docstring", + "message": "Missing class docstring", + "message-id": "C0115" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.importing", + "obj": "DMATableEntrie", + "line": 239, + "column": 4, + "endLine": null, + "endColumn": null, + "path": "importing.py", + "symbol": "invalid-name", + "message": "Attribute name \"offsetFromTable\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.importing", + "obj": "read_binary_dma_table_entries", + "line": 248, + "column": 4, + "endLine": 248, + "endColumn": 14, + "path": "importing.py", + "symbol": "invalid-name", + "message": "Variable name \"numEntries\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.importing", + "obj": "read_binary_dma_table_entries", + "line": 249, + "column": 4, + "endLine": 249, + "endColumn": 19, + "path": "importing.py", + "symbol": "invalid-name", + "message": "Variable name \"addrPlaceholder\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.importing", + "obj": "read_binary_dma_table_entries", + "line": 249, + "column": 4, + "endLine": 249, + "endColumn": 19, + "path": "importing.py", + "symbol": "unused-variable", + "message": "Unused variable 'addrPlaceholder'", + "message-id": "W0612" + }, + { + "type": "warning", + "module": "fast64-animations.fast64_internal.sm64.animation.importing", + "obj": "read_binary_dma_table_entries", + "line": 251, + "column": 8, + "endLine": 251, + "endColumn": 9, + "path": "importing.py", + "symbol": "unused-variable", + "message": "Unused variable 'i'", + "message-id": "W0612" + }, + { + "type": "refactor", + "module": "fast64-animations.fast64_internal.sm64.animation.importing", + "obj": "import_binary_dma_animation", + "line": 259, + "column": 0, + "endLine": 259, + "endColumn": 31, + "path": "importing.py", + "symbol": "too-many-arguments", + "message": "Too many arguments (6/5)", + "message-id": "R0913" + }, + { + "type": "refactor", + "module": "fast64-animations.fast64_internal.sm64.animation.importing", + "obj": "import_binary_dma_animation", + "line": 259, + "column": 0, + "endLine": 259, + "endColumn": 31, + "path": "importing.py", + "symbol": "inconsistent-return-statements", + "message": "Either all return statements in a function should return an expression, or none of them should.", + "message-id": "R1710" + }, + { + "type": "refactor", + "module": "fast64-animations.fast64_internal.sm64.animation.importing", + "obj": "import_binary_table", + "line": 282, + "column": 0, + "endLine": 282, + "endColumn": 23, + "path": "importing.py", + "symbol": "too-many-arguments", + "message": "Too many arguments (8/5)", + "message-id": "R0913" + }, + { + "type": "refactor", + "module": "fast64-animations.fast64_internal.sm64.animation.importing", + "obj": "import_binary_animations", + "line": 319, + "column": 0, + "endLine": 319, + "endColumn": 28, + "path": "importing.py", + "symbol": "too-many-arguments", + "message": "Too many arguments (10/5)", + "message-id": "R0913" + }, + { + "type": "refactor", + "module": "fast64-animations.fast64_internal.sm64.animation.importing", + "obj": "import_animation_to_blender", + "line": 347, + "column": 0, + "endLine": 347, + "endColumn": 31, + "path": "importing.py", + "symbol": "too-many-arguments", + "message": "Too many arguments (13/5)", + "message-id": "R0913" + }, + { + "type": "refactor", + "module": "fast64-animations.fast64_internal.sm64.animation.importing", + "obj": "import_animation_to_blender", + "line": 347, + "column": 0, + "endLine": 347, + "endColumn": 31, + "path": "importing.py", + "symbol": "too-many-locals", + "message": "Too many local variables (17/15)", + "message-id": "R0914" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.importing", + "obj": "", + "line": 5, + "column": 0, + "endLine": 5, + "endColumn": 18, + "path": "importing.py", + "symbol": "wrong-import-order", + "message": "standard import \"import dataclasses\" should be placed before \"import bpy\"", + "message-id": "C0411" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.importing", + "obj": "", + "line": 6, + "column": 0, + "endLine": 6, + "endColumn": 29, + "path": "importing.py", + "symbol": "wrong-import-order", + "message": "standard import \"from io import BufferedReader\" should be placed before \"import bpy\"", + "message-id": "C0411" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.importing", + "obj": "", + "line": 7, + "column": 0, + "endLine": 7, + "endColumn": 11, + "path": "importing.py", + "symbol": "wrong-import-order", + "message": "standard import \"import math\" should be placed before \"import bpy\"", + "message-id": "C0411" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.importing", + "obj": "", + "line": 8, + "column": 0, + "endLine": 8, + "endColumn": 9, + "path": "importing.py", + "symbol": "wrong-import-order", + "message": "standard import \"import os\" should be placed before \"import bpy\"", + "message-id": "C0411" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.importing", + "obj": "", + "line": 9, + "column": 0, + "endLine": 9, + "endColumn": 27, + "path": "importing.py", + "symbol": "wrong-import-order", + "message": "standard import \"from typing import Optional\" should be placed before \"import bpy\"", + "message-id": "C0411" + }, + { + "type": "error", + "module": "fast64-animations.fast64_internal.sm64.animation.panels", + "obj": "", + "line": 1, + "column": 0, + "endLine": 1, + "endColumn": 10, + "path": "panels.py", + "symbol": "import-error", + "message": "Unable to import 'bpy'", + "message-id": "E0401" + }, + { + "type": "error", + "module": "fast64-animations.fast64_internal.sm64.animation.panels", + "obj": "", + "line": 2, + "column": 0, + "endLine": 2, + "endColumn": 54, + "path": "panels.py", + "symbol": "import-error", + "message": "Unable to import 'bpy.utils'", + "message-id": "E0401" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.panels", + "obj": "SM64_ExportAnimPanel", + "line": 7, + "column": 0, + "endLine": 7, + "endColumn": 26, + "path": "panels.py", + "symbol": "missing-class-docstring", + "message": "Missing class docstring", + "message-id": "C0115" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.panels", + "obj": "SM64_ExportAnimPanel", + "line": 7, + "column": 0, + "endLine": 7, + "endColumn": 26, + "path": "panels.py", + "symbol": "invalid-name", + "message": "Class name \"SM64_ExportAnimPanel\" doesn't conform to PascalCase naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.panels", + "obj": "SM64_ImportAnimPanel", + "line": 16, + "column": 0, + "endLine": 16, + "endColumn": 26, + "path": "panels.py", + "symbol": "missing-class-docstring", + "message": "Missing class docstring", + "message-id": "C0115" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.panels", + "obj": "SM64_ImportAnimPanel", + "line": 16, + "column": 0, + "endLine": 16, + "endColumn": 26, + "path": "panels.py", + "symbol": "invalid-name", + "message": "Class name \"SM64_ImportAnimPanel\" doesn't conform to PascalCase naming style", + "message-id": "C0103" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.panels", + "obj": "SM64_ImportAnimPanel.draw", + "line": 23, + "column": 8, + "endLine": 23, + "endColumn": 17, + "path": "panels.py", + "symbol": "invalid-name", + "message": "Variable name \"sm64Props\" doesn't conform to snake_case naming style", + "message-id": "C0103" + }, + { + "type": "error", + "module": "fast64-animations.fast64_internal.sm64.animation.utility", + "obj": "", + "line": 4, + "column": 0, + "endLine": 4, + "endColumn": 10, + "path": "utility.py", + "symbol": "import-error", + "message": "Unable to import 'bpy'", + "message-id": "E0401" + }, + { + "type": "convention", + "module": "fast64-animations.fast64_internal.sm64.animation.utility", + "obj": "RomReading", + "line": 13, + "column": 0, + "endLine": 13, + "endColumn": 16, + "path": "utility.py", + "symbol": "missing-class-docstring", + "message": "Missing class docstring", + "message-id": "C0115" + } +] diff --git a/fast64_internal/sm64/animation/utility.py b/fast64_internal/sm64/animation/utility.py index 4ad367e38..04d3183ff 100644 --- a/fast64_internal/sm64/animation/utility.py +++ b/fast64_internal/sm64/animation/utility.py @@ -1,396 +1,115 @@ +from io import BufferedReader import math -from typing import BinaryIO + import bpy +from bpy.types import Object, Armature from ...utility_anim import getFrameInterval from ...utility import findStartBones, toAlnum, PluginError from ..sm64_geolayout_bone import animatableBoneTypes +# pylint: disable=too-few-public-methods class RomReading: - def __init__(self, ROMData: BinaryIO, startAddress: int): - self.startAddress = startAddress - self.address = startAddress - self.ROMData: BinaryIO = ROMData + def __init__(self, rom_data: BufferedReader, start_address: int): + self.start_address = start_address + self.address = start_address + self.rom_data = rom_data - def readValue(self, size, offset: int = None, signed=True): + def read_value(self, size, offset: int = None, signed=True): if offset is None: - self.ROMData.seek(self.address) + self.rom_data.seek(self.address) self.address += size else: - self.ROMData.seek(self.startAddress + offset) + self.rom_data.seek(self.start_address + offset) - return int.from_bytes(self.ROMData.read(size), "big", signed=signed) + return int.from_bytes(self.rom_data.read(size), "big", signed=signed) -def animationOperatorChecks(context, requiresAnimData=True): +def animation_operator_checks(context, requires_animation_data=True): if len(context.selected_objects) > 1: raise PluginError("Multiple objects selected, make sure to select only one.") if len(context.selected_objects) == 0: raise PluginError("No armature selected.") - armatureObj: bpy.types.Object = context.selected_objects[0] + armature_obj: Object = context.selected_objects[0] - if not isinstance(armatureObj.data, bpy.types.Armature): + if not isinstance(armature_obj.data, Armature): raise PluginError("Selected object is not an armature.") - if requiresAnimData and armatureObj.animation_data is None: + if requires_animation_data and armature_obj.animation_data is None: raise PluginError("Armature has no animation data.") -def updateHeaderVariantNumbers(variants): - for variantNum in range(len(variants)): - variant: "SM64_AnimHeader" = variants[variantNum] - variant.headerVariant = variantNum + 1 - - -def getEnumListName(exportProps): - return f"{exportProps.actorName.title()}Anims" - - -def animNameToEnum(animName: str): - enumName = toAlnum(animName).upper() - if animName == enumName: - enumName = f"ANIM_{enumName}" - return enumName - +def anim_name_to_enum(anim_name: str): + enum_name = toAlnum(anim_name).upper() + if anim_name == enum_name: + enum_name = f"ANIM_{enum_name}" + return enum_name -def getAnimEnum(actor_name: str, action: bpy.types.Action, header): - return animNameToEnum(getAnimName(actor_name, action, header)) +def get_action(action_name: str): + if action_name == "": + raise PluginError("Empty action name.") + if not action_name in bpy.data.actions: + raise PluginError(f"Action ({action_name}) is not in this file´s action data.") -def getAction(actionName, throwErrors=True): - if throwErrors: - if actionName == "": - raise PluginError("No selected action.") - if not actionName in bpy.data.actions: - raise PluginError(f"Action ({actionName}) is not in this file´s action data.") + return bpy.data.actions[action_name] - if actionName in bpy.data.actions: - return bpy.data.actions[actionName] - -def getAnimName(actor_name: str, action: bpy.types.Action, header): +def get_anim_name(actor_name: str, action: bpy.types.Action, header): action_props = action.fast64.sm64 if header.overrideName: - cName = header.customName + name = header.customName else: - cName = f"{actor_name}_anim_{action.name}" - if header.headerVariant != 0: - mainHeaderName = getAnimName(actor_name, action, action_props.get_headers()[0]) - cName = f"\ -{mainHeaderName}_{header.headerVariant}" - - return toAlnum(cName) - + name = f"{actor_name}_anim_{action.name}" + if header.header_variant != 0: + main_header_name = get_anim_name(actor_name, action, action_props.get_headers()[0]) + name = f"\ +{main_header_name}_{header.header_variant}" -def getAnimFileName(action: bpy.types.Action): - actionProps = action.fast64.sm64 + return toAlnum(name) - if actionProps.overrideFileName: - return actionProps.customFileName - return f"anim_{action.name}.inc.c" +def get_max_frame(action) -> int: + action_props = action.fast64.sm64 + if action_props.overrideMaxFrame: + return action_props.customMaxFrame -def getActionsInTable(table): - if not table: - return [] - actions = [] - for tableElement in table.elements: - try: - if tableElement.action not in actions: - actions.append(tableElement.action) - except: - raise PluginError(f'Action "{tableElement.action.name}" in table is not in this file´s action data') - - return actions + loop_ends: list[int] = [getFrameInterval(action)[1]] + for header in action_props.get_headers(): + loop_end = header.getFrameRange(action)[2] + loop_ends.append(loop_end) - -def getHeadersInTable(table): - headers = [] - if not table: - return headers - - for tableElement in table.elements: - try: - actionProps = tableElement.action.fast64.sm64 - headers.append(actionProps.headerFromIndex(tableElement.headerVariant)) - except: - raise PluginError(f'Action "{tableElement.action.name}" in table is not in this file´s action data') - - return headers - - -def getMaxFrame(scene, action): - actionProps = action.fast64.sm64 - - if actionProps.overrideMaxFrame: - return actionProps.customMaxFrame - - loopEnds = [getFrameInterval(action)[1]] - for header in actionProps.get_headers(): - startFrame, loopStart, loopEnd = header.getFrameRange(action) - loopEnds.append(loopEnd) - - return max(loopEnds) - - -class ReadArray: - def __init__( - self, - originString: str, - originPath: str, - keywords: list[str], - name: str, - values: list, - valuesAndMacros: list, - ): - self.originString, self.originPath = originString, originPath - self.keywords = keywords - self.name = name - self.values = values - self.valuesAndMacros = valuesAndMacros - - -def string_to_value(string: str): - string = string.strip() - - if string.startswith("0x"): - hexValue = string[2:] - intValue = int(hexValue, 16) - return intValue - - try: - return int(string) - except: - try: - return float(string) - except: - return string - - -class CArrayReader: - def checkForCommentEnd(self, char: str, previousChar: str, charIndex: str): - # Check if the comment has ended - if char == "\n" and not self.inMultiLineComment: - self.inComment = False - - # Check if a comment has ended in a multi-line comment - if self.inMultiLineComment and previousChar == "*" and char == "/": - if self.comentStart > self.keywordStart < charIndex: - self.keywordStart = charIndex + 1 - - if self.comentStart > self.valueStart < charIndex: - self.valueStart = charIndex + 1 - - self.inComment = False - self.inMultiLineComment = False - - if not self.inComment and self.readingKeywords: - if self.comentStart > self.keywordsStart < charIndex: - self.keywordsStart = charIndex + 1 - if self.comentStart > self.keywordStart < charIndex: - self.keywordStart = charIndex + 1 - - def checkForComments(self, char: str, previousChar: str, charIndex: str): - # Single line comment - if previousChar == "/" and char == "/": - # Single line comment detected - self.comentStart = charIndex - self.inComment = True - - # Multi-line comment - if previousChar == "/" and char == "*": - self.comentStart = charIndex - self.inComment = True - self.inMultiLineComment = True - - def readMacros(self, char, charIndex: str): - if self.readingMacroDef: - macroString = self.text[self.macroStart : charIndex] - if macroString in ["ifdef", "ifndef", "elif", "else", "endif"]: - self.macroString, self.macroDefStart = macroString, charIndex + 1 - self.readingMacroDef = False - if char != "\n": - return - - macroDefinesString = self.text[self.macroDefStart : charIndex] - macroDefinesStriped = macroDefinesString.replace(" ", "").replace("\t", "") - macroDefines = macroDefinesStriped.split("|") - - for macro in macroDefines: - if self.macroString == "ifdef": - self.macroDefines.add(macro) - elif self.macroString == "ifndef": - self.excludedMacroDefines.add(macro) - - if self.macroStart > self.valueStart < charIndex: - self.valueStart = charIndex + 1 - if self.readingKeywords: - if self.macroStart > self.keywordsStart < charIndex: - self.keywordsStart = charIndex + 1 - if self.macroStart > self.keywordStart < charIndex: - self.keywordStart = charIndex + 1 - - self.readingMacro = False - - def checkForMacroStart(self, char, charIndex: str): - if char == "#": # Start of macro - self.macroStart = charIndex + 1 - self.readingMacro, self.readingMacroDef = True, True - - def readKeywords(self, char: str, charIndex: str): - if char in ["\n", ";"]: - self.keywordsStart = charIndex + 1 - self.keywordStart = self.keywordsStart - - elif char in ["[", " ", "{", "="]: - keyword = self.text[self.keywordStart : charIndex] - if keyword not in [" ", ""]: - self.keywords.append(self.text[self.keywordStart : charIndex].strip()) - - self.keywordStart = charIndex + 1 - - if char in ["[", "=", "{"]: - self.readingKeywords = False - - def readValues(self, char: str, previousChar: str, charIndex: str): - if self.stack == 0 and char == "}": - textStart, textEnd = self.keywordsStart, self.text.find(";", charIndex) + 1 - structData = ReadArray( - self.text[textStart:textEnd], - self.originPath, - self.keywords[:-1], - self.keywords[-1], - self.values, - self.valuesAndMacros, - ) - self.arrays[structData.name] = structData - self.readingKeywords = True - self.keywords = [] - self.values, self.valuesAndMacros = [], [] - self.enumIndex = 0 - self.readingValues = False - - elif char in ["(", "{"]: - self.stack += 1 - elif char in [")", "}"]: - self.stack -= 1 - elif self.stack == 0 and char == ",": - value = self.text[self.valueStart : charIndex] - - value = string_to_value(self.text[self.valueStart : charIndex]) - if isinstance(value, str): - if value.startswith("["): - # Enum indexed - enumValue = value.split("=") - enumName = enumValue[0].strip().replace("[", "").replace("]", "") - value = (enumName, string_to_value(enumValue[1])) - - elif "struct" in self.keywords and value.startswith("."): - # Designated initializer - nameValue = value.split("=") - value = (nameValue[0].replace(".", ""), string_to_value(nameValue[1])) - - elif "enum" in self.keywords: - if "=" in value: - enumValue = value.split("=") - value = (enumValue[0].replace(" ", ""), string_to_value(enumValue[1])) - - self.values.append(value) - self.valuesAndMacros.append((value, self.macroDefines.copy(), self.excludedMacroDefines.copy())) - self.valueStart = charIndex + 1 - - def readChar(self, char: str, previousChar: str, charIndex: str): - if not self.inComment: - self.checkForComments(char, previousChar, charIndex) - if self.inComment: - self.checkForCommentEnd(char, previousChar, charIndex) - return # If not in comment continue parsing - - if not self.readingMacro: - self.checkForMacroStart(char, charIndex) - if self.readingMacro: - self.readMacros(char, charIndex) - return # If not reading macros - - if self.readingKeywords: - self.readKeywords(char, charIndex) - elif self.readingValues: # data after "={" - self.readValues(char, previousChar, charIndex) - # In between stage, = or [] has been reached so we are no longer reading keywords - # but we are still not reading values until the first "{"" - if not self.readingKeywords and not self.readingValues: - if char == "{": - self.readingValues = True - self.valueStart = charIndex + 1 - - def findAllCArraysInFile(self, text: str, originPath: str = ""): - """ - Parses the provided string for arrays. - """ - self.text = text - self.originPath = originPath - - self.macroDefStart, self.macroString = 0, "" - self.macroDefines, self.excludedMacroDefines = set(), set() - - self.inComment, self.inMultiLineComment = False, False - self.readingMacro, self.readingKeywords, self.readingValues = False, True, False - - self.keywordsStart, self.keywordStart, self.valueStart = 0, 0, 0 - - self.stack = 0 - - self.keywords = [] - self.values, self.valuesAndMacros = [], [] - - self.arrays: dict[str, "ReadArray"] = {} - - previousChar = "" - for charIndex, char in enumerate(self.text): - self.readChar(char, previousChar, charIndex) - previousChar = char - - return self.arrays - - -def readArrayToStructDict(array: "ReadArray", structDefinition: list[str]): - structDict = {} - for i, element in enumerate(array.values): - if isinstance(element, tuple): - structDict[element[0]] = element[1] - else: - structDict[structDefinition[i]] = element - return structDict + return max(loop_ends) -def sm64ToRadian(signedSM64Angle: int) -> float: - SM64Angle = int.from_bytes(signedSM64Angle.to_bytes(4, "big", signed=True), "big", signed=False) - degree = SM64Angle * (360.0 / (2.0**16.0)) +def sm64_to_radian(signed_sm64_angle: int) -> float: + sm64_angle = int.from_bytes(signed_sm64_angle.to_bytes(4, "big", signed=True), "big", signed=False) + degree = sm64_angle * (360.0 / (2.0**16.0)) return math.radians(degree % 360.0) -def get_anim_pose_bones(armature_obj): - bonesToProcess = findStartBones(armature_obj) - current_bone = armature_obj.data.bones[bonesToProcess[0]] +def get_anim_pose_bones(armature_obj: Armature): + bones_to_process: list[str] = findStartBones(armature_obj) + current_bone = armature_obj.data.bones[bones_to_process[0]] anim_bones: list[bpy.types.Bone] = [] # Get animation bones in order - while len(bonesToProcess) > 0: - boneName = bonesToProcess[0] - current_bone = armature_obj.data.bones[boneName] - current_pose_bone = armature_obj.pose.bones[boneName] - bonesToProcess = bonesToProcess[1:] + while len(bones_to_process) > 0: + bone_name = bones_to_process[0] + current_bone = armature_obj.data.bones[bone_name] + current_pose_bone = armature_obj.pose.bones[bone_name] + bones_to_process = bones_to_process[1:] # Only handle 0x13 bones for animation if current_bone.geo_cmd in animatableBoneTypes: anim_bones.append(current_pose_bone) # Traverse children in alphabetical order. - childrenNames = sorted([bone.name for bone in current_bone.children]) - bonesToProcess = childrenNames + bonesToProcess + children_names = sorted([bone.name for bone in current_bone.children]) + bones_to_process = children_names + bones_to_process return anim_bones