def dictionary(dict_type='aspell', dict_language='en_GB'):
wordlist = set()
join = os.path.join
fpath = join(susx._sussex_root, 'data', 'aspell', 'en-common.wl')
with open(fpath, 'r') as fh:
wordlist.union(_read_word_list(fh))
if dict_type not in _dict_types:
raise AttributeError('Unrecognized dictionary type (%s), must be '
'one of %s.' % (dict_type, ' '.join(_dict_types)))
if dict_language not in _dict_languages:
raise AttributeError('Unrecognized dictionary language (%s), must be '
'one of %s.' %
(dict_language, ' '.join(_dict_languages)))
wl_files = []
if dict_type == 'aspell':
wl_files = os.listdir(os.path.join(susx._sussex_root, 'data',
'aspell'))
wl_files = [f for f in wl_files if f.startswith(dict_language)]
for wl in wl_files:
with open(join(susx._sussex_root, 'data', 'aspell', wl),
'r') as fh:
wordlist = wordlist.union(_read_word_list(fh))
return wordlist
def __init__(self, name, problemStructureDict):
threading.Thread.__init__(self, name=name)
self.shutdownFlag = threading.Event()
self._config = problemStructureDict[name]
self.receiveQueue = Queue.Queue(maxsize=0)
self.sendQueue = Queue.Queue(maxsize=0)
self.listenThread = self._ReceiveingThread("%s-listener" % self.name,
self._config.port,
self.receiveQueue)
self.sendThread = self._SendingThread("%s-sender" % self.name,
self._config.sPort,
self.sendQueue, self._config)
self.others = problemStructureDict.copy()
self._maxFaulty = int((len(self.others) - 1) / 3.0)
if self.others.pop(self.name) is None:
raise AttributeError("Did not find self in soluton")
#Initialize self state
self._state = None
self._maxMessages = self._getMaxMessages(len(self.others) + 1)
self._timeoutS = float(self._maxMessages * len(self.others)) * 0.02 + 3
logger.info("Timeout set to %f seconds", self._timeoutS)
self._timeoutTime = 0
self._decision = None
self._givenOrder = None
self._decisionTree = None
self._debugCounter = 0
self._uniqueUpdates = 0
def __delattr__(self, name):
""" Deletes an attribute and updates hash
"""
if name not in self._data_holder:
raise AttributeError(name)
del self._data_holder[name]
self._update_hash()
def __setattr__(self, key, value):
if self._is_frozen and key in self._parent_names:
raise AttributeError(
"Class {} parents are frozen: cannot set {} = {}".format(
self.name, key, value))
else:
object.__setattr__(self, key, value)
def __init__(self, size=None, palette=None):
if size is not None:
self.size = size
self.cmap = np.empty((self.size, 3), dtype=np.uint8)
elif palette is not None:
self._buildPalette(palette)
else:
raise AttributeError("Invalid Colormap Initializer")
def __getattr__(self, key):
if key.startswith("_") or not key in self._meta.storage_attributes:
raise AttributeError("Unknown attribute %s" % key)
else:
try:
return self._storage_dict[key]
except KeyError:
attr = self._meta.storage_attributes[key]
if attr.optional:
return None
elif attr.default is not None:
if callable(attr.default):
return attr.default(self._storage_dict)
else:
return attr.default
else:
log.error("Missing attribute %s, %s" % (key, self._storage_dict))
raise AttributeError("attribute %s not found" % key)
def drawlines(self, path):
if self.data is None:
raise AttributeError("data or keypoint not initilized")
import matplotlib
matplotlib.use('Agg')
from matplotlib import pyplot as plt
ma = self.ma.as_matrix()
plt.figure(1, figsize=(200, 20))
xline = range(len(self.ma))
yline = self.data_np[:, 0]
plt.plot(xline, yline, 'r-')
yline1 = ma[:, 0]
plt.plot(xline, yline1, 'g-')
plt.savefig(path)
def translate(self, matrix, hue=None, colormap=None):
if hue is None and colormap is None:
raise AttributeError("Need either a hue or colormap")
vmin = np.min(self.values)
vmax = np.max(self.values)
values = (self.values - vmin) / (vmax - vmin)
if colormap is None:
for x in range(self.width):
for y in range(self.height):
color = hsvToRgb(hue + values[x, y] / 5, 1, values[x, y])
matrix.drawPixel(x, y, color)
else:
buffer = colormap.apply(values)
matrix.copyBuffer(buffer)
def add_parameter(self, name, classname):
""" Helper to add a parameter's instance to your Test instance
@param name: the name you want to give to this parameter
@param module : name of the module/class to load (as string). Should be something like "filename.ClassName",
the "path" of domogik will be appended
@raise ImportError if the module can't be imported
@raise AttributeError if a parameter with this name already exists
"""
if name in self._parameters:
raise AttributeError("A parameter instance already exists with this name")
modonly = classname.split('.')[0]
classonly = classname.split('.')[1]
module_name = "domogik.scenario.parameters.{0}".format(modonly)
#This may raise ImportError
cname = getattr(__import__(module_name, fromlist = [modonly]), classonly)
p = cname(log=self.log, trigger=self.cb_trigger)
self._parameters[name] = p
def drawlines(self, path):
if self.data is None:
raise AttributeError("data or keypoint not initilized")
import matplotlib
matplotlib.use('Agg')
from matplotlib import pyplot as plt
boll = self.boll.as_matrix()
plt.figure(1, figsize=(200, 20))
xline = range(len(self.boll))
plt.subplot(2, 1, 1)
yline = self.data_np[:, 0]
plt.plot(xline, yline, 'r-')
plt.subplot(2, 1, 2)
yline1 = boll[:, 0]
yline2 = boll[:, 1]
yline3 = boll[:, 2]
plt.plot(xline, yline1, 'r-')
plt.plot(xline, yline2, 'g-')
plt.plot(xline, yline3, 'b-')
plt.savefig(path)
def drawlines(self, path):
if self.data is None or self.keypoint is None:
raise AttributeError("data or keypoint not initilized")
import matplotlib
matplotlib.use('Agg')
from matplotlib import pyplot as plt
xline1 = [
self.rsi.index.indexer_at_time(e)[0] for e in self.keypoint.index
]
rsi = self.rsi.as_matrix()
plt.figure(1, figsize=(200, 20))
xline = range(len(self.rsi))
plt.subplot(2, 1, 1)
yline = self.data_np
plt.plot(xline, yline, 'r-')
plt.plot(xline1, yline[xline1], '*')
plt.subplot(2, 1, 2)
yline1 = rsi[:, 0]
yline2 = rsi[:, 1]
plt.plot(xline, yline2, 'y-')
plt.plot(xline, yline1, 'r-')
plt.plot(xline1, yline1[xline1], '*')
plt.savefig(path)
def __getattr__(self, name):
if name not in self._data_holder:
raise AttributeError(name)
return self._data_holder[name]
def __init__(self, path=''):
if self.__tablename__ == '':
from exceptions import AttributeError
raise AttributeError('__tablename__ must be needed.')
super(TableBase, self).__init__(path)
