def do_delete(self, line):
"""
PERMANENTLY DELETES A NODE
Syntax:
delete <subset>
"""
deleted = 0
cmd = Command(line)
if cmd.get(0) is None:
return print(
"Can't delete all machines at once. It's for your own good")
for node in self.inventory.find_nodes(cmd.get(0)):
print("About to PERMANENTLY DELETE THIS NODE: \n{node}".format(
node=colour_output(str(node))))
answer = None
while answer not in ("yes", "no"):
sys.stdout.write("Proceed ? (yes|no): ")
answer = input()
if answer == "yes":
print("Deleting")
self.driver.delete(node)
deleted += 1
else:
print("Skipping")
print("Deleted {num} nodes".format(num=deleted))
def complete_kill(self, text, line, begidx, endidx):
"""
Auto-complete for k8s pods killing
"""
cmd = Command(line)
namespace = cmd.get(1)
if len(cmd) == 1 or (len(cmd) == 2 and not cmd.finished):
return filter_text_insensitive(self.k8s_inventory.find_namespaces(), namespace)
else:
op = cmd.get(2)
return filter_text_insensitive(self.k8s_inventory.find_deployments(namespace), op)
def complete_pods(self, text, line, begidx, endidx):
"""
Auto-complete for k8s pods
"""
cmd = Command(line)
namespace = cmd.get(1)
if len(cmd) == 1 or (len(cmd) == 2 and not cmd.finished):
return filter_text_insensitive(self.k8s_inventory.find_namespaces(), namespace)
else:
payload = cmd.get(2)
if op == "namespace":
return filter_text_insensitive(self.k8s_inventory.find_namespaces(), payload)
return []
def do_pods(self, line):
"""
List pods
Syntax:
pods namespace [selector]
Selector is in the kubernetes native form: app=something,ver=1
"""
cmd = Command(line)
namespace = cmd.get(0)
selector = cmd.get(1)
for pod in self.k8s_inventory.find_pods(namespace=namespace,
selector=selector):
print(colour_output(str(pod)))
def do_pods_for_deployment(self, line):
"""
List pods for a deployment
Syntax:
pods_for_deployment namespace deployment-name
"""
cmd = Command(line)
namespace = cmd.get(0)
deployment_name = cmd.get(1)
for pod in self.k8s_inventory.find_pods(
namespace=namespace,
deployment_name=deployment_name,
):
print(colour_output(str(pod)))
def add_state_loop(factor=1,
pause=2.0,
first=-1,
last=-1,
loop=1,
start=0,
_self=cmd):
cmd = _self
if not start:
start = cmd.get_movie_length() + 1
loop = int(loop)
fps = float(cmd.get('movie_fps'))
n_state = cmd.count_states()
duration = (pause) + (factor * n_state) / fps
n_frame = int(round(fps * duration))
if n_frame > 0:
cmd.mset("1 x%d" % n_frame, start, freeze=1)
cmd.mview("store", start, state=1, freeze=1)
cmd.mview("store",
start + (n_frame * pause * 0.5) / duration,
state=1,
freeze=1)
cmd.mview("store",
start + n_state * factor +
(n_frame * pause * 0.5) / duration,
state=n_state,
freeze=1)
cmd.mview("store", start + n_frame - 1, state=n_state, freeze=1)
if loop and (start == 1):
cmd.mview("interpolate", wrap=1)
else:
cmd.mview("interpolate")
cmd.frame(start)
def add_nutate(duration=8.0,
angle=30.0,
spiral=0,
loop=1,
offset=0,
phase=0,
shift=math.pi / 2.0,
start=0,
_self=cmd):
cmd = _self
if not start:
start = cmd.get_movie_length() + 1
duration = float(duration)
angle = float(angle)
spiral = int(spiral)
loop = int(loop)
fps = float(cmd.get('movie_fps'))
n_frame = int(round(fps * duration))
if n_frame > 0:
cmd.mset("1 x%d" % n_frame, start, freeze=1)
for index in range(0, n_frame):
if spiral > 0:
sp_angle = angle * float(index + 1) / n_frame
elif spiral < 0:
sp_angle = angle * (1.0 - float(index + 1) / n_frame)
else:
sp_angle = angle
ang_cur = math.pi * phase / 180.0 + (2 * math.pi * index) / n_frame
x_rot = sp_angle * math.sin(ang_cur) / 2
y_rot = sp_angle * math.sin(ang_cur + shift) / 2
cmd.turn('x', x_rot)
cmd.turn('y', y_rot)
cmd.mview('store', start + index, freeze=1)
cmd.turn('y', -y_rot)
cmd.turn('x', -x_rot)
def _nutate_sub(start_frame, stop_frame, angle=15.0, spiral=0, loop=1,
offset=0, phase=0, shift=math.pi/2.0, _self=cmd):
cmd = _self
angle = float(angle)
spiral = int(spiral)
loop = int(loop)
fps = float(cmd.get('movie_fps'))
duration = (stop_frame - start_frame)/fps
n_frame = int(round(fps * duration))
if n_frame > 0:
for index in range(0,n_frame):
if spiral>0:
sp_angle = angle*float(index+1)/n_frame
elif spiral<0:
sp_angle = angle*(1.0 - float(index+1)/n_frame)
else:
sp_angle = angle
ang_cur = math.pi*phase/180.0 + (2*math.pi*index)/n_frame
x_rot = sp_angle * math.sin(ang_cur)/2
y_rot = sp_angle * math.sin(ang_cur+shift)/2
cmd.turn('x',x_rot)
cmd.turn('y',y_rot)
cmd.mview('store',start_frame+index,freeze=1)
cmd.turn('y',-y_rot)
cmd.turn('x',-x_rot)
def add_nutate(duration=8.0, angle=30.0, spiral=0, loop=1,
offset=0, phase=0, shift=math.pi/2.0, start=0,
_self=cmd):
cmd = _self
if not start:
start = cmd.get_movie_length()+1
duration = float(duration)
angle = float(angle)
spiral = int(spiral)
loop = int(loop)
fps = float(cmd.get('movie_fps'))
n_frame = int(round(fps * duration))
if n_frame > 0:
cmd.mset("1 x%d"%n_frame,start,freeze=1)
for index in range(0,n_frame):
if spiral>0:
sp_angle = angle*float(index+1)/n_frame
elif spiral<0:
sp_angle = angle*(1.0 - float(index+1)/n_frame)
else:
sp_angle = angle
ang_cur = math.pi*phase/180.0 + (2*math.pi*index)/n_frame
x_rot = sp_angle * math.sin(ang_cur)/2
y_rot = sp_angle * math.sin(ang_cur+shift)/2
cmd.turn('x',x_rot)
cmd.turn('y',y_rot)
cmd.mview('store',start+index,freeze=1)
cmd.turn('y',-y_rot)
cmd.turn('x',-x_rot)
def _nutate_sub(start_frame,
stop_frame,
angle=15.0,
spiral=0,
loop=1,
offset=0,
phase=0,
shift=math.pi / 2.0,
_self=cmd):
cmd = _self
angle = float(angle)
spiral = int(spiral)
loop = int(loop)
fps = float(cmd.get('movie_fps'))
duration = (stop_frame - start_frame) / fps
n_frame = int(round(fps * duration))
if n_frame > 0:
for index in range(0, n_frame):
if spiral > 0:
sp_angle = angle * float(index + 1) / n_frame
elif spiral < 0:
sp_angle = angle * (1.0 - float(index + 1) / n_frame)
else:
sp_angle = angle
ang_cur = math.pi * phase / 180.0 + (2 * math.pi * index) / n_frame
x_rot = sp_angle * math.sin(ang_cur) / 2
y_rot = sp_angle * math.sin(ang_cur + shift) / 2
cmd.turn('x', x_rot)
cmd.turn('y', y_rot)
cmd.mview('store', start_frame + index, freeze=1)
cmd.turn('y', -y_rot)
cmd.turn('x', -x_rot)
def add_roll(duration=12.0,loop=1,axis='y',start=0,_self=cmd):
cmd = _self
if not start:
start = cmd.get_movie_length()+1
duration = float(duration)
fps = float(cmd.get('movie_fps'))
n_frame = int(round(fps * duration))
if n_frame > 0:
cmd.mset("1 x%d"%n_frame,start,freeze=1)
cmd.mview("store",start,power=1,freeze=1)
cmd.turn(axis,120)
cmd.mview("store",start+n_frame/3,power=1,freeze=1)
cmd.turn(axis,120)
cmd.mview("store",start+(2*n_frame)/3,power=1,freeze=1)
if loop:
if (start == 1):
cmd.mview("interpolate",wrap=1)
cmd.turn(axis,120)
cmd.mview("store",start+n_frame-1,power=1,freeze=1)
cmd.turn(axis,120)
else:
adjustment = 360.0/n_frame
cmd.turn(axis,120 - adjustment)
cmd.mview("store",start+n_frame-1,power=1,freeze=1)
cmd.mview("interpolate")
cmd.turn(axis,adjustment)
else:
cmd.turn(axis,120)
cmd.mview("store",start+n_frame-1,power=1,freeze=1)
cmd.mview("interpolate")
cmd.frame(start)
def add_roll(duration=12.0, loop=1, axis='y', start=0, _self=cmd):
cmd = _self
if not start:
start = cmd.get_movie_length() + 1
duration = float(duration)
fps = float(cmd.get('movie_fps'))
n_frame = int(round(fps * duration))
if n_frame > 0:
cmd.mset("1 x%d" % n_frame, start, freeze=1)
cmd.mview("store", start, power=1, freeze=1)
cmd.turn(axis, 120)
cmd.mview("store", start + n_frame / 3, power=1, freeze=1)
cmd.turn(axis, 120)
cmd.mview("store", start + (2 * n_frame) / 3, power=1, freeze=1)
if loop:
if (start == 1):
cmd.mview("interpolate", wrap=1)
cmd.turn(axis, 120)
cmd.mview("store", start + n_frame - 1, power=1, freeze=1)
cmd.turn(axis, 120)
else:
adjustment = 360.0 / n_frame
cmd.turn(axis, 120 - adjustment)
cmd.mview("store", start + n_frame - 1, power=1, freeze=1)
cmd.mview("interpolate")
cmd.turn(axis, adjustment)
else:
cmd.turn(axis, 120)
cmd.mview("store", start + n_frame - 1, power=1, freeze=1)
cmd.mview("interpolate")
cmd.frame(start)
def do_deletepod(self, line):
"""
Delete a pod
Syntax:
delete pod-number
To show the pod numbers, run cached_pods.
Executes `kubectl delete pod <name>`
"""
cmd = Command(line)
pod_num = cmd.get(0)
if pod_num is None:
return
try:
pod_num = int(pod_num)
except ValueError:
return
# find the pod
pod = None
for p in self.k8s_inventory.last_pods:
if p.num == pod_num:
pod = p
break
if pod is None:
return print("Pod number not found.")
print("Will delete '%s' from namespace '%s'" % (pod.name, pod.namespace))
self.k8s_inventory.delete_pod(pod.namespace, pod.name)
def do_kill(self, line):
"""
Kill a pod
Syntax:
kill pod-number
To show the pod numbers, run cached_pods.
Executes `sudo docker kill <container ID> for each container in the pod`
"""
cmd = Command(line)
pod_num = cmd.get(0)
if pod_num is None:
return
try:
pod_num = int(pod_num)
except ValueError:
return
# find the pod
pod = None
for p in self.k8s_inventory.last_pods:
if p.num == pod_num:
pod = p
break
if pod is None:
return print("Pod number not found.")
if pod.state == 'Pending':
return print("Can't kill pod on pending state")
# In case we are setup to delete pods, instead of SSHing
if self.k8s_inventory.delete_pods:
ans = False
while ans not in ("y", "n"):
print(
"Will delete pod '%s' through kubernetes API. Continue ? [y/n]: "
% pod)
ans = six.moves.input().lower()
if ans != "y":
return print("Cancelling")
self.k8s_inventory.k8s_client.delete_pods([pod])
return
# find the node
node = self.inventory.get_node_by_ip(pod.host_ip)
if node is None:
return print("Node not found")
# execute docker of the pod on the node
for container_id in pod.container_ids:
cmd = self.executor.get_kill_command(
container_id.replace("docker://", ""))
ans = False
while ans not in ("y", "n"):
print("Will execute '%s' on %s. Continue ? [y/n]: " %
(cmd, node))
ans = six.moves.input().lower()
if ans != "y":
return print("Cancelling")
self.execute(cmd, [node])
def add_blank(duration=12.0,start=0,_self=cmd):
cmd = _self
if not start:
start = cmd.get_movie_length()+1
duration = float(duration)
fps = float(cmd.get('movie_fps'))
n_frame = int(round(fps * duration))
if n_frame > 0:
cmd.mset("1 x%d"%n_frame,start)
cmd.frame(start)
def add_blank(duration=12.0, start=0, _self=cmd):
cmd = _self
if not start:
start = cmd.get_movie_length() + 1
duration = float(duration)
fps = float(cmd.get('movie_fps'))
n_frame = int(round(fps * duration))
if n_frame > 0:
cmd.mset("1 x%d" % n_frame, start)
cmd.frame(start)
def do_deployments(self, line):
"""
List deployments
Syntax:
deployments [namespace=default]
"""
cmd = Command(line)
namespace = cmd.get(0)
for deploy in self.k8s_inventory.find_deployments(
namespace=namespace, ):
print(deploy)
def do_start(self, line):
"""
Brings up a subset of machines
"""
cmd = Command(line)
for node in self.find_nodes(cmd.get(0)):
print("Starting %s" % (node))
try:
self.driver.start(node)
except Exception as e:
print(e)
def do_stop(self, line):
"""
Brings down a subset of machines
"""
cmd = Command(line)
for node in self.inventory.find_nodes(cmd.get(0)):
print("Stopping %s" % (node))
try:
self.driver.stop(node)
except Exception as e:
print(e)
def get(remoteobj, hexdump=False):
"""Receives remote object specified by unicode or utf-8-encoded
string that is passed through HP encoding.
Currently only BINARY transfer is supported.
Returns data or prints hexdump if told so.
"""
remoteobj = tohp(remoteobj)
data = cmd.get(remoteobj)
if hexdump == False:
return data
else:
print hpstr.tohexstr(data)
return
def do_exec(self, line, prefix=None):
"""
Executes a line in shell on specified boxes
Syntax:
exec <subset> "command -to 'execute'"
"""
cmd = Command(line)
nodes = self.inventory.find_nodes(cmd.get(0))
command = " ".join(cmd.args[1:])
if prefix is not None:
command = prefix + " " + command
self.execute(command, nodes)
def do_nodes(self, line):
"""
Prints the nodes about a particular node
Syntax:
nodes [<subset>]
"""
cmd = Command(line)
query = cmd.get(0)
if query:
extras = {query: "blue"}
else:
extras = {}
for node in self.inventory.find_nodes(query):
print(colour_output(str(node), extras))
def do_kill(self, line):
"""
Kill a pod
Syntax:
kill pod-number
To show the pod numbers, run cached_pods.
Executes `sudo docker kill <container ID> for each container in the pod`
"""
cmd = Command(line)
pod_num = cmd.get(0)
if pod_num is None:
return
try:
pod_num = int(pod_num)
except ValueError:
return
# find the pod
pod = None
for p in self.k8s_inventory.last_pods:
if p.num == pod_num:
pod = p
break
if pod is None:
return print("Pod number not found.")
if pod.state.lower() != 'running':
return print("Can't kill pod with state", pod.state)
# check with the user
ans = False
while ans not in ("y", "n"):
print(
"Will delete pod '%s' through kubernetes API. Continue ? [y/n]: "
% pod)
ans = input().lower()
if ans != "y":
return print("Cancelling")
# kill the pod
success = self.executor.kill_pod(pod, self.inventory)
if success:
print("Done")
else:
print(colored("Could not delete the pod", "red"))
def do_kill(self, line):
"""
Kill a pod
Syntax:
kill pod-number
To show the pod numbers, run cached_pods.
Executes `sudo docker kill <container ID> for each container in the pod`
"""
cmd = Command(line)
pod_num = cmd.get(0)
if pod_num is None:
return
try:
pod_num = int(pod_num)
except ValueError:
return
# find the pod
pod = None
for p in self.k8s_inventory.last_pods:
if p.num == pod_num:
pod = p
break
if pod is None:
return print("Pod number not found.")
# find the node
node = self.inventory.get_node_by_ip(pod.host_ip)
if node is None:
return print("Node not found")
# execute docker of the pod on the node
cmd_template = "sudo docker kill %s"
for container_id in pod.container_ids:
cmd = cmd_template % container_id.replace("docker://", "")
ans = False
while ans not in ("y", "n"):
print("Will execute '%s' on %s. Continue ? [y/n]: " %
(cmd, node))
ans = six.moves.input().lower()
if ans != "y":
return print("Cancelling")
self.execute(cmd, [node])
def add_rock(duration=8.0,angle=30.0,loop=1,axis='y',start=0,_self=cmd):
cmd = _self
if not start:
start = cmd.get_movie_length()+1
duration = float(duration)
angle=float(angle)
loop=int(loop)
fps = float(cmd.get('movie_fps'))
n_frame = int(round(fps * duration))
if n_frame > 0:
cmd.mset("1 x%d"%n_frame,start,freeze=1)
cmd.turn(axis,angle/2.0)
cmd.mview("store",start+n_frame/4,power=-1,freeze=1)
cmd.turn(axis,-angle)
cmd.mview("store",start+(3*n_frame)/4,power=-1,freeze=1)
if loop and (start == 1):
cmd.mview("interpolate",wrap=1)
else:
cmd.mview("interpolate")
cmd.frame(start)
def add_state_loop(factor=1,pause=2.0,first=-1,last=-1,loop=1,start=0,_self=cmd):
cmd = _self
if not start:
start = cmd.get_movie_length() + 1
loop = int(loop)
fps = float(cmd.get('movie_fps'))
n_state = cmd.count_states()
duration = (pause) + (factor * n_state) / fps
n_frame = int(round(fps * duration))
if n_frame > 0:
cmd.mset("1 x%d"%n_frame, start, freeze=1)
cmd.mview("store",start, state=1, freeze=1)
cmd.mview("store",start + (n_frame * pause * 0.5) / duration, state=1, freeze=1)
cmd.mview("store",start + n_state * factor + (n_frame * pause * 0.5) / duration, state=n_state, freeze=1)
cmd.mview("store",start + n_frame-1, state=n_state, freeze=1)
if loop and (start == 1):
cmd.mview("interpolate",wrap=1)
else:
cmd.mview("interpolate")
cmd.frame(start)
def add_rock(duration=8.0, angle=30.0, loop=1, axis='y', start=0, _self=cmd):
cmd = _self
if not start:
start = cmd.get_movie_length() + 1
duration = float(duration)
angle = float(angle)
loop = int(loop)
fps = float(cmd.get('movie_fps'))
n_frame = int(round(fps * duration))
if n_frame > 0:
cmd.mset("1 x%d" % n_frame, start, freeze=1)
cmd.turn(axis, angle / 2.0)
cmd.mview("store", start + n_frame / 4, power=-1, freeze=1)
cmd.turn(axis, -angle)
cmd.mview("store", start + (3 * n_frame) / 4, power=-1, freeze=1)
if loop and (start == 1):
cmd.mview("interpolate", wrap=1)
else:
cmd.mview("interpolate")
cmd.frame(start)
def save(filename, selection='(all)', state=-1, format='', ref='',
ref_state=-1, quiet=1, partial=0,_self=cmd):
'''
DESCRIPTION
"save" writes content to a file.
USAGE
save filename [, selection [, state [, format ]]]
ARGUMENTS
filename = string: file path to be written
selection = string: atoms to save {default: (all)}
state = integer: state to save {default: -1 (current state)}
PYMOL API
cmd.save(string file, string selection, int state, string format)
NOTES
The file format is automatically chosen if the extesion is one of
the supported output formats: pdb, pqr, mol, pkl, mmd, mmod, pov,
png, pse, aln, obj, mtl, or wrl.
If the file format is not recognized, then a PDB file is written
by default.
For molecular files and where applicable and supported:
* if state = -1 (default), then only the current state is written.
* if state = 0, then a multi-state output file is written.
SEE ALSO
load, get_model
'''
# preprocess selection
input_selection = selection
selection = selector.process(input_selection)
#
r = DEFAULT_ERROR
lc_filename=string.lower(filename)
if format=='':
format = 'unknown'
# refactor following if/elif cascade
# with a dictionary lookup
if re.search("\.pdb$|\.ent$",lc_filename):
format = 'pdb'
elif re.search("\.pqr$",lc_filename):
format = 'pqr'
elif re.search("\.mol$",lc_filename):
format = 'mol'
elif re.search("\.sdf$",lc_filename):
format = 'sdf'
elif re.search("\.pkl$",lc_filename):
format = 'pkl'
elif re.search("\.pkl$",lc_filename):
format = 'pkla'
elif re.search("\.mmd$",lc_filename):
format = 'mmod'
elif re.search("\.out$",lc_filename):
format = 'mmod'
elif re.search("\.dat$",lc_filename):
format = 'mmod'
elif re.search("\.mmod$",lc_filename):
format = 'mmod'
elif re.search("\.pmo$",lc_filename):
format = 'pmo'
elif re.search("\.pov$",lc_filename):
format = 'pov'
elif re.search("\.png$",lc_filename):
format = 'png'
elif re.search("\.pse$|\.psw$",lc_filename):
format = 'pse'
elif re.search("\.aln$",lc_filename):
format = 'aln'
elif re.search("\.fasta$",lc_filename):
format = 'fasta'
elif re.search("\.obj$",lc_filename):
format = 'obj'
elif re.search("\.mtl$",lc_filename):
format = 'mtl'
elif re.search("\.wrl$",lc_filename):
format = 'wrl'
elif re.search("\.idtf$",lc_filename):
format = 'idtf'
elif re.search("\.mol2$",lc_filename):
format = 'mol2'
else:
format = str(format)
if format=='unknown':
if not quiet:
print " Save-Warning: Unrecognized file type -- defaulting to PDB format."
format='pdb'
filename = _self.exp_path(filename)
if format=='pdb': # standard PDB file
f=open(filename,"w")
if f:
st = ''
try:
_self.lock(_self)
st = _cmd.get_pdb(_self._COb,"("+str(selection)+")",int(state)-1,0,
str(ref),int(ref_state)-1,int(quiet))
if st != None:
r = DEFAULT_SUCCESS
finally:
_self.unlock(r,_self=_self)
f.write(st)
f.close()
if not quiet:
print " Save: wrote \""+filename+"\"."
elif format=='aln':
st = ''
try:
_self.lock(_self)
st = _cmd.get_seq_align_str(_self._COb,str(selection),int(state)-1,0,int(quiet))
if st != None:
r = DEFAULT_SUCCESS
finally:
_self.unlock(r,_self)
if st!=None:
f=open(filename,"w")
f.write(st)
f.close()
if not quiet:
print " Save: wrote \""+filename+"\"."
else:
r = DEFAULT_ERROR
elif format=='fasta':
st = _self.get_fastastr(selection)
if st != None:
r = DEFAULT_SUCCESS
f=open(filename,"w")
f.write(st)
f.close()
if not quiet:
print " Save: wrote \""+filename+"\"."
else:
r = DEFAULT_ERROR
elif format=='pqr': # PQR (modified PDB file)
f=open(filename,"w")
if f:
st = ''
try:
_self.lock(_self)
st = _cmd.get_pdb(_self._COb,"("+str(selection)+")",int(state)-1,1,
str(ref),int(ref_state)-1,int(quiet))
if st != None:
r = DEFAULT_SUCCESS
finally:
_self.unlock(r,_self)
f.write(st)
f.close()
if not quiet:
print " Save: wrote \""+filename+"\"."
elif format=='pkl': # python binary
io.pkl.toFile(_self.get_model(selection,state,ref,ref_state),filename)
r = DEFAULT_SUCCESS
if not quiet:
print " Save: wrote \""+filename+"\"."
elif format=='pkla': # ascii override
io.pkl.toFile(_self.get_model(selection,state,ref,ref_state),filename,bin=0)
r = DEFAULT_SUCCESS
if not quiet:
print " Save: wrote \""+filename+"\"."
elif format=='pse': # PyMOL session
filename = filename.replace("\\","/") # always use unix-like path separators
_self.set("session_file",filename,quiet=1)
if '(' in input_selection: # ignore selections
input_selection=''
if not quiet:
print " Save: Please wait -- writing session file..."
io.pkl.toFile(_self.get_session(str(input_selection),int(partial),int(quiet)),filename)
r = DEFAULT_SUCCESS
if not quiet:
print " Save: wrote \""+filename+"\"."
elif format=='mmod': # macromodel
io.mmd.toFile(_self.get_model(selection,state,ref,ref_state),filename)
r = DEFAULT_SUCCESS
if not quiet:
print " Save: wrote \""+filename+"\"."
elif format=='sdf':
state = int(state)
if state==0:
first_state = 1
last_state = cmd.count_states(selection)
else:
first_state = state
last_state = state
sdf = SDF(filename,'w')
for state in range(first_state, last_state+1):
rec = SDFRec(io.mol.toList(_self.get_model(selection,state,ref,ref_state))
+ ["$$$$\n"])
sdf.write(rec)
r = DEFAULT_SUCCESS
if not quiet:
print " Save: wrote %d states to \"%s\"."%(1+last_state-first_state,filename)
elif format=='mol':
io.mol.toFile(_self.get_model(selection,state,ref,ref_state),filename)
r = DEFAULT_SUCCESS
if not quiet:
print " Save: wrote \""+filename+"\"."
elif format=="mol2":
state = int(state)
if state==0:
first_state = 1
last_state = cmd.count_states(selection)
else:
first_state = state
last_state = state
recList=[]
for state in range(first_state, last_state+1):
# assign_atom_types selection, format [ mol2, macromodel ], state, quiet
assign_atom_types(selection, "mol2", state, 1, _self)
recList.extend(io.mol2.toList(_self.get_model(selection,state,ref,ref_state),selection=selection,state=state))
m = MOL2(cmd=cmd)
m.strToFile(recList,filename)
r = DEFAULT_SUCCESS
if not quiet:
print " Save: wrote %d states to \"%s\"."%(1+last_state-first_state,filename)
elif format=='png':
r = _self.png(filename,quiet=quiet)
# refactor below to lift repeated code
elif format=='pov':
tup = _self.get_povray()
f=open(filename,"w")
f.write(tup[0])
f.write(tup[1])
f.flush()
f.close()
if not quiet:
print " Save: wrote \""+filename+"\"."
r = DEFAULT_SUCCESS
elif format=='obj':
tup = _self.get_mtl_obj()
f=open(filename,"w")
f.write(tup[1])
f.flush()
f.close()
r = DEFAULT_SUCCESS
elif format=='mtl':
tup = _self.get_mtl_obj()
f=open(filename,"w")
f.write(tup[0])
f.flush()
f.close()
r = DEFAULT_SUCCESS
elif format=='wrl':
txt = _self.get_vrml()
f=open(filename,"w")
f.write(txt)
f.flush()
f.close()
if not quiet:
print " Save: wrote \""+filename+"\"."
r = DEFAULT_SUCCESS
elif format=='idtf':
tup = _self.get_idtf()
f=open(filename,"w")
f.write(tup[0]);
f.write(tup[1]);
f.flush()
f.close()
if not quiet:
fov = float(cmd.get("field_of_view"))
dist = cmd.get_view()[11]
print " 3Daac=%3.1f, 3Droll=0, 3Dc2c=0 0 1, 3Droo=%1.2f, 3Dcoo=0 0 %1.2f"%(fov,-dist,dist)
print " Save: wrote \""+filename+"\"."
r = DEFAULT_SUCCESS
if _self._raising(r,_self): raise QuietException
return r
def add_scenes(names=None,
pause=8.0,
cut=0.0,
loop=1,
rock=-1,
period=8.0,
animate=-1,
start=0,
_self=cmd):
cmd = _self
if not start:
start = cmd.get_movie_length() + 1
animate = float(animate)
pause = float(pause)
period = float(period)
if period > pause:
period = pause
rock = int(rock)
if animate < 0:
animate = float(cmd.get("scene_animation_duration"))
if names == None:
names = cmd.get_scene_list()
elif cmd.is_str(names):
names = cmd.safe_alpha_list_eval(names)
n_scene = len(names)
duration = n_scene * (pause + animate)
fps = float(cmd.get('movie_fps'))
n_frame = int(round(fps * duration))
if not loop:
act_n_frame = int(round(fps * (duration - animate)))
else:
act_n_frame = n_frame
if rock < 0:
sweep_mode = int(cmd.get('sweep_mode'))
elif rock:
sweep_mode = rock - 1
else:
sweep_mode = 0
if n_frame > 0:
cmd.mset("1 x%d" % act_n_frame, start, freeze=1)
cnt = 0
for scene in names:
frame = start + int((cnt * n_frame) / n_scene)
cmd.mview("store", frame, scene=scene, freeze=1)
if rock:
cmd.mview("interpolate", cut=cut, wrap=0)
sweep_first = frame + 1
sweep_last = start + int(pause * fps +
(cnt * n_frame) / n_scene) - 1
if sweep_last > act_n_frame:
sweep_last = act_n_frame
n_sweep_frame = sweep_last - sweep_first + 1
if n_sweep_frame > 0:
if sweep_mode == 1: # x-axis rock
_rock(sweep_mode,
'x',
sweep_first,
sweep_last,
period,
pause,
_self=_self)
elif sweep_mode < 3: # y-axis rock
_rock(sweep_mode,
'y',
sweep_first,
sweep_last,
period,
pause,
_self=_self)
elif sweep_mode == 3:
_nutate(sweep_mode,
sweep_first,
sweep_last,
period,
pause,
_self=_self)
frame = start + int(pause * fps + (cnt * n_frame) / n_scene)
if frame <= act_n_frame:
if sweep_mode != 3:
cmd.mview("store", frame, scene=scene, freeze=1)
cnt = cnt + 1
cmd.mview("interpolate", cut=cut, wrap=loop)
if rock:
cmd.mview("smooth")
cmd.frame(start)
def add_scenes(names=None, pause=8.0, cut=0.0, loop=1,
rock=-1, period=8.0, animate=-1, start=0,
_self=cmd):
cmd = _self
if not start:
start = cmd.get_movie_length()+1
animate = float(animate)
pause = float(pause)
period = float(period)
if period>pause:
period = pause
rock = int(rock)
if animate<0:
animate = float(cmd.get("scene_animation_duration"))
if names == None:
names = cmd.get_scene_list()
elif cmd.is_str(names):
names = cmd.safe_alpha_list_eval(names)
n_scene = len(names)
duration = n_scene*(pause+animate)
fps = float(cmd.get('movie_fps'))
n_frame = int(round(fps * duration))
if not loop:
act_n_frame = int(round(fps * (duration - animate)))
else:
act_n_frame = n_frame
if rock<0:
sweep_mode = int(cmd.get('sweep_mode'))
elif rock:
sweep_mode = rock - 1
else:
sweep_mode = 0
if n_frame > 0:
cmd.mset("1 x%d"%act_n_frame,start,freeze=1)
cnt = 0
for scene in names:
frame = start+int((cnt*n_frame)/n_scene)
cmd.mview("store",frame,scene=scene,freeze=1)
if rock:
cmd.mview("interpolate",cut=cut,wrap=0)
sweep_first = frame + 1
sweep_last = start + int(pause*fps+(cnt*n_frame)/n_scene) - 1
if sweep_last > act_n_frame:
sweep_last = act_n_frame
n_sweep_frame = sweep_last - sweep_first + 1
if n_sweep_frame > 0:
if sweep_mode==1: # x-axis rock
_rock(sweep_mode, 'x', sweep_first, sweep_last,
period, pause, _self=_self)
elif sweep_mode<3: # y-axis rock
_rock(sweep_mode, 'y', sweep_first, sweep_last,
period, pause, _self=_self)
elif sweep_mode == 3:
_nutate(sweep_mode, sweep_first, sweep_last,
period, pause, _self=_self)
frame = start+int(pause*fps+(cnt*n_frame)/n_scene)
if frame <= act_n_frame:
if sweep_mode!=3:
cmd.mview("store",frame,scene=scene,freeze=1)
cnt = cnt + 1
cmd.mview("interpolate",cut=cut,wrap=loop)
if rock:
cmd.mview("smooth")
cmd.frame(start)
async def process_cmd(self, substr, msg, privilege_level):
(left, right) = utils.separate_left_word(substr)
cmd_to_execute = cmd.get(self._cmd_dict, left, privilege_level)
await cmd_to_execute(self, right, msg, privilege_level)
return
def save(filename,
selection='(all)',
state=-1,
format='',
ref='',
ref_state=-1,
quiet=1,
partial=0,
_self=cmd):
'''
DESCRIPTION
"save" writes content to a file.
USAGE
save filename [, selection [, state [, format ]]]
ARGUMENTS
filename = string: file path to be written
selection = string: atoms to save {default: (all)}
state = integer: state to save {default: -1 (current state)}
PYMOL API
cmd.save(string file, string selection, int state, string format)
NOTES
The file format is automatically chosen if the extesion is one of
the supported output formats: pdb, pqr, mol, pkl, mmd, mmod, pov,
png, pse, aln, obj, mtl, or wrl.
If the file format is not recognized, then a PDB file is written
by default.
For molecular files and where applicable and supported:
* if state = -1 (default), then only the current state is written.
* if state = 0, then a multi-state output file is written.
SEE ALSO
load, get_model
'''
# preprocess selection
input_selection = selection
selection = selector.process(input_selection)
#
r = DEFAULT_ERROR
lc_filename = string.lower(filename)
if format == '':
format = 'unknown'
# refactor following if/elif cascade
# with a dictionary lookup
if re.search("\.pdb$|\.ent$", lc_filename):
format = 'pdb'
elif re.search("\.pqr$", lc_filename):
format = 'pqr'
elif re.search("\.mol$", lc_filename):
format = 'mol'
elif re.search("\.sdf$", lc_filename):
format = 'sdf'
elif re.search("\.pkl$", lc_filename):
format = 'pkl'
elif re.search("\.pkl$", lc_filename):
format = 'pkla'
elif re.search("\.mmd$", lc_filename):
format = 'mmod'
elif re.search("\.out$", lc_filename):
format = 'mmod'
elif re.search("\.dat$", lc_filename):
format = 'mmod'
elif re.search("\.mmod$", lc_filename):
format = 'mmod'
elif re.search("\.pmo$", lc_filename):
format = 'pmo'
elif re.search("\.pov$", lc_filename):
format = 'pov'
elif re.search("\.png$", lc_filename):
format = 'png'
elif re.search("\.pse$|\.psw$", lc_filename):
format = 'pse'
elif re.search("\.aln$", lc_filename):
format = 'aln'
elif re.search("\.fasta$", lc_filename):
format = 'fasta'
elif re.search("\.obj$", lc_filename):
format = 'obj'
elif re.search("\.mtl$", lc_filename):
format = 'mtl'
elif re.search("\.wrl$", lc_filename):
format = 'wrl'
elif re.search("\.idtf$", lc_filename):
format = 'idtf'
elif re.search("\.mol2$", lc_filename):
format = 'mol2'
else:
format = str(format)
if format == 'unknown':
if not quiet:
print " Save-Warning: Unrecognized file type -- defaulting to PDB format."
format = 'pdb'
filename = _self.exp_path(filename)
if format == 'pdb': # standard PDB file
f = open(filename, "w")
if f:
st = ''
try:
_self.lock(_self)
st = _cmd.get_pdb(_self._COb, "(" + str(selection) + ")",
int(state) - 1, 0, str(ref),
int(ref_state) - 1, int(quiet))
if st != None:
r = DEFAULT_SUCCESS
finally:
_self.unlock(r, _self=_self)
f.write(st)
f.close()
if not quiet:
print " Save: wrote \"" + filename + "\"."
elif format == 'aln':
st = ''
try:
_self.lock(_self)
st = _cmd.get_seq_align_str(_self._COb, str(selection),
int(state) - 1, 0, int(quiet))
if st != None:
r = DEFAULT_SUCCESS
finally:
_self.unlock(r, _self)
if st != None:
f = open(filename, "w")
f.write(st)
f.close()
if not quiet:
print " Save: wrote \"" + filename + "\"."
else:
r = DEFAULT_ERROR
elif format == 'fasta':
st = _self.get_fastastr(selection)
if st != None:
r = DEFAULT_SUCCESS
f = open(filename, "w")
f.write(st)
f.close()
if not quiet:
print " Save: wrote \"" + filename + "\"."
else:
r = DEFAULT_ERROR
elif format == 'pqr': # PQR (modified PDB file)
f = open(filename, "w")
if f:
st = ''
try:
_self.lock(_self)
st = _cmd.get_pdb(_self._COb, "(" + str(selection) + ")",
int(state) - 1, 1, str(ref),
int(ref_state) - 1, int(quiet))
if st != None:
r = DEFAULT_SUCCESS
finally:
_self.unlock(r, _self)
f.write(st)
f.close()
if not quiet:
print " Save: wrote \"" + filename + "\"."
elif format == 'pkl': # python binary
io.pkl.toFile(_self.get_model(selection, state, ref, ref_state),
filename)
r = DEFAULT_SUCCESS
if not quiet:
print " Save: wrote \"" + filename + "\"."
elif format == 'pkla': # ascii override
io.pkl.toFile(_self.get_model(selection, state, ref, ref_state),
filename,
bin=0)
r = DEFAULT_SUCCESS
if not quiet:
print " Save: wrote \"" + filename + "\"."
elif format == 'pse': # PyMOL session
filename = filename.replace(
"\\", "/") # always use unix-like path separators
_self.set("session_file", filename, quiet=1)
if '(' in input_selection: # ignore selections
input_selection = ''
if not quiet:
print " Save: Please wait -- writing session file..."
io.pkl.toFile(
_self.get_session(str(input_selection), int(partial),
int(quiet)), filename)
r = DEFAULT_SUCCESS
if not quiet:
print " Save: wrote \"" + filename + "\"."
elif format == 'mmod': # macromodel
io.mmd.toFile(_self.get_model(selection, state, ref, ref_state),
filename)
r = DEFAULT_SUCCESS
if not quiet:
print " Save: wrote \"" + filename + "\"."
elif format == 'sdf':
state = int(state)
if state == 0:
first_state = 1
last_state = cmd.count_states(selection)
else:
first_state = state
last_state = state
sdf = SDF(filename, 'w')
for state in range(first_state, last_state + 1):
rec = SDFRec(
io.mol.toList(
_self.get_model(selection, state, ref, ref_state)) +
["$$$$\n"])
sdf.write(rec)
r = DEFAULT_SUCCESS
if not quiet:
print " Save: wrote %d states to \"%s\"." % (
1 + last_state - first_state, filename)
elif format == 'mol':
io.mol.toFile(_self.get_model(selection, state, ref, ref_state),
filename)
r = DEFAULT_SUCCESS
if not quiet:
print " Save: wrote \"" + filename + "\"."
elif format == "mol2":
state = int(state)
if state == 0:
first_state = 1
last_state = cmd.count_states(selection)
else:
first_state = state
last_state = state
recList = []
for state in range(first_state, last_state + 1):
# assign_atom_types selection, format [ mol2, macromodel ], state, quiet
assign_atom_types(selection, "mol2", state, 1, _self)
recList.extend(
io.mol2.toList(_self.get_model(selection, state, ref,
ref_state),
selection=selection,
state=state))
m = MOL2(cmd=cmd)
m.strToFile(recList, filename)
r = DEFAULT_SUCCESS
if not quiet:
print " Save: wrote %d states to \"%s\"." % (
1 + last_state - first_state, filename)
elif format == 'png':
r = _self.png(filename, quiet=quiet)
# refactor below to lift repeated code
elif format == 'pov':
tup = _self.get_povray()
f = open(filename, "w")
f.write(tup[0])
f.write(tup[1])
f.flush()
f.close()
if not quiet:
print " Save: wrote \"" + filename + "\"."
r = DEFAULT_SUCCESS
elif format == 'obj':
tup = _self.get_mtl_obj()
f = open(filename, "w")
f.write(tup[1])
f.flush()
f.close()
r = DEFAULT_SUCCESS
elif format == 'mtl':
tup = _self.get_mtl_obj()
f = open(filename, "w")
f.write(tup[0])
f.flush()
f.close()
r = DEFAULT_SUCCESS
elif format == 'wrl':
txt = _self.get_vrml()
f = open(filename, "w")
f.write(txt)
f.flush()
f.close()
if not quiet:
print " Save: wrote \"" + filename + "\"."
r = DEFAULT_SUCCESS
elif format == 'idtf':
tup = _self.get_idtf()
f = open(filename, "w")
f.write(tup[0])
f.write(tup[1])
f.flush()
f.close()
if not quiet:
fov = float(cmd.get("field_of_view"))
dist = cmd.get_view()[11]
print " 3Daac=%3.1f, 3Droll=0, 3Dc2c=0 0 1, 3Droo=%1.2f, 3Dcoo=0 0 %1.2f" % (
fov, -dist, dist)
print " Save: wrote \"" + filename + "\"."
r = DEFAULT_SUCCESS
if _self._raising(r, _self): raise QuietException
return r
def save(filename, selection='(all)', state=-1, format='', ref='',
ref_state=-1, quiet=1, partial=0,_self=cmd):
'''
DESCRIPTION
"save" writes content to a file.
USAGE
save filename [, selection [, state [, format ]]]
ARGUMENTS
filename = string: file path to be written
selection = string: atoms to save {default: (all)}
state = integer: state to save {default: -1 (current state)}
PYMOL API
cmd.save(string file, string selection, int state, string format)
NOTES
The file format is automatically chosen if the extesion is one of
the supported output formats: pdb, pqr, mol, sdf, pkl, pkla, mmd, out,
dat, mmod, pmo, pov, png, pse, psw, aln, fasta, obj, mtl, wrl, dae, idtf,
or mol2.
If the file format is not recognized, then a PDB file is written
by default.
For molecular files and where applicable and supported:
* if state = -1 (default), then only the current state is written.
* if state = 0, then a multi-state output file is written.
SEE ALSO
load, get_model
'''
import cPickle
import gzip
do_gzip = False
# preprocess selection
input_selection = selection
selection = selector.process(input_selection)
#
r = DEFAULT_ERROR
lc_filename=string.lower(filename)
if format=='':
format = 'unknown'
# refactor following if/elif cascade
# with a dictionary lookup
if re.search("\.pdb$|\.ent$",lc_filename):
format = 'pdb'
elif re.search("\.cif$",lc_filename):
format = 'cif'
elif re.search("\.pqr$",lc_filename):
format = 'pqr'
elif re.search("\.mol$",lc_filename):
format = 'mol'
elif re.search("\.sdf$",lc_filename):
format = 'sdf'
elif re.search("\.pkl$",lc_filename):
format = 'pkl'
elif re.search("\.xyz$",lc_filename):
format = 'xyz'
elif re.search("\.mmd$",lc_filename):
format = 'mmod'
elif re.search("\.out$",lc_filename):
format = 'mmod'
elif re.search("\.dat$",lc_filename):
format = 'mmod'
elif re.search("\.mmod$",lc_filename):
format = 'mmod'
elif re.search("\.pmo$",lc_filename):
format = 'pmo'
elif re.search("\.pov$",lc_filename):
format = 'pov'
elif re.search("\.png$",lc_filename):
format = 'png'
elif re.search("\.pse$|\.psw$",lc_filename):
format = 'pse'
elif re.search("\.pze$|\.pzw$",lc_filename):
do_gzip = True
format = 'pse'
elif re.search("\.aln$",lc_filename):
format = 'aln'
elif re.search("\.fasta$",lc_filename):
format = 'fasta'
elif re.search("\.obj$",lc_filename):
format = 'obj'
elif re.search("\.mtl$",lc_filename):
format = 'mtl'
elif re.search("\.wrl$",lc_filename):
format = 'wrl'
elif re.search("\.dae$",lc_filename):
format = 'dae'
elif re.search("\.idtf$",lc_filename):
format = 'idtf'
elif re.search("\.mol2$",lc_filename):
format = 'mol2'
else:
format = str(format)
if format=='unknown':
if not quiet:
print " Save-Warning: Unrecognized file type -- defaulting to PDB format."
format='pdb'
filename = _self.exp_path(filename)
if format=='pdb': # standard PDB file
f=open(filename,"w")
if f:
st = ''
try:
_self.lock(_self)
st = _cmd.get_pdb(_self._COb,"("+str(selection)+")",int(state)-1,0,
str(ref),int(ref_state)-1,int(quiet))
if st != None:
r = DEFAULT_SUCCESS
finally:
_self.unlock(r,_self=_self)
f.write(st)
f.close()
if not quiet:
print " Save: wrote \""+filename+"\"."
if format=='cif': # mmCIF
with open(filename, "w") as f:
st = get_cifstr(selection, state, int(quiet), _self=_self)
f.write(st)
r = DEFAULT_SUCCESS
if not quiet:
print " Save: wrote \""+filename+"\"."
elif format=='aln':
st = ''
try:
_self.lock(_self)
st = _cmd.get_seq_align_str(_self._COb,str(selection),int(state)-1,0,int(quiet))
if st != None:
r = DEFAULT_SUCCESS
finally:
_self.unlock(r,_self)
if st!=None:
f=open(filename,"w")
f.write(st)
f.close()
if not quiet:
print " Save: wrote \""+filename+"\"."
else:
r = DEFAULT_ERROR
elif format=='fasta':
st = _self.get_fastastr(selection)
if st != None:
r = DEFAULT_SUCCESS
f=open(filename,"w")
f.write(st)
f.close()
if not quiet:
print " Save: wrote \""+filename+"\"."
else:
r = DEFAULT_ERROR
elif format=='pqr': # PQR (modified PDB file)
f=open(filename,"w")
if f:
st = ''
try:
_self.lock(_self)
st = _cmd.get_pdb(_self._COb,"("+str(selection)+")",int(state)-1,1,
str(ref),int(ref_state)-1,int(quiet))
if st != None:
r = DEFAULT_SUCCESS
finally:
_self.unlock(r,_self)
f.write(st)
f.close()
if not quiet:
print " Save: wrote \""+filename+"\"."
elif format=='pkl': # python binary
io.pkl.toFile(_self.get_model(selection,state,ref,ref_state),filename)
r = DEFAULT_SUCCESS
if not quiet:
print " Save: wrote \""+filename+"\"."
elif format=='pkla': # ascii override
io.pkl.toFile(_self.get_model(selection,state,ref,ref_state),filename,bin=0)
r = DEFAULT_SUCCESS
if not quiet:
print " Save: wrote \""+filename+"\"."
elif format=='pse': # PyMOL session
filename = filename.replace("\\","/") # always use unix-like path separators
_self.set("session_file",filename,quiet=1)
if '(' in input_selection: # ignore selections
input_selection=''
if not quiet:
print " Save: Please wait -- writing session file..."
session = _self.get_session(input_selection, partial, quiet)
contents = cPickle.dumps(session, 1)
with (gzip.open if do_gzip else open)(filename, 'wb') as handle:
handle.write(contents)
r = DEFAULT_SUCCESS
if not quiet:
print " Save: wrote \""+filename+"\"."
elif format=='mmod': # macromodel
io.mmd.toFile(_self.get_model(selection,state,ref,ref_state),filename)
r = DEFAULT_SUCCESS
if not quiet:
print " Save: wrote \""+filename+"\"."
elif format == 'xyz':
state = int(state)
buf = []
for i, (selection, state) in enumerate(
pymol.selecting.objsele_state_iter(selection, state)):
n_atoms_i = len(buf)
buf.append('') # natoms (deferred)
buf.append('') # comment
n = _self.iterate_state(state, selection,
'_buf.append("%s %f %f %f" % (elem, x, y, z))',
space={'_buf': buf})
buf[n_atoms_i] = str(n)
with open(filename, 'w') as handle:
print >> handle, '\n'.join(buf)
if not quiet:
print " Save: wrote %d states to \"%s\"." % (i + 1, filename)
elif format=='sdf':
state = int(state)
sdf = SDF(filename,'w')
for i, (selection, state) in enumerate(
pymol.selecting.objsele_state_iter(selection, state)):
rec = SDFRec(io.mol.toList(_self.get_model(selection,state,ref,ref_state))
+ ["$$$$\n"])
sdf.write(rec)
r = DEFAULT_SUCCESS
if not quiet:
print " Save: wrote %d states to \"%s\"." % (i + 1, filename)
elif format=='mol':
io.mol.toFile(_self.get_model(selection,state,ref,ref_state),filename)
r = DEFAULT_SUCCESS
if not quiet:
print " Save: wrote \""+filename+"\"."
elif format=="mol2":
state = int(state)
recList = []
entrycount = 0
for osele, ostate in pymol.selecting.objsele_state_iter(selection, state):
assign_atom_types(osele, "mol2", ostate, 1, _self)
recList.extend(io.mol2.toList(_self.get_model(osele,
ostate, ref, ref_state), selection=osele, state=ostate))
entrycount += 1
m = MOL2(cmd=cmd)
m.strToFile(recList,filename)
r = DEFAULT_SUCCESS
if not quiet:
print ' Save: wrote %d entries to "%s".' % (entrycount, filename)
elif format=='png':
r = _self.png(filename,quiet=quiet)
# refactor below to lift repeated code
elif format=='pov':
tup = _self.get_povray()
f=open(filename,"w")
f.write(tup[0])
f.write(tup[1])
f.flush()
f.close()
if not quiet:
print " Save: wrote \""+filename+"\"."
r = DEFAULT_SUCCESS
elif format=='obj':
tup = _self.get_mtl_obj()
f=open(filename,"w")
f.write(tup[1])
f.flush()
f.close()
r = DEFAULT_SUCCESS
elif format=='mtl':
tup = _self.get_mtl_obj()
f=open(filename,"w")
f.write(tup[0])
f.flush()
f.close()
r = DEFAULT_SUCCESS
elif format=='wrl':
txt = _self.get_vrml()
f=open(filename,"w")
f.write(txt)
f.flush()
f.close()
if not quiet:
print " Save: wrote \""+filename+"\"."
r = DEFAULT_SUCCESS
elif format=='dae':
txt = _self.get_collada()
if txt:
with open(filename, "w") as f:
f.write(txt)
if not quiet:
print " Save: wrote \""+filename+"\"."
r = DEFAULT_SUCCESS
elif not quiet:
print " COLLADA export failed, no file written"
elif format=='idtf':
tup = _self.get_idtf()
f=open(filename,"w")
f.write(tup[0]);
f.write(tup[1]);
f.flush()
f.close()
if not quiet:
fov = float(cmd.get("field_of_view"))
dist = cmd.get_view()[11]
print " 3Daac=%3.1f, 3Droll=0, 3Dc2c=0 0 1, 3Droo=%1.2f, 3Dcoo=0 0 %1.2f"%(fov,-dist,dist)
print " Save: wrote \""+filename+"\"."
r = DEFAULT_SUCCESS
if _self._raising(r,_self): raise QuietException
return r
