INSTRUCTION stringlengths 1 8.43k | RESPONSE stringlengths 75 104k |
|---|---|
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'
if not format:
... |
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 up parameters necessary for updating WCS
# Check to see if new value is provided,
... |
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 value: True] controls whether or not to retain the original
distortion solution in the CD matrix.
'''
_ratio = pixel_scale / self.pscale
# Correct the siz... |
This method would apply the WCS keywords to a position to generate a new sky position. | def xy2rd(self,pos):
"""
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)
"""
if self.ctype1.find('TAN') < 0 or self.ctype2.find('TAN') < 0:
... |
This method would use the WCS keywords to compute the XY position from a given RA/ Dec tuple ( in deg ). | def rd2xy(self,skypos,hour=no):
"""
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
"""
if self.ctype1.find('T... |
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
# reference frame.
_delta = self.get_orient() - orient
... |
Write out the values of the WCS keywords to the specified image. | def write(self,fitsname=None,wcs=None,archive=True,overwrite=False,quiet=True):
"""
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... |
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:
return
for key in self.backup.keys():
if key != 'WCSCDATE':
... |
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=None,overwrite=no,quiet=yes):
""" 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.
... |
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 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.
"""
# S... |
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. | def write_archive(self,fitsname=None,overwrite=no,quiet=yes):
""" 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, ... |
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
image = self.rootname
if prepend: _prepend = prepend
elif self.prepend: _prepend = self.prep... |
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 already exists, delete it to make way for new file
if os.path.exists(refname):
... |
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['EXTVER'] = 1
# Now, update original image size information
hdu.header['WCSAXE... |
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 empty dir " + str(new... |
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 4th years, every 4th or 400th but not 100th, every 4th but not 128th)
'''
method = method or 'equinox'
if year in (3, 7, 11):
return True
elif year < ... |
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 day number containing fall equinox (first day of the FR year)'''
p = ephem.previous_fall_equinox(dublin.from_jd(jd))
previous = trunc(dublin.to_jd(p) - 0.5) + 0.5
... |
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 > 13:
raise ValueError("Invalid month for this calendar")
... |
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 every-four-years method below year 16 (madler) or below 15 (ro... |
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
"sansculottides" are considered a thirteenth
month in the results of this function.'''
method = method or 'equinox'
if method == 'equinox':
return _from_jd_equinox(jd)
... |
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
y0, y1, y2, y3, y4, y5 = 0, 0, 0, 0, 0, 0
intercal_cyc... |
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 - equinoxe) % 30) + 1
return (an, mois, jour) |
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 = 31
else:
Caitra = 30
if... |
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 = gregorian.from_jd(jd) # Gregorian date for Julian day
leap = isleap(greg[0]) # Is this a leap... |
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_name
) for f in islice(frame_iterator(sys._getframe(1 ... |
Decorates func to have logging. | def log(func=None,
stacktrace=10,
stacktrace_align=60,
attributes=(),
module=True,
call=True,
call_args=True,
call_args_repr=repr,
result=True,
exception=True,
exception_repr=repr,
result_repr=strip_non_ascii,
use_logging='C... |
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 current
state.
:param cfg: the config object.
:return:
"""
logger = logging.getLogger('recorder')
httpPoster = cfg.handlers.get('remote')
csvLogger = ... |
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):
"""
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.
... |
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.
: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).
"""
record = self.measur... |
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 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.
"""
recor... |
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=None, callback=None):
"""
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 callba... |
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.
"""
self.statuses.append({'name': ScheduledMeasurementStatus.RUNNING.name, 'time': datetime.utcnow()})
try:
s... |
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 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.
"""
if at is not Non... |
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 since that will no... | def launch_and_wait(mp_proc_list, pool_size):
""" 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 inclu... |
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 ). | def best_tile_layout(pool_size):
""" 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)... |
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._completeTask()
except:
logger.exception("... |
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 not None:
self._workQueue.put((requestType, list(*args)))
else:
logg... |
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
tealGui = self._mainGuiObj
tealGui.show... |
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'):
""" 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. """
... |
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 unicode. So we u... | def ndarr2bytes(arr, encoding='ascii'):
""" 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 instanc... |
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' 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. """
# NOTE: after we abandon... |
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 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. """
if PY3K:
if isi... |
Decorator that retries the call retries times if func raises exceptions. Can use a backoff function to sleep till next retry. | def retry(func=None, retries=5, backoff=None, exceptions=(IOError, OSError, EOFError), cleanup=None, sleep=time.sleep):
"""
Decorator that retries the call ``retries`` times if ``func`` raises ``exceptions``. Can use a ``backoff`` function
to sleep till next retry.
Example::
>>> 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=None):
"""
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 ... |
: 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.
:param tmpCacheEntry: the cache entry.
:return:
"""
from analyser.common.signal import loadSignalFromWav
tmpCacheEntry['sta... |
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, filename, chunkIdx=None):
"""
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... |
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 1kHz sample rate file output file.
:param filename:
:param totalChunks:
:param status:
:return:
"""
def getChunkIdx(x):
try:
... |
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 targetFs and writes it to filename.
:param filename: the filename.
:param signal: the signal to resample.
:param targetFs: the target fs.
:return: None
"""
import li... |
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['name'] == name), (None, None))
if entry is not None:
logger.info("Deleti... |
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,
defaultsVerb="Default", bg=None, indent=False,
fl... |
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('<ButtonRelease-1>', self.watchTextSelection, "+")
self.e... |
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:
# Entry value is OK
# Save the last selectio... |
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 certain
cases we manually add the text to the clipboard (though on most
platforms the correct behavior happens automatically). """
# Note that this isn't perfect - it is a key click be... |
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
# scrolls and text selection when the focus moves in an... |
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 times itself handling the removal of any/ all ... | def widgetEdited(self, event=None, val=None, action='entry', skipDups=True):
""" 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 so... |
Popup right - click menu of special parameter operations | def popupChoices(self, event=None):
"""Popup right-click menu of special parameter operations
Relies on browserEnabled, clearEnabled, unlearnEnabled, helpEnabled
instance attributes to determine which items are available.
"""
# don't bother if all items are disabled
if N... |
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 fname:
return # canceled
... |
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.configure(state=st) |
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 decisions about when it can skip ... | def flagThisPar(self, currentVal, force):
""" 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 a... |
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 from shortcut keys, but ignore it anyway)
... |
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:
# initial null value may not be in list
... |
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() in ('1','on','yes','true') |
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)
return EparOption.entryCheck(self, event, repair = repair) |
: Purpose: Interpolates y based on the given xval. | def xyinterp(x,y,xval):
"""
: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 ... |
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 = self.getPacketSize()
if self.sampleSizeBytes > 0:
self.maxBytesPerFifoRead = (32 // self.sampl... |
the current packet size.: return: the current packet size based on the enabled registers. | def getPacketSize(self):
"""
the current packet size.
:return: the current packet size based on the enabled registers.
"""
size = 0
if self.isAccelerometerEnabled():
size += 6
if self.isGyroEnabled():
size += 6
if self.isTemperature... |
performs initialisation of the device: param batchSize: the no of samples that each provideData call should yield: return: | def initialiseDevice(self):
"""
performs initialisation of the device
:param batchSize: the no of samples that each provideData call should yield
:return:
"""
logger.debug("Initialising device")
self.getInterruptStatus()
self.setAccelerometerSensitivity(se... |
Specifies the device should write acceleration values to the FIFO is not applied until enableFIFO is called.: return: | def enableAccelerometer(self):
"""
Specifies the device should write acceleration values to the FIFO, is not applied until enableFIFO is called.
:return:
"""
logger.debug("Enabling acceleration sensor")
self.fifoSensorMask |= self.enableAccelerometerMask
self._acc... |
Specifies the device should NOT write acceleration values to the FIFO is not applied until enableFIFO is called.: return: | def disableAccelerometer(self):
"""
Specifies the device should NOT write acceleration values to the FIFO, is not applied until enableFIFO is
called.
:return:
"""
logger.debug("Disabling acceleration sensor")
self.fifoSensorMask &= ~self.enableAccelerometerMask
... |
Specifies the device should write gyro values to the FIFO is not applied until enableFIFO is called.: return: | def enableGyro(self):
"""
Specifies the device should write gyro values to the FIFO, is not applied until enableFIFO is called.
:return:
"""
logger.debug("Enabling gyro sensor")
self.fifoSensorMask |= self.enableGyroMask
self._gyroEnabled = True
self._set... |
Specifies the device should NOT write gyro values to the FIFO is not applied until enableFIFO is called.: return: | def disableGyro(self):
"""
Specifies the device should NOT write gyro values to the FIFO, is not applied until enableFIFO is called.
:return:
"""
logger.debug("Disabling gyro sensor")
self.fifoSensorMask &= ~self.enableGyroMask
self._gyroEnabled = False
s... |
Specifies the device should write temperature values to the FIFO is not applied until enableFIFO is called.: return: | def enableTemperature(self):
"""
Specifies the device should write temperature values to the FIFO, is not applied until enableFIFO is called.
:return:
"""
logger.debug("Enabling temperature sensor")
self.fifoSensorMask |= self.enableTemperatureMask
self._setSampl... |
Specifies the device should NOT write temperature values to the FIFO is not applied until enableFIFO is called.: return: | def disableTemperature(self):
"""
Specifies the device should NOT write temperature values to the FIFO, is not applied until enableFIFO is called.
:return:
"""
logger.debug("Disabling temperature sensor")
self.fifoSensorMask &= ~self.enableTemperatureMask
self._s... |
Sets the gyro sensitivity to 250 500 1000 or 2000 according to the given value ( and implicitly disables the self tests ): param value: the target sensitivity. | def setGyroSensitivity(self, value):
"""
Sets the gyro sensitivity to 250, 500, 1000 or 2000 according to the given value (and implicitly disables the
self
tests)
:param value: the target sensitivity.
"""
try:
self.i2c_io.write(self.MPU6050_ADDRESS, se... |
Sets the accelerometer sensitivity to 2 4 8 or 16 according to the given value. Throws an ArgumentError if the value provided is not valid.: param value: the target sensitivity. | def setAccelerometerSensitivity(self, value):
"""
Sets the accelerometer sensitivity to 2, 4, 8 or 16 according to the given value. Throws an ArgumentError if
the value provided is not valid.
:param value: the target sensitivity.
"""
# note that this implicitly disables t... |
Sets the internal sample rate of the MPU - 6050 this requires writing a value to the device to set the sample rate as Gyroscope Output Rate/ ( 1 + SMPLRT_DIV ) where the gryoscope outputs at 8kHz and the peak sampling rate is 1kHz. The target sample rate is therefore capped at 1kHz.: param targetSampleRate: the target ... | def setSampleRate(self, targetSampleRate):
"""
Sets the internal sample rate of the MPU-6050, this requires writing a value to the device to set the sample
rate as Gyroscope Output Rate / (1 + SMPLRT_DIV) where the gryoscope outputs at 8kHz and the peak sampling rate
is 1kHz. The target... |
Resets the FIFO by first disabling the FIFO then sending a FIFO_RESET and then re - enabling the FIFO.: return: | def resetFifo(self):
"""
Resets the FIFO by first disabling the FIFO then sending a FIFO_RESET and then re-enabling the FIFO.
:return:
"""
logger.debug("Resetting FIFO")
self.i2c_io.write(self.MPU6050_ADDRESS, self.MPU6050_RA_USER_CTRL, 0b00000000)
pass
se... |
Enables the FIFO resets it and then sets which values should be written to the FIFO.: return: | def enableFifo(self):
"""
Enables the FIFO, resets it and then sets which values should be written to the FIFO.
:return:
"""
logger.debug("Enabling FIFO")
self.i2c_io.write(self.MPU6050_ADDRESS, self.MPU6050_RA_FIFO_EN, 0)
self.resetFifo()
self.i2c_io.writ... |
gets the amount of data available on the FIFO right now.: return: the number of bytes available on the FIFO which will be proportional to the number of samples available based on the values the device is configured to sample. | def getFifoCount(self):
"""
gets the amount of data available on the FIFO right now.
:return: the number of bytes available on the FIFO which will be proportional to the number of samples available
based on the values the device is configured to sample.
"""
bytes = self.i... |
reads the specified number of bytes from the FIFO should be called after a call to getFifoCount to ensure there is new data available ( to avoid reading duplicate data ).: param bytesToRead: the number of bytes to read.: return: the bytes read. | def getDataFromFIFO(self, bytesToRead):
"""
reads the specified number of bytes from the FIFO, should be called after a call to getFifoCount to ensure there
is new data available (to avoid reading duplicate data).
:param bytesToRead: the number of bytes to read.
:return: the byte... |
reads a batchSize batch of data from the FIFO while attempting to optimise the number of times we have to read from the device itself.: return: a list of data where each item is a single sample of data converted into real values and stored as a dict. | def provideData(self):
"""
reads a batchSize batch of data from the FIFO while attempting to optimise the number of times we have to read
from the device itself.
:return: a list of data where each item is a single sample of data converted into real values and stored as a
dict.
... |
unpacks a single sample of data ( where sample length is based on the currently enabled sensors ).: param rawData: the data to convert: return: a converted data set. | def unpackSample(self, rawData):
"""
unpacks a single sample of data (where sample length is based on the currently enabled sensors).
:param rawData: the data to convert
:return: a converted data set.
"""
length = len(rawData)
# TODO error if not multiple of 2
... |
Like: func: textwrap. wrap but preserves existing newlines which: func: textwrap. wrap does not otherwise handle well. | def wrap(text, width, *args, **kwargs):
"""
Like :func:`textwrap.wrap` but preserves existing newlines which
:func:`textwrap.wrap` does not otherwise handle well.
See Also
--------
:func:`textwrap.wrap`
"""
return sum([textwrap.wrap(line, width, *args, **kwargs)
if line... |
Outputs line - wrapped text wrapped in a box drawn with a repeated ( usually ASCII ) character. | def textbox(text, width=78, boxchar='#', indent=0):
"""
Outputs line-wrapped text wrapped in a box drawn with a repeated (usually
ASCII) character.
For example:
>>> print(textbox('Text to wrap', width=16))
################
# #
# Text to wrap #
# ... |
Entrypoint function. | def main():
"""Entrypoint function."""
parser = argparse.ArgumentParser()
parser.add_argument('-u', '--username',
help='Hydro Quebec username')
parser.add_argument('-p', '--password',
help='Password')
parser.add_argument('-j', '--json', action='store_t... |
Calculate western easter | def easter(year):
'''Calculate western easter'''
# formula taken from http://aa.usno.navy.mil/faq/docs/easter.html
c = trunc(year / 100)
n = year - 19 * trunc(year / 19)
k = trunc((c - 17) / 25)
i = c - trunc(c / 4) - trunc((c - k) / 3) + (19 * n) + 15
i = i - 30 * trunc(i / 30)
i = i ... |
July 4th | def independence_day(year, observed=None):
'''July 4th'''
day = 4
if observed:
if calendar.weekday(year, JUL, 4) == SAT:
day = 3
if calendar.weekday(year, JUL, 4) == SUN:
day = 5
return (year, JUL, day) |
in USA: 2nd Monday in Oct Elsewhere: Oct 12 | def columbus_day(year, country='usa'):
'''in USA: 2nd Monday in Oct
Elsewhere: Oct 12'''
if country == 'usa':
return nth_day_of_month(2, MON, OCT, year)
else:
return (year, OCT, 12) |
USA: last Thurs. of November Canada: 2nd Mon. of October | def thanksgiving(year, country='usa'):
'''USA: last Thurs. of November, Canada: 2nd Mon. of October'''
if country == 'usa':
if year in [1940, 1941]:
return nth_day_of_month(3, THU, NOV, year)
elif year == 1939:
return nth_day_of_month(4, THU, NOV, year)
else:
... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.