def __init__(self, top, queue, UseOldTypes):
#print "New instance of Wizard SetAtomType"
Wizard.__init__(self)
self.top = top
self.FlexAID = self.top.top
self.queue = queue
# Save view
self.View = cmd.get_view()
self.State = cmd.get_state()
#self.pdbPath = self.FlexAID.SimPath + 'tmp.pdb'
self.pdbPath = self.FlexAID.IOFile.ProcessedLigandPath.get()
self.ErrorCode = 1
self.SelAtomName = '...'
self.SelAtomType = '...'
self.Set_DDL_Colors(UseOldTypes)
smm = []
smm.append([ 2, 'Type Selection', '' ])
for a in self.types:
smm.append([ 1, self.type_name[a], 'cmd.get_wizard().set_AtomType("' + a + '")'])
self.menu['type']=smm
self.atom = list()
self.ID = ''
def __init__(self, top, queue, Sphere, SphereDisplay, SphereSize, ExtraPrompt):
#print "New instance of flexsphere Wizard"
Wizard.__init__(self)
self.top = top
self.queue = queue
self.App = self.top.top
self.App.WizardError = False
self.App.WizardResult = 0
self.Sphere = Sphere
self.SphereView = self.Sphere.Copy()
self.SphereSize = SphereSize
self.SphereDisplay = SphereDisplay
self.View = cmd.get_view()
self.ErrorCode = 0
self.Prompt = [ "Press Shift + Mouse3 (Wheel Click) to move the sphere.",
"Use the scaler in the " + self.App.Name + " interface to edit its radius." ]
if ExtraPrompt:
self.Prompt.append( ExtraPrompt )
def __init__(self,_self=cmd):
Wizard.__init__(self,_self)
self.editing_name = 0
self.copying = 0
self.points_name = ''
self.set_name(default_name)
self.mode = default_mode
self.modes = [
'box',
'walls',
'plane',
'quad',
]
self.mode_name = {
'box':'Box',
'walls':'Walls',
'plane':'Plane',
'quad':'Quad',
}
smm = []
smm.append([ 2, 'Box Mode', '' ])
for a in self.modes:
smm.append([ 1, self.mode_name[a], 'cmd.get_wizard().set_mode("'+a+'")'])
self.menu['mode']=smm
self.update_box()
def __init__(self, app, _self=cmd):
Wizard.__init__(self, _self)
# Clean the slate
self.cmd.unpick()
self.app = app
# Default values
self.rmsd_cutoff = 1.0
self.number_of_structures = 25
self.full_match = False
self.url = URL
self.LOGOurl = LOGOURL
self.ref = Wizard
# default values for sequence logo UI
self.operations = []
self.searches = []
self.database = DATABASE_FULL
self.database_name = "Full"
self.search = None # current search action
self.operation = None # current operation
self.dictionary = {}
self.searchThread = None
self.logoThread = None
self.status = 'waiting for selection'
self.searchProgress = 0.0
self.errorMessage = ''
self.makeLogo = 0
self.update()
def __init__(self,old_name,mode='object',_self=cmd):
Wizard.__init__(self,_self)
self.prefix = 'Renaming \\999%s\\--- to: \\999'%old_name
self.old_name = old_name
self.new_name = old_name
self.mode = mode
def __init__(self, _self=cmd):
Wizard.__init__(self, _self)
self.modes = ["labchg", "addchg", "cpychg", "zrochg", "mzochg", "cbachg", "movchg", "rbachg", "sumchg"]
self.mode = default_mode
self.status = 0
self.mode_name = {
"labchg": "Show",
"cpychg": "Copy",
"addchg": "Add",
"zrochg": "Zero",
"mzochg": "Move & Zero (atom)",
"cbachg": "Move & Zero (resi)",
"movchg": "Move & Remove (atom)",
"rbachg": "Move & Remove (resi)",
"sumchg": "Get Total Charge",
}
# initialize mode menu
smm = []
smm.append([2, "Atom Charge Mode", ""])
for a in self.modes:
smm.append([1, self.mode_name[a], 'cmd.get_wizard().set_mode("' + a + '")'])
self.menu["mode"] = smm
self.memory = 0
_self.edit_mode()
def __init__(self,mode='label',pos='[0.0,0.0,0.0]',_self=cmd):
Wizard.__init__(self,_self)
self.mode = mode
if mode == 'label':
self.prefix = 'Label text: \888'
self.text = ''
self.pos = pos
def __init__(self,_self=cmd):
Wizard.__init__(self,_self)
self.cmd.unpick()
self.status = 0 # 0 no atoms selections, 1 atom selected, 2 atoms selected, 3 atoms selected
self.error = None
self.object_name = None
# mode selection subsystem
self.mode = self.session.get('default_mode','pairs')
self.modes = [
'pairs',
'angle',
'dihed',
'polar',
'heavy',
'neigh',
]
self.mode_name = {
'polar':'Polar Neighbors',
'heavy':'Heavy Neighbors',
'neigh':'Neighbors',
'pairs':'Distances',
'angle':'Angles',
'dihed':'Dihedrals',
}
smm = []
smm.append([ 2, 'Measurement Mode', '' ])
for a in self.modes:
smm.append([ 1, self.mode_name[a], 'cmd.get_wizard().set_mode("'+a+'")'])
self.menu['mode']=smm
# overwrite mode selection subsystem
self.object_mode = self.session.get('default_object_mode','append')
self.object_modes = [
'merge',
'overwr',
'append',
]
self.object_mode_name = {
'merge':'Merge With Previous',
'overwr':'Replace Previous',
'append':'Create New Object',
}
smm = []
smm.append([ 2, 'New Measurements?', '' ])
for a in self.object_modes:
smm.append([ 1, self.object_mode_name[a], 'cmd.get_wizard().set_object_mode("'+a+'")'])
self.menu['object_mode']=smm
self.selection_mode = self.cmd.get_setting_legacy("mouse_selection_mode")
self.cmd.set("mouse_selection_mode",0) # set selection mode to atomic
self.cmd.deselect() # disable the active selection (if any)
def __init__(self,*arg,**kw):
_self = kw.get('_self',cmd)
self.valid = 1
Wizard.__init__(self,_self)
if len(arg):
self.old_button_mode = int(arg[0])
self.check_valid()
if self.valid:
self.recount()
def __init__(self,arg0=None,_self=cmd):
Wizard.__init__(self,_self)
self.gl = 5.0
self.short_cpu = 8.0
self.long_cpu = 16.0
self.message = []
if arg0!=None:
if hasattr(self,arg0):
getattr(self,arg0)()
def __init__(self,_self=cmd):
self.cmd = _self
self.cmd.unpick()
Wizard.__init__(self,_self)
# mode selection subsystem
self.radius = default_radius
self.map = copy.deepcopy(default_map)
self.level = copy.deepcopy(default_level)
self.track = copy.deepcopy(default_track)
self.avail_maps = []
self.menu['radius'] = [
[1, '4.0 A Radius','cmd.get_wizard().set_radius(4)'],
[1, '5.0 A Radius','cmd.get_wizard().set_radius(5)'],
[1, '6.0 A Radius','cmd.get_wizard().set_radius(6)'],
[1, '8.0 A Radius','cmd.get_wizard().set_radius(8)'],
[1, '10.0 A Radius','cmd.get_wizard().set_radius(10)'],
[1, '15.0 A Radius','cmd.get_wizard().set_radius(15)'],
[1, '20.0 A Radius','cmd.get_wizard().set_radius(20)'],
[1, '50.0 A Radius','cmd.get_wizard().set_radius(50)'],
]
self.menu['map0'] = []
self.menu['map1'] = []
self.menu['map2'] = []
level_menu = lambda x:[ [1, '1.0 sigma','cmd.get_wizard().set_level(%d,1.0)'%x],
[1, '1.5 sigma','cmd.get_wizard().set_level(%d,1.5)'%x],
[1, '2.0 sigma','cmd.get_wizard().set_level(%d,2.0)'%x],
[1, '3.0 sigma','cmd.get_wizard().set_level(%d,3.0)'%x],
[1, '5.0 sigma','cmd.get_wizard().set_level(%d,5.0)'%x],
[1, '-3.0 sigma','cmd.get_wizard().set_level(%d,-3.0)'%x]]
self.menu['level0'] = level_menu(0)
self.menu['level1'] = level_menu(1)
self.menu['level2'] = level_menu(2)
self.menu['track'] = [
[ 1, "Track & Zoom", 'cmd.get_wizard().set_track(0)'],
[ 1, "Track & Center", 'cmd.get_wizard().set_track(1)'],
[ 1, "Track & Set Origin", 'cmd.get_wizard().set_track(2)'],
[ 1, "Track Off", 'cmd.get_wizard().set_track(3)'],
]
if (self.map[0] == '') and (self.map[1] == '') and (self.map[2]==''):
for a in self.cmd.get_names(): # automatically load first map we find
if self.cmd.get_type(a)=='object:map':
self.map[0]=a
break
self.update_map_menus()
self.cmd.set_key('pgup',lambda c=cmd:c.get_wizard().next_res(d=-1))
self.cmd.set_key('pgdn',lambda c=cmd:c.get_wizard().next_res())
def __init__(self,*arg,**kw):
_self = kw.get('_self',cmd)
Wizard.__init__(self,_self)
self.message = []
for a in arg:
if not isinstance(a,list):
self.message.append(a)
else:
self.message.extend(a)
def __init__(self,_self=cmd):
Wizard.__init__(self,_self)
self.memory = 0
self.n_pair = 0
self.status = 0 # 0 no atoms selections, 1 atom selected
self.message = None
self.selection_mode = cmd.get_setting_int("mouse_selection_mode")
cmd.set("mouse_selection_mode",0) # set selection mode to atomic
cmd.deselect() # disable the active selection (if any)
def __init__(self,*arg,**kw):
_self = kw.get('_self',cmd)
Wizard.__init__(self,_self)
self.message = []
for a in arg:
if not isinstance(a,list):
self.message.append(a)
else:
self.message.extend(a)
for a in self.message:
print(" " + _nuke_color_re.sub('',a))
self.dismiss = int(kw.get("dismiss",1))
def __init__(self,_self=cmd):
cmd.unpick();
Wizard.__init__(self,_self)
self.status = 0 # 0 no atoms selections, 1 atom selected
self.error = None
self.object_name = None
# mode selection subsystem
self.mode = default_mode
self.modes = [
'polar',
'heavy',
'neigh',
'pairs',
]
self.mode_name = {
'polar':'Polar Neighbors',
'heavy':'Heavy Neighbors',
'neigh':'Neighbors',
'pairs':'Pairwise Distances',
}
smm = []
smm.append([ 2, 'Measurement Mode', '' ])
for a in self.modes:
smm.append([ 1, self.mode_name[a], 'cmd.get_wizard().set_mode("'+a+'")'])
self.menu['mode']=smm
# overwrite mode selection subsystem
self.object_mode=default_object_mode
self.object_modes = [
'overwr',
'append',
]
self.object_mode_name = {
'overwr':'Replace Previous',
'append':'Create New',
}
smm = []
smm.append([ 2, 'New Distances?', '' ])
for a in self.object_modes:
smm.append([ 1, self.object_mode_name[a], 'cmd.get_wizard().set_object_mode("'+a+'")'])
self.menu['object_mode']=smm
self.selection_mode = cmd.get_setting_int("mouse_selection_mode")
cmd.set("mouse_selection_mode",0) # set selection mode to atomic
cmd.deselect() # disable the active selection (if any)
def __init__(self,_self=cmd):
Wizard.__init__(self,_self)
self.ligand = ""
for a in self.cmd.get_names("public_objects",1):
if self.cmd.count_atoms(a) < 1000:
self.ligand = a
break
self.target = "(none)"
self.message = []
self.menu = {}
self.update_menus()
self.cmd.edit_mode()
def __init__(self,_self=cmd):
Wizard.__init__(self,_self)
self.cmd.unpick()
self.cmd.deselect()
self.cmd.set('mouse_selection_mode', 0)
self.menu = {
'mode': [
[2, 'Mode', ''],
] + [
[1, name, 'cmd.get_wizard().set_mode(%d)' % i]
for (i, name) in enumerate(self.mode_names)
]
}
def __init__(self):
Wizard.__init__(self)
# some attributes to do with picking
self.pick_count = 0
self.object_count = 0
self.object_prefix = "pw"
# the plane facet size (the 'radius' of the section of plane we show)
self.facetSize = 5
self.selection_mode = cmd.get_setting_legacy("mouse_selection_mode")
cmd.set("mouse_selection_mode",0) # set selection mode to atomic
cmd.deselect()
def __init__(self,*arg,**kw):
_self=kw.get('_self',cmd)
Wizard.__init__(self,_self)
self.message = []
self.last = None
cmd.full_screen("off")
if not ("mono" in list(kw.keys())):
cmd.stereo("on")
cmd.set("sphere_mode","5")
if 'last' in saved:
self.last = saved['last']
if len(arg):
self.launch(arg[0])
else:
self.launch("cartoon")
def __init__(self, app, _self = cmd):
Wizard.__init__(self, _self)
# Clean the slate
self.cmd.unpick()
self.do_select(SELECTION_NAME, 'none')
self.prompt = ['Select motifs using left click']
self.app = app
# type Key = (Object, Model, Segi, Chain, Resn, Resi, Name)
# type Val = Selection corresponding to the key
# word_list :: Dict Key Val
self.word_list = {}
# Default values
self.rmsd_cutoff = 1.0
self.random_seed = 0
self.number_of_structures = 100
self.suns_server_address = SUNS_SERVER_ADDRESS
self.group_name = SUNS_DEFAULT_GROUP_NAME
self.searchThread = None
# Rebind left click to select bonds. I choose left click since it is
# the most portable input method across devices, especially laptops, and
# also because the user definitely does not need the old left click
# function for the duration of the wizard.
self.cmd.button('single_left', 'None', 'PkTB')
# PyMOL has this really obscure and undocumented 'auto_hide_selections'
# setting that auto hides selections when using editing commands. This
# wizard overrides "PkTB", which is one of those editing commands, but
# we still want to display selections to the user, so we must disable
# this setting.
self.prev_auto_hide_setting = self.cmd.get('auto_hide_selections')
self.cmd.set('auto_hide_selections',0)
self.prev_auto_zoom_setting = self.cmd.get('auto_zoom')
self.cmd.set('auto_zoom', 0)
# There are a few functions which would like to use a Tcl window
# to communicate with the user. This can cause some unsafe threading
# issues with the global PyMol Tcl window. Thus, we will instead
# store the function calls in the pymol module itself, and when
# the time comes, just ask the PyMol module to execute it for us.
pymol.stored.aacycler = lambda: AACycler(self.app, self.cmd)
pymol.stored.fetch_full_context = lambda: self.fetch_full_context()
pymol.stored.ask_group_name = lambda: self.ask_group_name()
pymol.stored.ask_server_address = lambda: self.ask_server_address()
def __init__(self,_self=cmd):
Wizard.__init__(self,_self)
if auto_configure() < 1:
raise pymol.CmdException('cannot find "szybki" executable, please '
'set OE_DIR environment variable')
self.ligand = ""
for a in self.cmd.get_names("public_objects",1):
if self.cmd.count_atoms(a) < 1000:
self.ligand = a
break
self.target = "(none)"
self.message = []
self.menu = {}
self.update_menus()
self.cmd.edit_mode()
def __init__(self,_self=cmd):
# initialize parent class
Wizard.__init__(self,_self)
self.update_object_menu()
# restore previous state from global storage
self.dict = static_dict
self.object = default_object if default_object in self.avail_objects else None
self.browse = default_browse
self.state_dict = {}
# if we don't have a current object, choose the first multi-state object
if not self.object and self.avail_objects:
self.object = self.avail_objects[0]
# menu for
self.menu['browse'] = [
[2, 'Browse Mode',''],
[1, 'Browse All','cmd.get_wizard().set_browse(1)'],
[1, 'Browse Accepted','cmd.get_wizard().set_browse(2)'],
[1, 'Browse Rejected','cmd.get_wizard().set_browse(3)'],
[1, 'Browse Deferred','cmd.get_wizard().set_browse(4)'],
[1, 'Browse Remaining','cmd.get_wizard().set_browse(5)'],
]
self.menu['create'] = [
[2, 'Create Filtered Object', ''],
[1, 'Accepted','cmd.get_wizard().create_object("Accept")'],
[1, 'Rejected','cmd.get_wizard().create_object("Reject")'],
[1, 'Deferred','cmd.get_wizard().create_object("Defer")'],
]
self.count_object()
self.load_state_dict()
self.update_object_menu()
cmd.set_key('F1',lambda s=self:s.accept())
cmd.set_key('F2',lambda s=self:s.reject())
cmd.set_key('F3',lambda s=self:s.defer())
cmd.set_key('right',lambda s=self:s.forward())
cmd.set_key('left',lambda s=self:s.backward())
def __init__(self,_self=cmd):
Wizard.__init__(self,_self)
self.cmd.unpick()
self.cutoff = self.cmd.get_setting_float("neighbor_cutoff")
self.heavy_neighbor_cutoff = self.cmd.get_setting_float("heavy_neighbor_cutoff")
self.polar_neighbor_cutoff = self.cmd.get_setting_float("polar_neighbor_cutoff")
self.hbond_cutoff = self.cmd.get_setting_float("h_bond_cutoff_center")
self.status = 0 # 0 no atoms selections, 1 atom selected, 2 atoms selected, 3 atoms selected
self.error = None
self.object_name = None
# mode selection subsystem
self.mode = self.session.get('default_mode','pairs')
self.neighbor_target = ""
# TODO:
# make this a function, and call it when we call refresh wizard
# to update the object/selection list
smm = []
smm.append([ 2, 'Measurement Mode', '' ])
for a in self.modes:
if a in ("neigh", "polar", "heavy"):
smm.append([ 1, self.mode_name[a], self.neighbor_submenu(a)])
else:
smm.append([ 1, self.mode_name[a], 'cmd.get_wizard().set_mode("'+a+'")'])
self.menu['mode']=smm
# overwrite mode selection subsystem
self.object_mode = self.session.get('default_object_mode','append')
smm = []
smm.append([ 2, 'New Measurements?', '' ])
for a in self.object_modes:
smm.append([ 1, self.object_mode_name[a], 'cmd.get_wizard().set_object_mode("'+a+'")'])
self.menu['object_mode']=smm
# initially select atoms, but now users can change this
self.selection_mode = self.cmd.get_setting_legacy("mouse_selection_mode")
self.cmd.set("mouse_selection_mode",0) # set selection mode to atomic
self.cmd.deselect() # disable the active selection (if any)
self.mouse_mode = 0
def __init__(self, app, _self=cmd):
Wizard.__init__(self, _self)
# Clean the slate
self.cmd.unpick()
self.app = app
# Default values
self.rmsd_cutoff = 1.0
self.number_of_structures = 25
self.full_match = False
self.url = URL
self.LOGOurl = LOGOURL
self.ref = Wizard
# default values for sequence logo UI
self.operations = []
self.searches = []
self.database = DATABASE_TEST
self.database_name = "Test"
self.search = None # current search action
self.operation = None # current operation
self.jobIDs = {}
self.qSeqs = {}
self.searchThread = None
self.logoThread = None
self.status = 'waiting for selection'
self.searchProgress = 0.0
self.errorMessage = ''
self.makeLogo = 0
self.popup_app = None
self.done_adding = False
self.live_app = False
self.logo_flag = None
self.filename = None
self.res_info = None
self.update()
def __init__(self,_self=cmd):
Wizard.__init__(self,_self)
self.modes = [
'labchg',
'addchg',
'cpychg',
'zrochg',
'mzochg',
'cbachg',
'movchg',
'rbachg',
'sumchg',
]
self.mode = default_mode
self.status = 0
self.mode_name = {
'labchg':'Show',
'cpychg':'Copy',
'addchg':'Add',
'zrochg':'Zero',
'mzochg':'Move & Zero (atom)',
'cbachg':'Move & Zero (resi)',
'movchg':'Move & Remove (atom)',
'rbachg':'Move & Remove (resi)',
'sumchg':'Get Total Charge'
}
# initialize mode menu
smm = []
smm.append([ 2, 'Atom Charge Mode', '' ])
for a in self.modes:
smm.append([ 1, self.mode_name[a], 'cmd.get_wizard().set_mode("'+a+'")'])
self.menu['mode']=smm
self.memory = 0
_self.edit_mode()
def __init__(self, _self=cmd):
# initialize parent class
Wizard.__init__(self, _self)
# restore previous state from global storage
self.dict = static_dict
self.object = default_object
self.browse = default_browse
self.avail_objects = []
self.state_dict = {}
# if we don't have a current object, choose the first multi-state object
if self.object == None:
for a in cmd.get_names("objects"):
if cmd.get_type(a) == "object:molecule":
if cmd.count_states(a) > 1:
self.object = a
break
# menu for
self.menu["browse"] = [
[2, "Browse Mode", ""],
[1, "Browse All", "cmd.get_wizard().set_browse(1)"],
[1, "Browse Accepted", "cmd.get_wizard().set_browse(2)"],
[1, "Browse Rejected", "cmd.get_wizard().set_browse(3)"],
[1, "Browse Deferred", "cmd.get_wizard().set_browse(4)"],
[1, "Browse Remaining", "cmd.get_wizard().set_browse(5)"],
]
self.count_object()
self.load_state_dict()
self.update_object_menu()
cmd.set_key("F1", lambda s=self: s.accept())
cmd.set_key("F2", lambda s=self: s.reject())
cmd.set_key("F3", lambda s=self: s.defer())
cmd.set_key("right", lambda s=self: s.forward())
cmd.set_key("left", lambda s=self: s.backward())
def __init__(self, top, queue, LigandPath, AnchorAtom):
#print("New instance of anchor Class.\n")
Wizard.__init__(self)
self.top = top
self.queue = queue
self.FlexAID = self.top.top
self.FlexAID.WizardError = False
self.LigandPath = LigandPath
self.PrevAnchorAtom = AnchorAtom
self.AnchorAtom = self.PrevAnchorAtom
self.View = cmd.get_view()
self.State = cmd.get_state()
self.auto_zoom = cmd.get("auto_zoom")
self.ErrorStatus = []
def __init__(self,name=None,_self=cmd):
Wizard.__init__(self,_self)
self.message = []
self.last = None
if saved.has_key('last'):
self.last = saved['last']
if name!=None:
demo = DemoInfo(_self=_self)
if self.last:
if hasattr(demo,self.last):
getattr(demo,self.last)(cleanup=1)
if hasattr(demo,name):
self.last = name
demo_fn = getattr(demo,name)
t = threading.Thread(target=demo_fn)
t.setDaemon(1)
t.start()
self.message = demo.message_dict.get(name,None)
else:
self.last = None
saved['last']=self.last
def __init__(self, _self=pymol.cmd): #PyMOL pattern
Wizard.__init__(self, _self) #PyMOL pattern
if self.cmd.get_movie_length() > 0:
raise pymol.wizarding.WizardError(
'Mutagenesis Wizard cannot be used with Movie')
self.cmd.unpick()
self._stored = pymol.Scratch_Storage()
self._space = {'stored': self._stored}
self._status = Status.NO_SELECTION
self._auto_center = "ON"
self.mode = DEFAULT_MODE
self.rep = DEFAULT_REP
self.selection_mode = self.cmd.get_setting_int("mouse_selection_mode")
self.cmd.set("mouse_selection_mode", 1)
tmp_menu = [[2, 'Mutant', '']]
for mode in self._mode_labels:
tmp_menu.append(
[1, mode, 'cmd.get_wizard().set_mode("' + mode + '")'])
self.menu['mode'] = tmp_menu
tmp_menu2 = [[2, 'Representation', '']]
for rep in self._reps:
tmp_menu2.append([
1, self._rep_name[rep],
'cmd.get_wizard().set_rep("' + rep + '")'
])
self.menu['rep'] = tmp_menu2
tmp_menu = [[2, 'Auto Center',
''], [1, "ON", 'cmd.get_wizard().set_auto_center("ON")'],
[1, "OFF", 'cmd.get_wizard().set_auto_center("OFF")']]
self.menu['auto_center'] = tmp_menu
def __init__(self, _self=cmd):
cmd.unpick();
Wizard.__init__(self, _self)
self.mouse_selection_mode = cmd.get_setting_int('mouse_selection_mode')
cmd.set('mouse_selection_mode',0) # set selection mode to atomic
cmd.deselect() # disable the active selection (if any)
self.error = None
self.selection_mode = 1 if self.mouse_selection_mode == 6 else 0
self.selection_modes = [
'Residues',
'C-alphas',
]
smm = []
smm.append([ 2, 'Selection Mode', '' ])
for i, label in enumerate(self.selection_modes):
smm.append([1, label, 'cmd.get_wizard().set_mode(%d)' % i])
self.menu['selection_mode'] = smm
self.name = None
def cleanup(self):
self.cmd.delete(display_sele)
Wizard.cleanup(self)
def __init__(self, _self=cmd):
self.cmd = _self
self.cmd.unpick()
Wizard.__init__(self, _self)
# mode selection subsystem
self.radius = default_radius
self.map = copy.deepcopy(default_map)
self.level = copy.deepcopy(default_level)
self.track = copy.deepcopy(default_track)
self.avail_maps = []
self.menu['radius'] = [
[1, '4.0 A Radius', 'cmd.get_wizard().set_radius(4)'],
[1, '5.0 A Radius', 'cmd.get_wizard().set_radius(5)'],
[1, '6.0 A Radius', 'cmd.get_wizard().set_radius(6)'],
[1, '8.0 A Radius', 'cmd.get_wizard().set_radius(8)'],
[1, '10.0 A Radius', 'cmd.get_wizard().set_radius(10)'],
[1, '15.0 A Radius', 'cmd.get_wizard().set_radius(15)'],
[1, '20.0 A Radius', 'cmd.get_wizard().set_radius(20)'],
[1, '50.0 A Radius', 'cmd.get_wizard().set_radius(50)'],
]
self.menu['map0'] = []
self.menu['map1'] = []
self.menu['map2'] = []
level_menu = lambda x: [
[1, '1.0 sigma',
'cmd.get_wizard().set_level(%d,1.0)' % x],
[1, '1.5 sigma',
'cmd.get_wizard().set_level(%d,1.5)' % x],
[1, '2.0 sigma',
'cmd.get_wizard().set_level(%d,2.0)' % x],
[1, '3.0 sigma',
'cmd.get_wizard().set_level(%d,3.0)' % x],
[1, '5.0 sigma',
'cmd.get_wizard().set_level(%d,5.0)' % x],
[1, '-3.0 sigma',
'cmd.get_wizard().set_level(%d,-3.0)' % x]
]
self.menu['level0'] = level_menu(0)
self.menu['level1'] = level_menu(1)
self.menu['level2'] = level_menu(2)
self.menu['track'] = [
[1, "Track & Zoom", 'cmd.get_wizard().set_track(0)'],
[1, "Track & Center", 'cmd.get_wizard().set_track(1)'],
[1, "Track & Set Origin", 'cmd.get_wizard().set_track(2)'],
[1, "Track Off", 'cmd.get_wizard().set_track(3)'],
]
if (self.map[0] == '') and (self.map[1] == '') and (self.map[2] == ''):
for a in self.cmd.get_names(
): # automatically load first map we find
if self.cmd.get_type(a) == 'object:map':
self.map[0] = a
break
self.update_map_menus()
self.cmd.set_key('pgup', lambda c=cmd: c.get_wizard().next_res(d=-1))
self.cmd.set_key('pgdn', lambda c=cmd: c.get_wizard().next_res())
def __init__(self, _self=cmd):
Wizard.__init__(self, _self)
self.cmd.unpick()
def _validate_instance(self):
Wizard._validate_instance(self)
if not hasattr(self, 'meas_count'):
self.meas_count = self.session.get('meas_count', 0)
def __init__(self, _self=cmd):
Wizard.__init__(self, _self)
self.cmd.unpick()
self.click_list = []
cmd.select(click_sele, "none", enable=0)
cmd.select(disp_sele, "none", enable=1)
def __init__(self, _self=cmd):
Wizard.__init__(self, _self)
for a in self.get_prompt():
print a
def __init__(self,_self=cmd):
Wizard.__init__(self,_self)
self.cmd.deselect()
self.cmd.unpick()
self.selection_mode = self.cmd.get_setting_legacy("mouse_selection_mode")
self.cmd.set("mouse_selection_mode",0) # set selection mode to atomic
self.current_mode = saved_mode
self.current_what = saved_what
self.current_scope = saved_scope
self.current_color = saved_color
self.menu['mode'] = [
[2, 'Mode', '' ],
[1, self.mode_dict[0][0], 'cmd.get_wizard().set_mode(0)' ],
[1, self.mode_dict[1][0], 'cmd.get_wizard().set_mode(1)' ],
[ 0, '' , '' ],
[1, self.mode_dict[2][0], 'cmd.get_wizard().set_mode(2)' ],
[1, self.mode_dict[3][0], 'cmd.get_wizard().set_mode(3)' ],
[1, self.mode_dict[4][0], 'cmd.get_wizard().set_mode(4)' ],
# [1, self.mode_dict[5][0], 'cmd.get_wizard().set_mode(4)' ],
]
self.menu['what'] = [
[2, 'What', '' ],
[1, self.what_dict[1][0], 'cmd.get_wizard().set_what(1)' ],
[1, self.what_dict[2][0], 'cmd.get_wizard().set_what(2)' ],
[1, self.what_dict[3][0], 'cmd.get_wizard().set_what(3)' ],
[1, self.what_dict[4][0], 'cmd.get_wizard().set_what(4)' ],
[1, self.what_dict[5][0], 'cmd.get_wizard().set_what(5)' ],
[0, '', '' ],
[1, self.what_dict[6][0], 'cmd.get_wizard().set_what(6)' ],
[0, '', '' ],
[1, self.what_dict[7][0], 'cmd.get_wizard().set_what(7)' ],
[1, self.what_dict[8][0], 'cmd.get_wizard().set_what(8)' ],
[1, self.what_dict[9][0], 'cmd.get_wizard().set_what(9)' ],
[0, '', '' ],
[1, self.what_dict[10][0], 'cmd.get_wizard().set_what(10)' ],
[1, self.what_dict[11][0], 'cmd.get_wizard().set_what(11)' ],
]
self.menu['color'] = [
[2, 'Color', '' ],
[1, self.color_dict[1][0], 'cmd.get_wizard().set_color(1)' ],
[1, self.color_dict[2][0], 'cmd.get_wizard().set_color(2)' ],
[1, self.color_dict[3][0], 'cmd.get_wizard().set_color(3)' ],
[1, self.color_dict[4][0], 'cmd.get_wizard().set_color(4)' ],
[1, self.color_dict[5][0], 'cmd.get_wizard().set_color(5)' ],
[1, self.color_dict[6][0], 'cmd.get_wizard().set_color(6)' ],
[1, self.color_dict[7][0], 'cmd.get_wizard().set_color(7)' ],
[1, self.color_dict[8][0], 'cmd.get_wizard().set_color(8)' ],
[1, self.color_dict[9][0], 'cmd.get_wizard().set_color(9)' ],
[1, self.color_dict[10][0], 'cmd.get_wizard().set_color(10)' ],
[1, self.color_dict[11][0], 'cmd.get_wizard().set_color(11)' ],
[1, self.color_dict[12][0], 'cmd.get_wizard().set_color(12)' ],
[1, self.color_dict[13][0], 'cmd.get_wizard().set_color(13)' ],
[1, self.color_dict[14][0], 'cmd.get_wizard().set_color(14)' ],
]
self.menu['scope'] = [
[ 2, 'Scope', ''],
[ 1, self.scope_dict[0][0], 'cmd.get_wizard().set_scope(0)' ],
[ 1, self.scope_dict[1][0], 'cmd.get_wizard().set_scope(1)' ],
[ 1, self.scope_dict[2][0], 'cmd.get_wizard().set_scope(2)' ],
[ 1, self.scope_dict[3][0], 'cmd.get_wizard().set_scope(3)' ],
[ 1, self.scope_dict[4][0], 'cmd.get_wizard().set_scope(4)' ],
[ 0, '' , '' ],
[ 1, self.scope_dict[5][0], 'cmd.get_wizard().set_scope(5)' ],
]
def __init__(self,_self=cmd):
Wizard.__init__(self,_self)
cmd=self.cmd
if self.cmd.get_movie_length() > 0:
raise pymol.wizarding.WizardError('Mutagenesis Wizard cannot be used with Movie')
cmd.unpick()
self.stored = pymol.Scratch_Storage()
self.space = {'stored': self.stored}
self.bump_scores = []
self.dep = default_dep
self.ind_library = io.pkl.fromFile(os.environ['PYMOL_DATA']+
"/chempy/sidechains/sc_bb_ind.pkl")
self.load_library()
self.status = 0 # 0 no selection, 1 mutagenizing
self.bump_check = 1
self.auto_center = 1
self.error = None
self.object_name = None
self.modes = [
'current'
]
self.mode = default_mode
self.rep = default_rep
self.hyd = default_hyd
self.n_cap = default_n_cap
self.c_cap = default_c_cap
residues = list(self.ind_library.keys())
# could extent with additional fragments manually as below
residues.extend(['GLY','ALA'])
residues.extend(['HID','HIE','HIP'])
residues.extend(['ARGN','LYSN','ASPH','GLUH'])
residues.sort()
res_copy = deepcopy(residues)
for a in res_copy:
residues.append('NT_'+a)
residues.append('CT_'+a)
self.modes.extend(residues)
self.mode_label={}
for a in self.modes:
self.mode_label[a] = ""+a
self.mode_label['current']="No Mutant"
self.selection_mode = cmd.get_setting_int("mouse_selection_mode")
cmd.set("mouse_selection_mode",1)
smm = []
smm.append([ 2, 'Mutant', '' ])
smm.append([ 1, 'No change', 'cmd.get_wizard().set_mode("current")' ])
# smm.append([ 1, 'N-Term', [] ])
# smm.append([ 1, 'C-Term', [] ])
smm.append([ 0, '', '' ])
for a in self.modes:
if a == 'current':
pass
elif a[0:3]=='NT_':
pass
# smm[2][2].append([ 1, self.mode_label[a[3:]], 'cmd.get_wizard().set_mode("'+a+'")'])
elif a[0:3]=='CT_':
pass
# smm[3][2].append([ 1, self.mode_label[a[3:]], 'cmd.get_wizard().set_mode("'+a+'")'])
else:
smm.append([ 1, self.mode_label[a], 'cmd.get_wizard().set_mode("'+a+'")'])
# group arg, lys, his, glu, asp
for lst in [ smm ]: # [ smm, smm[2][2], smm[3][2] ]:
for a in 'ARG','LYS','HID','GLU','ASP':
ix = 0
start = 0
stop = 0
for b in lst:
if start==0:
if b[1][0:]==a:
start = ix
stop = ix + 1
elif b[1][0:3]==a[0:3] or ( b[1][0:2]==a[0:2] and a[0:2]=='HI' ):
stop = ix + 1
ix = ix + 1
if start!=0 and stop!=0:
slice = lst[start:stop]
if a != 'HID':
slice2 = [slice[0] ] + [ [0,'',''] ] + slice[1:]
lst[start:stop] = [ [1, self.mode_label[a] + "... " , slice2 ] ]
else:
slice2 = [ slice[3] ] + [ [0,'',''] ] + slice[0:3]
lst[start:stop] = [ [1, self.mode_label['HIS']+ "... ", slice2 ] ]
self.menu['mode']=smm
self.reps = [
'lines',
'sticks',
'spheres',
'dots'
]
self.rep_name = {
'lines' : "Show Lines",
'sticks' : "Show Sticks",
'spheres' : "Show Spheres",
'dots' : "Show Dots",
}
self.dep_name = {
'dep' : "Backbone Depen. Rotamers",
'ind' : "Backbone Indep. Rotamers"
}
self.hyd_name = {
'auto' : "Hydrogens: Current",
'keep' : "Hydrogens: Add & Retain",
# 'polar' : "Polar Hydrogens",
'none' : "Hydrogens: Remove",
}
self.hyds = [ 'auto', 'keep', 'none' ]
self.n_cap_name = {
'none' : 'Open',
'posi' : 'NH3+',
'acet' : 'Acetyl',
}
self.n_caps = [ 'none', 'posi', 'acet' ]
self.c_cap_name = {
'none' : 'Open',
'nega' : 'COO-',
'amin' : 'Amine',
'nmet' : 'N-methyl',
}
self.c_caps = [ 'none', 'nega', 'amin', 'nmet' ]
smm = []
smm.append([ 2, 'N-Cap', '' ])
for a in self.n_caps:
smm.append([ 1, self.n_cap_name[a], 'cmd.get_wizard().set_n_cap("'+a+'")'])
self.menu['n_cap']=smm
smm = []
smm.append([ 2, 'C-Cap', '' ])
for a in self.c_caps:
smm.append([ 1, self.c_cap_name[a], 'cmd.get_wizard().set_c_cap("'+a+'")'])
self.menu['c_cap']=smm
smm = []
smm.append([ 2, 'Hydrogens', '' ])
for a in self.hyds:
smm.append([ 1, self.hyd_name[a], 'cmd.get_wizard().set_hyd("'+a+'")'])
self.menu['hyd']=smm
smm = []
smm.append([ 2, 'Representation', '' ])
for a in self.reps:
smm.append([ 1, self.rep_name[a], 'cmd.get_wizard().set_rep("'+a+'")'])
self.menu['rep']=smm
self.deps = [ 'dep', 'ind' ]
smm = []
smm.append([ 2, 'Rotamers', '' ])
for a in self.deps:
smm.append([ 1, self.dep_name[a], 'cmd.get_wizard().set_dep("'+a+'")'])
self.menu['dep']=smm
if 'pk1' in cmd.get_names('selections'):
cmd.select(src_sele,"(byres pk1)")
cmd.unpick()
cmd.enable(src_sele)
self.status = 1
self.error = None
self.do_library()
cmd.refresh_wizard()
def __init__(self):
Wizard.__init__(self)
self.reset()
def __init__(self,_self):
Wizard.__init__(self,_self)
self.actionHash = str(self.__class__)
def __init__(self,_self=cmd):
Wizard.__init__(self,_self)
self.status = NO_SELECTIONS
self.error = None
self.object_name = None
self.radius = default_radius
self.cushion = default_cushion
# activate editing mode if not already active
if "Editing" not in self.cmd.get("button_mode_name"):
self.cmd.edit_mode(1)
self.restore_edit_mode = 0
else:
self.restore_edit_mode = None
# activate bumps
self.restore_sculpt_vdw_vis_mode = self.cmd.get('sculpt_vdw_vis_mode')
self.cmd.set("sculpt_vdw_vis_mode")
# deactivate all objects
self.cmd.sculpt_deactivate("all")
# turn on sculpting
self.cmd.set("sculpting")
# unmask all atoms so that they can be picked
self.cmd.unmask("all")
# mode selection subsystem
self.mode = default_mode
self.modes = [
'ligand_rx',
# 'ligand_re',
# 'by_atom',
'by_resi',
]
self.mode_name = {
'by_atom':'Atom Shells',
'by_resi':'Residue Shells',
'ligand_rx' :'One Residue',
'ligand_re' :'Residue v. Free',
'ligand_cx' :'Chain v. Fixed',
'ligand_ce' :'Chain v. Free',
}
smm = []
smm.append([ 2, 'Selection Mode', '' ])
for a in self.modes:
smm.append([ 1, self.mode_name[a], 'cmd.get_wizard().set_mode("'+a+'")'])
self.menu['mode']=smm
self.menu['radius'] = [[ 2, 'Mobile Atom Sphere', '' ],
[1, '4.0 A Radius','cmd.get_wizard().set_radius(4)'],
[1, '5.0 A Radius','cmd.get_wizard().set_radius(5)'],
[1, '6.0 A Radius','cmd.get_wizard().set_radius(6)'],
[1, '8.0 A Radius','cmd.get_wizard().set_radius(8)'],
[1, '10.0 A Radius','cmd.get_wizard().set_radius(10)'],
[1, '15.0 A Radius','cmd.get_wizard().set_radius(15)'],
[1, '20.0 A Radius','cmd.get_wizard().set_radius(20)'],
]
self.menu['cushion'] = [[ 2, 'Fixed Atom Cushion', '' ],
[1, '2.0 A Cushion','cmd.get_wizard().set_cushion(2)'],
[1, '3.0 A Cushion','cmd.get_wizard().set_cushion(3)'],
[1, '4.0 A Cushion','cmd.get_wizard().set_cushion(4)'],
[1, '6.0 A Cushion','cmd.get_wizard().set_cushion(6)'],
[1, '8.0 A Cushion','cmd.get_wizard().set_cushion(8)'],
[1, '10.0 A Cushion','cmd.get_wizard().set_cushion(10)'],
[1, '12.0 A Cushion','cmd.get_wizard().set_cushion(12)'],
]
def __init__(self, _self=cmd):
Wizard.__init__(self, _self)
self.cmd.unpick()
self.cutoff = self.cmd.get_setting_float("neighbor_cutoff")
self.heavy_neighbor_cutoff = self.cmd.get_setting_float(
"heavy_neighbor_cutoff")
self.polar_neighbor_cutoff = self.cmd.get_setting_float(
"polar_neighbor_cutoff")
self.hbond_cutoff = self.cmd.get_setting_float("h_bond_cutoff_center")
self.status = 0 # 0 no atoms selections, 1 atom selected, 2 atoms selected, 3 atoms selected
self.error = None
self.object_name = None
# mode selection subsystem
self.mode = self.session.get('default_mode', 'pairs')
self.modes = [
'pairs',
'angle',
'dihed',
'polar',
'heavy',
'neigh',
'hbond',
]
self.mode_name = {
'polar': 'Polar Neighbors',
'heavy': 'Heavy Neighbors',
'neigh': 'Neighbors',
'pairs': 'Distances',
'angle': 'Angles',
'dihed': 'Dihedrals',
'hbond': 'Polar Contacts',
}
# users can now specify how they're finding neighbors
self.neighbor_modes = [
'same', 'other', 'enabled', 'all', 'in_object', 'in_selection'
]
self.neighbor_target = ""
# TODO:
# make this a function, and call it when we call refresh wizard
# to update the object/selection list
smm = []
smm.append([2, 'Measurement Mode', ''])
for a in self.modes:
if a in ("neigh", "polar", "heavy"):
smm.append([1, self.mode_name[a], self.neighbor_submenu(a)])
else:
smm.append([
1, self.mode_name[a],
'cmd.get_wizard().set_mode("' + a + '")'
])
self.menu['mode'] = smm
# overwrite mode selection subsystem
self.object_mode = self.session.get('default_object_mode', 'append')
self.object_modes = [
'merge',
'overwr',
'append',
]
self.object_mode_name = {
'merge': 'Merge With Previous',
'overwr': 'Replace Previous',
'append': 'Create New Object',
}
smm = []
smm.append([2, 'New Measurements?', ''])
for a in self.object_modes:
smm.append([
1, self.object_mode_name[a],
'cmd.get_wizard().set_object_mode("' + a + '")'
])
self.menu['object_mode'] = smm
# initially select atoms, but now users can change this
self.selection_mode = self.cmd.get_setting_legacy(
"mouse_selection_mode")
self.cmd.set("mouse_selection_mode", 0) # set selection mode to atomic
self.cmd.deselect() # disable the active selection (if any)
self.mouse_mode = 0
