code string | signature string | docstring string | loss_without_docstring float64 | loss_with_docstring float64 | factor float64 |
|---|---|---|---|---|---|
def I(x,y):
xout, iout = _fun.integrate_data(x, y, autozero=autozero)
print("Total =", scale*iout[-1])
return xout, scale*iout
if fyname==1: fyname = "$"+str(scale)+"\\times \\int dx$"
manipulate_shown_data(I, fxname=None, fyname=fyname, **kwargs) | def integrate_shown_data(scale=1, fyname=1, autozero=0, **kwargs) | Numerically integrates the data visible on the current/specified axes using
scale*fun.integrate_data(x,y). Modifies the visible data using
manipulate_shown_data(**kwargs)
autozero is the number of data points used to estimate the background
for subtraction. If autozero = 0, no background subtraction is performed. | 7.442212 | 6.049955 | 1.230127 |
# get the axes
if input_axes == "gca": a1 = _pylab.gca()
else: a1 = input_axes
# get the xlimits
xmin, xmax = a1.get_xlim()
# get the name to stick on the x and y labels
if fxname==1: fxname = f.__name__
if fyname==1: fyname = f.__name__
# get the output axes
if output_axes == None:
_pylab.figure(a1.figure.number+1)
a2 = _pylab.axes()
else:
a2 = output_axes
if clear: a2.clear()
# loop over the data
for line in a1.get_lines():
# if it's a line, do the manipulation
if isinstance(line, _mpl.lines.Line2D):
# get the data
x, y = line.get_data()
# trim the data according to the current zoom level
x, y = _fun.trim_data(xmin, xmax, x, y)
# do the manipulation
new_x, new_y = f(x,y)
# plot the new
_s.plot.xy.data(new_x, new_y, clear=0, label=line.get_label().replace("_", "-"), axes=a2, **kwargs)
# pause after each curve if we're supposed to
if pause:
_pylab.draw()
input("<enter> ")
# set the labels and title.
if fxname in [0,None]: a2.set_xlabel(a1.get_xlabel())
else: a2.set_xlabel(fxname+"("+a1.get_xlabel()+")")
if fyname in [0,None]: a2.set_ylabel(a1.get_ylabel())
else: a2.set_ylabel(fyname+"("+a1.get_ylabel()+")")
_pylab.draw() | def manipulate_shown_data(f, input_axes="gca", output_axes=None, fxname=1, fyname=1, clear=1, pause=False, **kwargs) | Loops over the visible data on the specified axes and modifies it based on
the function f(xdata, ydata), which must return new_xdata, new_ydata
input_axes which axes to pull the data from
output_axes which axes to dump the manipulated data (None for new figure)
fxname the name of the function on x
fyname the name of the function on y
1 means "use f.__name__"
0 or None means no change.
otherwise specify a string
**kwargs are sent to axes.plot | 2.746079 | 2.745585 | 1.00018 |
def f(x,y): return fx(x), y
f.__name__ = fx.__name__
manipulate_shown_data(f, fxname=fxname, fyname=None, **kwargs) | def manipulate_shown_xdata(fx, fxname=1, **kwargs) | This defines a function f(xdata,ydata) returning fx(xdata), ydata and
runs manipulate_shown_data() with **kwargs sent to this. See
manipulate_shown_data() for more info. | 5.264899 | 3.865858 | 1.361897 |
def f(x,y): return x, fy(y)
f.__name__ = fy.__name__
manipulate_shown_data(f, fxname=None, fyname=fyname, **kwargs) | def manipulate_shown_ydata(fy, fyname=1, **kwargs) | This defines a function f(xdata,ydata) returning xdata, fy(ydata) and
runs manipulate_shown_data() with **kwargs sent to this. See
manipulate_shown_data() for more info. | 4.688021 | 3.614085 | 1.297153 |
for fig in figures:
# get the temp path
temp_path = _os.path.join(_settings.path_home, "temp")
# make the temp folder
_settings.MakeDir(temp_path)
# output the figure to postscript
path = _os.path.join(temp_path, "graph."+file_format)
# get the dimensions of the figure in inches
w=fig.get_figwidth()
h=fig.get_figheight()
# we're printing to 8.5 x 11, so aim for 7.5 x 10
target_height = target_height-2*target_pad
target_width = target_width -2*target_pad
# depending on the aspect we scale by the vertical or horizontal value
if 1.0*h/w > target_height/target_width:
# scale down according to the vertical dimension
new_h = target_height
new_w = w*target_height/h
else:
# scale down according to the hozo dimension
new_w = target_width
new_h = h*target_width/w
fig.set_figwidth(new_w)
fig.set_figheight(new_h)
# save it
fig.savefig(path, bbox_inches=_pylab.matplotlib.transforms.Bbox(
[[-target_pad, new_h-target_height-target_pad],
[target_width-target_pad, target_height-target_pad]]))
# set it back
fig.set_figheight(h)
fig.set_figwidth(w)
if not arguments == '':
c = _settings['instaprint'] + ' ' + arguments + ' "' + path + '"'
else:
c = _settings['instaprint'] + ' "' + path + '"'
print(c)
_os.system(c) | def _print_figures(figures, arguments='', file_format='pdf', target_width=8.5, target_height=11.0, target_pad=0.5) | figure printing loop designed to be launched in a separate thread. | 3.107793 | 3.115774 | 0.997439 |
global _settings
if 'instaprint' not in _settings.keys():
print("No print command setup. Set the user variable settings['instaprint'].")
return
if figure=='gcf': figure=[_pylab.gcf().number]
elif figure=='all': figure=_pylab.get_fignums()
if not getattr(figure,'__iter__',False): figure = [figure]
print("figure numbers in queue:", figure)
figures=[]
for n in figure: figures.append(_pylab.figure(n))
# now run the ps printing command
if threaded:
# store the canvas type of the last figure
canvas_type = type(figures[-1].canvas)
# launch the aforementioned function as a separate thread
_thread.start_new_thread(_print_figures, (figures,arguments,file_format,))
# wait until the thread is running
_time.sleep(0.25)
# wait until the canvas type has returned to normal
t0 = _time.time()
while not canvas_type == type(figures[-1].canvas) and _time.time()-t0 < 5.0:
_time.sleep(0.1)
if _time.time()-t0 >= 5.0:
print("WARNING: Timed out waiting for canvas to return to original state!")
# bring back the figure and command line
_pylab.draw()
else:
_print_figures(figures, arguments, file_format)
_pylab.draw() | def instaprint(figure='gcf', arguments='', threaded=False, file_format='pdf') | Quick function that saves the specified figure as a postscript and then
calls the command defined by spinmob.prefs['instaprint'] with this
postscript file as the argument.
figure='gcf' can be 'all', a number, or a list of numbers | 4.185012 | 4.102739 | 1.020053 |
if _fun.is_a_number(f): f = _pylab.figure(f)
f.canvas.manager.window.raise_() | def raise_figure_window(f=0) | Raises the supplied figure number or figure window. | 7.491014 | 5.98767 | 1.251073 |
if type(fig)==str: fig = _pylab.gcf()
elif _fun.is_a_number(fig): fig = _pylab.figure(fig)
# Qt4Agg backend. Probably would work for other Qt stuff
if _pylab.get_backend().find('Qt') >= 0:
w = fig.canvas.window()
if not size == None:
w.resize(size[0],size[1])
if not position == None:
w.move(position[0], position[1])
# WXAgg backend. Probably would work for other Qt stuff.
elif _pylab.get_backend().find('WX') >= 0:
w = fig.canvas.Parent
if not size == None:
w.SetSize(size)
if not position == None:
w.SetPosition(position) | def set_figure_window_geometry(fig='gcf', position=None, size=None) | This will currently only work for Qt4Agg and WXAgg backends.
postion = [x, y]
size = [width, height]
fig can be 'gcf', a number, or a figure object. | 3.319223 | 3.067472 | 1.082071 |
if axes=="gca": axes = _pylab.gca()
# first get one of the tick label locations
xposition = axes.yaxis.get_ticklabels()[0].get_position()[0]
# get the bounds
ymin, ymax = axes.get_ylim()
# get the starting tick
nstart = int(_pylab.floor((ymin-start)/step))
nstop = int(_pylab.ceil((ymax-start)/step))
ticks = []
for n in range(nstart,nstop+1): ticks.append(start+n*step)
axes.set_yticks(ticks)
# set the x-position
for t in axes.yaxis.get_ticklabels():
x, y = t.get_position()
t.set_position((xposition, y))
_pylab.draw() | def set_yticks(start, step, axes="gca") | This will generate a tick array and apply said array to the axis | 3.00935 | 3.045151 | 0.988243 |
if axes=="gca": axes = _pylab.gca()
# first get one of the tick label locations
yposition = axes.xaxis.get_ticklabels()[0].get_position()[1]
# get the bounds
xmin, xmax = axes.get_xlim()
# get the starting tick
nstart = int(_pylab.floor((xmin-start)/step))
nstop = int(_pylab.ceil((xmax-start)/step))
ticks = []
for n in range(nstart,nstop+1): ticks.append(start+n*step)
axes.set_xticks(ticks)
# set the y-position
for t in axes.xaxis.get_ticklabels():
x, y = t.get_position()
t.set_position((x, yposition))
_pylab.draw() | def set_xticks(start, step, axes="gca") | This will generate a tick array and apply said array to the axis | 2.985276 | 3.020258 | 0.988418 |
# get the actual data values
xdata = line.get_xdata()
ydata = line.get_ydata()
xdata,ydata = _fun.coarsen_data(xdata, ydata, level=level, exponential=exponential)
# don't do anything if we don't have any data left
if len(ydata) == 0: print("There's nothing left in "+str(line)+"!")
# otherwise set the data with the new arrays
else: line.set_data(xdata, ydata)
# we refresh in real time for giggles
if draw: _pylab.draw() | def coarsen_line(line, level=2, exponential=False, draw=True) | Coarsens the specified line (see spinmob.coarsen_data() for more information).
Parameters
----------
line
Matplotlib line instance.
level=2
How strongly to coarsen.
exponential=False
If True, use the exponential method (great for log-x plots).
draw=True
Redraw when complete. | 4.574931 | 4.511933 | 1.013962 |
if axes=="gca": axes=_pylab.gca()
if axes=="all":
if not figure: f = _pylab.gcf()
axes = f.axes
if not _fun.is_iterable(axes): axes = [axes]
for a in axes:
# get the lines from the plot
lines = a.get_lines()
# loop over the lines and trim the data
for line in lines:
if isinstance(line, _mpl.lines.Line2D):
coarsen_line(line, level, exponential, draw=False)
_pylab.draw() | def coarsen_all_traces(level=2, exponential=False, axes="all", figure=None) | This function does nearest-neighbor coarsening of the data. See
spinmob.fun.coarsen_data for more information.
Parameters
----------
level=2
How strongly to coarsen.
exponential=False
If True, use the exponential method (great for log-x plots).
axes="all"
Which axes to coarsen.
figure=None
Which figure to use. | 3.776865 | 4.0759 | 0.926633 |
if axes=='gca': axes = _pylab.gca()
lines = axes.get_lines()
for line in lines:
if isinstance(line, _mpl.lines.Line2D):
xdata, ydata = line.get_data()
if not fx==None: xdata = fx(xdata)
if not fy==None: ydata = fy(ydata)
line.set_data(xdata,ydata)
_pylab.draw() | def line_math(fx=None, fy=None, axes='gca') | applies function fx to all xdata and fy to all ydata. | 2.065186 | 2.01022 | 1.027344 |
if figure=="gcf": figure = _pylab.gcf()
if path==None: path = _s.dialogs.Save("*.*", default_directory="save_plot_default_directory")
if path=="":
print("aborted.")
return
figure.savefig(path, dpi=dpi) | def export_figure(dpi=200, figure="gcf", path=None) | Saves the actual postscript data for the figure. | 7.58169 | 7.665332 | 0.989088 |
global line_attributes
# choose a path to save to
if path==None: path = _s.dialogs.Save("*.plot", default_directory="save_plot_default_directory")
if path=="":
print("aborted.")
return
if not path.split(".")[-1] == "plot": path = path+".plot"
f = file(path, "w")
# if no argument was given, get the current axes
if axes=="gca": axes=_pylab.gca()
# now loop over the available lines
f.write("title=" +axes.title.get_text().replace('\n', '\\n')+'\n')
f.write("xlabel="+axes.xaxis.label.get_text().replace('\n','\\n')+'\n')
f.write("ylabel="+axes.yaxis.label.get_text().replace('\n','\\n')+'\n')
for l in axes.lines:
# write the data header
f.write("trace=new\n")
f.write("legend="+l.get_label().replace('\n', '\\n')+"\n")
for a in line_attributes: f.write(a+"="+str(_pylab.getp(l, a)).replace('\n','')+"\n")
# get the data
x = l.get_xdata()
y = l.get_ydata()
# loop over the data
for n in range(0, len(x)): f.write(str(float(x[n])) + " " + str(float(y[n])) + "\n")
f.close() | def save_plot(axes="gca", path=None) | Saves the figure in my own ascii format | 3.288429 | 3.246181 | 1.013014 |
# choose a path to save to
path = _s.dialogs.Save(**kwargs)
if path=="": return "aborted."
# if no argument was given, get the current axes
if figure=="gcf": figure = _pylab.gcf()
for n in range(len(figure.axes)):
a = figure.axes[n]
for m in range(len(a.lines)):
l = a.lines[m]
x = l.get_xdata()
y = l.get_ydata()
p = _os.path.split(path)
p = _os.path.join(p[0], "axes" + str(n) + " line" + str(m) + " " + p[1])
print(p)
# loop over the data
f = open(p, 'w')
for j in range(0, len(x)):
f.write(str(x[j]) + "\t" + str(y[j]) + "\n")
f.close() | def save_figure_raw_data(figure="gcf", **kwargs) | This will just output an ascii file for each of the traces in the shown figure.
**kwargs are sent to dialogs.Save() | 3.098055 | 2.902569 | 1.06735 |
i = self.line_colors_index
self.line_colors_index += increment
if self.line_colors_index >= len(self.line_colors):
self.line_colors_index = self.line_colors_index-len(self.line_colors)
if self.line_colors_index >= len(self.line_colors): self.line_colors_index=0 # to be safe
return self.line_colors[i] | def get_line_color(self, increment=1) | Returns the current color, then increments the color by what's specified | 2.332338 | 2.368683 | 0.984656 |
i = self.markers_index
self.markers_index += increment
if self.markers_index >= len(self.markers):
self.markers_index = self.markers_index-len(self.markers)
if self.markers_index >= len(self.markers): self.markers_index=0 # to be safe
return self.markers[i] | def get_marker(self, increment=1) | Returns the current marker, then increments the marker by what's specified | 2.887839 | 3.043481 | 0.948861 |
i = self.linestyles_index
self.linestyles_index += increment
if self.linestyles_index >= len(self.linestyles):
self.linestyles_index = self.linestyles_index-len(self.linestyles)
if self.linestyles_index >= len(self.linestyles): self.linestyles_index=0 # to be safe
return self.linestyles[i] | def get_linestyle(self, increment=1) | Returns the current marker, then increments the marker by what's specified | 2.323085 | 2.366953 | 0.981466 |
i = self.face_colors_index
self.face_colors_index += increment
if self.face_colors_index >= len(self.face_colors):
self.face_colors_index = self.face_colors_index-len(self.face_colors)
if self.face_colors_index >= len(self.face_colors): self.face_colors_index=0 # to be safe
return self.face_colors[i] | def get_face_color(self, increment=1) | Returns the current face, then increments the face by what's specified | 2.308787 | 2.355811 | 0.980039 |
i = self.edge_colors_index
self.edge_colors_index += increment
if self.edge_colors_index >= len(self.edge_colors):
self.edge_colors_index = self.edge_colors_index-len(self.edge_colors)
if self.edge_colors_index >= len(self.edge_colors): self.edge_colors_index=0 # to be safe
return self.edge_colors[i] | def get_edge_color(self, increment=1) | Returns the current face, then increments the face by what's specified | 2.33054 | 2.349435 | 0.991958 |
if axes == "gca": axes = _pylab.gca()
self.reset()
lines = axes.get_lines()
for l in lines:
l.set_color(self.get_line_color(1))
l.set_mfc(self.get_face_color(1))
l.set_marker(self.get_marker(1))
l.set_mec(self.get_edge_color(1))
l.set_linestyle(self.get_linestyle(1))
_pylab.draw() | def apply(self, axes="gca") | Applies the style cycle to the lines in the axes specified | 2.517169 | 2.388187 | 1.054008 |
assert any([message, image_files])
attachment_items = None
if image_files:
attachment_items = Photo._upload_messages_photos_for_group(session, user_id, image_files)
message_id = session.fetch("messages.send", user_id=user_id, message=message, attachment=attachment_items, random_id=random.randint(1, 10**6))
return message_id | def _send_message(session, user_id, message=None, image_files=None) | https://vk.com/dev/messages.send | 3.866201 | 3.324058 | 1.163097 |
response = session.fetch("messages.getDialogs", unread=unread, important=important, unanswered=unanswered)
dialog_json_items = response["items"]
return (Message.from_json(session, dialog_json["message"]) for dialog_json in dialog_json_items) | def get_dialog(session, unread=False, important=False, unanswered=False) | https://vk.com/dev/messages.getDialogs | 4.030981 | 3.337165 | 1.207906 |
return self._session.fetch_items("groups.getMembers", User.from_json, 1000, group_id=self.id, sort=sort, fields=User.__slots__ + User.USER_FIELDS) | def get_members(self, sort='id_asc') | :param: sort {id_asc, id_desc, time_asc, time_desc} string
Docs: https://vk.com/dev/groups.getMembers | 9.322867 | 7.926385 | 1.176181 |
return session.fetch_items('groups.get', Group.from_json, count=1000, user_id=user_id, filter=filter, extended=1, fields=",".join(Group.GROUP_FIELDS)) | def _get_user_groups(session, user_id, filter) | https://vk.com/dev/groups.get
:param filter: {admin, editor, moder, groups, publics, events}
:yield: Groups | 8.552027 | 6.086686 | 1.405038 |
b = spline_array()
b.x_splines = a.x_splines
b.y_splines = a.y_splines
b.max_y_splines = a.max_y_splines
b.xmin = a.xmin
b.xmax = a.xmax
b.ymin = a.ymin
b.ymax = a.ymax
b.xlabel = a.xlabel
b.ylabel = a.ylabel
b.zlabel = a.zlabel
b.simple = a.simple
b.generate_y_values()
return b | def copy_spline_array(a) | This returns an instance of a new spline_array with all the fixins, and the data from a. | 2.646739 | 2.632854 | 1.005274 |
if axes=="gca": axes = _pylab.gca()
xlabel = axes.xaxis.label.get_text()
ylabel = axes.yaxis.label.get_text()
xdata = axes.get_lines()[0].get_xdata()
ydata = axes.get_lines()[0].get_ydata()
if interactive:
return splinteractive(xdata, ydata, smoothing, degree, presmoothing, spline_class, xlabel, ylabel)
else:
return spline_class(xdata, ydata, smoothing, degree, presmoothing, plot, xlabel, ylabel) | def splot(axes="gca", smoothing=5000, degree=5, presmoothing=0, plot=True, spline_class=spline_single, interactive=True, show_derivative=1) | gets the data from the plot and feeds it into splint
returns an instance of spline_single
axes="gca" which axes to get the data from.
smoothing=5000 spline_single smoothing parameter
presmoothing=0 spline_single data presmoothing factor (nearest neighbor)
plot=True should we plot the result?
spline_class=spline_single which data class to use?
interactive=False should we spline fit interactively or just make a spline_single? | 2.354342 | 2.375809 | 0.990964 |
if simple=='auto': simple = self.simple
# make it into an array if it isn't one, and remember that we did
is_array = True
if not type(x) == type(_pylab.array([])):
x = _pylab.array([x])
is_array = False
if simple:
# loop over all supplied x data, and come up with a y for each
y = []
for n in range(0, len(x)):
# get a window of data around x
if smooth:
[xtemp, ytemp, etemp] = _fun.trim_data(self.xdata, self.ydata, None, [x[n]-smooth, x[n]+smooth])
else:
i1 = _fun.index_nearest(x[n], self.xdata)
# if the nearest data point is lower than x, use the next point to interpolate
if self.xdata[i1] <= x[n] or i1 <= 0: i2 = i1+1
else: i2 = i1-1
# if we're at the max, extrapolate
if i2 >= len(self.xdata):
print(x[n], "is out of range. extrapolating")
i2 = i1-1
x1 = self.xdata[i1]
y1 = self.ydata[i1]
x2 = self.xdata[i2]
y2 = self.ydata[i2]
slope = (y2-y1)/(x2-x1)
xtemp = _numpy.array([x[n]])
ytemp = _numpy.array([y1 + (x[n]-x1)*slope])
# calculate the slope based on xtemp and ytemp (if smoothing)
# or just use the raw slope if smoothing=0
if derivative == 1:
if smooth:
y.append((_numpy.average(xtemp*ytemp)-_numpy.average(xtemp)*_numpy.average(ytemp)) /
(_numpy.average(xtemp*xtemp)-_numpy.average(xtemp)**2))
else:
y.append(slope)
# otherwise just average (even with one element)
elif derivative==0:
y.append(_numpy.average(ytemp))
if is_array: return _numpy.array(y)
else: return y[0]
if smooth:
y = []
for n in range(0, len(x)):
# take 20 data points from x+/-smooth
xlow = max(self.xmin,x[n]-smooth)
xhi = min(self.xmax,x[n]+smooth)
xdata = _pylab.linspace(xlow, xhi, 20)
ydata = _interpolate.splev(xdata, self.pfit, derivative)
y.append(_numpy.average(ydata))
if is_array: return _numpy.array(y)
else: return y[0]
else:
return _interpolate.splev(x, self.pfit, derivative) | def evaluate(self, x, derivative=0, smooth=0, simple='auto') | smooth=0 is how much to smooth the spline data
simple='auto' is whether we should just use straight interpolation
you may want smooth > 0 for this, when derivative=1 | 3.151011 | 3.147034 | 1.001264 |
if simple=='auto': simple = self.simple
# find which values y is in between
for n in range(0, len(self.y_values)-1):
# if it's in between, interpolate!
if self.y_values[n] <= y and self.y_values[n+1] >= y:
y1 = self.y_values[n]
y2 = self.y_values[n+1]
z1 = self.x_splines[y1].evaluate(x, x_derivative, smooth, simple)
z2 = self.x_splines[y2].evaluate(x, x_derivative, smooth, simple)
return z1 + (y-y1)*(z2-z1)/(y2-y1)
print("YARG! The y value "+str(y)+" is out of interpolation range!")
if y >= self.y_values[-1]: return self.x_splines[self.y_values[-1]].evaluate(x, x_derivative, smooth, simple)
else : return self.x_splines[self.y_values[0]].evaluate(x, x_derivative, smooth, simple) | def evaluate(self, x, y, x_derivative=0, smooth=0, simple='auto') | this evaluates the 2-d spline by doing linear interpolation of the curves | 2.489598 | 2.409192 | 1.033375 |
if simple=='auto': simple=self.simple
# get the min and max
if ymin=="auto": ymin = self.ymin
if ymax=="auto": ymax = self.ymax
if clear: _pylab.gca().clear()
if not type(x_values) in [type([]), type(_pylab.array([]))]: x_values = [x_values]
for x in x_values:
# define a new simple function to plot, then plot it
def f(y): return self.evaluate(x, y, x_derivative, smooth, simple)
_pylab_help.plot_function(f, ymin, ymax, steps, 0, False)
# label it
a = _pylab.gca()
a.set_xlabel(self.ylabel)
if x_derivative: a.set_ylabel(str(x_derivative)+" "+str(self.xlabel)+" derivative of "+self.zlabel)
else: a.set_ylabel(self.zlabel)
a.set_title(self._path+"\nSpline array plot at fixed x = "+self.xlabel)
a.get_lines()[-1].set_label("x ("+self.xlabel+") = "+str(x))
if format: _s.format_figure()
return a | def plot_fixed_x(self, x_values, x_derivative=0, steps=1000, smooth=0, simple='auto', ymin="auto", ymax="auto", format=True, clear=1) | plots the data at fixed x-value, so z vs x | 4.26214 | 4.216013 | 1.010941 |
if simple=='auto': simple=self.simple
# get the min and max
if xmin=="auto": xmin = self.xmin
if xmax=="auto": xmax = self.xmax
if clear: _pylab.gca().clear()
if not type(y_values) in [type([]), type(_pylab.array([]))]: y_values = [y_values]
for y in y_values:
# define a new simple function to plot, then plot it
def f(x): return self.evaluate(x, y, x_derivative, smooth, simple)
_pylab_help.plot_function(f, xmin, xmax, steps, 0, True)
# label it
a = _pylab.gca()
th = "th"
if x_derivative == 1: th = "st"
if x_derivative == 2: th = "nd"
if x_derivative == 3: th = "rd"
if x_derivative: a.set_ylabel(str(x_derivative)+th+" "+self.xlabel+" derivative of "+self.zlabel+" spline")
else: a.set_ylabel(self.zlabel)
a.set_xlabel(self.xlabel)
a.set_title(self._path+"\nSpline array plot at fixed y "+self.ylabel)
a.get_lines()[-1].set_label("y ("+self.ylabel+") = "+str(y))
if format: _s.format_figure()
return a | def plot_fixed_y(self, y_values, x_derivative=0, steps=1000, smooth=0, simple='auto', xmin="auto", xmax="auto", format=True, clear=1) | plots the data at a fixed y-value, so z vs y | 4.003571 | 3.988875 | 1.003684 |
def get_window(self):
x = self
while not x._parent == None and \
not isinstance(x._parent, Window):
x = x._parent
return x._parent | Returns the object's parent window. Returns None if no window found. | null | null | null | |
t0 = _t.time()
while _t.time()-t0 < seconds:
# Pause a bit to avoid heavy CPU
_t.sleep(dt)
# process events
self.process_events() | def sleep(self, seconds=0.05, dt=0.01) | A "smooth" version of time.sleep(): waits for the time to pass but
processes events every dt as well.
Note this requires that the object is either a window or embedded
somewhere within a window. | 6.228767 | 5.635485 | 1.105276 |
self._widget.blockSignals(True)
self._widget.setUpdatesEnabled(False) | def block_events(self) | Prevents the widget from sending signals. | 6.674905 | 3.988963 | 1.673343 |
self._widget.blockSignals(False)
self._widget.setUpdatesEnabled(True) | def unblock_events(self) | Allows the widget to send signals. | 6.682495 | 4.298124 | 1.554747 |
if self.log == None: print(message)
else: self.log.append_text(message) | def print_message(self, message="heya!") | If self.log is defined to be an instance of TextLog, it print the
message there. Otherwise use the usual "print" to command line. | 6.851211 | 4.124657 | 1.661038 |
# only if we're supposed to!
if self._autosettings_path:
# Get the gui settings directory
gui_settings_dir = _os.path.join(_cwd, 'egg_settings')
# make sure the directory exists
if not _os.path.exists(gui_settings_dir): _os.mkdir(gui_settings_dir)
# make a path with a sub-directory
path = _os.path.join(gui_settings_dir, self._autosettings_path)
# for saving header info
d = _d.databox()
# add all the controls settings
for x in self._autosettings_controls: self._store_gui_setting(d, x)
# save the file
d.save_file(path, force_overwrite=True) | def save_gui_settings(self, *a) | Saves just the current configuration of the controls if the
autosettings_path is set. | 5.769457 | 5.112167 | 1.128574 |
# only do this if we're supposed to
if self._autosettings_path is not None:
# Get the gui settings directory
gui_settings_dir = _os.path.join(_cwd, 'egg_settings')
# assemble the path with a sub-directory
path = _os.path.join(gui_settings_dir, self._autosettings_path)
# databox just for loading a cfg file
d = _d.databox()
# if the settings path exists
if _os.path.exists(path):
# Load the settings
d.load_file(path, header_only=True, quiet=True)
# Store the settings in the lazy dictionary
self._lazy_load.update(d.headers)
# Loop over the settings we're supposed to change
# Note without specifying d, this will try to pop
# the value off of self._lazy_load. If
#
if not lazy_only:
for x in self._autosettings_controls:
self._load_gui_setting(x) | def load_gui_settings(self, lazy_only=False) | Loads the settings (if we're supposed to).
Parameters
----------
lazy_only=False
If True, it will only load the settings into self._lazy_load, and
not try to update the value. Presumably the widget will apply these
settings later, e.g., when enough tabs exist to set the current
tab in TabArea. | 7.49051 | 7.086994 | 1.056938 |
# Whether we should pop the value from the dictionary when we set it.
pop_value = False
# If d is None, assume we're using the lazy load settings.
if d == None:
d = self._lazy_load
pop_value = True
# If we have a databox, take the header dictionary
if not type(d) == dict: d = d.headers
# only do this if the key exists
if key in d:
try:
# Try to set the value
eval(key).set_value(d[key])
# If this fails, perhaps the element does not yet exist
# For example, TabArea may not have all the tabs created
# and cannot set the active tab until later.
# If it's here, it worked, so pop if necessary
if pop_value: d.pop(key)
except:
print("ERROR: Could not load gui setting "+repr(key)) | def _load_gui_setting(self, key, d=None) | Safely reads the header setting and sets the appropriate control
value.
Parameters
----------
key
Key string of the format 'self.controlname'.
d = None
Databox instance or dictionary, presumably containing the aforementioned
key. If d=None, pops the value from self._lazy_load. | 8.099641 | 6.635951 | 1.22057 |
try: databox.insert_header(name, eval(name + ".get_value()"))
except: print("ERROR: Could not store gui setting "+repr(name)) | def _store_gui_setting(self, databox, name) | Stores the gui setting in the header of the supplied databox.
hkeys in the file are set to have the format
"self.controlname" | 10.262356 | 7.970569 | 1.287531 |
# pick a column
if column==None:
column = self._auto_column
self._auto_column += 1
# pick a row
if row==None: row = self._auto_row
# create the object
self.objects.append(object)
# add the widget to the layout
try:
object._widget
widget = object._widget
# allows the user to specify a standard widget
except: widget = object
self._layout.addWidget(widget, row, column,
row_span, column_span,
_g.Qt.QtCore.Qt.Alignment(alignment))
# try to store the parent object (self) in the placed object
try: object.set_parent(self)
except: None
return object | def place_object(self, object, column=None, row=None, column_span=1, row_span=1, alignment=1) | This adds either one of our simplified objects or a QWidget to the
grid at the specified position, appends the object to self.objects.
alignment=0 Fill the space.
alignment=1 Left-justified.
alignment=2 Right-justified.
If column isn't specified, the new object will be placed in a new column. | 5.193965 | 5.023944 | 1.033842 |
if type(object) in [int, int]: n = object
else: n = self.objects.index(object)
# pop it from the list
object = self.objects.pop(n)
# remove it from the GUI and delete it
if hasattr_safe(object, '_widget'):
self._layout.removeWidget(object._widget)
object._widget.hide()
if delete: object._widget.deleteLater()
else:
self._layout.removeWidget(object)
object.hide()
if delete: object.deleteLater() | def remove_object(self, object=0, delete=True) | Removes the supplied object from the grid. If object is an integer,
it removes the n'th object. | 3.276462 | 3.293329 | 0.994878 |
self._layout.setColumnStretch(column, stretch)
return self | def set_column_stretch(self, column=0, stretch=10) | Sets the column stretch. Larger numbers mean it will expand more to
fill space. | 5.522826 | 6.61227 | 0.835239 |
self._layout.setRowStretch(row, stretch)
return self | def set_row_stretch(self, row=0, stretch=10) | Sets the row stretch. Larger numbers mean it will expand more to fill
space. | 5.837384 | 6.548813 | 0.891365 |
if row==None: self._auto_row += 1
else: self._auto_row = row
self._auto_column=0
return self | def new_autorow(self, row=None) | Sets the auto-add row. If row=None, increments by 1 | 5.396101 | 4.680495 | 1.152891 |
# map of options
m = dict(top = _g.QtCore.Qt.TopDockWidgetArea,
bottom = _g.QtCore.Qt.BottomDockWidgetArea,
left = _g.QtCore.Qt.LeftDockWidgetArea,
right = _g.QtCore.Qt.RightDockWidgetArea)
# set the parent
docker.set_parent(self)
# events
docker._window.resizeEvent = self._event_resize
docker._window.moveEvent = self._event_move
# Keep it in the window
docker._window.setFeatures(docker._window.DockWidgetMovable)
# set it
self._window.addDockWidget(m[area], docker._window)
return docker | def place_docker(self, docker, area='top') | IN DEVELOPMENT
Places a DockWindow instance at the specified area ('top', 'bottom',
'left', 'right', or None) | 4.220308 | 3.960363 | 1.065637 |
if self._autosettings_path == None: return
# Get the gui settings directory
gui_settings_dir = _os.path.join(_cwd, 'egg_settings')
# make sure the directory exists
if not _os.path.exists(gui_settings_dir): _os.mkdir(gui_settings_dir)
# make a path with a sub-directory
path = _os.path.join(gui_settings_dir, self._autosettings_path)
# Create a Qt settings object
settings = _g.QtCore.QSettings(path, _g.QtCore.QSettings.IniFormat)
settings.clear()
# Save values
if hasattr_safe(self._window, "saveState"):
settings.setValue('State',self._window.saveState())
settings.setValue('Geometry', self._window.saveGeometry()) | def _save_settings(self) | Saves all the parameters to a text file. | 4.209072 | 4.040203 | 1.041797 |
if self._autosettings_path == None: return
# Get the gui settings directory
gui_settings_dir = _os.path.join(_cwd, 'egg_settings')
# make a path with a sub-directory
path = _os.path.join(gui_settings_dir, self._autosettings_path)
# make sure the directory exists
if not _os.path.exists(path): return
# Create a Qt settings object
settings = _g.QtCore.QSettings(path, _g.QtCore.QSettings.IniFormat)
# Load it up! (Extra steps required for windows command line execution)
if settings.contains('State') and hasattr_safe(self._window, "restoreState"):
x = settings.value('State')
if hasattr(x, "toByteArray"): x = x.toByteArray()
self._window.restoreState(x)
if settings.contains('Geometry'):
x = settings.value('Geometry')
if hasattr(x, "toByteArray"): x = x.toByteArray()
self._window.restoreGeometry(x) | def _load_settings(self) | Loads all the parameters from a databox text file. If path=None,
loads from self._autosettings_path. | 4.443498 | 4.189521 | 1.060622 |
self._is_open = True
self._window.show()
self._window.raise_()
# start the blocking loop
if block_command_line:
# stop when the window closes
while self._is_open:
_a.processEvents()
_t.sleep(block_timing)
# wait a moment in case there is some shutdown stuff.
_t.sleep(0.5)
return self | def show(self, block_command_line=False, block_timing=0.05) | Shows the window and raises it.
If block_command_line is 0, this will start the window up and allow you
to monkey with the command line at the same time. Otherwise, the
window will block the command line and process events every
block_timing seconds. | 5.459306 | 5.320993 | 1.025994 |
if block_events: self._widget.blockSignals(True)
self._widget.setChecked(value)
if block_events: self._widget.blockSignals(False)
return self | def set_checked(self, value=True, block_events=False) | This will set whether the button is checked.
Setting block_events=True will temporarily disable signals
from the button when setting the value. | 2.650209 | 3.048473 | 0.869356 |
if self.is_checkable():
if self.is_checked(): self.set_checked(False)
else: self.set_checked(True)
self.signal_clicked.emit(self.is_checked())
else:
self.signal_clicked.emit(True)
return self | def click(self) | Pretends to user clicked it, sending the signal and everything. | 3.228928 | 2.764674 | 1.167924 |
# assemble the string
s = "QLabel {"
for a in args: s = s+a+"; "
for k in list(kwargs.keys()): s = s+k.replace("_","-")+": "+kwargs[k]+"; "
s = s+"}"
# set it!
self._widget.setStyleSheet(s)
return self | def set_style(self, *args, **kwargs) | Provides access to any number of style sheet settings via
self._widget.SetStyleSheet()
*args can be any element between semicolons, e.g.
self.set_stylesheet('text-align: right; padding-left: 5px')
**kwargs can be any key-value pair, replacing '-' with '_' in the key, e.g.
self.set_stylesheet(text_align='right', padding_left='5px')
See QLabel.SetStyleSheet() documentation. | 4.463258 | 3.994131 | 1.117454 |
if block_events: self.block_events()
self._widget.setValue(value)
if block_events: self.unblock_events() | def set_value(self, value, block_events=False) | Sets the current value of the number box.
Setting block_events=True will temporarily block the widget from
sending any signals when setting the value. | 3.04774 | 3.606718 | 0.845018 |
if block_events: self.block_events()
self._widget.setSingleStep(value)
if block_events: self.unblock_events() | def set_step(self, value, block_events=False) | Sets the step of the number box.
Setting block_events=True will temporarily block the widget from
sending any signals when setting the value. | 3.649306 | 3.860302 | 0.945342 |
if index==None:
return self.get_text(self.get_value())
else:
return str(self._widget.itemText(index)) | def get_text(self, index=None) | Gets text from a given index. If index=None, returns the current value
self.get_text(self.get_value()) | 5.109552 | 3.117928 | 1.638765 |
return [self._widget.itemText(k) for k in range(self._widget.count())] | def get_all_items(self) | Returns all items in the combobox dictionary. | 7.235255 | 4.288013 | 1.687321 |
self._widget.blockSignals(block_events)
# create a widget to go in the tab
tab = GridLayout()
self.tabs.append(tab)
tab.set_parent(self)
# create and append the tab to the list
self._widget.addTab(tab._widget, title)
# try to lazy set the current tab
if 'self' in self._lazy_load and self.get_tab_count() > self._lazy_load['self']:
v = self._lazy_load.pop('self')
self.set_current_tab(v)
self._widget.blockSignals(False)
return tab | def add_tab(self, title="Yeah!", block_events=True) | Adds a tab to the area, and creates the layout for this tab. | 4.593005 | 4.493444 | 1.022157 |
# pop it from the list
t = self.tabs.pop(tab)
# remove it from the gui
self._widget.removeTab(tab)
# return it in case someone cares
return t | def remove_tab(self, tab=0) | Removes the tab by index. | 6.1774 | 6.124012 | 1.008718 |
x = self._widget.item(row, column)
if x==None: return x
else: return str(self._widget.item(row,column).text()) | def get_value(self, column=0, row=0) | Returns a the value at column, row. | 5.79921 | 5.245749 | 1.105507 |
if block_events: self.block_events()
# dynamically resize
while column > self._widget.columnCount()-1: self._widget.insertColumn(self._widget.columnCount())
while row > self._widget.rowCount() -1: self._widget.insertRow( self._widget.rowCount())
# set the value
self._widget.setItem(row, column, _g.Qt.QtGui.QTableWidgetItem(str(value)))
if block_events: self.unblock_events()
return self | def set_value(self, column=0, row=0, value='', block_events=False) | Sets the value at column, row. This will create elements dynamically,
and in a totally stupid while-looping way.
Setting block_events=True will temporarily block the widget from
sending any signals when setting the value. | 3.320919 | 3.604674 | 0.921281 |
self._widget.setColumnWidth(n, width)
return self | def set_column_width(self, n=0, width=120) | Sets the n'th column width in pixels. | 6.108934 | 4.553643 | 1.341549 |
if row: self._widget.verticalHeader().show()
else: self._widget.verticalHeader().hide()
if column: self._widget.horizontalHeader().show()
else: self._widget.horizontalHeader().hide()
return self | def set_header_visibility(self, column=False, row=False) | Sets whether we can see the column and row headers. | 2.937875 | 2.751423 | 1.067766 |
self._widget.setRowHeight(n, height)
return self | def set_row_height(self, n=0, height=18) | Sets the n'th row height in pixels. | 6.054098 | 4.639045 | 1.305031 |
for n in self.naughty: key = key.replace(n, '_')
return key | def _clean_up_key(self, key) | Returns the key string with no naughty characters. | 8.987054 | 4.280204 | 2.099679 |
# block all signals during the update (to avoid re-calling this)
self.block_events()
# loop over the rows
for n in range(self.get_row_count()):
# get the keys and values (as text)
key = self.get_value(0,n)
value = self.get_value(1,n)
# get rid of the None's
if key == None:
key = ''
self.set_value(0,n, '')
if value == None:
value = ''
self.set_value(1,n, '')
# if it's not an empty entry make sure it's valid
if not key == '':
# clean up the key
key = self._clean_up_key(key)
# now make sure the value is python-able
try:
eval(value)
self._widget.item(n,1).setData(_g.QtCore.Qt.BackgroundRole, _g.Qt.QtGui.QColor('white'))
except:
self._widget.item(n,1).setData(_g.QtCore.Qt.BackgroundRole, _g.Qt.QtGui.QColor('pink'))
# unblock all signals
self.unblock_events() | def _cell_changed(self, *a) | Called whenever a cell is changed. Updates the dictionary. | 3.789555 | 3.694435 | 1.025747 |
keys = list(self.keys())
# make sure it exists
if not key in keys:
self.print_message("ERROR: '"+str(key)+"' not found.")
return None
try:
x = eval(self.get_value(1,keys.index(key)))
return x
except:
self.print_message("ERROR: '"+str(self.get_value(1,keys.index(key)))+"' cannot be evaluated.")
return None | def get_item(self, key) | Returns the value associated with the key. | 3.4399 | 3.279207 | 1.049004 |
keys = list()
for n in range(len(self)):
# only append the valid keys
key = self.get_value()
if not key in ['', None]: keys.append(key)
return keys | def keys(self) | Returns a sorted list of keys | 7.472954 | 7.269361 | 1.028007 |
keys = list(self.keys())
# if it exists, update
if key in keys:
self.set_value(1,keys.index(key),str(value))
# otherwise we have to add an element
else:
self.set_value(0,len(self), str(key))
self.set_value(1,len(self)-1, str(value)) | def set_item(self, key, value) | Sets the item by key, and refills the table sorted. | 4.106662 | 3.915533 | 1.048813 |
if not dictionary == None: kwargs.update(dictionary)
for k in list(kwargs.keys()): self[k] = kwargs[k] | def update(self, dictionary=None, **kwargs) | Adds/overwrites all the keys and values from the dictionary. | 4.257622 | 3.557228 | 1.196893 |
if self._multiline: return str(self._widget.toPlainText())
else: return str(self._widget.text()) | def get_text(self) | Returns the current text. | 6.421324 | 5.086069 | 1.262532 |
# Make sure the text is actually different, so as not to
# trigger a value changed signal
s = str(text)
if not s == self.get_text(): self._widget.setText(str(text))
return self | def set_text(self, text="YEAH.") | Sets the current value of the text box. | 9.356293 | 8.111247 | 1.153496 |
if self._multiline: self._widget.setStyleSheet("QTextEdit {background-color: "+str(background)+"; color: "+str(text)+"}")
else: self._widget.setStyleSheet("QLineEdit {background-color: "+str(background)+"; color: "+str(text)+"}") | def set_colors(self, text='black', background='white') | Sets the colors of the text area. | 2.546198 | 2.53331 | 1.005087 |
# block events in the usual way
BaseObject.block_events(self)
# loop over all top level parameters
for i in range(self._widget.topLevelItemCount()):
self._widget.topLevelItem(i).param.blockSignals(True)
return self | def block_events(self) | Special version of block_events that loops over all tree elements. | 8.381206 | 7.869361 | 1.065043 |
# unblock events in the usual way
BaseObject.unblock_events(self)
# loop over all top level parameters
for i in range(self._widget.topLevelItemCount()):
self._widget.topLevelItem(i).param.blockSignals(False)
return self | def unblock_events(self) | Special version of unblock_events that loops over all tree elements as well. | 7.913323 | 7.118501 | 1.111656 |
# loop over all top level parameters
for i in range(self._widget.topLevelItemCount()):
# make sure there is only one connection!
try:
self._widget.topLevelItem(i).param.sigTreeStateChanged.connect(
function, type=_g.QtCore.Qt.UniqueConnection)
except:
pass
return self | def connect_any_signal_changed(self, function) | Connects the "anything changed" signal for all of the tree to the
specified function.
Parameters
----------
function
Function to connect to this signal. | 7.945632 | 8.770937 | 0.905905 |
x = self._find_parameter(name.split("/"))
# if it pooped.
if x==None: return None
# connect it
x.sigValueChanged.connect(function)
# Keep track of the functions
if name in self._connection_lists: self._connection_lists[name].append(function)
else: self._connection_lists[name] = [function]
return self | def connect_signal_changed(self, name, function) | Connects a changed signal from the parameters of the specified name
to the supplied function. | 6.242416 | 6.070303 | 1.028353 |
x = self._find_parameter(name.split("/"), quiet=ignore_error)
# if it pooped.
if x==None: return None
# disconnect it from all its functions
if name in self._connection_lists:
for f in self._connection_lists[name]: x.sigValueChanged.disconnect(f)
return self | def block_user_signals(self, name, ignore_error=False) | Temporarily disconnects the user-defined signals for the specified
parameter name.
Note this only affects those connections made with
connect_signal_changed(), and I do not recommend adding new connections
while they're blocked! | 11.172383 | 11.004062 | 1.015296 |
x = self._find_parameter(name.split("/"), quiet=ignore_error)
# if it pooped.
if x==None: return None
# reconnect it to all its functions
if name in self._connection_lists:
for f in self._connection_lists[name]: x.sigValueChanged.connect(f)
return self | def unblock_user_signals(self, name, ignore_error=False) | Reconnects the user-defined signals for the specified
parameter name (blocked with "block_user_signal_changed")
Note this only affects those connections made with
connect_signal_changed(), and I do not recommend adding new connections
while they're blocked! | 12.249015 | 11.620962 | 1.054045 |
# make a copy so this isn't destructive to the supplied list
s = list(name_list)
# if the length is zero, return the root widget
if len(s)==0: return self._widget
# the first name must be treated differently because it is
# the main widget, not a branch
r = self._clean_up_name(s.pop(0))
# search for the root name
result = self._widget.findItems(r, _g.QtCore.Qt.MatchCaseSensitive | _g.QtCore.Qt.MatchFixedString)
# if it pooped and we're not supposed to create it, quit
if len(result) == 0 and not create_missing:
if not quiet: self.print_message("ERROR: Could not find '"+r+"'")
return None
# otherwise use the first value
elif len(result): x = result[0].param
# otherwise, if there are more names in the list,
# create the branch and keep going
else:
x = _g.parametertree.Parameter.create(name=r, type='group', children=[])
self._widget.addParameters(x)
# loop over the remaining names, and use a different search method
for n in s:
# first clean up
n = self._clean_up_name(n)
# try to search for the name
try: x = x.param(n)
# name doesn't exist
except:
# if we're supposed to, create the new branch
if create_missing: x = x.addChild(_g.parametertree.Parameter.create(name=n, type='group', children=[]))
# otherwise poop out
else:
if not quiet: self.print_message("ERROR: Could not find '"+n+"' in '"+x.name()+"'")
return None
# return the last one we found / created.
return x | def _find_parameter(self, name_list, create_missing=False, quiet=False) | Tries to find and return the parameter of the specified name. The name
should be of the form
['branch1','branch2', 'parametername']
Setting create_missing=True means if it doesn't find a branch it
will create one.
Setting quiet=True will suppress error messages (for checking) | 4.231642 | 4.349226 | 0.972964 |
for n in self.naughty: name = name.replace(n, '_')
return name | def _clean_up_name(self, name) | Cleans up the name according to the rules specified in this exact
function. Uses self.naughty, a list of naughty characters. | 9.117823 | 4.508784 | 2.022235 |
# first clean up the name
name = self._clean_up_name(name)
# split into (presumably existing) branches and parameter
s = name.split('/')
# make sure it doesn't already exist
if not self._find_parameter(s, quiet=True) == None:
self.print_message("Error: '"+name+"' already exists.")
return None
# get the leaf name off the list.
p = s.pop(-1)
# create / get the branch on which to add the leaf
b = self._find_parameter(s, create_missing=True)
# quit out if it pooped
if b == None: return None
# create the leaf object
ap = _g.parametertree.Parameter.create(name=p, type='action')
# add it to the tree (different methods for root)
if b == self._widget: b.addParameters(ap)
else: b.addChild(ap)
# modify the existing class to fit our conventions
ap.signal_clicked = ap.sigActivated
# Now set the default value if any
if name in self._lazy_load:
v = self._lazy_load.pop(name)
self._set_value_safe(name, v, True, True)
# Connect it to autosave (will only create unique connections)
self.connect_any_signal_changed(self.autosave)
return Button(name, checkable, checked, list(ap.items.keys())[0].button) | def add_button(self, name, checkable=False, checked=False) | Adds (and returns) a button at the specified location. | 8.468097 | 8.360334 | 1.01289 |
# update the default kwargs
other_kwargs = dict(type=None)
other_kwargs.update(kwargs)
# Auto typing
if other_kwargs['type'] == None: other_kwargs['type'] = type(value).__name__
# Fix 'values' for list objects to be only strings
if other_kwargs['type'] == 'list':
for n in range(len(other_kwargs['values'])):
other_kwargs['values'][n] = str(other_kwargs['values'][n])
# split into (presumably existing) branches and parameter
s = name.split('/')
# make sure it doesn't already exist
if not self._find_parameter(s, quiet=True) == None:
self.print_message("Error: '"+name+"' already exists.")
return self
# get the leaf name off the list.
p = s.pop(-1)
# create / get the branch on which to add the leaf
b = self._find_parameter(s, create_missing=True)
# quit out if it pooped
if b == None: return self
# create the leaf object
leaf = _g.parametertree.Parameter.create(name=p, value=value, **other_kwargs)
# add it to the tree (different methods for root)
if b == self._widget: b.addParameters(leaf)
else: b.addChild(leaf)
# Now set the default value if any
if name in self._lazy_load:
v = self._lazy_load.pop(name)
self._set_value_safe(name, v, True, True)
# Connect it to autosave (will only create unique connections)
self.connect_any_signal_changed(self.autosave)
return self | def add_parameter(self, name='test', value=42.0, **kwargs) | Adds a parameter "leaf" to the tree.
Parameters
----------
name='test'
The name of the leaf. It should be a string of the form
"branch1/branch2/parametername" and will be nested as indicated.
value=42.0
Value of the leaf.
Common Keyword Arguments
------------------------
type=None
If set to None, type will be automatically set to type(value).__name__.
This will not work for all data types, but is
a nice shortcut for floats, ints, strings, etc.
If it doesn't work, just specify the type manually (see below).
values
Not used by default. Only relevant for 'list' type, and should then
be a list of possible values.
step=1
Step size of incrementing numbers
dec=False
Set to True to enable decade increments.
limits
Not used by default. Should be a 2-element tuple or list used to
bound numerical values.
default
Not used by default. Used to specify the default numerical value
siPrefix=False
Set to True to display units on numbers
suffix
Not used by default. Used to add unit labels to elements.
See pyqtgraph ParameterTree for more options. Particularly useful is the
tip='insert your text' option, which supplies a tooltip! | 6.023531 | 5.538133 | 1.087647 |
# assemble the key for this parameter
k = base_name + "/" + parameter.name()
# first add this parameter (if it has a value)
if not parameter.value()==None:
sorted_keys.append(k[1:])
dictionary[sorted_keys[-1]] = parameter.value()
# now loop over the children
for p in parameter.children():
self._get_parameter_dictionary(k, dictionary, sorted_keys, p) | def _get_parameter_dictionary(self, base_name, dictionary, sorted_keys, parameter) | Recursively loops over the parameter's children, adding
keys (starting with base_name) and values to the supplied dictionary
(provided they do not have a value of None). | 3.527936 | 3.247877 | 1.086228 |
k, d = self.get_dictionary()
destination_databox.update_headers(d,k) | def send_to_databox_header(self, destination_databox) | Sends all the information currently in the tree to the supplied
databox's header, in alphabetical order. If the entries already
exists, just updates them. | 14.021369 | 10.905882 | 1.28567 |
# output
k = list()
d = dict()
# loop over the root items
for i in range(self._widget.topLevelItemCount()):
# grab the parameter item, and start building the name
x = self._widget.topLevelItem(i).param
# now start the recursive loop
self._get_parameter_dictionary('', d, k, x)
return k, d | def get_dictionary(self) | Returns the list of parameters and a dictionary of values
(good for writing to a databox header!)
Return format is sorted_keys, dictionary | 9.03949 | 8.638081 | 1.04647 |
# first clean up the name
name = self._clean_up_name(name)
# now get the parameter object
x = self._find_parameter(name.split('/'))
# quit if it pooped.
if x == None: return None
# get the value and test the bounds
value = x.value()
# handles the two versions of pyqtgraph
bounds = None
# For lists, just make sure it's a valid value
if x.opts['type'] == 'list':
# If it's not one from the master list, choose
# and return the default value.
if not value in x.opts['values']:
# Only choose a default if there exists one
if len(x.opts('values')):
self.set_value(name, x.opts['values'][0])
return x.opts['values'][0]
# Otherwise, just return None and do nothing
else: return None
# For strings, make sure the returned value is always a string.
elif x.opts['type'] in ['str']: return str(value)
# Otherwise assume it is a value with bounds or limits (depending on
# the version of pyqtgraph)
else:
if 'limits' in x.opts: bounds = x.opts['limits']
elif 'bounds' in x.opts: bounds = x.opts['bounds']
if not bounds == None:
if not bounds[1]==None and value > bounds[1]: value = bounds[1]
if not bounds[0]==None and value < bounds[0]: value = bounds[0]
# return it
return value | def get_value(self, name) | Returns the value of the parameter with the specified name. | 5.055206 | 4.963501 | 1.018476 |
# Make sure it's a list
if not self.get_type(name) in ['list']:
self.print_message('ERROR: "'+name+'" is not a list.')
return
# Return a copy of the list values
return list(self.get_widget(name).opts['values']) | def get_list_values(self, name) | Returns the values for a list item of the specified name. | 5.245977 | 5.222075 | 1.004577 |
# first clean up the name
name = self._clean_up_name(name)
# If we're supposed to, block the user signals for this parameter
if block_user_signals: self.block_user_signals(name, ignore_error)
# now get the parameter object
x = self._find_parameter(name.split('/'), quiet=ignore_error)
# quit if it pooped.
if x == None: return None
# for lists, make sure the value exists!!
if x.type() in ['list']:
# Make sure it exists before trying to set it
if str(value) in list(x.forward.keys()): x.setValue(str(value))
# Otherwise default to the first key
else: x.setValue(list(x.forward.keys())[0])
# Bail to a hopeful set method for other types
else: x.setValue(eval(x.opts['type'])(value))
# If we're supposed to unblock the user signals for this parameter
if block_user_signals: self.unblock_user_signals(name, ignore_error)
return self | def set_value(self, name, value, ignore_error=False, block_user_signals=False) | Sets the variable of the supplied name to the supplied value.
Setting block_user_signals=True will temporarily block the widget from
sending any signals when setting the value. | 5.421531 | 5.537076 | 0.979133 |
if path==None:
if self._autosettings_path == None: return self
# Get the gui settings directory
gui_settings_dir = _os.path.join(_cwd, 'egg_settings')
# make sure the directory exists
if not _os.path.exists(gui_settings_dir): _os.mkdir(gui_settings_dir)
# Assemble the path
path = _os.path.join(gui_settings_dir, self._autosettings_path)
# make the databox object
d = _d.databox()
# get the keys and dictionary
keys, dictionary = self.get_dictionary()
# loop over the keys and add them to the databox header
for k in keys:
d.insert_header(k, dictionary[k])
# save it
try:
d.save_file(path, force_overwrite=True, header_only=True)
except:
print('Warning: could not save '+path.__repr__()+' once. Could be that this is being called too rapidly.')
return self | def save(self, path=None) | Saves all the parameters to a text file using the databox
functionality. If path=None, saves to self._autosettings_path. If
self._autosettings_path=None, does not save. | 5.37445 | 4.675804 | 1.149417 |
if path==None:
# Bail if there is no path
if self._autosettings_path == None: return self
# Get the gui settings directory
gui_settings_dir = _os.path.join(_cwd, 'egg_settings')
# Get the final path
path = _os.path.join(gui_settings_dir, self._autosettings_path)
# make the databox object
d = _d.databox()
# only load if it exists
if _os.path.exists(path): d.load_file(path, header_only=True)
else: return None
# update the settings
self.update(d, ignore_errors=ignore_errors, block_user_signals=block_user_signals)
return self | def load(self, path=None, ignore_errors=True, block_user_signals=False) | Loads all the parameters from a databox text file. If path=None,
loads from self._autosettings_path (provided this is not None).
Parameters
----------
path=None
Path to load the settings from. If None, will load from the
specified autosettings_path.
ignore_errors=True
Whether we should raise a stink when a setting doesn't exist.
When settings do not exist, they are stuffed into the dictionary
self._lazy_load.
block_user_signals=False
If True, the load will not trigger any signals. | 5.241292 | 4.533242 | 1.15619 |
if not type(d) == dict: d = d.headers
# Update the lazy load
self._lazy_load.update(d)
# loop over the dictionary and update
for k in list(self._lazy_load.keys()):
# Only proceed if the parameter exists
if not self._find_parameter(k.split('/'), False, True) == None:
# Pop the value so it's not set again in the future
v = self._lazy_load.pop(k)
self._set_value_safe(k, v, ignore_errors, block_user_signals)
return self | def update(self, d, ignore_errors=True, block_user_signals=False) | Supply a dictionary or databox with a header of the same format
and see what happens! (Hint: it updates the existing values.)
This will store non-existent key-value pairs in the dictionary
self._lazy_load. When you add settings in the future,
these will be checked for the default values. | 5.523884 | 4.571023 | 1.208457 |
# for safety: by default assume it's a repr() with python code
try:
self.set_value(k, v, ignore_error = ignore_errors,
block_user_signals = block_user_signals)
except:
print("TreeDictionary ERROR: Could not set '"+k+"' to '"+v+"'") | def _set_value_safe(self, k, v, ignore_errors=False, block_user_signals=False) | Actually sets the value, first by trying it directly, then by | 9.781616 | 10.081442 | 0.97026 |
if checked:
# get the path from the user
path = _spinmob.dialogs.save(filters=self.file_type)
# abort if necessary
if not path:
self.button_autosave.set_checked(False)
return
# otherwise, save the info!
self._autosave_directory, filename = _os.path.split(path)
self._label_path.set_text(filename)
self.save_gui_settings() | def _button_autosave_clicked(self, checked) | Called whenever the button is clicked. | 7.547621 | 7.303655 | 1.033403 |
# Update the binary mode
if not 'binary' in kwargs: kwargs['binary'] = self.combo_binary.get_text()
# if it's just the settings file, make a new databox
if just_settings: d = _d.databox()
# otherwise use the internal databox
else: d = self
# add all the controls settings to the header
for x in self._autosettings_controls: self._store_gui_setting(d, x)
# save the file using the skeleton function, so as not to recursively
# call this one again!
_d.databox.save_file(d, path, self.file_type, self.file_type, force_overwrite, **kwargs) | def save_file(self, path=None, force_overwrite=False, just_settings=False, **kwargs) | Saves the data in the databox to a file.
Parameters
----------
path=None
Path for output. If set to None, use a save dialog.
force_overwrite=False
Do not question the overwrite if the file already exists.
just_settings=False
Set to True to save only the state of the DataboxPlot controls
**kwargs are sent to the normal databox save_file() function. | 9.517209 | 8.819817 | 1.079071 |
# if it's just the settings file, make a new databox
if just_settings:
d = _d.databox()
header_only = True
# otherwise use the internal databox
else:
d = self
header_only = False
# import the settings if they exist in the header
if not None == _d.databox.load_file(d, path, filters=self.file_type, header_only=header_only, quiet=just_settings):
# loop over the autosettings and update the gui
for x in self._autosettings_controls: self._load_gui_setting(x,d)
# always sync the internal data
self._synchronize_controls()
# plot the data if this isn't just a settings load
if not just_settings:
self.plot()
self.after_load_file() | def load_file(self, path=None, just_settings=False) | Loads a data file. After the file is loaded, calls self.after_load_file(self),
which you can overwrite if you like!
just_settings=True will only load the configuration of the controls,
and will not plot anything or run after_load_file | 8.456978 | 8.128654 | 1.040391 |
# This should never happen unless I screwed up.
if self.combo_autoscript.get_index() == 0: return "ERROR: Ask Jack."
# if there is no data, leave it blank
if len(self)==0: return "x = []; y = []; xlabels=[]; ylabels=[]"
# if there is one column, make up a one-column script
elif len(self)==1: return "x = [None]\ny = [ d[0] ]\n\nxlabels=[ 'Data Point' ]\nylabels=[ 'd[0]' ]"
# Shared x-axis (column 0)
elif self.combo_autoscript.get_index() == 1:
# hard code the first columns
sx = "x = [ d[0]"
sy = "y = [ d[1]"
# hard code the first labels
sxlabels = "xlabels = '" +self.ckeys[0]+"'"
sylabels = "ylabels = [ '"+self.ckeys[1]+"'"
# loop over any remaining columns and append.
for n in range(2,len(self)):
sy += ", d["+str(n)+"]"
sylabels += ", '"+self.ckeys[n]+"'"
return sx+" ]\n"+sy+" ]\n\n"+sxlabels+"\n"+sylabels+" ]\n"
# Column pairs
elif self.combo_autoscript.get_index() == 2:
# hard code the first columns
sx = "x = [ d[0]"
sy = "y = [ d[1]"
# hard code the first labels
sxlabels = "xlabels = [ '"+self.ckeys[0]+"'"
sylabels = "ylabels = [ '"+self.ckeys[1]+"'"
# Loop over the remaining columns and append
for n in range(1,int(len(self)/2)):
sx += ", d["+str(2*n )+"]"
sy += ", d["+str(2*n+1)+"]"
sxlabels += ", '"+self.ckeys[2*n ]+"'"
sylabels += ", '"+self.ckeys[2*n+1]+"'"
return sx+" ]\n"+sy+" ]\n\n"+sxlabels+" ]\n"+sylabels+" ]\n"
print("test")
# Column triples
elif self.combo_autoscript.get_index() == 3:
# hard code the first columns
sx = "x = [ d[0], d[0]"
sy = "y = [ d[1], d[2]"
# hard code the first labels
sxlabels = "xlabels = [ '"+self.ckeys[0]+"', '"+self.ckeys[0]+"'"
sylabels = "ylabels = [ '"+self.ckeys[1]+"', '"+self.ckeys[2]+"'"
# Loop over the remaining columns and append
for n in range(1,int(len(self)/3)):
sx += ", d["+str(3*n )+"], d["+str(3*n )+"]"
sy += ", d["+str(3*n+1)+"], d["+str(3*n+2)+"]"
sxlabels += ", '"+self.ckeys[3*n ]+"', '"+self.ckeys[3*n ]+"'"
sylabels += ", '"+self.ckeys[3*n+1]+"', '"+self.ckeys[3*n+2]+"'"
return sx+" ]\n"+sy+" ]\n\n"+sxlabels+" ]\n"+sylabels+" ]\n"
else: return self.autoscript_custom() | def _autoscript(self) | Automatically generates a python script for plotting. | 2.204135 | 2.154533 | 1.023023 |
# if we're disabled or have no data columns, clear everything!
if not self.button_enabled.is_checked() or len(self) == 0:
self._set_number_of_plots(0)
return self
# if there is no script, create a default
if not self.combo_autoscript.get_index()==0:
self.script.set_text(self._autoscript())
##### Try the script and make the curves / plots match
try:
# get globals for sin, cos etc
g = _n.__dict__
g.update(dict(d=self))
g.update(dict(xlabels='x', ylabels='y'))
# run the script.
exec(self.script.get_text(), g)
# x & y should now be data arrays, lists of data arrays or Nones
x = g['x']
y = g['y']
# make it the right shape
if x == None: x = [None]
if y == None: y = [None]
if not _spinmob.fun.is_iterable(x[0]) and not x[0] == None: x = [x]
if not _spinmob.fun.is_iterable(y[0]) and not y[0] == None: y = [y]
if len(x) == 1 and not len(y) == 1: x = x*len(y)
if len(y) == 1 and not len(x) == 1: y = y*len(x)
# xlabels and ylabels should be strings or lists of strings
xlabels = g['xlabels']
ylabels = g['ylabels']
# make sure we have exactly the right number of plots
self._set_number_of_plots(len(x))
self._update_linked_axes()
# return if there is nothing.
if len(x) == 0: return
# now plot everything
for n in range(max(len(x),len(y))-1,-1,-1):
# Create data for "None" cases.
if x[n] is None: x[n] = list(range(len(y[n])))
if y[n] is None: y[n] = list(range(len(x[n])))
self._curves[n].setData(x[n],y[n])
# get the labels for the curves
# if it's a string, use the same label for all axes
if type(xlabels) in [str,type(None)]: xlabel = xlabels
elif n < len(xlabels): xlabel = xlabels[n]
else: xlabel = ''
if type(ylabels) in [str,type(None)]: ylabel = ylabels
elif n < len(ylabels): ylabel = ylabels[n]
else: ylabel = ''
# set the labels
i = min(n, len(self.plot_widgets)-1)
self.plot_widgets[i].setLabel('left', ylabel)
self.plot_widgets[i].setLabel('bottom', xlabel)
# special case: hide if None
if xlabel == None: self.plot_widgets[i].getAxis('bottom').showLabel(False)
if ylabel == None: self.plot_widgets[i].getAxis('left') .showLabel(False)
# unpink the script, since it seems to have worked
self.script.set_colors('black','white')
# otherwise, look angry and don't autosave
except: self.script.set_colors('black','pink')
return self | def plot(self) | Sets the internal databox to the supplied value and plots it.
If databox=None, this will plot the internal databox. | 3.788102 | 3.80371 | 0.995897 |
# make sure we're suppoed to
if self.button_autosave.is_checked():
# save the file
self.save_file(_os.path.join(self._autosave_directory, "%04d " % (self.number_file.get_value()) + self._label_path.get_text()))
# increment the counter
self.number_file.increment() | def autosave(self) | Autosaves the currently stored data, but only if autosave is checked! | 7.495974 | 6.805351 | 1.101482 |
if n==None:
for p in self.plot_widgets: p.autoRange()
else: self.plot_widgets[n].autoRange()
return self | def autozoom(self, n=None) | Auto-scales the axes to fit all the data in plot index n. If n == None,
auto-scale everyone. | 6.807909 | 6.519088 | 1.044304 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.