model_editor.py @ 0aeba4e

ticket-1094-headless

Last change on this file since 0aeba4e was c6dfb9f, checked in by krzywon, 7 years ago
Update the Sum\|Multi editor model selectors when a new user model is generated.
Property mode set to `100644`
File size: 43.1 KB

Line
1	'''
2	This module provides three model editor classes: the composite model editor,
3	the easy editor which provides a simple interface with tooltip help to enter
4	the parameters of the model and their default value and a panel to input a
5	function of y (usually the intensity). It also provides a drop down of
6	standard available math functions. Finally a full python editor panel for
7	complete customization is provided.
8
9	:TODO the writing of the file and name checking (and maybe some other
10	functions?) should be moved to a computational module which could be called
11	from a python script. Basically one just needs to pass the name,
12	description text and function text (or in the case of the composite editor
13	the names of the first and second model and the operator to be used).
14	'''
15
16	################################################################################
17	#This software was developed by the University of Tennessee as part of the
18	#Distributed Data Analysis of Neutron Scattering Experiments (DANSE)
19	#project funded by the US National Science Foundation.
20	#
21	#See the license text in license.txt
22	#
23	#copyright 2009, University of Tennessee
24	################################################################################
25	from __future__ import print_function
26
27	import wx
28	import sys
29	import os
30	import math
31	import re
32	import logging
33	import datetime
34
35	from wx.py.editwindow import EditWindow
36
37	from sas.sasgui.guiframe.documentation_window import DocumentationWindow
38
39	from .pyconsole import show_model_output, check_model
40
41	logger = logging.getLogger(__name__)
42
43	if sys.platform.count("win32") > 0:
44	FONT_VARIANT = 0
45	PNL_WIDTH = 450
46	PNL_HEIGHT = 320
47	else:
48	FONT_VARIANT = 1
49	PNL_WIDTH = 590
50	PNL_HEIGHT = 350
51	M_NAME = 'Model'
52	EDITOR_WIDTH = 800
53	EDITOR_HEIGTH = 735
54	PANEL_WIDTH = 500
55	_BOX_WIDTH = 55
56
57	def _delete_file(path):
58	"""
59	Delete file in the path
60	"""
61	try:
62	os.remove(path)
63	except:
64	raise
65
66
67	class TextDialog(wx.Dialog):
68	"""
69	Dialog for easy custom composite models. Provides a wx.Dialog panel
70	to choose two existing models (including pre-existing Plugin Models which
71	may themselves be composite models) as well as an operation on those models
72	(add or multiply) the resulting model will add a scale parameter for summed
73	models and a background parameter for a multiplied model.
74
75	The user also gives a brief help for the model in a description box and
76	must provide a unique name which is verified as unique before the new
77	model is saved.
78
79	This Dialog pops up for the user when they press 'Sum\|Multi(p1,p2)' under
80	'Plugin Model Operations' under 'Fitting' menu. This is currently called as
81	a Modal Dialog.
82
83	:TODO the built in compiler currently balks at when it tries to import
84	a model whose name contains spaces or symbols (such as + ... underscore
85	should be fine). Have fixed so the editor cannot save such a file name
86	but if a file is dropped in the plugin directory from outside this class
87	will create a file that cannot be compiled. Should add the check to
88	the write method or to the on_modelx method.
89
90	- PDB:April 5, 2015
91	"""
92	def __init__(self, parent=None, base=None, id=None, title='',
93	model_list=[], plugin_dir=None):
94	"""
95	This class is run when instatiated. The __init__ initializes and
96	calls the internal methods necessary. On exiting the wx.Dialog
97	window should be destroyed.
98	"""
99	wx.Dialog.__init__(self, parent=parent, id=id,
100	title=title, size=(PNL_WIDTH, PNL_HEIGHT))
101	self.parent = base
102	#Font
103	self.SetWindowVariant(variant=FONT_VARIANT)
104	# default
105	self.overwrite_name = False
106	self.plugin_dir = plugin_dir
107	self.model_list = model_list
108	self.model1_string = "sphere"
109	self.model2_string = "cylinder"
110	self.name = 'Sum' + M_NAME
111	self._notes = ''
112	self._operator = '+'
113	self._operator_choice = None
114	self.explanation = ''
115	self.explanationctr = None
116	self.type = None
117	self.name_sizer = None
118	self.name_tcl = None
119	self.desc_sizer = None
120	self.desc_tcl = None
121	self._selection_box = None
122	self.model1 = None
123	self.model2 = None
124	self.static_line_1 = None
125	self.ok_button = None
126	self.close_button = None
127	self._msg_box = None
128	self.msg_sizer = None
129	self.fname = None
130	self.cm_list = None
131	self.is_p1_custom = False
132	self.is_p2_custom = False
133	self._build_sizer()
134	self.model1_name = str(self.model1.GetValue())
135	self.model2_name = str(self.model2.GetValue())
136	self.good_name = True
137	self.fill_operator_combox()
138
139	def _layout_name(self):
140	"""
141	Do the layout for file/function name related widgets
142	"""
143	#container for new model name input
144	self.name_sizer = wx.BoxSizer(wx.HORIZONTAL)
145
146	#set up label and input box with tool tip and event handling
147	name_txt = wx.StaticText(self, -1, 'Function Name : ')
148	self.name_tcl = wx.TextCtrl(self, -1, value='MySumFunction')
149	self.name_tcl.Bind(wx.EVT_TEXT_ENTER, self.on_change_name)
150	hint_name = "Unique Sum/Multiply Model Function Name."
151	self.name_tcl.SetToolTipString(hint_name)
152
153	self.name_sizer.AddMany([(name_txt, 0, wx.LEFT \| wx.TOP, 10),
154	(self.name_tcl, -1,
155	wx.EXPAND \| wx.RIGHT \| wx.TOP \| wx.BOTTOM,
156	10)])
157
158
159	def _layout_description(self):
160	"""
161	Do the layout for description related widgets
162	"""
163	#container for new model description input
164	self.desc_sizer = wx.BoxSizer(wx.HORIZONTAL)
165
166	#set up description label and input box with tool tip and event handling
167	desc_txt = wx.StaticText(self, -1, 'Description (optional) : ')
168	self.desc_tcl = wx.TextCtrl(self, -1)
169	hint_desc = "Write a short description of this model function."
170	self.desc_tcl.SetToolTipString(hint_desc)
171
172	self.desc_sizer.AddMany([(desc_txt, 0, wx.LEFT \| wx.TOP, 10),
173	(self.desc_tcl, -1,
174	wx.EXPAND \| wx.RIGHT \| wx.TOP \| wx.BOTTOM,
175	10)])
176
177
178	def _layout_model_selection(self):
179	"""
180	Do the layout for model selection related widgets
181	"""
182	box_width = 195 # combobox width
183
184	#First set up main sizer for the selection
185	selection_box_title = wx.StaticBox(self, -1, 'Select',
186	size=(PNL_WIDTH - 30, 70))
187	self._selection_box = wx.StaticBoxSizer(selection_box_title,
188	wx.VERTICAL)
189
190	#Next create the help labels for the model selection
191	select_help_box = wx.BoxSizer(wx.HORIZONTAL)
192	model_string = " Model%s (p%s):"
193	select_help_box.Add(wx.StaticText(self, -1, model_string % (1, 1)),
194	0, 0)
195	select_help_box.Add((box_width - 25, 10), 0, 0)
196	select_help_box.Add(wx.StaticText(self, -1, model_string % (2, 2)),
197	0, 0)
198	self._selection_box.Add(select_help_box, 0, 0)
199
200	#Next create the actual selection box with 3 combo boxes
201	selection_box_choose = wx.BoxSizer(wx.HORIZONTAL)
202
203	self.model1 = wx.ComboBox(self, -1, style=wx.CB_READONLY)
204	wx.EVT_COMBOBOX(self.model1, -1, self.on_model1)
205	self.model1.SetMinSize((box_width * 5 / 6, -1))
206	self.model1.SetToolTipString("model1")
207
208	self._operator_choice = wx.ComboBox(self, -1, size=(50, -1),
209	style=wx.CB_READONLY)
210	wx.EVT_COMBOBOX(self._operator_choice, -1, self.on_select_operator)
211	operation_tip = "Add: +, Multiply: * "
212	self._operator_choice.SetToolTipString(operation_tip)
213
214	self.model2 = wx.ComboBox(self, -1, style=wx.CB_READONLY)
215	wx.EVT_COMBOBOX(self.model2, -1, self.on_model2)
216	self.model2.SetMinSize((box_width * 5 / 6, -1))
217	self.model2.SetToolTipString("model2")
218	self._set_model_list()
219
220	selection_box_choose.Add(self.model1, 0, 0)
221	selection_box_choose.Add((15, 10))
222	selection_box_choose.Add(self._operator_choice, 0, 0)
223	selection_box_choose.Add((15, 10))
224	selection_box_choose.Add(self.model2, 0, 0)
225	# add some space between labels and selection
226	self._selection_box.Add((20, 5), 0, 0)
227	self._selection_box.Add(selection_box_choose, 0, 0)
228
229	def _build_sizer(self):
230	"""
231	Build GUI with calls to _layout_name, _layout Description
232	and _layout_model_selection which each build a their portion of the
233	GUI.
234	"""
235	mainsizer = wx.BoxSizer(wx.VERTICAL) # create main sizer for dialog
236
237	# build fromm top by calling _layout_name and _layout_description
238	# and adding to main sizer
239	self._layout_name()
240	mainsizer.Add(self.name_sizer, 0, wx.EXPAND)
241	self._layout_description()
242	mainsizer.Add(self.desc_sizer, 0, wx.EXPAND)
243
244	# Add an explanation of dialog (short help)
245	self.explanationctr = wx.StaticText(self, -1, self.explanation)
246	self.fill_explanation_helpstring(self._operator)
247	mainsizer.Add(self.explanationctr, 0, wx.LEFT \| wx.EXPAND, 15)
248
249	# Add the selection box stuff with border and labels built
250	# by _layout_model_selection
251	self._layout_model_selection()
252	mainsizer.Add(self._selection_box, 0, wx.LEFT, 15)
253
254	# Add a space and horizontal line before the notification
255	#messages and the buttons at the bottom
256	mainsizer.Add((10, 10))
257	self.static_line_1 = wx.StaticLine(self, -1)
258	mainsizer.Add(self.static_line_1, 0, wx.EXPAND, 10)
259
260	# Add action status notification line (null at startup)
261	self._msg_box = wx.StaticText(self, -1, self._notes)
262	self.msg_sizer = wx.BoxSizer(wx.HORIZONTAL)
263	self.msg_sizer.Add(self._msg_box, 0, wx.LEFT, 0)
264	mainsizer.Add(self.msg_sizer, 0,
265	wx.LEFT \| wx.RIGHT \| wx.ADJUST_MINSIZE \| wx.BOTTOM, 10)
266
267	# Finally add the buttons (apply and close) on the bottom
268	# Eventually need to add help here
269	self.ok_button = wx.Button(self, wx.ID_OK, 'Apply')
270	_app_tip = "Save the new Model."
271	self.ok_button.SetToolTipString(_app_tip)
272	self.ok_button.Bind(wx.EVT_BUTTON, self.check_name)
273	self.help_button = wx.Button(self, -1, 'HELP')
274	_app_tip = "Help on composite model creation."
275	self.help_button.SetToolTipString(_app_tip)
276	self.help_button.Bind(wx.EVT_BUTTON, self.on_help)
277	self.close_button = wx.Button(self, wx.ID_CANCEL, 'Close')
278	sizer_button = wx.BoxSizer(wx.HORIZONTAL)
279	sizer_button.AddMany([((20, 20), 1, 0),
280	(self.ok_button, 0, 0),
281	(self.help_button, 0, 0),
282	(self.close_button, 0, wx.LEFT \| wx.RIGHT, 10)])
283	mainsizer.Add(sizer_button, 0, wx.EXPAND \| wx.BOTTOM \| wx.TOP, 10)
284
285	self.SetSizer(mainsizer)
286	self.Centre()
287
288	def on_change_name(self, event=None):
289	"""
290	Change name
291	"""
292	if event is not None:
293	event.Skip()
294	self.name_tcl.SetBackgroundColour('white')
295	self.Refresh()
296
297	def check_name(self, event=None):
298	"""
299	Check that proposed new model name is a valid Python module name
300	and that it does not already exist. If not show error message and
301	pink background in text box else call on_apply
302
303	:TODO this should be separated out from the GUI code. For that we
304	need to pass it the name (or if we want to keep the default name
305	option also need to pass the self._operator attribute) We just need
306	the function to return an error code that the name is good or if
307	not why (not a valid name, name exists already). The rest of the
308	error handling should be done in this module. so on_apply would then
309	start by checking the name and then either raise errors or do the
310	deed.
311	"""
312	#Get the function/file name
313	mname = M_NAME
314	self.on_change_name(None)
315	title = self.name_tcl.GetValue().lstrip().rstrip()
316	if title == '':
317	text = self._operator
318	if text.count('+') > 0:
319	mname = 'Sum'
320	else:
321	mname = 'Multi'
322	mname += M_NAME
323	title = mname
324	self.name = title
325	t_fname = title + '.py'
326
327	#First check if the name is a valid Python name
328	if re.match('^[A-Za-z0-9_]*$', title):
329	self.good_name = True
330	else:
331	self.good_name = False
332	msg = ("%s is not a valid Python name. Only alphanumeric \n" \
333	"and underscore allowed" % self.name)
334
335	#Now check if the name already exists
336	if not self.overwrite_name and self.good_name:
337	#Create list of existing model names for comparison
338	list_fnames = os.listdir(self.plugin_dir)
339	# fake existing regular model name list
340	m_list = [model + ".py" for model in self.model_list]
341	list_fnames.append(m_list)
342	if t_fname in list_fnames and title != mname:
343	self.good_name = False
344	msg = "Name exists already."
345
346	if not self.good_name:
347	self.name_tcl.SetBackgroundColour('pink')
348	info = 'Error'
349	wx.MessageBox(msg, info)
350	self._notes = msg
351	color = 'red'
352	self._msg_box.SetLabel(msg)
353	self._msg_box.SetForegroundColour(color)
354	return self.good_name
355	self.fname = os.path.join(self.plugin_dir, t_fname)
356	s_title = title
357	if len(title) > 20:
358	s_title = title[0:19] + '...'
359	self._notes = "Model function (%s) has been set! \n" % str(s_title)
360	self.good_name = True
361	self.on_apply(self.fname)
362	return self.good_name
363
364	def on_apply(self, path):
365	"""
366	This method is a misnomer - it is not bound to the apply button
367	event. Instead the apply button event goes to check_name which
368	then calls this method if the name of the new file is acceptable.
369
370	:TODO this should be bound to the apply button. The first line
371	should call the check_name method which itself should be in another
372	module separated from the the GUI modules.
373	"""
374	self.name_tcl.SetBackgroundColour('white')
375	try:
376	label = self.get_textnames()
377	fname = path
378	name1 = label[0]
379	name2 = label[1]
380	self.write_string(fname, name1, name2)
381	success = show_model_output(self, fname)
382	if success:
383	self.parent.update_custom_combo()
384	msg = self._notes
385	info = 'Info'
386	color = 'blue'
387	except:
388	msg = "Easy Sum/Multipy Plugin: Error occurred..."
389	info = 'Error'
390	color = 'red'
391	self._msg_box.SetLabel(msg)
392	self._msg_box.SetForegroundColour(color)
393	self._set_model_list()
394	if self.parent.parent is not None:
395	from sas.sasgui.guiframe.events import StatusEvent
396	wx.PostEvent(self.parent.parent, StatusEvent(status=msg,
397	info=info))
398
399	def on_help(self, event):
400	"""
401	Bring up the Composite Model Editor Documentation whenever
402	the HELP button is clicked.
403
404	Calls DocumentationWindow with the path of the location within the
405	documentation tree (after /doc/ ....". Note that when using old
406	versions of Wx (before 2.9) and thus not the release version of
407	installers, the help comes up at the top level of the file as
408	webbrowser does not pass anything past the # to the browser when it is
409	running "file:///...."
410
411	:param evt: Triggers on clicking the help button
412	"""
413
414	_TreeLocation = "user/sasgui/perspectives/fitting/fitting_help.html"
415	_PageAnchor = "#sum-multi-p1-p2"
416	_doc_viewer = DocumentationWindow(self, -1, _TreeLocation, _PageAnchor,
417	"Composite Model Editor Help")
418
419	def _set_model_list(self):
420	"""
421	Set the list of models
422	"""
423	# list of model names
424	# get regular models
425	main_list = self.model_list
426	# get custom models
427	self.update_cm_list()
428	# add custom models to model list
429	for name in self.cm_list:
430	if name not in main_list:
431	main_list.append(name)
432
433	if len(main_list) > 1:
434	main_list.sort()
435	self.model1.Clear()
436	self.model2.Clear()
437	for idx in range(len(main_list)):
438	self.model1.Append(str(main_list[idx]), idx)
439	self.model2.Append(str(main_list[idx]), idx)
440	self.model1.SetStringSelection(self.model1_string)
441	self.model2.SetStringSelection(self.model2_string)
442
443	def update_cm_list(self):
444	"""
445	Update custom model list
446	"""
447	cm_list = []
448	al_list = os.listdir(self.plugin_dir)
449	for c_name in al_list:
450	if c_name.split('.')[-1] == 'py' and \
451	c_name.split('.')[0] != '__init__':
452	name = str(c_name.split('.')[0])
453	cm_list.append(name)
454	self.cm_list = cm_list
455
456	def on_model1(self, event):
457	"""
458	Set model1
459	"""
460	event.Skip()
461	self.update_cm_list()
462	self.model1_name = str(self.model1.GetValue())
463	self.model1_string = self.model1_name
464	if self.model1_name in self.cm_list:
465	self.is_p1_custom = True
466	else:
467	self.is_p1_custom = False
468
469	def on_model2(self, event):
470	"""
471	Set model2
472	"""
473	event.Skip()
474	self.update_cm_list()
475	self.model2_name = str(self.model2.GetValue())
476	self.model2_string = self.model2_name
477	if self.model2_name in self.cm_list:
478	self.is_p2_custom = True
479	else:
480	self.is_p2_custom = False
481
482	def on_select_operator(self, event=None):
483	"""
484	On Select an Operator
485	"""
486	# For Mac
487	if event is not None:
488	event.Skip()
489	item = event.GetEventObject()
490	text = item.GetValue()
491	self.fill_explanation_helpstring(text)
492
493	def fill_explanation_helpstring(self, operator):
494	"""
495	Choose the equation to use depending on whether we now have
496	a sum or multiply model then create the appropriate string
497	"""
498	name = ''
499	if operator == '*':
500	name = 'Multi'
501	factor = 'background'
502	else:
503	name = 'Sum'
504	factor = 'scale_factor'
505
506	self._operator = operator
507	self.explanation = (" Plugin_model = scale_factor * (model_1 {} "
508	"model_2) + background").format(operator)
509	self.explanationctr.SetLabel(self.explanation)
510	self.name = name + M_NAME
511
512
513	def fill_operator_combox(self):
514	"""
515	fill the current combobox with the operator
516	"""
517	operator_list = ['+', '*']
518	for oper in operator_list:
519	pos = self._operator_choice.Append(str(oper))
520	self._operator_choice.SetClientData(pos, str(oper))
521	self._operator_choice.SetSelection(0)
522
523	def get_textnames(self):
524	"""
525	Returns model name string as list
526	"""
527	return [self.model1_name, self.model2_name]
528
529	def write_string(self, fname, model1_name, model2_name):
530	"""
531	Write and Save file
532	"""
533	self.fname = fname
534	description = self.desc_tcl.GetValue().lstrip().rstrip()
535	desc_line = ''
536	if description.strip() != '':
537	# Sasmodels generates a description for us. If the user provides
538	# their own description, add a line to overwrite the sasmodels one
539	desc_line = "\nmodel_info.description = '{}'".format(description)
540	name = os.path.splitext(os.path.basename(self.fname))[0]
541	output = SUM_TEMPLATE.format(name=name, model1=model1_name,
542	model2=model2_name, operator=self._operator, desc_line=desc_line)
543	with open(self.fname, 'w') as out_f:
544	out_f.write(output)
545
546	def compile_file(self, path):
547	"""
548	Compile the file in the path
549	"""
550	path = self.fname
551	show_model_output(self, path)
552
553	def delete_file(self, path):
554	"""
555	Delete file in the path
556	"""
557	_delete_file(path)
558
559
560	class EditorPanel(wx.ScrolledWindow):
561	"""
562	Simple Plugin Model function editor
563	"""
564	def __init__(self, parent, base, path, title, args, *kwds):
565	kwds['name'] = title
566	# kwds["size"] = (EDITOR_WIDTH, EDITOR_HEIGTH)
567	kwds["style"] = wx.FULL_REPAINT_ON_RESIZE
568	wx.ScrolledWindow.__init__(self, parent, args, *kwds)
569	self.SetScrollbars(1,1,1,1)
570	self.parent = parent
571	self.base = base
572	self.path = path
573	self.font = wx.SystemSettings_GetFont(wx.SYS_SYSTEM_FONT)
574	self.font.SetPointSize(10)
575	self.reader = None
576	self.name = 'untitled'
577	self.overwrite_name = False
578	self.is_2d = False
579	self.fname = None
580	self.main_sizer = None
581	self.name_sizer = None
582	self.name_hsizer = None
583	self.name_tcl = None
584	self.overwrite_cb = None
585	self.desc_sizer = None
586	self.desc_tcl = None
587	self.param_sizer = None
588	self.param_tcl = None
589	self.function_sizer = None
590	self.func_horizon_sizer = None
591	self.button_sizer = None
592	self.param_strings = ''
593	self.function_strings = ''
594	self._notes = ""
595	self._msg_box = None
596	self.msg_sizer = None
597	self.warning = ""
598	#This does not seem to be used anywhere so commenting out for now
599	# -- PDB 2/26/17
600	#self._description = "New Plugin Model"
601	self.function_tcl = None
602	self.math_combo = None
603	self.bt_apply = None
604	self.bt_close = None
605	#self._default_save_location = os.getcwd()
606	self._do_layout()
607
608
609
610	def _define_structure(self):
611	"""
612	define initial sizer
613	"""
614	#w, h = self.parent.GetSize()
615	self.main_sizer = wx.BoxSizer(wx.VERTICAL)
616	self.name_sizer = wx.BoxSizer(wx.VERTICAL)
617	self.name_hsizer = wx.BoxSizer(wx.HORIZONTAL)
618	self.desc_sizer = wx.BoxSizer(wx.VERTICAL)
619	self.param_sizer = wx.BoxSizer(wx.VERTICAL)
620	self.function_sizer = wx.BoxSizer(wx.VERTICAL)
621	self.func_horizon_sizer = wx.BoxSizer(wx.HORIZONTAL)
622	self.button_sizer = wx.BoxSizer(wx.HORIZONTAL)
623	self.msg_sizer = wx.BoxSizer(wx.HORIZONTAL)
624
625	def _layout_name(self):
626	"""
627	Do the layout for file/function name related widgets
628	"""
629	#title name [string]
630	name_txt = wx.StaticText(self, -1, 'Function Name : ')
631	self.overwrite_cb = wx.CheckBox(self, -1, "Overwrite existing plugin model of this name?", (10, 10))
632	self.overwrite_cb.SetValue(False)
633	self.overwrite_cb.SetToolTipString("Overwrite it if already exists?")
634	wx.EVT_CHECKBOX(self, self.overwrite_cb.GetId(), self.on_over_cb)
635	self.name_tcl = wx.TextCtrl(self, -1, size=(PANEL_WIDTH * 3 / 5, -1))
636	self.name_tcl.Bind(wx.EVT_TEXT_ENTER, self.on_change_name)
637	self.name_tcl.SetValue('')
638	self.name_tcl.SetFont(self.font)
639	hint_name = "Unique Model Function Name."
640	self.name_tcl.SetToolTipString(hint_name)
641	self.name_hsizer.AddMany([(self.name_tcl, 0, wx.LEFT \| wx.TOP, 0),
642	(self.overwrite_cb, 0, wx.LEFT, 20)])
643	self.name_sizer.AddMany([(name_txt, 0, wx.LEFT \| wx.TOP, 10),
644	(self.name_hsizer, 0,
645	wx.LEFT \| wx.TOP \| wx.BOTTOM, 10)])
646
647
648	def _layout_description(self):
649	"""
650	Do the layout for description related widgets
651	"""
652	#title name [string]
653	desc_txt = wx.StaticText(self, -1, 'Description (optional) : ')
654	self.desc_tcl = wx.TextCtrl(self, -1, size=(PANEL_WIDTH * 3 / 5, -1))
655	self.desc_tcl.SetValue('')
656	hint_desc = "Write a short description of the model function."
657	self.desc_tcl.SetToolTipString(hint_desc)
658	self.desc_sizer.AddMany([(desc_txt, 0, wx.LEFT \| wx.TOP, 10),
659	(self.desc_tcl, 0,
660	wx.LEFT \| wx.TOP \| wx.BOTTOM, 10)])
661	def _layout_param(self):
662	"""
663	Do the layout for parameter related widgets
664	"""
665	param_txt = wx.StaticText(self, -1, 'Fit Parameters NOT requiring' + \
666	' polydispersity (if any): ')
667
668	param_tip = "#Set the parameters NOT requiring polydispersity " + \
669	"and their initial values.\n"
670	param_tip += "#Example:\n"
671	param_tip += "A = 1\nB = 1"
672	#param_txt.SetToolTipString(param_tip)
673	newid = wx.NewId()
674	self.param_tcl = EditWindow(self, newid, wx.DefaultPosition,
675	wx.DefaultSize,
676	wx.CLIP_CHILDREN \| wx.SUNKEN_BORDER)
677	self.param_tcl.setDisplayLineNumbers(True)
678	self.param_tcl.SetToolTipString(param_tip)
679
680	self.param_sizer.AddMany([(param_txt, 0, wx.LEFT, 10),
681	(self.param_tcl, 1, wx.EXPAND \| wx.ALL, 10)])
682
683	# Parameters with polydispersity
684	pd_param_txt = wx.StaticText(self, -1, 'Fit Parameters requiring ' + \
685	'polydispersity (if any): ')
686
687	pd_param_tip = "#Set the parameters requiring polydispersity and " + \
688	"their initial values.\n"
689	pd_param_tip += "#Example:\n"
690	pd_param_tip += "C = 2\nD = 2"
691	newid = wx.NewId()
692	self.pd_param_tcl = EditWindow(self, newid, wx.DefaultPosition,
693	wx.DefaultSize,
694	wx.CLIP_CHILDREN \| wx.SUNKEN_BORDER)
695	self.pd_param_tcl.setDisplayLineNumbers(True)
696	self.pd_param_tcl.SetToolTipString(pd_param_tip)
697
698	self.param_sizer.AddMany([(pd_param_txt, 0, wx.LEFT, 10),
699	(self.pd_param_tcl, 1, wx.EXPAND \| wx.ALL, 10)])
700
701	def _layout_function(self):
702	"""
703	Do the layout for function related widgets
704	"""
705	function_txt = wx.StaticText(self, -1, 'Function(x) : ')
706	hint_function = "#Example:\n"
707	hint_function += "if x <= 0:\n"
708	hint_function += " y = A + B\n"
709	hint_function += "else:\n"
710	hint_function += " y = A + B * cos(2 * pi * x)\n"
711	hint_function += "return y\n"
712	math_txt = wx.StaticText(self, -1, '*Useful math functions: ')
713	math_combo = self._fill_math_combo()
714
715	newid = wx.NewId()
716	self.function_tcl = EditWindow(self, newid, wx.DefaultPosition,
717	wx.DefaultSize,
718	wx.CLIP_CHILDREN \| wx.SUNKEN_BORDER)
719	self.function_tcl.setDisplayLineNumbers(True)
720	self.function_tcl.SetToolTipString(hint_function)
721
722	self.func_horizon_sizer.Add(function_txt)
723	self.func_horizon_sizer.Add(math_txt, 0, wx.LEFT, 250)
724	self.func_horizon_sizer.Add(math_combo, 0, wx.LEFT, 10)
725
726	self.function_sizer.Add(self.func_horizon_sizer, 0, wx.LEFT, 10)
727	self.function_sizer.Add(self.function_tcl, 1, wx.EXPAND \| wx.ALL, 10)
728
729	def _layout_msg(self):
730	"""
731	Layout msg
732	"""
733	self._msg_box = wx.StaticText(self, -1, self._notes,
734	size=(PANEL_WIDTH, -1))
735	self.msg_sizer.Add(self._msg_box, 0, wx.LEFT, 10)
736
737	def _layout_button(self):
738	"""
739	Do the layout for the button widgets
740	"""
741	self.bt_apply = wx.Button(self, -1, "Apply", size=(_BOX_WIDTH, -1))
742	self.bt_apply.SetToolTipString("Save changes into the imported data.")
743	self.bt_apply.Bind(wx.EVT_BUTTON, self.on_click_apply)
744
745	self.bt_help = wx.Button(self, -1, "HELP", size=(_BOX_WIDTH, -1))
746	self.bt_help.SetToolTipString("Get Help For Model Editor")
747	self.bt_help.Bind(wx.EVT_BUTTON, self.on_help)
748
749	self.bt_close = wx.Button(self, -1, 'Close', size=(_BOX_WIDTH, -1))
750	self.bt_close.Bind(wx.EVT_BUTTON, self.on_close)
751	self.bt_close.SetToolTipString("Close this panel.")
752
753	self.button_sizer.AddMany([(self.bt_apply, 0,0),
754	(self.bt_help, 0, wx.LEFT \| wx.BOTTOM,15),
755	(self.bt_close, 0, wx.LEFT \| wx.RIGHT, 15)])
756
757	def _do_layout(self):
758	"""
759	Draw the current panel
760	"""
761	self._define_structure()
762	self._layout_name()
763	self._layout_description()
764	self._layout_param()
765	self._layout_function()
766	self._layout_msg()
767	self._layout_button()
768	self.main_sizer.AddMany([(self.name_sizer, 0, wx.EXPAND \| wx.ALL, 5),
769	(wx.StaticLine(self), 0,
770	wx.ALL \| wx.EXPAND, 5),
771	(self.desc_sizer, 0, wx.EXPAND \| wx.ALL, 5),
772	(wx.StaticLine(self), 0,
773	wx.ALL \| wx.EXPAND, 5),
774	(self.param_sizer, 1, wx.EXPAND \| wx.ALL, 5),
775	(wx.StaticLine(self), 0,
776	wx.ALL \| wx.EXPAND, 5),
777	(self.function_sizer, 2,
778	wx.EXPAND \| wx.ALL, 5),
779	(wx.StaticLine(self), 0,
780	wx.ALL \| wx.EXPAND, 5),
781	(self.msg_sizer, 0, wx.EXPAND \| wx.ALL, 5),
782	(self.button_sizer, 0, wx.ALIGN_RIGHT)])
783	self.SetSizer(self.main_sizer)
784	self.SetAutoLayout(True)
785
786	def _fill_math_combo(self):
787	"""
788	Fill up the math combo box
789	"""
790	self.math_combo = wx.ComboBox(self, -1, size=(100, -1),
791	style=wx.CB_READONLY)
792	for item in dir(math):
793	if item.count("_") < 1:
794	try:
795	exec "float(math.%s)" % item
796	self.math_combo.Append(str(item))
797	except Exception:
798	self.math_combo.Append(str(item) + "()")
799	self.math_combo.Bind(wx.EVT_COMBOBOX, self._on_math_select)
800	self.math_combo.SetSelection(0)
801	return self.math_combo
802
803	def _on_math_select(self, event):
804	"""
805	On math selection on ComboBox
806	"""
807	event.Skip()
808	label = self.math_combo.GetValue()
809	self.function_tcl.SetFocus()
810	# Put the text at the cursor position
811	pos = self.function_tcl.GetCurrentPos()
812	self.function_tcl.InsertText(pos, label)
813	# Put the cursor at appropriate position
814	length = len(label)
815	print(length)
816	if label[length-1] == ')':
817	length -= 1
818	f_pos = pos + length
819	self.function_tcl.GotoPos(f_pos)
820
821	def get_notes(self):
822	"""
823	return notes
824	"""
825	return self._notes
826
827	def on_change_name(self, event=None):
828	"""
829	Change name
830	"""
831	if event is not None:
832	event.Skip()
833	self.name_tcl.SetBackgroundColour('white')
834	self.Refresh()
835
836	def check_name(self):
837	"""
838	Check name if exist already
839	"""
840	self._notes = ''
841	self.on_change_name(None)
842	plugin_dir = self.path
843	list_fnames = os.listdir(plugin_dir)
844	# function/file name
845	title = self.name_tcl.GetValue().lstrip().rstrip()
846	self.name = title
847	t_fname = title + '.py'
848	if not self.overwrite_name:
849	if t_fname in list_fnames:
850	self.name_tcl.SetBackgroundColour('pink')
851	return False
852	self.fname = os.path.join(plugin_dir, t_fname)
853	s_title = title
854	if len(title) > 20:
855	s_title = title[0:19] + '...'
856	self._notes += "Model function name is set "
857	self._notes += "to %s. \n" % str(s_title)
858	return True
859
860	def on_over_cb(self, event):
861	"""
862	Set overwrite name flag on cb event
863	"""
864	if event is not None:
865	event.Skip()
866	cb_value = event.GetEventObject()
867	self.overwrite_name = cb_value.GetValue()
868
869	def on_click_apply(self, event):
870	"""
871	Changes are saved in data object imported to edit.
872
873	checks firs for valid name, then if it already exists then checks
874	that a function was entered and finally that if entered it contains at
875	least a return statement. If all passes writes file then tries to
876	compile. If compile fails or import module fails or run method fails
877	tries to remove any .py and pyc files that may have been created and
878	sets error message.
879
880	:todo this code still could do with a careful going over to clean
881	up and simplify. the non GUI methods such as this one should be removed
882	to computational code of SasView. Most of those computational methods
883	would be the same for both the simple editors.
884	"""
885	#must post event here
886	event.Skip()
887	name = self.name_tcl.GetValue().lstrip().rstrip()
888	info = 'Info'
889	msg = ''
890	result, check_err = '', ''
891	# Sort out the errors if occur
892	# First check for valid python name then if the name already exists
893	if not name or not bool(re.match('^[A-Za-z0-9_]*$', name)):
894	msg = '"%s" '%name
895	msg += "is not a valid model name. Name must not be empty and \n"
896	msg += "may include only alpha numeric or underline characters \n"
897	msg += "and no spaces"
898	elif self.check_name():
899	description = self.desc_tcl.GetValue()
900	param_str = self.param_tcl.GetText()
901	pd_param_str = self.pd_param_tcl.GetText()
902	func_str = self.function_tcl.GetText()
903	# No input for the model function
904	if func_str.lstrip().rstrip():
905	if func_str.count('return') > 0:
906	self.write_file(self.fname, name, description, param_str,
907	pd_param_str, func_str)
908	try:
909	result, msg = check_model(self.fname), None
910	except Exception:
911	import traceback
912	result, msg = None, "error building model"
913	check_err = "\n"+traceback.format_exc(limit=2)
914	else:
915	msg = "Error: The func(x) must 'return' a value at least.\n"
916	msg += "For example: \n\nreturn 2*x"
917	else:
918	msg = 'Error: Function is not defined.'
919	else:
920	msg = "Name exists already."
921
922	#
923	if self.base is not None and not msg:
924	self.base.update_custom_combo()
925
926	# Prepare the messagebox
927	if msg:
928	info = 'Error'
929	color = 'red'
930	self.overwrite_cb.SetValue(True)
931	self.overwrite_name = True
932	else:
933	self._notes = result
934	msg = "Successful! Please look for %s in Plugin Models."%name
935	msg += " " + self._notes
936	info = 'Info'
937	color = 'blue'
938	self._msg_box.SetLabel(msg)
939	self._msg_box.SetForegroundColour(color)
940	# Send msg to the top window
941	if self.base is not None:
942	from sas.sasgui.guiframe.events import StatusEvent
943	wx.PostEvent(self.base.parent,
944	StatusEvent(status=msg+check_err, info=info))
945	self.warning = msg
946
947	def write_file(self, fname, name, desc_str, param_str, pd_param_str, func_str):
948	"""
949	Write content in file
950
951	:param fname: full file path
952	:param desc_str: content of the description strings
953	:param param_str: content of params; Strings
954	:param pd_param_str: content of params requiring polydispersity; Strings
955	:param func_str: content of func; Strings
956	"""
957	out_f = open(fname, 'w')
958
959	out_f.write(CUSTOM_TEMPLATE % {
960	'name': name,
961	'title': 'User model for ' + name,
962	'description': desc_str,
963	'date': datetime.datetime.now().strftime('%YYYY-%mm-%dd'),
964	})
965
966	# Write out parameters
967	param_names = [] # to store parameter names
968	pd_params = []
969	out_f.write('parameters = [ \n')
970	out_f.write('# ["name", "units", default, [lower, upper], "type", "description"],\n')
971	for pname, pvalue, desc in self.get_param_helper(param_str):
972	param_names.append(pname)
973	out_f.write(" ['%s', '', %s, [-inf, inf], '', '%s'],\n"
974	% (pname, pvalue, desc))
975	for pname, pvalue, desc in self.get_param_helper(pd_param_str):
976	param_names.append(pname)
977	pd_params.append(pname)
978	out_f.write(" ['%s', '', %s, [-inf, inf], 'volume', '%s'],\n"
979	% (pname, pvalue, desc))
980	out_f.write(' ]\n')
981
982	# Write out function definition
983	out_f.write('def Iq(%s):\n' % ', '.join(['x'] + param_names))
984	out_f.write(' """Absolute scattering"""\n')
985	if "scipy." in func_str:
986	out_f.write(' import scipy')
987	if "numpy." in func_str:
988	out_f.write(' import numpy')
989	if "np." in func_str:
990	out_f.write(' import numpy as np')
991	for func_line in func_str.split('\n'):
992	out_f.write('%s%s\n' % (spaces4, func_line))
993	out_f.write('## uncomment the following if Iq works for vector x\n')
994	out_f.write('#Iq.vectorized = True\n')
995
996	# If polydisperse, create place holders for form_volume, ER and VR
997	if pd_params:
998	out_f.write('\n')
999	out_f.write(CUSTOM_TEMPLATE_PD % {'args': ', '.join(pd_params)})
1000
1001	# Create place holder for Iqxy
1002	out_f.write('\n')
1003	out_f.write('#def Iqxy(%s):\n' % ', '.join(["x", "y"] + param_names))
1004	out_f.write('# """Absolute scattering of oriented particles."""\n')
1005	out_f.write('# ...\n')
1006	out_f.write('# return oriented_form(x, y, args)\n')
1007	out_f.write('## uncomment the following if Iqxy works for vector x, y\n')
1008	out_f.write('#Iqxy.vectorized = True\n')
1009
1010	out_f.close()
1011
1012	def get_param_helper(self, param_str):
1013	"""
1014	yield a sequence of name, value pairs for the parameters in param_str
1015
1016	Parameters can be defined by one per line by name=value, or multiple
1017	on the same line by separating the pairs by semicolon or comma. The
1018	value is optional and defaults to "1.0".
1019	"""
1020	for line in param_str.replace(';', ',').split('\n'):
1021	for item in line.split(','):
1022	defn, desc = item.split('#', 1) if '#' in item else (item, '')
1023	name, value = defn.split('=', 1) if '=' in defn else (defn, '1.0')
1024	if name:
1025	yield [v.strip() for v in (name, value, desc)]
1026
1027	def set_function_helper(self, line):
1028	"""
1029	Get string in line to define the local params
1030
1031	:param line: one line of string got from the param_str
1032	"""
1033	params_str = ''
1034	spaces = ' '#8spaces
1035	items = line.split(";")
1036	for item in items:
1037	name = item.split("=")[0].lstrip().rstrip()
1038	params_str += spaces + "%s = self.params['%s']\n" % (name, name)
1039	return params_str
1040
1041	def get_warning(self):
1042	"""
1043	Get the warning msg
1044	"""
1045	return self.warning
1046
1047	def on_help(self, event):
1048	"""
1049	Bring up the New Plugin Model Editor Documentation whenever
1050	the HELP button is clicked.
1051
1052	Calls DocumentationWindow with the path of the location within the
1053	documentation tree (after /doc/ ....". Note that when using old
1054	versions of Wx (before 2.9) and thus not the release version of
1055	installers, the help comes up at the top level of the file as
1056	webbrowser does not pass anything past the # to the browser when it is
1057	running "file:///...."
1058
1059	:param evt: Triggers on clicking the help button
1060	"""
1061
1062	_TreeLocation = "user/sasgui/perspectives/fitting/fitting_help.html"
1063	_PageAnchor = "#new-plugin-model"
1064	_doc_viewer = DocumentationWindow(self, -1, _TreeLocation, _PageAnchor,
1065	"Plugin Model Editor Help")
1066
1067	def on_close(self, event):
1068	"""
1069	leave data as it is and close
1070	"""
1071	self.parent.Show(False)#Close()
1072	event.Skip()
1073
1074	class EditorWindow(wx.Frame):
1075	"""
1076	Editor Window
1077	"""
1078	def __init__(self, parent, base, path, title,
1079	size=(EDITOR_WIDTH, EDITOR_HEIGTH), args, *kwds):
1080	"""
1081	Init
1082	"""
1083	kwds["title"] = title
1084	kwds["size"] = size
1085	wx.Frame.__init__(self, parent=None, args, *kwds)
1086	self.parent = parent
1087	self.panel = EditorPanel(parent=self, base=parent,
1088	path=path, title=title)
1089	self.Show(True)
1090	wx.EVT_CLOSE(self, self.on_close)
1091
1092	def on_close(self, event):
1093	"""
1094	On close event
1095	"""
1096	self.Show(False)
1097	#if self.parent is not None:
1098	# self.parent.new_model_frame = None
1099	#self.Destroy()
1100
1101	## Templates for plugin models
1102
1103	CUSTOM_TEMPLATE = '''\
1104	r"""
1105	Definition
1106	----------
1107
1108	Calculates %(name)s.
1109
1110	%(description)s
1111
1112	References
1113	----------
1114
1115	Authorship and Verification
1116	---------------------------
1117
1118	* Author: --- Date: %(date)s
1119	* Last Modified by: --- Date: %(date)s
1120	* Last Reviewed by: --- Date: %(date)s
1121	"""
1122
1123	from math import *
1124	from numpy import inf
1125
1126	name = "%(name)s"
1127	title = "%(title)s"
1128	description = """%(description)s"""
1129
1130	'''
1131
1132	CUSTOM_TEMPLATE_PD = '''\
1133	def form_volume(%(args)s):
1134	"""
1135	Volume of the particles used to compute absolute scattering intensity
1136	and to weight polydisperse parameter contributions.
1137	"""
1138	return 0.0
1139
1140	def ER(%(args)s):
1141	"""
1142	Effective radius of particles to be used when computing structure factors.
1143
1144	Input parameters are vectors ranging over the mesh of polydispersity values.
1145	"""
1146	return 0.0
1147
1148	def VR(%(args)s):
1149	"""
1150	Volume ratio of particles to be used when computing structure factors.
1151
1152	Input parameters are vectors ranging over the mesh of polydispersity values.
1153	"""
1154	return 1.0
1155	'''
1156
1157	SUM_TEMPLATE = """
1158	from sasmodels.core import load_model_info
1159	from sasmodels.sasview_model import make_model_from_info
1160
1161	model_info = load_model_info('{model1}{operator}{model2}')
1162	model_info.name = '{name}'{desc_line}
1163	Model = make_model_from_info(model_info)
1164	"""
1165	if __name__ == "__main__":
1166	main_app = wx.App()
1167	main_frame = TextDialog(id=1, model_list=["SphereModel", "CylinderModel"],
1168	plugin_dir='../fitting/plugin_models')
1169	main_frame.ShowModal()
1170	main_app.MainLoop()

Note: See TracBrowser for help on using the repository browser.

SasView

source: sasview/src/sas/sasgui/perspectives/calculator/model_editor.py @ 0aeba4e

Download in other formats: