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):
"""main mtsslWizard class"""
Wizard.__init__(self)
self.printStartupInfo()
self.setupMenus()
self.reset()
self.path = os.path.dirname(__file__)
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):
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, top, queue):
#print "New instance of FlexSC Wizard"
Wizard.__init__(self)
self.top = top
self.queue = queue
self.FlexAID = self.top.top
self.FlexAID.WizardError = False
self.TargetName = self.FlexAID.IOFile.Target
self.TargetFlex = self.top.Vars.TargetFlex
self.ResidueName = '...'
self.PanelResidue = ' Residue: '
# Initial view
self.View = cmd.get_view()
self.State = cmd.get_state()
self.auto_zoom = cmd.get("auto_zoom")
# for Quit_Wizard
self.ErrorCode = 1
self.ErrorStatus = [ "Side-chains shown in white are already set as flexible.",
"Side-chains shown in orange are 'active' and are ready to be added." ]
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, 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,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, top, queue, ResSeq, LigandPath):
#print "New instance of flexbond Class.\n"
Wizard.__init__(self)
self.top = top
self.queue = queue
self.FlexAID = self.top.top
self.FlexAID.WizardError = False
self.ResSeq = ResSeq
self.dictFlexBonds = self.FlexAID.IOFile.Vars.dictFlexBonds
self.dictNeighbours = self.FlexAID.IOFile.Vars.dictNeighbours
self.RefLigand = LigandPath
self.View = cmd.get_view()
self.State = cmd.get_state()
self.auto_zoom = cmd.get("auto_zoom")
self.pick_count = 0
self.panelForceBond = 'Adv.: Force bond OFF'
self.Force = False
self.point1 = list()
self.point2 = list()
self.atom1 = list()
self.atom2 = list()
self.ErrorStatus = [ "Flexible bonds of the ligand are shown in orange.",
"Selected flexible bonds of the ligand are shown in white." ]
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, 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,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, 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, _self=cmd):
Wizard.__init__(self, _self)
self.pattern = Find.prev_pattern
self.hitnum = 0
self.hitcount = 0
self.find_now()
def __init__(self, *arg, _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,_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)
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, 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 is not None:
if hasattr(self, arg0):
getattr(self, arg0)()
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):
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):
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, types.ListType):
self.message.append(a)
else:
self.message.extend(a)
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)
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, name="cartoon", mono=None, _self=cmd):
Wizard.__init__(self,_self)
self.message = []
self.last = None
cmd.full_screen("off")
if not mono:
cmd.stereo("on")
if 'last' in saved:
self.last = saved['last']
self.launch(name)
def __init__(self, _self=cmd):
Wizard.__init__(self, _self)
self.pick_state = [0, 0, 0, 0]
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_int("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, *arg, dismiss=1, _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(dismiss)
def __init__(self, _self=cmd):
"""
Initialize PyMol to the wizard!
Parameters
----------
_self
"""
self.logic_handler = Logic.Logic_Handler(
pu.pymol_selection_to_atom_list('all'))
Wizard.__init__(self, _self)
self.set_wizard_style()
# reset gui selections:
self.cmd.unpick()
self.cmd.deselect()
self.cmd.set('mouse_selection_mode', 0)
##generate Menu drop down
### Pymols python interpreter will not be able to understand a reference to self. But we can find the Way back here via cmd.get_wizard.
### We can not use the __class__ attribute: The function will be passed as a string to the interface_Pymol Python interpreter. So its ars have to be strings themselves
self.update_menu()
##Settings
self.show_message = True
self.supress_prompt = False
self.quicksnapshot_nr = 1
self.last_hashes = {
'atoms': 0,
'selection': 0,
'restraints': 0,
'test_mode': 0
} # hashes to keep work of interface_Pymol: self.redraw only redraw things that actually changed\
self.check_result_dict = {
} # crd (check_results_dict) is an dict that can beused by the test mode to store information
self.check_results_mode = 0 # Check results mode indicates if we are using a special test mode at the moment.
self.tmp_cnt = 0 # The different check_opzimier_results functions indicate in whihc mode they are called
## Set up objs
self.cmd.set('retain_order') # NEVER CHANGE IDS OF ATOMS
self.pymol_molecule_objects = pu.create_pymol_objects_for_molecules(
) # Must be done before logic handler, because it changes atom ids!
if (len(self.cmd.get_object_list()) > 0):
self.cmd.delete(
self.cmd.get_object_list()[0]
) # Delete the object containing all molecules. If not all Molecules are doubled
## Update
self.redraw()
self.cmd.refresh_wizard()
self.cmd.viewing.reset()
def __init__(self):
Wizard.__init__(self)
# some attributes to do with picking
self.pick_count = 0
self.object_count = 0
self.object_prefix = "pw"
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, _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, selection='?pk1', _self=cmd):
Wizard.__init__(self, _self)
self.selection_mode = cmd.get_setting_int("mouse_selection_mode")
_self.set("mouse_selection_mode", 0)
self.identifiers = None
self.cursor = 0
self.label = ""
self.selename = _self.get_unused_name('_labeledit')
self.sele = '?' + self.selename
self.do_select(selection)
for (a, text) in [
('color', 'Label Color'),
('bg_color', 'Background Color'),
]:
m = self.menu[a] = [[2, text, '']]
for color in [
'default',
'front',
'back',
]:
m.append([
1, color, 'cmd.get_wizard().set_' + a + '("' + color + '")'
])
m += [
[0, '', ''],
[
1, 'all colors', lambda s='label_' + a: menu.by_rep_sub(
self.cmd, 'labels', s, self.sele)
],
]
self.menu['size'] = [[2, 'Label Size', '']] + [[
1, str(size), 'cmd.get_wizard().set_size(%d)' % size
] for size in (10, 14, 18, 24, 36)]
self.menu['bg_transparency'] = [
[2, 'Background Transparency', ''],
] + [[
1,
'%d%%' % (i),
'cmd.get_wizard().set_bg_transparency(%f)' % (i / 100.)
] for i in (0, 20, 40, 60, 80)]
self.menu['connector'] = [
[2, 'Connector', ''],
[1, 'Show', 'cmd.get_wizard().set_connector(1)'],
[1, 'Hide', 'cmd.get_wizard().set_connector(0)'],
]
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):
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):
Wizard.__init__(self, _self)
self.memory = 0
self.n_pair = 0
self.status = 0 # 0 node not selected, 1 node selected
self.message = None
self.selection_mode = cmd.get_setting_legacy("process_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):
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.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):
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):
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,_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, *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,*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): Wizard.__init__(self) self.viewer = design_viewer() self.resfile = Resfile() sess = cmd.get_session() base = "" for i in sess["names"]: if type(i) is ListType: base = i[0] if base != "": self.setDesigned(base) self.wiz_ros = wizard_rosetta()
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):
# 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)
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):
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):
# 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,_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, 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
