ModelCheckerForMaya/checker.py

"""
Checker classes
"""

import re

from abc import ABCMeta, abstractmethod
from maya import cmds
from maya.api import OpenMaya
from PySide2 import QtWidgets


if not cmds.pluginInfo("meshChecker", q=True, loaded=True):
    try:
        cmds.loadPlugin("meshChecker")
    except RuntimeError:
        cmds.warning("Failed to load meshChecker plugin")

if not cmds.pluginInfo("uvChecker", q=True, loaded=True):
    try:
        cmds.loadPlugin("uvChecker")
    except RuntimeError:
        cmds.warning("Failed to load uvChecker plugin")

if not cmds.pluginInfo("findUvOverlaps", q=True, loaded=True):
    try:
        cmds.loadPlugin("findUvOverlaps")
    except RuntimeError:
        cmds.warning("Failed to load uvOverlap checker plugin")


class Error(QtWidgets.QListWidgetItem):
    """ Custom error object """

    def __init__(self, fullPath, errors=None, parent=None):
        # type: (str, list) -> (None)
        super(Error, self).__init__(parent)
        self.components = errors
        self.longName = fullPath
        self.shortName = fullPath.split("|")[-1]

        self.setText(self.shortName)


class BaseChecker:
    """ Base abstract class for each checker """

    __metaclass__ = ABCMeta
    __category__ = ""
    __name__ = ""
    isWarning = False
    isEnabled = True
    isFixable = False

    def __init__(self):

        self.errors = []

    def __eq__(self, other):
        return self.name == self.name

    def __ne__(self, other):
        return not (self == other)

    def __lt__(self, other):
        return (self.category < other.category)

    @abstractmethod
    def checkIt(self, objs, settings=None):
        """ Check method """

        pass

    @abstractmethod
    def fixIt(self):
        """ Fix method """

        pass

    @property
    def name(self):
        """ Label property """

        return self.__name__

    @property
    def category(self):
        return self.__category__


class TriangleChecker(BaseChecker):
    """ Triangle checker class """

    __name__ = "Triangles"
    __category__ = "Topology"
    isWarning = True

    def checkIt(self, obj, settings=None):
        # type: (list) -> (list)

        errorsDict = {}
        self.errors = []

        errs = cmds.checkMesh(obj, c=0)

        for e in errs:
            base, comp = e.split(".")

            if base in errorsDict:
                errorsDict[base].append(e)
            else:
                errorsDict[base] = [e]

        for err_key in errorsDict:
            components = errorsDict[err_key]
            errorObj = Error(err_key, errorsDict[err_key])
            self.errors.append(errorObj)

        return self.errors

    def fixIt(self):
        pass


class NgonChecker(BaseChecker):

    __name__ = "N-gons"
    __category__ = "Topology"

    def checkIt(self, obj, settings=None):
        # type: (list) -> (list)

        errorsDict = {}
        self.errors = []

        errs = cmds.checkMesh(obj, c=1)

        for e in errs:
            base, comp = e.split(".")

            if base in errorsDict:
                errorsDict[base].append(e)
            else:
                errorsDict[base] = [e]

        for err_key in errorsDict:
            components = errorsDict[err_key]
            errorObj = Error(err_key, errorsDict[err_key])
            self.errors.append(errorObj)

        return self.errors

    def fixIt(self):
        pass


class NonmanifoldEdgeChecker(BaseChecker):

    __name__ = "Nonmanifold Edges"
    __category__ = "Topology"

    def checkIt(self, obj, settings=None):
        # type: (list) -> (list)

        errorsDict = {}
        self.errors = []

        errs = cmds.checkMesh(obj, c=2)

        for e in errs:
            base, comp = e.split(".")

            if base in errorsDict:
                errorsDict[base].append(e)
            else:
                errorsDict[base] = [e]

        for err_key in errorsDict:
            components = errorsDict[err_key]
            errorObj = Error(err_key, errorsDict[err_key])
            self.errors.append(errorObj)

        return self.errors

    def fixIt(self):
        pass


class NonmanifoldVertexChecker(BaseChecker):

    __name__ = "Nonmanifold Vertices"
    __category__ = "Topology"

    def checkIt(self, obj, settings=None):
        # type: (list) -> (list)

        self.errors = []

        children = cmds.listRelatives(obj, fullPath=True, ad=True, type="mesh")

        for obj in children:
            try:
                errs = cmds.polyInfo(obj, nmv=True)
                if errs:
                    errorObj = Error(obj, errs)
                    self.errors.append(errorObj)
            except RuntimeError:
                pass

        return self.errors

    def fixIt(self):
        pass


class LaminaFaceChecker(BaseChecker):

    __name__ = "Lamina Faces"
    __category__ = "Topology"

    def checkIt(self, obj, settings=None):
        # type: (list) -> (list)

        errorsDict = {}
        self.errors = []

        errs = cmds.checkMesh(obj, c=3)

        for e in errs:
            base, comp = e.split(".")

            if base in errorsDict:
                errorsDict[base].append(e)
            else:
                errorsDict[base] = [e]

        for err_key in errorsDict:
            components = errorsDict[err_key]
            errorObj = Error(err_key, errorsDict[err_key])
            self.errors.append(errorObj)

        return self.errors

    def fixIt(self):
        pass


class BiValentFaceChecker(BaseChecker):

    __name__ = "Bi-valent Faces"
    __category__ = "Topology"

    def checkIt(self, obj, settings=None):
        # type: (list) -> (list)

        errorsDict = {}
        self.errors = []

        errs = cmds.checkMesh(obj, c=4)

        for e in errs:
            base, comp = e.split(".")

            if base in errorsDict:
                errorsDict[base].append(e)
            else:
                errorsDict[base] = [e]

        for err_key in errorsDict:
            components = errorsDict[err_key]
            errorObj = Error(err_key, errorsDict[err_key])
            self.errors.append(errorObj)

        return self.errors

    def fixIt(self):
        pass


class ZeroAreaFaceChecker(BaseChecker):

    __name__ = "Zero Area Faces"
    __category__ = "Topology"

    def checkIt(self, obj, settings):
        # type: (list) -> (list)

        mfa = settings.getSettings()['maxFaceArea']

        errorsDict = {}
        self.errors = []

        errs = cmds.checkMesh(obj, c=5, maxFaceArea=mfa)

        for e in errs:
            base, comp = e.split(".")

            if base in errorsDict:
                errorsDict[base].append(e)
            else:
                errorsDict[base] = [e]

        for err_key in errorsDict:
            components = errorsDict[err_key]
            errorObj = Error(err_key, errorsDict[err_key])
            self.errors.append(errorObj)

        return self.errors

    def fixIt(self):
        pass


class MeshBorderEdgeChecker(BaseChecker):

    __name__ = "Mesh Border Edges"
    isWarning = True
    __category__ = "Topology"

    def checkIt(self, obj, settings=None):
        # type: (list) -> (list)

        errorsDict = {}
        self.errors = []

        errs = cmds.checkMesh(obj, c=6)

        for e in errs:
            base, comp = e.split(".")

            if base in errorsDict:
                errorsDict[base].append(e)
            else:
                errorsDict[base] = [e]

        for err_key in errorsDict:
            components = errorsDict[err_key]
            errorObj = Error(err_key, errorsDict[err_key])
            self.errors.append(errorObj)

        return self.errors

    def fixIt(self):
        pass


class CreaseEdgeChecker(BaseChecker):

    __name__ = "Crease Edges"
    __category__ = "Topology"

    def checkIt(self, obj, settings=None):
        # type: (list) -> (list)

        errorsDict = {}
        self.errors = []

        errs = cmds.checkMesh(obj, c=7)

        for e in errs:
            base, comp = e.split(".")

            if base in errorsDict:
                errorsDict[base].append(e)
            else:
                errorsDict[base] = [e]

        for err_key in errorsDict:
            components = errorsDict[err_key]
            errorObj = Error(err_key, errorsDict[err_key])
            self.errors.append(errorObj)

        return self.errors

    def fixIt(self):
        pass


class ZeroLengthEdgeChecker(BaseChecker):

    __name__ = "Zero-length Edges"
    __category__ = "Topology"

    def checkIt(self, obj, settings=None):
        # type: (list) -> (list)

        errorsDict = {}
        self.errors = []

        errs = cmds.checkMesh(obj, c=8)

        for e in errs:
            base, comp = e.split(".")

            if base in errorsDict:
                errorsDict[base].append(e)
            else:
                errorsDict[base] = [e]

        for err_key in errorsDict:
            components = errorsDict[err_key]
            errorObj = Error(err_key, errorsDict[err_key])
            self.errors.append(errorObj)

        return self.errors

    def fixIt(self):
        pass


class VertexPntsChecker(BaseChecker):

    __name__ = "Vertex Pnts Attribute"
    __category__ = "Attribute"
    isFixable = True

    def checkIt(self, obj, settings=None):
        # type: (list) -> (list)

        self.errors = []

        errs = cmds.checkMesh(obj, c=9)

        for e in errs:
            errObj = Error(e)
            self.errors.append(errObj)

        return self.errors

    def fixIt(self):
        mSel = OpenMaya.MSelectionList()
        for n, e in enumerate(self.errors):
            if cmds.objExists(e.longName):
                obj = e.longName
                mSel.add(obj)
                try:
                    cmds.polyMoveVertex(
                        obj, lt=(0, 0, 0), nodeState=1, ch=False)
                except RuntimeError:
                    pass

class EmptyGeometryChecker(BaseChecker):

    __name__ = "Empty Geometry"
    __category__ = "Topology"
    isFixable = False

    def checkIt(self, obj, settings=None):
        # type: (list) -> (list)

        self.errors = []

        errs = cmds.checkMesh(obj, c=10)

        for e in errs:
            errObj = Error(e)
            self.errors.append(errObj)

        return self.errors

    def fixIt(self):
        pass


class NameChecker(BaseChecker):

    __name__ = "Name"
    __category__ = "Name"
    isEnabled = False

    def checkIt(self, objs, settings=None):
        # type: (list) -> (list)

        self.errors = []

        for obj in objs:
            try:
                pass
            except RuntimeError:
                pass

        return self.errors

    def fixIt(self):
        pass


class ShapeNameChecker(BaseChecker):

    __name__ = "ShapeName"
    __category__ = "Name"
    isFixable = True

    def checkIt(self, root, settings=None):
        # type: (list) -> (list)

        self.errors = []

        objs = cmds.listRelatives(root, ad=True, fullPath=True, type="transform") or []
        objs.insert(0, root)

        for obj in objs:
            shapes = cmds.listRelatives(
                obj, children=True, fullPath=True, shapes=True) or []
            if shapes:
                for shape in shapes:
                    isIntermediate = cmds.getAttr(
                        shape + ".intermediateObject")
                    if isIntermediate:
                        continue
                    shortName = obj.split("|")[-1]
                    shapeShortName = shape.split("|")[-1]

                    if shortName + "Shape" != shapeShortName:
                        err = Error(shape)
                        self.errors.append(err)

        return self.errors

    def fixIt(self):
        for e in self.errors:
            shape = e.longName
            parent = cmds.listRelatives(shape, parent=True, fullPath=False)[0]
            newShapeName = parent + "Shape"
            cmds.rename(shape, newShapeName)


class HistoryChecker(BaseChecker):

    __name__ = "History"
    __category__ = "Node"
    isEnabled = True
    isFixable = True

    def checkIt(self, root, settings=None):
        # type: (list) -> (list)

        self.errors = []

        objs = cmds.listRelatives(root, ad=True, fullPath=True, type="transform") or []
        objs.insert(0, root)

        for obj in objs:
            mesh = cmds.listRelatives(obj, children=True, type="mesh")
            if mesh is not None:
                for m in mesh:
                    inMesh = cmds.listConnections(m + ".inMesh", source=True)
                    if inMesh is not None:
                        err = Error(obj)
                        self.errors.append(err)

        return self.errors

    def fixIt(self):

        for e in self.errors:
            cmds.delete(e.longName, ch=True)


class TransformChecker(BaseChecker):

    __name__ = "Transform"
    __category__ = "Attribute"

    def checkIt(self, root, settings=None):
        # type: (list) -> (list)

        ignore = []

        self.errors = []

        identity = OpenMaya.MMatrix.kIdentity
        mSel = OpenMaya.MSelectionList()

        objs = cmds.listRelatives(root, ad=True, fullPath=True, type="transform") or []
        objs.insert(0, root)

        for n, i in enumerate(objs):
            mSel.add(i)
            dagPath = mSel.getDagPath(n)
            groupName = dagPath.fullPathName().split("|")[-1]
            if groupName in ignore:
                continue
            dagNode = OpenMaya.MFnDagNode(dagPath)
            transform = dagNode.transformationMatrix()
            if not transform == identity:
                errorObj = Error(i)
                self.errors.append(errorObj)

        return self.errors

    def fixIt(self):
        pass


class LockedTransformChecker(BaseChecker):

    __name__ = "Locked Transform"
    __category__ = "Attribute"
    isFixable = True

    def __init__(self):
        super(LockedTransformChecker, self).__init__()
        self.attrs = ["tx", "ty", "tz", "rx", "ry", "rz", "sx", "sy", "sz"]

    def checkIt(self, root, settings=None):
        # type: (list) -> (list)

        self.errors = []

        objs = cmds.listRelatives(root, ad=True, fullPath=True, type="transform") or []
        objs.insert(0, root)

        for obj in objs:
            try:
                for at in self.attrs:
                    isLocked = cmds.getAttr(obj + ".{}".format(at), lock=True)
                    if isLocked:
                        err = Error(obj)
                        self.errors.append(err)
                        break
            except RuntimeError:
                pass

        return self.errors

    def fixIt(self):
        for e in self.errors:
            for at in self.attrs:
                cmds.setAttr(e.longName + ".{}".format(at), lock=False)


class SmoothPreviewChecker(BaseChecker):

    __name__ = "Smooth Preview"
    __category__ = "Attribute"
    isFixable = True

    def checkIt(self, root, settings=None):
        # type: (list) -> (list)

        self.errors = []

        meshes = cmds.listRelatives(root, ad=True, fullPath=True, type="mesh") or []

        for mesh in meshes:
            isSmooth = cmds.getAttr(mesh + ".displaySmoothMesh")

            if isSmooth:
                err = Error(mesh)
                self.errors.append(err)

        return self.errors

    def fixIt(self):

        for e in self.errors:
            cmds.setAttr(e.longName + ".displaySmoothMesh", 0)


class KeyframeChecker(BaseChecker):

    __name__ = "Keyframe"
    __category__ = "Attribute"
    isFixable = True

    def checkIt(self, root, settings=None):
        # type: (list) -> (list)

        self.errors = []

        keyNodes = ["animCurveTU", "animCurveTA", "animCurveTL"]

        objs = cmds.listRelatives(root, ad=True, fullPath=True, type="transform") or []
        objs.insert(0, root)

        for i in objs:
            conns = cmds.listConnections(i, source=True)
            keys = []

            if conns is None:
                continue

            for c in conns:
                if cmds.objectType(c) in keyNodes:
                    keys.append(c)
            if keys:
                err = Error(i, keys)
                self.errors.append(err)

        return self.errors

    def fixIt(self):

        for e in self.errors:
            cmds.delete(e.components)


class UnusedVertexChecker(BaseChecker):
    """ Unused vertex checker class """

    __name__ = "Unused Vertices"
    __category__ = "Topology"

    def __init__(self):
        super(UnusedVertexChecker, self).__init__()

    def checkIt(self, obj, settings=None):
        # type: (list) -> (list)

        errorsDict = {}
        self.errors = []

        errs = cmds.checkMesh(obj, c=11)

        for e in errs:
            base, comp = e.split(".")

            if base in errorsDict:
                errorsDict[base].append(e)
            else:
                errorsDict[base] = [e]

        for err_key in errorsDict:
            components = errorsDict[err_key]
            errorObj = Error(err_key, errorsDict[err_key])
            self.errors.append(errorObj)

        return self.errors

    def fixIt(self):
        """ Unused vertices ARE fixable """

        pass


class IntermediateObjectChecker(BaseChecker):

    __name__ = "Intermediate Object"
    __category__ = "Node"
    isFixable = True

    def checkIt(self, root, settings=None):
        # type: (list) -> (list)

        self.errors = []

        meshes = cmds.listRelatives(root, ad=True, fullPath=True, type="mesh")

        for mesh in meshes:
            isIntermediate = cmds.getAttr(mesh + ".intermediateObject")
            if isIntermediate:
                err = Error(mesh)
                self.errors.append(err)

        return self.errors

    def fixIt(self):
        for e in self.errors:
            shape = e.longName

            if cmds.objExists(shape):
                parents = cmds.listRelatives(
                    shape, fullPath=True, parent=True) or []
                for i in parents:
                    # Delete history for parents
                    cmds.delete(i, ch=True)
                try:
                    cmds.delete(shape)
                except ValueError:
                    pass


class InstanceShapeChecker(BaseChecker):

    __name__ = "Instance Shape"
    __category__ = "Node"

    def checkIt(self, obj, settings=None):
        # type: (list) -> (list)

        self.errors = []

        errs = cmds.checkMesh(obj, c=12)

        for e in errs:
            errObj = Error(e)
            self.errors.append(errObj)

        return self.errors

    def fixIt(self):
        pass


class ConnectionChecker(BaseChecker):

    __name__ = "Connections"
    __category__ = "Node"

    def checkIt(self, obj, settings=None):
        # type: (list) -> (list)

        self.errors = []

        errs = cmds.checkMesh(obj, c=13)

        for e in errs:
            errObj = Error(e)
            self.errors.append(errObj)

        return self.errors

    def fixIt(self):
        pass


class DisplayLayerCheck(BaseChecker):

    __name__ = "Display layers"
    __category__ = "other"
    isFixable = True

    def checkIt(self, root, settings=None):
        # type: (list) -> (list)

        self.errors = []

        objs = cmds.listRelatives(root, ad=True, fullPath=True, type="transform") or []
        objs.insert(0, root)

        for obj in objs:
            layers = cmds.listConnections(obj + ".drawOverride") or []
            if layers:
                err = Error(obj, layers)
                self.errors.append(err)

        return self.errors

    def fixIt(self):

        for e in self.errors:
            layers = e.components
            node = e.longName
            for layer in layers:
                cmds.disconnectAttr(
                    layer + ".drawInfo", node + ".drawOverride")


class UnusedLayerChecker(BaseChecker):

    __name__ = "Unused layers"
    __category__ = "other"
    isFixable = True

    def checkIt(self, root, settings=None):
        # type: (list) -> (list)

        self.errors = []

        layers = cmds.ls(type="displayLayer")
        layers.remove("defaultLayer")
        for layer in layers:
            contents = cmds.editDisplayLayerMembers(
                layer, q=True, fullNames=True)
            if contents is None:
                err = Error(layer, [layer])
                self.errors.append(err)

        return self.errors

    def fixIt(self):
        for e in self.errors:
            try:
                cmds.delete(e.longName)
            except RuntimeError:
                pass


class Map1Checker(BaseChecker):

    __name__ = "UVSet to map1"
    __category__ = "UV"
    isFixable = True

    def checkIt(self, root, settings=None):
        # type: (list) -> (list)

        self.errors = []

        meshes = cmds.listRelatives(root, ad=True, fullPath=True, type="mesh") or []

        for mesh in meshes:
            curUVSet = cmds.polyUVSet(mesh, q=True, currentUVSet=True)[0]
            if curUVSet != "map1":
                err = Error(mesh)
                self.errors.append(err)

        return self.errors

    def fixIt(self):

        for e in self.errors:
            cmds.polyUVSet(e.longName, uvSet="map1", currentUVSet=True)


class NegativeUvChecker(BaseChecker):

    __name__ = "UVs in negative space"
    __category__ = "UV"

    def checkIt(self, obj, settings=None):

        self.errors = []
        errorsDict = {}

        errs = cmds.checkUV(obj, c=4)

        for e in errs:
            base, comp = e.split(".")

            if base in errorsDict:
                errorsDict[base].append(e)
            else:
                errorsDict[base] = [e]

        for err_key in errorsDict:
            components = errorsDict[err_key]
            errorObj = Error(err_key, errorsDict[err_key])
            self.errors.append(errorObj)

        return self.errors

    def fixIt(self):
        pass


class UdimIntersectionChecker(BaseChecker):

    __name__ = "UDIM intersection"
    __category__ = "UV"

    def checkIt(self, obj, settings=None):
        # type: (list) -> (list)
        
        self.errors = []

        errorsDict = {}

        errs = cmds.checkUV(obj, c=0)

        for e in errs:
            base, comp = e.split(".")

            if base in errorsDict:
                errorsDict[base].append(e)
            else:
                errorsDict[base] = [e]

        for err_key in errorsDict:
            components = errorsDict[err_key]
            errorObj = Error(err_key, errorsDict[err_key])
            self.errors.append(errorObj)

        return self.errors

    def fixIt(self):
        pass


class UnassignedUvChecker(BaseChecker):

    __name__ = "Unassigned UVs"
    __category__ = "UV"

    def checkIt(self, obj, settings=None):
        # type: (list) -> (list)
        
        self.errors = []

        errorsDict = {}

        errs = cmds.checkUV(obj, c=3)

        for e in errs:
            base, comp = e.split(".")

            if base in errorsDict:
                errorsDict[base].append(e)
            else:
                errorsDict[base] = [e]

        for err_key in errorsDict:
            components = errorsDict[err_key]
            errorObj = Error(err_key, errorsDict[err_key])
            self.errors.append(errorObj)

        return self.errors

    def fixIt(self):
        pass


class UnmappedPolygonFaceChecker(BaseChecker):

    __name__ = "Unmapped polygon faces"
    __category__ = "UV"

    def checkIt(self, obj, settings=None):
        # type: (list) -> (list)
        
        self.errors = []

        errorsDict = {}

        errs = cmds.checkUV(obj, c=1)

        for e in errs:
            base, comp = e.split(".")

            if base in errorsDict:
                errorsDict[base].append(e)
            else:
                errorsDict[base] = [e]

        for err_key in errorsDict:
            components = errorsDict[err_key]
            errorObj = Error(err_key, errorsDict[err_key])
            self.errors.append(errorObj)

        return self.errors

    def fixIt(self):
        pass


class ZeroAreaUVFaceChecker(BaseChecker):

    __name__ = "Zero area UV Faces"
    __category__ = "UV"

    def checkIt(self, obj, settings=None):
        # type: (list) -> (list)
        
        self.errors = []
        errorsDict = {}

        errs = cmds.checkUV(obj, c=2)

        for e in errs:
            base, comp = e.split(".")

            if base in errorsDict:
                errorsDict[base].append(e)
            else:
                errorsDict[base] = [e]

        for err_key in errorsDict:
            components = errorsDict[err_key]
            errorObj = Error(err_key, errorsDict[err_key])
            self.errors.append(errorObj)

        return self.errors

    def fixIt(self):
        pass


class ConcaveUVChecker(BaseChecker):

    __name__ = "Concave UV Faces"
    __category__ = "UV"

    def checkIt(self, obj, settings=None):
        # type: (list) -> (list)
        
        self.errors = []
        errorsDict = {}

        errs = cmds.checkUV(obj, c=5)

        for e in errs:
            base, comp = e.split(".")

            if base in errorsDict:
                errorsDict[base].append(e)
            else:
                errorsDict[base] = [e]

        for err_key in errorsDict:
            components = errorsDict[err_key]
            errorObj = Error(err_key, errorsDict[err_key])
            self.errors.append(errorObj)

        return self.errors

    def fixIt(self):
        pass


class ReversedUVChecker(BaseChecker):

    __name__ = "Reversed UV Faces"
    __category__ = "UV"
    isWarning = True

    def checkIt(self, obj, settings=None):
        # type: (list) -> (list)
        
        self.errors = []
        errorsDict = {}

        errs = cmds.checkUV(obj, c=6)

        for e in errs:
            base, comp = e.split(".")

            if base in errorsDict:
                errorsDict[base].append(e)
            else:
                errorsDict[base] = [e]

        for err_key in errorsDict:
            components = errorsDict[err_key]
            errorObj = Error(err_key, errorsDict[err_key])
            self.errors.append(errorObj)

        return self.errors

    def fixIt(self):
        pass


class UvOverlapChecker(BaseChecker):

    __name__ = "UV Overlaps"
    __category__ = "UV"
    isEnabled = False

    def checkIt(self, root, settings=None):

        self.errors = []

        objs = cmds.listRelatives(root, ad=True, fullPath=True, type="mesh") or []

        mSel = OpenMaya.MSelectionList()

        for obj in objs:
            mSel.add(obj)

        for i in range(mSel.length()):
            dagPath = mSel.getDagPath(i)
            try:
                dagPath.extendToShape()

            except RuntimeError:
                # Not mesh. Do no nothing
                pass

        return self.errors

    def fixIt(self):
        pass


class SelectionSetChecker(BaseChecker):

    __name__ = "Selection Sets"
    __category__ = "other"
    isFixable = True

    def getSets(self, path, typ):

        if typ == "transform":
            conns = cmds.listConnections(path + ".instObjGroups") or []
            return [i for i in conns if cmds.objectType(i) == "objectSet"]
        elif typ == "shape":
            conns = cmds.listConnections(
                path + ".instObjGroups.objectGroups") or []
            return [i for i in conns if cmds.objectType(i) == "objectSet"]
        else:
            pass

        return []

    def checkIt(self, root, settings=None):
        # type: (list) -> (list)

        self.errors = []
        objectSets = []
        ignore = ["modelPanel[0-9]ViewSelectedSet"]

        objs = cmds.listRelatives(root, ad=True, fullPath=True, type="transform") or []
        objs.insert(0, root)

        for obj in objs:
            shapes = cmds.listRelatives(
                obj, children=True, fullPath=True, shapes=True) or []

            for shape in shapes:
                objectSets.extend(self.getSets(shape, "shape"))

            objectSets.extend(self.getSets(obj, "transform"))

        objectSets = list(set(objectSets))

        for objSet in objectSets:
            for i in ignore:
                if re.match(i, objSet) is None:
                    err = Error(objSet)
                    self.errors.append(err)

        return self.errors

    def fixIt(self):
        for e in self.errors:
            try:
                cmds.delete(e.longName)
            except Exception:
                pass


class ColorSetChecker(BaseChecker):

    __name__ = "Color Sets"
    __category__ = "other"
    isFixable = True

    def checkIt(self, root, settings=None):
        # type: (list) -> (list)

        # Reset result
        self.errors = []

        objs = cmds.listRelatives(root, ad=True, fullPath=True, type="mesh") or []

        for obj in objs:
            try:
                allColorSets = cmds.polyColorSet(
                    obj, q=True, allColorSets=True)
                if allColorSets is None:
                    continue
                else:
                    err = Error(obj)
                    self.errors.append(err)
            except RuntimeError:
                pass

        return self.errors

    def fixIt(self):
        for i in self.errors:
            allSets = cmds.polyColorSet(
                i.longName, q=True, allColorSets=True) or []
            for s in allSets:
                cmds.polyColorSet(i.longName, delete=True, colorSet=s)


CHECKERS = [
    NameChecker,
    ShapeNameChecker,
    HistoryChecker,
    TransformChecker,
    LockedTransformChecker,
    SmoothPreviewChecker,
    KeyframeChecker,
    TriangleChecker,
    NgonChecker,
    NonmanifoldEdgeChecker,
    NonmanifoldVertexChecker,
    LaminaFaceChecker,
    BiValentFaceChecker,
    ZeroAreaFaceChecker,
    MeshBorderEdgeChecker,
    CreaseEdgeChecker,
    ZeroLengthEdgeChecker,
    VertexPntsChecker,
    EmptyGeometryChecker,
    UnusedVertexChecker,
    IntermediateObjectChecker,
    InstanceShapeChecker,
    ConnectionChecker,
    DisplayLayerCheck,
    UnusedLayerChecker,
    Map1Checker,
    NegativeUvChecker,
    UdimIntersectionChecker,
    UnassignedUvChecker,
    UnmappedPolygonFaceChecker,
    ZeroAreaUVFaceChecker,
    ConcaveUVChecker,
    ReversedUVChecker,
    UvOverlapChecker,
    SelectionSetChecker,
    ColorSetChecker]