text stringlengths 81 112k |
|---|
Get a parameter field value
def _getField(self, field, native=0, prompt=1):
"""Get a parameter field value"""
try:
# expand field name using minimum match
field = _getFieldDict[field]
except KeyError as e:
# re-raise the exception with a bit more info
... |
Set a parameter field value
def _setField(self, value, field, check=1):
"""Set a parameter field value"""
try:
# expand field name using minimum match
field = _setFieldDict[field]
except KeyError as e:
raise SyntaxError("Cannot set field " + field +
... |
Return .par format string for this parameter
If dolist is set, returns fields as a list of strings. Default
is to return a single string appropriate for writing to a file.
def save(self, dolist=0):
"""Return .par format string for this parameter
If dolist is set, returns fields as a ... |
Return dpar-style executable assignment for parameter
Default is to write CL version of code; if cl parameter is
false, writes Python executable code instead. Note that
dpar doesn't even work for arrays in the CL, so we just use
Python syntax here.
def dpar(self, cl=1):
"""Ret... |
Return value of this parameter as a string (or in native format
if native is non-zero.)
def get(self, field=None, index=None, lpar=0, prompt=1, native=0, mode="h"):
"""Return value of this parameter as a string (or in native format
if native is non-zero.)"""
if field: return self._getF... |
Set value of this parameter from a string or other value.
Field is optional parameter field (p_prompt, p_minimum, etc.)
Index is optional array index (zero-based). Set check=0 to
assign the value without checking to see if it is within
the min-max range or in the choice list.
def set(s... |
Check and convert a parameter value.
Raises an exception if the value is not permitted for this
parameter. Otherwise returns the value (converted to the
right type.)
def checkValue(self,value,strict=0):
"""Check and convert a parameter value.
Raises an exception if the value ... |
Convert tuple index to 1-D index into value
def _sumindex(self, index=None):
"""Convert tuple index to 1-D index into value"""
try:
ndim = len(index)
except TypeError:
# turn index into a 1-tuple
index = (index,)
ndim = 1
if len(self.shape... |
Coerce parameter to appropriate type
Should accept None or null string. Must be an array.
def _coerceValue(self,value,strict=0):
"""Coerce parameter to appropriate type
Should accept None or null string. Must be an array.
"""
try:
if isinstance(value,str):
... |
Create min-match dictionary for choice list
def _setChoiceDict(self):
"""Create min-match dictionary for choice list"""
# value is full name of choice parameter
self.choiceDict = minmatch.MinMatchDict()
for c in self.choice: self.choiceDict.add(c, c) |
Check initial attributes to make sure they are legal
def _checkAttribs(self, strict):
"""Check initial attributes to make sure they are legal"""
if self.min:
warning("Minimum value not allowed for boolean-type parameter " +
self.name, strict)
self.min = None
... |
Check initial attributes to make sure they are legal
def _checkAttribs(self, strict):
"""Check initial attributes to make sure they are legal"""
if self.choice:
warning("Choice values not allowed for real-type parameter " +
self.name, strict)
self.choice = No... |
Updates the device with the given data. Supports a json payload like
{
fs: newFs
samplesPerBatch: samplesPerBatch
gyroEnabled: true
gyroSensitivity: 500
accelerometerEnabled: true
accelerometerSensitivity: 2
}
A heartbeat is... |
Check if this is a legal date in the Gregorian calendar
def legal_date(year, month, day):
'''Check if this is a legal date in the Gregorian calendar'''
if month == 2:
daysinmonth = 29 if isleap(year) else 28
else:
daysinmonth = 30 if month in HAVE_30_DAYS else 31
if not (0 < day <= day... |
Gregorian to Julian Day Count for years between 1801-2099
def to_jd2(year, month, day):
'''Gregorian to Julian Day Count for years between 1801-2099'''
# http://quasar.as.utexas.edu/BillInfo/JulianDatesG.html
legal_date(year, month, day)
if month <= 2:
year = year - 1
month = month + ... |
Return Gregorian date in a (Y, M, D) tuple
def from_jd(jd):
'''Return Gregorian date in a (Y, M, D) tuple'''
wjd = floor(jd - 0.5) + 0.5
depoch = wjd - EPOCH
quadricent = floor(depoch / INTERCALATION_CYCLE_DAYS)
dqc = depoch % INTERCALATION_CYCLE_DAYS
cent = floor(dqc / LEAP_SUPPRESSION_DAYS)... |
Stores a new item in the cache if it is allowed in.
:param name: the name.
:param hingePoints: the hinge points.
:return: true if it is stored.
def storeFromHinge(self, name, hingePoints):
"""
Stores a new item in the cache if it is allowed in.
:param name: the name.
... |
Stores a new item in the cache.
:param name: file name.
:param start: start time.
:param end: end time.
:return: true if stored.
def storeFromWav(self, uploadCacheEntry, start, end):
"""
Stores a new item in the cache.
:param name: file name.
:param start... |
Deletes the named entry in the cache.
:param name: the name.
:return: true if it is deleted.
def delete(self, name):
"""
Deletes the named entry in the cache.
:param name: the name.
:return: true if it is deleted.
"""
if name in self._cache:
d... |
reads the specified file.
:param name: the name.
:return: the analysis as frequency/Pxx.
def analyse(self, name):
"""
reads the specified file.
:param name: the name.
:return: the analysis as frequency/Pxx.
"""
if name in self._cache:
target =... |
Performs a log space 1d interpolation.
:param xx: the x values.
:param yy: the y values.
:param kind: the type of interpolation to apply (as per scipy interp1d)
:return: the interpolation function.
def log_interp1d(self, xx, yy, kind='linear'):
"""
Performs a log space 1... |
Retrieve the Julian date equivalent for this date
def to_jd(year, month, day):
"Retrieve the Julian date equivalent for this date"
return day + (month - 1) * 30 + (year - 1) * 365 + floor(year / 4) + EPOCH - 1 |
Create a new date from a Julian date.
def from_jd(jdc):
"Create a new date from a Julian date."
cdc = floor(jdc) + 0.5 - EPOCH
year = floor((cdc - floor((cdc + 366) / 1461)) / 365) + 1
yday = jdc - to_jd(year, 1, 1)
month = floor(yday / 30) + 1
day = yday - (month - 1) * 30 + 1
return yea... |
Computes the roll angle at the target position based on::
the roll angle at the V1 axis(roll),
the dec of the target(dec), and
the V2/V3 position of the aperture (v2,v3) in arcseconds.
Based on the algorithm provided by Colin Cox that is used in
Generic Conversion a... |
Prints out archived WCS keywords.
def print_archive(self,format=True):
""" Prints out archived WCS keywords."""
if len(list(self.orig_wcs.keys())) > 0:
block = 'Original WCS keywords for ' + self.rootname+ '\n'
block += ' backed up on '+repr(self.orig_wcs['WCSCDATE'])+'\n'
... |
Compute the pixel scale based on active WCS values.
def set_pscale(self):
""" Compute the pixel scale based on active WCS values. """
if self.new:
self.pscale = 1.0
else:
self.pscale = self.compute_pscale(self.cd11,self.cd21) |
Compute the pixel scale based on active WCS values.
def compute_pscale(self,cd11,cd21):
""" Compute the pixel scale based on active WCS values. """
return N.sqrt(N.power(cd11,2)+N.power(cd21,2)) * 3600. |
Return the computed orientation based on CD matrix.
def set_orient(self):
""" Return the computed orientation based on CD matrix. """
self.orient = RADTODEG(N.arctan2(self.cd12,self.cd22)) |
Create a new CD Matrix from the absolute pixel scale
and reference image orientation.
def updateWCS(self, pixel_scale=None, orient=None,refpos=None,refval=None,size=None):
"""
Create a new CD Matrix from the absolute pixel scale
and reference image orientation.
"""
# Set... |
Scale the WCS to a new pixel_scale. The 'retain' parameter
[default value: True] controls whether or not to retain the original
distortion solution in the CD matrix.
def scale_WCS(self,pixel_scale,retain=True):
''' Scale the WCS to a new pixel_scale. The 'retain' parameter
[default valu... |
This method would apply the WCS keywords to a position to
generate a new sky position.
The algorithm comes directly from 'imgtools.xy2rd'
translate (x,y) to (ra, dec)
def xy2rd(self,pos):
"""
This method would apply the WCS keywords to a position to
generate a new sky ... |
This method would use the WCS keywords to compute the XY position
from a given RA/Dec tuple (in deg).
NOTE: Investigate how to let this function accept arrays as well
as single positions. WJH 27Mar03
def rd2xy(self,skypos,hour=no):
"""
This method would use the WCS keywords to ... |
Rotates WCS CD matrix to new orientation given by 'orient'
def rotateCD(self,orient):
""" Rotates WCS CD matrix to new orientation given by 'orient'
"""
# Determine where member CRVAL position falls in ref frame
# Find out whether this needs to be rotated to align with
# referen... |
Write out the values of the WCS keywords to the
specified image.
If it is a GEIS image and 'fitsname' has been provided,
it will automatically make a multi-extension
FITS copy of the GEIS and update that file. Otherwise, it
throw an Exception if the user attempts to directly upd... |
Reset the active WCS keywords to values stored in the
backup keywords.
def restore(self):
""" Reset the active WCS keywords to values stored in the
backup keywords.
"""
# If there are no backup keys, do nothing...
if len(list(self.backup.keys())) == 0:
... |
Create backup copies of the WCS keywords with the given prepended
string.
If backup keywords are already present, only update them if
'overwrite' is set to 'yes', otherwise, do warn the user and do nothing.
Set the WCSDATE at this time as well.
def archive(self,prepend=N... |
Extract a copy of WCS keywords from an open file header,
if they have already been created and remember the prefix
used for those keywords. Otherwise, setup the current WCS
keywords as the archive values.
def read_archive(self,header,prepend=None):
""" Extract a copy of WCS ... |
Saves a copy of the WCS keywords from the image header
as new keywords with the user-supplied 'prepend'
character(s) prepended to the old keyword names.
If the file is a GEIS image and 'fitsname' is not None, create
a FITS copy and update that version; otherwise, raise
... |
Resets the WCS values to the original values stored in
the backup keywords recorded in self.backup.
def restoreWCS(self,prepend=None):
""" Resets the WCS values to the original values stored in
the backup keywords recorded in self.backup.
"""
# Open header for image
... |
Write out the values of the WCS keywords to the NEW
specified image 'fitsname'.
def createReferenceWCS(self,refname,overwrite=yes):
""" Write out the values of the WCS keywords to the NEW
specified image 'fitsname'.
"""
hdu = self.createWcsHDU()
# If refname alr... |
Generate a WCS header object that can be used to
populate a reference WCS HDU.
def createWcsHDU(self):
""" Generate a WCS header object that can be used to
populate a reference WCS HDU.
"""
hdu = fits.ImageHDU()
hdu.header['EXTNAME'] = 'WCS'
hdu.header['E... |
The main routine.
def main(args=None):
""" The main routine. """
logger = cfg.configureLogger()
for root, dirs, files in os.walk(cfg.dataDir):
for dir in dirs:
newDir = os.path.join(root, dir)
try:
os.removedirs(newDir)
logger.info("Deleted em... |
Determine if this is a leap year in the FR calendar using one of three methods: 4, 100, 128
(every 4th years, every 4th or 400th but not 100th, every 4th but not 128th)
def leap(year, method=None):
'''
Determine if this is a leap year in the FR calendar using one of three methods: 4, 100, 128
(every 4t... |
Determine the year in the French revolutionary calendar in which a given Julian day falls.
Returns Julian day number containing fall equinox (first day of the FR year)
def premier_da_la_annee(jd):
'''Determine the year in the French revolutionary calendar in which a given Julian day falls.
Returns Julian d... |
Obtain Julian day from a given French Revolutionary calendar date.
def to_jd(year, month, day, method=None):
'''Obtain Julian day from a given French Revolutionary calendar date.'''
method = method or 'equinox'
if day < 1 or day > 30:
raise ValueError("Invalid day for this calendar")
if month... |
Calculate JD using various leap-year calculation methods
def _to_jd_schematic(year, month, day, method):
'''Calculate JD using various leap-year calculation methods'''
y0, y1, y2, y3, y4, y5 = 0, 0, 0, 0, 0, 0
intercal_cycle_yrs, over_cycle_yrs, leap_suppression_yrs = None, None, None
# Use the ever... |
Calculate date in the French Revolutionary
calendar from Julian day. The five or six
"sansculottides" are considered a thirteenth
month in the results of this function.
def from_jd(jd, method=None):
'''Calculate date in the French Revolutionary
calendar from Julian day. The five or six
"sansc... |
Convert from JD using various leap-year calculation methods
def _from_jd_schematic(jd, method):
'''Convert from JD using various leap-year calculation methods'''
if jd < EPOCH:
raise ValueError("Can't convert days before the French Revolution")
# days since Epoch
J = trunc(jd) + 0.5 - EPOCH
... |
Calculate the FR day using the equinox as day 1
def _from_jd_equinox(jd):
'''Calculate the FR day using the equinox as day 1'''
jd = trunc(jd) + 0.5
equinoxe = premier_da_la_annee(jd)
an = gregorian.from_jd(equinoxe)[0] - YEAR_EPOCH
mois = trunc((jd - equinoxe) / 30.) + 1
jour = int((jd - equi... |
Obtain Julian day for Indian Civil date
def to_jd(year, month, day):
'''Obtain Julian day for Indian Civil date'''
gyear = year + 78
leap = isleap(gyear)
# // Is this a leap year ?
# 22 - leap = 21 if leap, 22 non-leap
start = gregorian.to_jd(gyear, 3, 22 - leap)
if leap:
Caitra =... |
Calculate Indian Civil date from Julian day
Offset in years from Saka era to Gregorian epoch
def from_jd(jd):
'''Calculate Indian Civil date from Julian day
Offset in years from Saka era to Gregorian epoch'''
start = 80
# Day offset between Saka and Gregorian
jd = trunc(jd) + 0.5
greg = g... |
Returns a one-line string with the current callstack.
def format_stack(skip=0, length=6, _sep=os.path.sep):
"""
Returns a one-line string with the current callstack.
"""
return ' < '.join("%s:%s:%s" % (
'/'.join(f.f_code.co_filename.split(_sep)[-2:]),
f.f_lineno,
f.f_code.co_nam... |
Decorates `func` to have logging.
Args
func (function):
Function to decorate. If missing log returns a partial which you can use as a decorator.
stacktrace (int):
Number of frames to show.
stacktrace_align (int):
Column to align the framelist to.
... |
If the device is configured to run against a remote server, ping that device on a scheduled basis with our current
state.
:param cfg: the config object.
:return:
def wireHandlers(cfg):
"""
If the device is configured to run against a remote server, ping that device on a scheduled basis with our cur... |
The main routine.
def main(args=None):
""" The main routine. """
cfg.configureLogger()
wireHandlers(cfg)
# get config from a flask standard place not our config yml
app.run(debug=cfg.runInDebug(), host='0.0.0.0', port=cfg.getPort()) |
lists all known active measurements.
def get(self, deviceId):
"""
lists all known active measurements.
"""
measurementsByName = self.measurements.get(deviceId)
if measurementsByName is None:
return []
else:
return list(measurementsByName.values()) |
details the specific measurement.
def get(self, deviceId, measurementId):
"""
details the specific measurement.
"""
record = self.measurements.get(deviceId)
if record is not None:
return record.get(measurementId)
return None |
Schedules a new measurement at the specified time.
:param deviceId: the device to measure.
:param measurementId: the name of the measurement.
:return: 200 if it was scheduled, 400 if the device is busy, 500 if the device is bad.
def put(self, deviceId, measurementId):
"""
Schedu... |
Deletes a stored measurement.
:param deviceId: the device to measure.
:param measurementId: the name of the measurement.
:return: 200 if it was deleted, 400 if no such measurement (or device).
def delete(self, deviceId, measurementId):
"""
Deletes a stored measurement.
:... |
signals a stop for the given measurement.
:param deviceId: the device to measure.
:param measurementId: the name of the measurement.
:return: 200 if stop is signalled, 400 if it doesn't exist or is not running.
def get(self, deviceId, measurementId):
"""
signals a stop for the g... |
schedules the measurement (to execute asynchronously).
:param duration: how long to run for.
:param at: the time to start at.
:param delay: the time to wait til starting (use at or delay).
:param callback: a callback.
:return: nothing.
def schedule(self, duration, at=None, delay... |
Executes the measurement, recording the event status.
:param duration: the time to run for.
:return: nothing.
def execute(self, duration):
"""
Executes the measurement, recording the event status.
:param duration: the time to run for.
:return: nothing.
"""
... |
Creates the delay from now til the specified start time, uses "at" if available.
:param at: the start time in %a %b %d %H:%M:%S %Y format.
:param delay: the delay from now til start.
:return: the delay.
def calculateDelay(self, at, delay):
"""
Creates the delay from now til the ... |
Given a list of multiprocessing.Process objects which have not yet
been started, this function launches them and blocks until the last
finishes. This makes sure that only <pool_size> processes are ever
working at any one time (this number does not include the main process
which called this function, si... |
Determine and return the best layout of "tiles" for fastest
overall parallel processing of a rectangular image broken up into N
smaller equally-sized rectangular tiles, given as input the number
of processes/chunks which can be run/worked at the same time (pool_size).
This attempts to return a layout w... |
Work loop runs forever (or until running is False)
:return:
def _accept(self):
"""
Work loop runs forever (or until running is False)
:return:
"""
logger.warning("Reactor " + self._name + " is starting")
while self.running:
try:
self._... |
public interface to the reactor.
:param requestType:
:param args:
:return:
def offer(self, requestType, *args):
"""
public interface to the reactor.
:param requestType:
:param args:
:return:
"""
if self._funcsByRequest.get(requestType) is ... |
Called when this button is clicked. Execute code from .cfgspc
def clicked(self):
""" Called when this button is clicked. Execute code from .cfgspc """
try:
from . import teal
except:
teal = None
try:
# start drilling down into the tpo to get the code
... |
This is used to ensure that the return value of arr.tostring()
is actually a string. This will prevent lots of if-checks in calling
code. As of numpy v1.6.1 (in Python 3.2.3), the tostring() function
still returns type 'bytes', not 'str' as it advertises.
def ndarr2str(arr, encoding='ascii'):
""" Thi... |
This is used to ensure that the return value of arr.tostring()
is actually a *bytes* array in PY3K. See notes in ndarr2str above. Even
though we consider it a bug that numpy's tostring() function returns
a bytes array in PY3K, there are actually many instances where that is what
we want - bytes, not u... |
Convert string s to the 'bytes' type, in all Pythons, even
back before Python 2.6. What 'str' means varies by PY3K or not.
In Pythons before 3.0, this is technically the same as the str type
in terms of the character data in memory.
def tobytes(s, encoding='ascii'):
""" Convert string s to the 'bytes'... |
Convert string-like-thing s to the 'str' type, in all Pythons, even
back before Python 2.6. What 'str' means varies by PY3K or not.
In Pythons before 3.0, str and bytes are the same type.
In Python 3+, this may require a decoding step.
def tostr(s, encoding='ascii'):
""" Convert string-like-thing s to... |
Decorator that retries the call ``retries`` times if ``func`` raises ``exceptions``. Can use a ``backoff`` function
to sleep till next retry.
Example::
>>> should_fail = lambda foo=[1,2,3]: foo and foo.pop()
>>> @retry
... def flaky_func():
... if should_fail():
...... |
Loads the named entry from the upload cache as a signal.
:param name: the name.
:param start: the time to start from in HH:mm:ss.SSS format
:param end: the time to end at in HH:mm:ss.SSS format.
:return: the signal if the named upload exists.
def loadSignal(self, name, start=None, end=N... |
:param name: the name of the cache entry.
:return: the entry or none.
def _getCacheEntry(self, name):
"""
:param name: the name of the cache entry.
:return: the entry or none.
"""
return next((x for x in self._uploadCache if x['name'] == name), None) |
Moves a tmp file to the upload dir, resampling it if necessary, and then deleting the tmp entries.
:param tmpCacheEntry: the cache entry.
:return:
def _convertTmp(self, tmpCacheEntry):
"""
Moves a tmp file to the upload dir, resampling it if necessary, and then deleting the tmp entries.... |
Streams an uploaded chunk to a file.
:param stream: the binary stream that contains the file.
:param filename: the name of the file.
:param chunkIdx: optional chunk index (for writing to a tmp dir)
:return: no of bytes written or -1 if there was an error.
def writeChunk(self, stream, f... |
Completes the upload which means converting to a single 1kHz sample rate file output file.
:param filename:
:param totalChunks:
:param status:
:return:
def finalise(self, filename, totalChunks, status):
"""
Completes the upload which means converting to a single 1k... |
Resamples the signal to the targetFs and writes it to filename.
:param filename: the filename.
:param signal: the signal to resample.
:param targetFs: the target fs.
:return: None
def writeOutput(self, filename, samples, srcFs, targetFs):
"""
Resamples the signal to the ... |
Deletes the named entry.
:param name: the entry.
:return: the deleted entry.
def delete(self, name):
"""
Deletes the named entry.
:param name: the entry.
:return: the deleted entry.
"""
i, entry = next(((i, x) for i, x in enumerate(self._uploadCache) if x... |
Return EparOption item of appropriate type for the parameter param
def eparOptionFactory(master, statusBar, param, defaultParam,
doScroll, fieldWidths,
plugIn=None, editedCallbackObj=None,
helpCallbackObj=None, mainGuiObj=None,
def... |
Collect in 1 place the bindings needed for watchTextSelection()
def extraBindingsForSelectableText(self):
""" Collect in 1 place the bindings needed for watchTextSelection() """
# See notes in watchTextSelection
self.entry.bind('<FocusIn>', self.watchTextSelection, "+")
self.entry.bind(... |
Clear selection (if text is selected in this widget)
def focusOut(self, event=None):
"""Clear selection (if text is selected in this widget)"""
# do nothing if this isn't a text-enabled widget
if not self.isSelectable:
return
if self.entryCheck(event) is None:
# ... |
Callback used to see if there is a new text selection. In certain
cases we manually add the text to the clipboard (though on most
platforms the correct behavior happens automatically).
def watchTextSelection(self, event=None):
""" Callback used to see if there is a new text selection. In certai... |
Select all text (if applicable) on taking focus
def focusIn(self, event=None):
"""Select all text (if applicable) on taking focus"""
try:
# doScroll returns false if the call was ignored because the
# last call also came from this widget. That avoids unwanted
# scro... |
A general method for firing any applicable triggers when
a value has been set. This is meant to be easily callable from any
part of this class (or its subclasses), so that it can be called
as soon as need be (immed. on click?). This is smart enough to
be called multiple... |
Popup right-click menu of special parameter operations
Relies on browserEnabled, clearEnabled, unlearnEnabled, helpEnabled
instance attributes to determine which items are available.
def popupChoices(self, event=None):
"""Popup right-click menu of special parameter operations
Relies o... |
Invoke a tkinter file dialog
def fileBrowser(self):
"""Invoke a tkinter file dialog"""
if capable.OF_TKFD_IN_EPAR:
fname = askopenfilename(parent=self.entry, title="Select File")
else:
from . import filedlg
self.fd = filedlg.PersistLoadFileDialog(self.entry,
... |
Invoke a tkinter directory dialog
def dirBrowser(self):
"""Invoke a tkinter directory dialog"""
if capable.OF_TKFD_IN_EPAR:
fname = askdirectory(parent=self.entry, title="Select Directory")
else:
raise NotImplementedError('Fix popupChoices() logic.')
if not fnam... |
Force-set a parameter entry to the given value
def forceValue(self, newVal, noteEdited=False):
"""Force-set a parameter entry to the given value"""
if newVal is None:
newVal = ""
self.choice.set(newVal)
if noteEdited:
self.widgetEdited(val=newVal, skipDups=False) |
Unlearn a parameter value by setting it back to its default
def unlearnValue(self):
"""Unlearn a parameter value by setting it back to its default"""
defaultValue = self.defaultParamInfo.get(field = "p_filename",
native = 0, prompt = 0)
self.choice.set(defaultValue) |
Use this to enable or disable (grey out) a parameter.
def setActiveState(self, active):
""" Use this to enable or disable (grey out) a parameter. """
st = DISABLED
if active: st = NORMAL
self.entry.configure(state=st)
self.inputLabel.configure(state=st)
self.promptLabel.... |
If this par's value is different from the default value, it is here
that we flag it somehow as such. This basic version simply makes the
surrounding text red (or returns it to normal). May be overridden.
Leave force at False if you want to allow this mehtod to make smart
time-saving dec... |
Allow keys typed in widget to select items
def keypress(self, event):
"""Allow keys typed in widget to select items"""
try:
self.choice.set(self.shortcuts[event.keysym])
except KeyError:
# key not found (probably a bug, since we intend to catch
# only events ... |
Make sure proper entry is activated when menu is posted
def postcmd(self):
"""Make sure proper entry is activated when menu is posted"""
value = self.choice.get()
try:
index = self.paramInfo.choice.index(value)
self.entry.menu.activate(index)
except ValueError:
... |
Convert to native bool; interpret certain strings.
def convertToNative(self, aVal):
""" Convert to native bool; interpret certain strings. """
if aVal is None:
return None
if isinstance(aVal, bool): return aVal
# otherwise interpret strings
return str(aVal).lower() i... |
Toggle value between Yes and No
def toggle(self, event=None):
"""Toggle value between Yes and No"""
if self.choice.get() == "yes":
self.rbno.select()
else:
self.rbyes.select()
self.widgetEdited() |
Ensure any INDEF entry is uppercase, before base class behavior
def entryCheck(self, event = None, repair = True):
""" Ensure any INDEF entry is uppercase, before base class behavior """
valupr = self.choice.get().upper()
if valupr.strip() == 'INDEF':
self.choice.set(valupr)
... |
:Purpose: Interpolates y based on the given xval.
x and y are a pair of independent/dependent variable arrays that must
be the same length. The x array must also be sorted.
xval is a user-specified value. This routine looks
up xval in the x array and uses that information to properly interpolate
th... |
updates the current record of the packet size per sample and the relationship between this and the fifo reads.
def _setSampleSizeBytes(self):
"""
updates the current record of the packet size per sample and the relationship between this and the fifo reads.
"""
self.sampleSizeBytes = se... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.