def job(scroll='', k=False):
    import webrImport as web
    ss = web.mod('selectionSet_lib')
    # print '\n  run job  \n'
    #
    add = []
    if scroll:
        if cmds.control(scroll, ex=True):
            cmds.textScrollList(scroll, edit=True, ra=True)
            selection = cmds.ls(sl=True, fl=True)  # returns full path if same object with dif namespace existskeys
            if selection:
                for sel in selection:
                    if '|' in sel:
                        sel = sel.split('|')
                        sel = sel[len(sel) - 1]
                        add.append(sel)
                    else:
                        add.append(sel)
                add = ss.outputDict(add)
                # keys or values
                if k:
                    # add to list
                    cmds.textScrollList(scroll, edit=True, append=sorted(add.keys()))
                else:
                    # add to list
                    cmds.textScrollList(scroll, edit=True, append=sorted(add.values()))
            else:
                pass
                # message('no selection', warning=True)
        else:
            pass

 def cmdConstrain(self, *args):
     cn = web.mod('constraint_lib')
     sel = cmds.ls(sl=True)
     if len(sel) == 2:
         v9 = cmds.checkBox(self.actionColumn.c9, q=True, v=True)
         v10 = cmds.checkBox(self.actionColumn.c10, q=True, v=True)
         if v10:
             v10 = 'none'
         else:
             v10 = ['x', 'y', 'z']
         v11 = cmds.checkBox(self.actionColumn.c11, q=True, v=True)
         if v11:
             v11 = 'none'
         else:
             v11 = ['x', 'y', 'z']
         # constrain
         con = cn.getConstraint(sel[1])
         if con:
             cmds.parentConstraint(sel[0], sel[1], mo=v9)
             if v10 == 'none' or v11 == 'none':
                 message('A constraint already exists, rotations/tranlations cannot be skipped, argument ignored.')
         else:
             cmds.parentConstraint(sel[0], sel[1], mo=v9, st=v10, sr=v11)
     else:
         cmds.warning('-- Select 2 objects --')

 def cmdBakeToLoc(self, *args):
     cn = web.mod('constraint_lib')
     # v6 = cmds.checkBox(self.actionColumn.c6, q=True, v=True)
     v7 = cmds.checkBox(self.actionColumn.c7, q=True, v=True)
     v8 = cmds.checkBox(self.actionColumn.c8, q=True, v=True)
     v12 = cmds.checkBox(self.actionColumn.c12, q=True, v=True)
     cn.controllerToLocator(p=v7, r=v8, timeLine=False, sim=v12, size=1.25)

 def cmdAimRig(self, *args):
     ar = web.mod('animRig_lib')
     axs = [None, [1, 0, 0], [0, 1, 0], [0, 0, 1]]
     inverseA = cmds.checkBox(self.actionColumn.c15, q=True, v=True)
     aimGp = cmds.radioButtonGrp(self.actionColumn.aimGrp, q=True, select=True)
     inverseU = cmds.checkBox(self.actionColumn.c16, q=True, v=True)
     upGp = cmds.radioButtonGrp(self.actionColumn.upGrp, q=True, select=True)
     ar.aimRig(target=None, obj=None, aim=axs[aimGp], u=axs[upGp], tipOffset=1.0, mo=False, bake=True, inverseA=inverseA, inverseU=inverseU)

 def cmdAimPivotRig(self, *args):
     ar = web.mod('animRig_lib')
     axs = [None, [1, 0, 0], [0, 1, 0], [0, 0, 1]]
     inverseA = cmds.checkBox(self.actionColumn.c18, q=True, v=True)
     aimGp = cmds.radioButtonGrp(self.actionColumn.aimPivotGrp, q=True, select=True)
     inverseU = cmds.checkBox(self.actionColumn.c19, q=True, v=True)
     upGp = cmds.radioButtonGrp(self.actionColumn.upPivotGrp, q=True, select=True)
     master = cmds.checkBox(self.actionColumn.c21, q=True, v=True)
     masterPos = cmds.radioButtonGrp(self.actionColumn.masterGrp, q=True, select=True) - 1
     distance = cmds.floatSliderGrp(self.actionColumn.sl1, q=True, v=True)
     autoDs = cmds.checkBox(self.actionColumn.c22, q=True, v=True)
     # ar.aimPivotRig(target=None, obj=None, size=0.3, aim=axs[aimGp], u=axs[upGp], tipOffset=1.0, mo=False, bake=True, inverseA=inverseA, inverseU=inverseU)
     ar.aimPivotRig(aim=axs[aimGp], u=axs[upGp], offset=distance, masterControl=master, masterPosition=masterPos, inverseA=inverseA, inverseU=inverseU, autoDistance=autoDs)

def toggleButton(*args):
    ds = web.mod('display_lib')
    ui = ds.GraphEditorButtonNames()
    # sftSel
    global idB
    # List shelf buttons
    buttons = cmds.lsUI(type='button')
    # iterate through buttons to find one using appropriate images
    for btn in buttons:
        if ui.sftSel in btn:
            if idB:
                # turn off
                cmds.button(btn, edit=True, bgc=[0.38, 0.38, 0.38])
                idB = False
            else:
                # turn on
                cmds.button(btn, edit=True, bgc=[0.3, 0.35, 0.5])
                idB = True

 def cmdPlace(self, *args):
     cn = web.mod('constraint_lib')
     sel = cmds.ls(sl=1)
     sl = False
     v5 = cmds.checkBox(self.actionColumn.c5, q=True, v=True)
     v13 = cmds.checkBox(self.actionColumn.c13, q=True, v=True)
     if v5:
         conGp = cmds.radioButtonGrp(self.actionColumn.conGrp, q=True, select=True)
         if 1 == conGp:  # 1 == first radio button
             sl = True
     # print sl, '========='
     locs = cn.locatorOnSelection(ro='zxy', X=1.3, constrain=v5, toSelection=sl)
     i = 0
     if v13:
         if sel:
             for loc in locs:
                 cn.matchKeyedFrames(A=sel[i], B=loc, subtractive=True)
                 i = i + 1

def shapeLocal(shape=''):
    ac = web.mod('atom_controlShapes_lib')
    path = ac.shapeDir()
    # print path
    if os.path.isdir(path):
        shapePath = os.path.join(path, shape + '.txt')
        if os.path.isfile(shapePath):
            inFile = open(shapePath, 'r')
            cvInfo = []
            for line in inFile.readlines():
                cvLine = line.strip('\n')
                cvLine = cvLine.split(' ')
                tmp = float(cvLine[0]), float(cvLine[1]), float(cvLine[2])
                cvInfo.append(tmp)
            inFile.close()
            return cvInfo
        else:
            print 'shape:  ' + shape + '  is missing, default shape will be used'
    else:
        pass

def removeRow(row, path, files, *arg):
    '''
    arg = partial fuckery, leave empty
    row =  ''
    path = ''
    files = []
    '''
    # command looses scope when executed from button, need to re import
    import maya.cmds as cmds
    import webrImport as web
    # web
    cl = web.mod('clips_lib')

    # check for thumbnail, delete
    mov = cl.movExt()
    dat = cl.getDataPath()
    name = files[0].split('.')[0]
    ext = files[0].split('.')[len(files[0].split('.')) - 1]
    if ext in mov:
        thumb = os.path.join(dat, name + cl.getThumbSuffix() + '.png')
        if os.path.isfile(thumb):
            # print thumb, 'yes'
            os.remove(thumb)
        else:
            pass
            # print thumb
    # delete UI row
    cmds.deleteUI(str(row))
    # delete image seq
    for f in files:
        p = os.path.join(path, f)
        if os.path.isfile(p):
            os.remove(os.path.join(path, f))
    # delete if path empty
    if not os.listdir(path):
        shutil.rmtree(path)

from pymel.core import *
import maya.cmds as cmds
import webrImport as web
# web
place = web.mod('atom_place_lib')
splnFk = web.mod('atom_splineFk_lib')


class EarRig(object):

    def __init__(self, mid_name, mid_start_jnt, mid_end_jnt, mid_parent1, mid_parent2,
                 front_name, front_start_jnt, front_end_jnt, front_parent1, front_parent2,
                 back_name, back_start_jnt, back_end_jnt, back_parent1, back_parent2,
                 suffix, controllerSize=2, stretch=1, make='all', visibility=0, clean=True, ik=None):

        self.mid_name = mid_name
        self.mid_start_jnt = mid_start_jnt
        self.mid_end_jnt = mid_end_jnt
        self.mid_parent1 = mid_parent1
        self.mid_parent2 = mid_parent2

        self.front_name = front_name
        self.front_start_jnt = front_start_jnt
        self.front_end_jnt = front_end_jnt
        self.front_parent1 = front_parent1
        self.front_parent2 = front_parent2

        self.back_name = back_name
        self.back_start_jnt = back_start_jnt
        self.back_end_jnt = back_end_jnt
        self.back_parent1 = back_parent1

import maya.cmds as cmds
import maya.mel as mel
#
import webrImport as web
# web
cs = web.mod('characterSet_lib')
cn = web.mod('constraint_lib')
ds = web.mod('display_lib')
ac = web.mod('animCurve_lib')
plc = web.mod('atom_place_lib')

'''
import maya.cmds as cmds
import webrImport as web
ar = web.mod("animRig_lib")

ns = cmds.ls(sl=True)[0].split(':')[0]

sel = [
ns + ':R_leg_bigToe3Fk_ctrl',
ns + ':R_leg_bigToe2Fk_ctrl',
ns + ':R_leg_bigToe1Fk_ctrl',
ns + ':R_leg_mainIk_ctrl'
]
ar.fingerRig(name='toe', obj=sel, size=3.0, aim=[-1.0, 0.0, 0.0], u=[0.0, 0.0, -1.0], mlt=-2.0, baseWorld=False, parentTarget=True)
sel = [
ns + ':R_leg_indexToe4Fk_ctrl',
ns + ':R_leg_indexToe2Fk_ctrl',
ns + ':R_leg_indexToe1Fk_ctrl',
ns + ':R_leg_mainIk_ctrl'
]

import maya.cmds as cmds
import maya.mel as mel
#
# import display_lib as ds
# import animCurve_lib as ac
import webrImport as web
# web
ds = web.mod('display_lib')
ac = web.mod('animCurve_lib')


def message(what='', maya=True):
    what = '-- ' + what + ' --'
    if maya:
        mel.eval('print \"' + what + '\";')
    else:
        print what


def graphFilterCore(attr='', panel=''):
    '''\n
    adds/clears filters for the default graphEditor
    '''
    # check for any filters currently being used
    c = cmds.outlinerEditor(panel + 'OutlineEd', q=True, af=True)
    cf = ''
    # if attrs arg is not empty execute, else delete filters reset filter to None
    if attr != '':
        # make new filter
        f = cmds.itemFilterAttr(bn=attr)
        # if a filter is already being used merge new/current #else use new filter

import maya.cmds as cmds
#
import webrImport as web
# web
place = web.mod('atom_place_lib')
# misc = web.mod('atom_miscellaneous_lib')
appendage = web.mod('atom_appendage_lib')


def hexapod(*args):
    # creates groups and master controller from arguments specified as 'True'
    place.rigPrebuild(Top=0, Ctrl=True, SknJnts=True, Geo=True, World=True, Master=True, OlSkool=True, Size=12)

    # lists for joints and controllers

    endJntL = ['front_leg_end_jnt_L', 'mid_leg_end_jnt_L', 'back_leg_end_jnt_L']
    endJntR = ['front_leg_end_jnt_R', 'mid_leg_end_jnt_R', 'back_leg_end_jnt_R']
    kneeJntL = ['front_knee_jnt_L', 'mid_knee_jnt_L', 'back_knee_jnt_L']
    kneeJntR = ['front_knee_jnt_R', 'mid_knee_jnt_R', 'back_knee_jnt_R']
    legJntL = ['front_leg_jnt_L', 'mid_leg_jnt_L', 'back_leg_jnt_L']
    legJntR = ['front_leg_jnt_R', 'mid_leg_jnt_R', 'back_leg_jnt_R']

    btmCtrl_L = ['front_L', 'mid_L', 'back_L']
    btmCtrl_R = ['front_R', 'mid_R', 'back_R']
    topCtrl_L = ['frontTop_L', 'midTop_L', 'backTop_L']
    topCtrl_R = ['frontTop_R', 'midTop_R', 'backTop_R']

    pvNamesL = ['front_pv_L', 'mid_pv_L', 'back_pv_L']
    pvNamesR = ['front_pv_R', 'mid_pv_R', 'back_pv_R']
    ikNamesL = ['frontIk_L', 'midIK_L', 'backIk_L']
    ikNamesR = ['frontIk_R', 'midIk_R', 'backIk_R']

import maya.cmds as cmds
import webrImport as web
reload(web)
# pt = web.mod("atom_path_lib")
anm = web.mod("anim_lib")
cn = web.mod("constraint_lib")


def nsPaths():
    nsList = cmds.namespaceInfo(lon=True)
    nsPathsList = []
    for ns in nsList:
        if 'Path_' in ns:
            nsPathsList.append(ns)
    return nsPathsList


def nsHollow(roots, reverse=True):
    nsList = cmds.namespaceInfo(lon=True)
    newRoots = []
    newRoot = []
    ns = None
    for ns in nsList:
        if 'Scarecrow_' in ns:
            for root in roots:
                for ct in rev(root, reverse=reverse):
                    newRoot.append(ns + ':' + ct.split(':')[1])
                newRoots.append(newRoot)
                newRoot = []
            return newRoots

#.........这里部分代码省略.........
    cmds.separator()
    atom_qrig_prerigBut = cmds.button(l='Build Snake Pre-Rig', c='import atom\natom.atom_snakeSimplePreBuild_lib.snakePreBuild()')
    atom_qrig_buildSpineBut = cmds.button(l='Build Snake Splines', c='import atom\natom.atom_snakeSimpleSplines_lib.snakeSplines()')
    atom_qrig_buildDeformBut = cmds.button(l='Build Snake Deformation', c='import atom\natom.atom_snakeDeformation_lib.snakeDeform()')
    bldSnkFace = BuildSnakeFacerigCallback()
    atom_qrig_faceRig = cmds.button(l='Build Face Rig', c=bldSnkFace.CMD)
    atom_qrig_faceRig = cmds.button(l='Finalize Rig', c=createTagGroups)
    cmds.setParent('..')
    cmds.setParent('..')
    '''

    # atom_rat_frameLayout = ratFrameLayout()

    # atom_reindeer_frameLayout = reindeerFrameLayout()

    atom_biped_frameLayout = bipedFrameLayout()

    # atom_raptor_frameLayout = raptorFrameLayout()

    atom_mos_frameLayout = mosFrameLayout()

    atom_pteranodon_frameLayout = pteranodonFrameLayout()

    #---------------------------
    # Control Curve Shape Toolbox
    #---------------------------
    atom_ccst_frameLayout = cmds.frameLayout('atom_ccst_frameLayout', label='Control Curve Shape Toolbox',
                                             cc=refresh.RefreshCall, ec=refresh.RefreshCall,
                                             mh=5, mw=5, cll=False, cl=True)

    atom_ccst_columnLayout = cmds.columnLayout('atom_ccst_main_columnLayout', adj=True, rs=5)
    import webrImport as web
    # web
    ac = web.mod('atom_controlShapes_lib')
    atom_ccst_path = ac.shapeDir()
    atom_ccst_formLayout = cmds.formLayout('atom_csst_formLayout', numberOfDivisions=100)
    # atom_csst_exportPath_text = cmds.text('atom_csst_exportPath_text', label='Export Path:', align='left', width=70, height=14)
    # atom_csst_exportPath_textField = cmds.textField('atom_csst_exportPath_textField', text=atom_ccst_path)
    atom_csst_exportName_text = cmds.text('atom_csst_exportName_text', label='Export Name:', align='left', width=71, height=14)
    atom_csst_exportName_textField = cmds.textField('atom_csst_exportName_textField', text='None', cc='import atom_ui_lib\natom_ui_lib.validateFieldTextInput("atom_csst_exportName_textField")')
    atom_csst_exportName_button = cmds.button('atom_csst_exportName_button', label='Export Curve Shape', c='import webrImport as web\naul = web.mod("atom_ui_lib")\naul.exportCurveShape()')
    atom_csst_separatorTop = cmds.separator('atom_csst_separatorTop', h=5)
    atom_csst_importName_text = cmds.text('atom_csst_importName_text', label='Import Curve Shape')
    atom_csst_separatorBottom = cmds.separator('atom_csst_separatorBottom')
    atom_csst_curveScale_text = cmds.text('atom_csst_curveScale_text', label='Import Curve Scale:', align='left', width=105, height=14)
    atom_csst_curveScale_floatField = cmds.floatField('atom_csst_curveScale_floatField', v=1.0, pre=1, width=34)
    cmds.setParent('..')
    # Dynamically create button based on saved .txt file with cv positional data in them
    uil.addControlCurveButton(atom_ccst_path)

    cmds.formLayout(atom_ccst_formLayout, edit=True,
                    attachForm=[(atom_csst_exportName_text, 'left', 0), (atom_csst_exportName_button, 'left', 0),
                                (atom_csst_separatorTop, 'left', 0),
                                (atom_csst_importName_text, 'left', 0),
                                (atom_csst_separatorBottom, 'left', 0),
                                (atom_csst_exportName_button, 'right', 0),
                                (atom_csst_separatorTop, 'right', 0),
                                (atom_csst_importName_text, 'right', 0),
                                (atom_csst_separatorBottom, 'right', 0),
                                (atom_csst_exportName_textField, 'right', 0),
                                (atom_csst_curveScale_floatField, 'right', 0)],
                    attachControl=[(atom_csst_exportName_textField, 'left', 5, atom_csst_exportName_text),
                                   (atom_csst_exportName_button, 'top', 5, atom_csst_exportName_textField),
                                   (atom_csst_separatorTop, 'top', 5, atom_csst_exportName_button),
                                   (atom_csst_importName_text, 'top', 5, atom_csst_separatorTop),
                                   (atom_csst_separatorBottom, 'top', 0, atom_csst_importName_text),

import maya.cmds as cmds
import os
import fnmatch
from subprocess import call
import subprocess
import maya.mel as mel
#
import webrImport as web
# web
ui = web.mod('ui_micro_lib')
cs = web.mod('characterSet_lib')

# TODO: ui overhaul
# include import export in one window
# easier string replacement, include char sets in replace consideration
# include membership editing in ui
# remove location editing, force paths
# add multi namespace remapping
# fix problem with reopening window while its open


class CSUI(object):
    '''
    Build CharacterSet UI
    '''

    def __init__(self, export=False, path='', filters=['.chr', '.txt', '.mb', '.ma', '*.*'], columnWidth=200):
        # external
        self.export = export
        self.path = cs.defaultPath()
        self.filters = filters

import maya.cmds as cmds
import maya.mel as mel
import webrImport as web
# web
build = web.mod('atom_splineBuild_lib')
spln = web.mod('atom_spline_lib')
ui = web.mod('atom_ui_lib')


def splineStage(stage, colorScheme='yellow'):
    """Arguments:
    stage = int 1-4
    \rDescription:
    Stage0 = Collect build options
    -rotateOrder
    -rotateAxis
    -AimAxis
    -UpAxis
    -ControllerScale
    -VectorDistance
    Stage1 = Build cluster control groups
    Stage2 = Build cluster groups
    Stage3 = Build IK groups
    Stage4 = Build vector groups
    colorScheme = yellow, red, blue
    """
    if stage > 0 and stage < 5:
        # ############################## Variables ###################################
        BUS_Stage1_BUS = [None]
        BUS_Stage2_BUS = [None]
        BUS_Stage3_BUS = [None]

import maya.cmds as cmds
import webrImport as web
# web
place = web.mod('atom_place_lib')


def snakePreBuild(
        COG_jnt='upperA_jnt_01',
        LOWER_jnt=['lowerB_jnt_01', 'lowerC_jnt_01', 'lowerD_jnt_01', 'lowerE_jnt_01', 'lowerF_jnt_01', 'lowerG_jnt_01', 'lowerH_jnt_01',
                   'lowerI_jnt_01', 'lowerJ_jnt_01', 'lowerK_jnt_01', 'lowerL_jnt_01', 'lowerM_jnt_01', 'lowerN_jnt_01', 'lowerO_jnt_01', 'lowerP_jnt_01',
                   'lowerQ_jnt_01', 'lowerR_jnt_01'],
        UPPER_jnt=['upperB_jnt_01', 'upperC_jnt_01', 'upperD_jnt_01'],
        NECK_jnt='neck_jnt_01',
        HEAD_jnt='head_jnt',
        LOWERTIP_jnt='lowerR_jnt_05',
        GEO_gp='buddy_GP',
        SKIN_jnt='root_jnt'):

    face = None
    X = cmds.floatField('atom_srig_conScale', query=True, value=True)
    '''
    if check == 0:
	face   = False
    else:
	face=True
    '''

    PreBuild = place.rigPrebuild(Top=0, Ctrl=True, SknJnts=True, Geo=True, World=True, Master=True, OlSkool=True, Size=110)
    CHARACTER = PreBuild[0]
    CONTROLS = PreBuild[1]
    SKIN_JOINTS = PreBuild[2]

import os
import maya.cmds as cmds
import maya.mel as mel
import math
import json
import tempfile
import urllib
import shutil
import py_compile

#
# import display_lib as ds
import webrImport as web
# web
ds = web.mod('display_lib')

# FUTURE: use Castejeau method to draw nicer curve
# globals
idB = None
glPlg = None


def message(what='', maya=False):
    what = '-- ' + what + ' --'
    if maya:
        mel.eval('print \"' + what + '\";')
    else:
        print what


def jobValue(*args):

import maya.cmds as cmds
import maya.mel as mel
import os
#
import webrImport as web
# web
# place = web.mod('atom_placement_lib')
misc = web.mod('atom_miscellaneous_lib')
ui = web.mod('atom_ui_lib')


# place Clusters on CV derived from 'curve' variable
# curve
# curve from which to make clusters
# clstrSuffix
# suffix for cluster


def clstrOnCV(curve, clstrSuffix):
    clstr = []
    i = 0
    num = cmds.getAttr((curve + '.cv[*]'))
    for item in num:
        c = cmds.cluster((curve + '.cv[' + str(i) + ']'), n=(clstrSuffix + str(i)), envelope=True)[1]
        i = i + 1
        clstr.append(c)
    return clstr

# places curve on points derived from selection