def __fetch_requests(self, task_entry):
p = Pattern(task_entry, self.__getCurrentShell(task_entry), self.global_data)
timeout = task_entry.get('timeout', 120)
urls = p.convertPattern('url')
s = requests.session()
headers = task_entry.get('headers', [])
task_entry['datas'] = []
if not urls:
return task_entry
for url in urls:
self.logger.info("fetching " + url)
data = ""
if not url:
# do not fetch null url
continue
try:
response = s.get(url, timeout=timeout, headers=headers)
if 200 != response.status_code:
self.logger.error("fetch " + url + " failed with code " + (str)(response.status_code))
data = response.text
except:
self.logger.error("fetch " + url + " failed in sockets")
task_entry['datas'].append(data)
return task_entry
def getPattern(self):
pat = Pattern()
for i in range(0, self.length):
try:
note = MIDI_Dict[self.GetCellValue(NOTE_ROW,i)]
except KeyError, e:
note = REST_NOTE
if 'A' in self.GetCellValue(EFFECT_ROW, i):
accent = True
else:
accent = False
if 'S' in self.GetCellValue(EFFECT_ROW,i):
slide = True
else:
slide = False
if 'U' in self.GetCellValue(EFFECT_ROW, i):
transpose = TRANSPOSE_UP
elif 'D' in self.GetCellValue(EFFECT_ROW, i):
transpose = TRANSPOSE_DOWN
else:
transpose = TRANSPOSE_NONE
pat.appendNote(note, accent, slide, transpose)
class If:
def __init__(self, predicate):
if isinstance(predicate, str):
self.predicate = Pattern(predicate)
else:
self.predicate = predicate
self.predicate_assertion = True
self.deduction = Pattern('')
def is_(self, v):
self.predicate_assertion = v
return self
def then(self, deduction):
if isinstance(deduction, str):
self.deduction = Pattern(deduction)
else:
self.deduction = deduction
return self
def deduct(self, input_):
refs, successful = self.predicate.match(input_)
if self.predicate_assertion and successful:
return self.deduction.evaluate(refs)
else:
raise Paradox
def __str__(self):
return 'if %s then %s' % (self.predicate, self.deduction)
def __init__(self, predicate):
if isinstance(predicate, str):
self.predicate = Pattern(predicate)
else:
self.predicate = predicate
self.predicate_assertion = True
self.deduction = Pattern('')
def export(self):
"""
"""
logger.debug("Begin RSS Export:")
db = CrawlDB()
rep = Pattern()
for pat in db.getPatterns():
pid = pat["pid"]
pattern = pat["pattern"]
description = pat["name"]
items = []
for page in db.getPages("where pid=%d limit 10" % pid):
items.append(self.rssitem % (page["url"],
page["title"],
"",
pattern,
"",
page["url"],
rep.sub(page["content"])))
itemout = "\n".join(items)
output = self.rssframe % (pattern,
"http://hjbbs.com/bbs",
description,
"Learning English Tool",
itemout)
logger.debug("LET %d:\n%s\n" % (pid, output))
# write out
fp = open("%slet%d.xml" % (config.RSSDIR, pid), "w")
fp.write(output.encode('utf8'))
fp.close()
logger.debug("End RSS Export.")
def __init__(self, filename):
Pattern.__init__(self, filename)
if self.n&1023 != 0:
raise ValueError('Number of patterns must be a multiple of 1024.')
self.patterns_gpu = cuda.mem_alloc(self.patterns.nbytes)
cuda.memcpy_htod(self.patterns_gpu, self.patterns)
self.input_gpu = cuda.mem_alloc(4*((40*8)+16))
self.result_gpu = gpuarray.empty((40,self.n), dtype=numpy.float32, allocator=cuda.mem_alloc)
def __init__(self, config, config_global):
"""Init pattern."""
self.config_defaults = {
'xxx': 0,
"list": [
[
1,
-1,
-1,
-1,
-1,
1,
-1,
-1,
-1,
-1,
1,
-1,
-1,
-1,
-1,
1
],
[
0,
-1,
-1,
-1,
-1,
0,
-1,
-1,
-1,
-1,
0,
-1,
-1,
-1,
-1,
0
]
],
}
# python3 syntax
# super().__init__()
# python2 syntax
# super(Pattern, self).__init__()
# explicit call
Pattern.__init__(self, config, config_global)
# inits for this pattern
self.strobe_state = False
def __fetch(self, task_entry):
p = Pattern(task_entry, self.__getCurrentShell(task_entry), self.config_data)
urls = p.convertPattern('url')
s = requests.session()
task_entry['datas'] = []
for url in urls:
self.logger.info("fetching " + url)
if "" == url:
# do not fetch null url
continue
response = s.get(url)
if 200 != response.status_code:
self.logger.error("fetch " + url + " failed with code" + response.status_code)
data = response.text
task_entry['datas'].append(data)
return task_entry
def loadPatternsFromFile(f):
# load patterns from file f
# return: a list of patterns
patterns = list();
xy = False;
p = 0;
ifile = open(f);
for line in ifile:
if(line.startswith("===")):
if p!=0:
patterns.append(p)
p = Pattern();
xy = True;
continue;
elements = line.strip().split("\t");
if xy == True:
xy = False;
p.x = elements[0];
p.y = elements[1];
v1 = p.g.add_node(elements[0],l=int(elements[1]));
for i in range(2,len(elements)):
p.g.add_edge(elements[0],elements[i]);
# g.elements[0]
p.covered.add(p.id);
if(p!=0):
patterns.append(p);
if(debug):
for p in patterns:
# printG(g,1,0);
print p.id;
print p.g.nodes(data=True)
print p.g.edges();
return patterns;
def __fetch_webkit(self, task_entry):
p = Pattern(task_entry, self.__getCurrentShell(task_entry), self.global_data)
import cwebbrowser
task_entry['datas'] = []
urls = p.convertPattern('url')
timeout = task_entry.get('timeout', 120)
delay = task_entry.get('delay', 0)
for url in urls:
self.logger.info("fetching " + url)
data = ""
if not url:
# do not fetch null url
continue
browser = cwebbrowser.CWebBrowser()
browser.setHeaders(task_entry.get('headers', []))
#browser.show();
try:
browser.load(url=url, load_timeout=timeout, delay=delay)
except cwebbrowser.Timeout:
self.logger.error("fetch " + url + " timeout ")
except Exception, exception:
self.logger.error("fetch " + url + " error ")
print "Exception message:", exception
else:
html = browser.html()
if html:
html = html.encode('utf-8')
data = html
else:
self.logger.error("fetch " + url + " failed with no response")
task_entry['datas'].append(data)
browser.close()
def __init__(self, input, length=0.05, gain=0.67):
PyoObject.__init__(self)
self.points = None
self.viewFrame = None
self._input = input
self._length = length
self._gain = gain
self._width = 500
self._height = 400
self._in_fader = InputFader(input)
in_fader, lmax = convertArgsToLists(self._in_fader)
self._base_objs = [Scope_base(wrap(in_fader,i), length) for i in range(lmax)]
self.view()
self._timer = Pattern(self.refreshView, length).play()
def test_refracted_color_with_refracted_ray(self):
w = World.default_world()
a = w.objects[0]
a.material.ambient = 1.0
a.material.pattern = Pattern.test_pattern()
b = w.objects[1]
b.material.transparency = 1.0
b.material.refractive_index = 1.5
r = Ray(Point(0, 0, 0.1), Vector(0, 1, 0))
xs = Intersection.intersections(Intersection(-0.9899, a),
Intersection(-0.4899, b),
Intersection(0.4899, b),
Intersection(0.9899, a))
comps = Computations.prepare_computations(xs[2], r, xs)
c = World.refracted_color(w, comps, 5)
self.assertEqual(c, Color(0, 0.99888, 0.04725))
def __init__(self, input, function=None, mul=1, add=0):
PyoObject.__init__(self, mul, add)
self._input = input
if callable(function):
self._function = getWeakMethodRef(function)
else:
self._function = None
self._in_fader = InputFader(input)
in_fader, mul, add, lmax = convertArgsToLists(self._in_fader, mul, add)
self._base_objs = [
PeakAmp_base(wrap(in_fader, i), wrap(mul, i), wrap(add, i))
for i in range(lmax)
]
sr = self.getSamplingRate()
bs = self.getBufferSize()
self._timer = Pattern(self._buildList, bs / sr).play()
def __init__(
self,
uri,
path=None,
revision=None,
remote=None, # pylint: disable=W0613
pattern=None,
*args,
**kws):
self.uri = self._safepath(uri)
self.path = self._safepath(path)
self.revision = revision
self.remote = remote
self.source = kws.get('source') or remote
self.pattern = pattern or Pattern()
self.args = args
self.kws = kws
def sendReadPatternMessage(self, bank, loc):
self.s.flushInput()
self.sendBasicPacket(READ_PATTERN_MSG, content=chr(bank) + chr(loc))
packet = self.getBasicPacket()
if packet.isCorrect:
packet.printMe()
else:
packet.printMe()
print 'Bad packet!'
if packet.isCorrect and packet.messageType() == X0X_PATT_MSG:
pat = Pattern(packet.content())
return pat
else:
print 'Error: Received a bad pattern.'
raise BadPacketException('Received a bad pattern.')
def siatech(d):
d = Dataset.sort_ascending(d)
# Map of difference vector, index list pairs.
mtp_map = {}
# Compute the difference vectors between points and add both
# the starting and ending index as pair to the lists corresponding to the
# difference vector.
for i in range(len(d)):
for j in range(i + 1, len(d)):
diff = d[j] - d[i]
if diff in mtp_map:
mtp_map[diff].append((i, j))
else:
mtp_map[diff] = [(i, j)]
tecs = []
handled_patterns = set()
for diff_vec in mtp_map:
pattern = []
pattern_indices = []
mtp = mtp_map[diff_vec]
for index_pair in mtp:
pattern_indices.append(index_pair[0])
pattern.append(d[index_pair[0]])
vectorized_pattern = Pattern(vec(pattern))
if vectorized_pattern not in handled_patterns:
translators = []
if len(pattern) == 1:
for point in d:
translators.append(point - pattern[0])
else:
translators = find_translators_h(pattern, vectorized_pattern,
mtp_map, d)
tecs.append(TEC(pattern, pattern_indices, translators))
handled_patterns.add(vectorized_pattern)
return tecs
def respond_to_key(self, k):
GestureClassifier.respond_to_key(self, k)
if k == 'w':
if self.recording:
self.recording = False
print "STOPPED RECORDING"
name = raw_input("Enter a name for this gesture: ")
self.patterns.append(Pattern(name, self.pattern_points))
#print self.patterns[-1].normalize()
self.reset()
else:
print "STARTED RECORDING"
self.recording = True
self.reset()
elif k == 's':
if len(self.patterns) > 0:
self.write_to_file()
return
def load_from(path: str):
collection = PatternCollection()
with open(path, 'r', encoding='utf8') as csv:
next(csv)
for line in csv:
line = line.strip()
parts = line.split(';')
tool = None
sentiment = None
for t in Tool:
if parts[0] == t.name:
tool = t
break
for s in Sentiment:
if parts[1] == s.name:
sentiment = s
break
change = parts[2]
collection.append(Pattern(sentiment, tool, '', change))
return collection
class PatternListener(liblo.ServerThread):
def __init__(self, address=8765):
liblo.ServerThread.__init__(self, address)
self.pattern = Pattern()
@liblo.make_method('/pattern/set', 'ii')
def set_callback(self, path, args):
track, step = args
self.pattern.set_step(track, step)
@liblo.make_method('/pattern/clear', 'ii')
def clear_callback(self, path, args):
track, step = args
self.pattern.clear_step(track, step)
@liblo.make_method('/pattern/mute', 'i')
def mute_callback(self, path, track):
self.pattern.mute(track)
@liblo.make_method('/pattern/unmute', 'i')
def unmute_callback(self, path, track):
self.pattern.unmute(track)
class PatternListener(liblo.ServerThread):
def __init__(self, address=8765):
liblo.ServerThread.__init__(self, address)
self.pattern = Pattern()
@liblo.make_method('/pattern/set', 'ii')
def set_callback(self, path, args):
track, step = args
self.pattern.set_step(track, step)
@liblo.make_method('/pattern/clear', 'ii')
def clear_callback(self, path, args):
track, step = args
self.pattern.clear_step(track, step)
@liblo.make_method('/pattern/mute', 'i')
def mute_callback(self, path, track):
self.pattern.mute(track)
@liblo.make_method('/pattern/unmute', 'i')
def unmute_callback(self, path, track):
self.pattern.unmute(track)
def __init__(self, input, size=1024, wintype=2, function=None):
PyoObject.__init__(self)
self.points = None
self.viewFrame = None
self._input = input
self._size = size
self._wintype = wintype
self._function = getWeakMethodRef(function)
self._fscaling = 0
self._mscaling = 1
self._lowbound = 0
self._highbound = 0.5
self._width = 500
self._height = 400
self._gain = 1
self._in_fader = InputFader(input)
in_fader, size, wintype, lmax = convertArgsToLists(self._in_fader, size, wintype)
self._base_objs = [Spectrum_base(wrap(in_fader,i), wrap(size,i), wrap(wintype,i)) for i in range(lmax)]
if function == None:
self.view()
self._timer = Pattern(self.refreshView, 0.05).play()
def read_bytes(self, data):
try:
self.name = data[0:20].rstrip(b'\0').decode()
except UnicodeDecodeError:
self.name = 'invalid'
for offset in range(20, 950, 30):
sample = Sample(data[offset:offset + 30])
self.samples.append(sample)
if sample.name:
self.vanity += '\n' + sample.name
length = data[950]
self.positions = [byte for byte in data[952:1080]][:length]
self.mk = data[1080:1084]
num_patterns = max(self.positions) + 1
dex = 1024 * num_patterns + 1084
for offset in range(1084, dex, 1024):
self.patterns.append(Pattern(data[offset:offset + 1024]))
for sample in self.samples[1:]:
dex2 = dex + sample.length
sample.wave = data[dex:dex2]
dex = dex2
def wait(image_name, timeout=None, precision=None, in_region=None):
"""Wait for a Pattern or image to appear
:param image_name: String or Pattern
:param timeout: Number as maximum waiting time in seconds.
:param precision: Matching similarity
:param in_region: Region object in order to minimize the area
:return: True if found
"""
if isinstance(image_name, str) and is_ocr_text(image_name):
a_match = text_search_by(image_name, True, in_region)
if a_match is not None:
return True
else:
raise FindError('Unable to find text %s' % image_name)
elif isinstance(image_name, str) or isinstance(image_name, Pattern):
if timeout is None:
timeout = Settings.AutoWaitTimeout
if precision is None:
precision = Settings.MinSimilarity
try:
pattern = Pattern(image_name)
except Exception:
pattern = image_name
image_found = positive_image_search(pattern, timeout, precision,
in_region)
if image_found is not None:
return True
else:
raise FindError('Unable to find image %s' % image_name)
else:
raise ValueError(INVALID_GENERIC_INPUT)
def _general_click(where=None,
clicks=None,
duration=None,
in_region=None,
button=None):
"""General Mouse Click
:param where: Location , image name or Pattern
:param clicks: Number of mouse clicks
:param duration: speed of hovering from current location to target
:param in_region: Region object in order to minimize the area
:param button: Mouse button clicked (can be left, right, middle, 1, 2, 3)
:return: None
"""
if duration is None:
duration = Settings.MoveMouseDelay
if isinstance(where, str) and is_ocr_text(where):
a_match = text_search_by(where, True, in_region)
if a_match is not None:
click_location = Location(a_match['x'] + a_match['width'] / 2,
a_match['y'] + a_match['height'] / 2)
_click_at(click_location, clicks, duration, button)
elif isinstance(where, Location):
_click_at(where, clicks, duration, button)
elif isinstance(where, str) or isinstance(where, Pattern):
try:
pattern = Pattern(where)
except Exception:
pattern = where
_click_pattern(pattern, clicks, duration, in_region, button)
else:
raise ValueError(INVALID_GENERIC_INPUT)
def __add_pattern_to_trade_candidate_list_for_buy_trigger__(
self, pattern: Pattern, buy_trigger: str, trade_strategies: list):
best_strategy = self.__get_best_trade_strategy_for_pattern__(
buy_trigger, pattern, trade_strategies)
if best_strategy == '':
key = self.__get_key_for_black_buy_pattern_id_readable_list(
pattern, buy_trigger)
self.__add_to_black_buy_pattern_id_readable_list__(
key, BLR.NO_BEST_STRATEGY)
return
# we want to have limit fix strategy for all trades - for statistics reasons
trade_strategy_list = [best_strategy
] if best_strategy == TSTR.LIMIT_FIX else [
best_strategy, TSTR.LIMIT_FIX
]
for trade_strategy in trade_strategy_list:
key_buy_and_strategy = self.__get_key_for_black_buy_and_strategy_pattern_id_readable_list(
pattern, buy_trigger, trade_strategy)
if key_buy_and_strategy in self._black_buy_and_strategy_pattern_id_readable_list:
pass
# print('Already in black_buy_trigger_trade_strategy_pattern_id_list: {}'.format(key_buy_and_strategy))
else:
print('Add_to_candidate_list: Checking trade strategy: {}'.
format(key_buy_and_strategy))
if pattern.are_conditions_for_trade_strategy_fulfilled(
trade_strategy):
trade_api = PatternTradeApi(pattern, buy_trigger,
trade_strategy)
trade_api.exchange_config = self.exchange_config
trade_api.last_price_mean_aggregation = self.__get_optimal_last_price_mean_aggregation__(
pattern)
self.__add_trade_candidate_entry_to_ticker_id_dict__(
TradeCandidate(PatternTrade(trade_api)))
else:
self.__add_to_black_buy_strategy_pattern_id_readable_list__(
key_buy_and_strategy, BLR.TRADE_STRATEGY_CONDITIONS)
def waitVanish(image_name, timeout=None, precision=None, in_region=None):
"""Wait until a Pattern or image disappears
:param image_name: Image, Pattern or string
:param timeout: Number as maximum waiting time in seconds.
:param precision: Matching similarity
:param in_region: Region object in order to minimize the area
:return: True if vanished
"""
if timeout is None:
timeout = Settings.AutoWaitTimeout
if precision is None:
precision = Settings.MinSimilarity
pattern = Pattern(image_name)
image_found = negative_image_search(pattern, timeout, precision, in_region)
if image_found is not None:
return True
else:
raise FindError('%s did not vanish' % image_name)
def extract_patterns_unitary(ld_graph: rdflib.Graph):
"""Extracts from the linked data graph the patterns of length 1 together
with the instance nodes that are involved in such pattern.
The information for each semantic relation is represented in a Pattern
object.
See the Pattern class docs for more details about the information handling.
Parameters
----------
ld_graph: rdflib.Graph
The graph object containing the triples of the Linked data
Returns
-------
list
List of patterns (class Pattern) of length 1
"""
qres = ld_graph.query(queries.length_1_triples)
P1 = dict()
i = 0
for row in qres:
(x, c1, p, y, c2) = row
semantic_relation = (str(c1), str(p), str(c2))
if semantic_relation not in P1.keys():
# Create pattern graph and Pattern object
new_p = Pattern(i, 1, 0)
P1[semantic_relation] = new_p
i += 1
pattern = P1[semantic_relation]
pattern.add_relation(c1, c2, p)
pattern.add_relation_instance(c1, x, c2, y, p)
pattern.frequency += 1
#pickle.dump(P1, open('P1.pkl', 'wb'), protocol=pickle.HIGHEST_PROTOCOL)
return list(P1.values())
def write_dists(n, nr, group_name):
p = Pattern(n)
p.group(group_name)
p.to_fractional_coordinate()
lattice_vectors = np.array([p.a1, p.a2])
center_cell_fracts = np.mod(p.xys + .5, 1) - .5
rmax = np.max([
np.linalg.norm(np.dot(ij, lattice_vectors))
for ij in product((-1, 1), repeat=2)
])
num_layer = 36
x = range(-num_layer, num_layer + 1)
I, J = np.meshgrid(x, x)
I, J = I.flatten(), J.flatten()
xys = I[:, None] * p.a1 + J[:, None] * p.a2
mask = xys[:, 0]**2 + xys[:, 1]**2 <= rmax * rmax * 4
I, J = I[mask], J[mask]
image_cell_fracts = np.concatenate(
[center_cell_fracts + np.array(ij) for ij in zip(I, J)])
center_cell_carts = np.array(
[np.dot(fract, lattice_vectors) for fract in center_cell_fracts])
image_cell_carts = np.array(
[np.dot(fract, lattice_vectors) for fract in image_cell_fracts])
dists = cdist(center_cell_carts, image_cell_carts)
dists = dists[np.logical_and(dists > 0, dists <= rmax)]
bins = np.linspace(0, rmax, nr)
hist = np.histogram(dists, bins)
counts = hist[0]
rho = (len(center_cell_carts) / np.linalg.norm(np.cross(p.a1, p.a2)))
return counts / counts.sum() / rho / (2 * np.pi * bins[1:]) / (bins[1] -
bins[0])
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import regex
from collections import Counter
from pattern import Pattern, raw_patterns, categories, HSC_RANGE_8, HSC_GROUP_8, HSC_GROUP_8_NC
import pprint
## -----------------------------------------------------------------------------
## Globals
## -----------------------------------------------------------------------------
search_patterns = {}
for name, category in categories.items():
search_patterns[name] = Pattern(name, raw_patterns[name], category)
## -----------------------------------------------------------------------------
## Class Definition
## -----------------------------------------------------------------------------
class RoO:
"""Represent the Rules of Origin (with relevant methods) of a single FTA.
Methods:
plot_chapter_restrictions():
Create a line plot of cumulative roo_1 (y-axis) vs HS chapter (x-axis).
scatter_plot():
Create a scatter plot of roo_1 (y-axis) vs HS chapter (x-axis).
restrictions_table():
print "recheck with bigQ: " , bigQ; while len(bigQ)!=0: p = bigQ.pop() print "p.id=",p.id,"p.x,p.y",p.x, p.y if len(shouldHaveAll.difference(p.covered))!=0: # not contain all required nodes print "discards p id=",p.id,"since don't covered all should cover." pass; else: #generate several Q' for e2y in p.g.out_edges(): if node_match(p.g.node[e2y[1]],p.g.node[p.y]): # edges every x->y r = Pattern(); r.g = p.g.copy(); r.x = p.x; r.y = e2y[1]; print r.x,"---",r.y print "edgesize,b4",len(r.g.edges()),r.g.degree(r.y) r.g.remove_edge(e2y[0],e2y[1]); print "edgesize,aft",len(r.g.edges()),r.g.degree(r.y) if r.g.degree(r.y)==0: print "remove y", r.y r.g.remove_node(r.y); # print float(suppThreshold)/confThreshold; if computeSupport(baseG,r) <= float(suppThreshold)/confThreshold: # WARN: r will be 0; sigma.append(r);
m1_int_sel_gpot, m1_int_sel_spike,
np.zeros(N1_gpot, dtype=np.double),
np.zeros(N1_spike, dtype=int),
['interface', 'io', 'type'],
CTRL_TAG, GPOT_TAG, SPIKE_TAG, time_sync=True)
m2_id = 'm2 '
man.add(MyModule, m2_id, m2_int_sel, m2_int_sel_in, m2_int_sel_out,
m2_int_sel_gpot, m2_int_sel_spike,
np.zeros(N2_gpot, dtype=np.double),
np.zeros(N2_spike, dtype=int),
['interface', 'io', 'type'],
CTRL_TAG, GPOT_TAG, SPIKE_TAG, time_sync=True)
# Make sure that all ports in the patterns' interfaces are set so
# that they match those of the modules:
pat12 = Pattern(m1_int_sel, m2_int_sel)
pat12.interface[m1_int_sel_out_gpot] = [0, 'in', 'gpot']
pat12.interface[m1_int_sel_in_gpot] = [0, 'out', 'gpot']
pat12.interface[m1_int_sel_out_spike] = [0, 'in', 'spike']
pat12.interface[m1_int_sel_in_spike] = [0, 'out', 'spike']
pat12.interface[m2_int_sel_in_gpot] = [1, 'out', 'gpot']
pat12.interface[m2_int_sel_out_gpot] = [1, 'in', 'gpot']
pat12.interface[m2_int_sel_in_spike] = [1, 'out', 'spike']
pat12.interface[m2_int_sel_out_spike] = [1, 'in', 'spike']
pat12['/a/out/gpot0', '/b/in/gpot0'] = 1
pat12['/a/out/gpot1', '/b/in/gpot1'] = 1
pat12['/b/out/gpot0', '/a/in/gpot0'] = 1
pat12['/b/out/gpot1', '/a/in/gpot1'] = 1
pat12['/a/out/spike0', '/b/in/spike0'] = 1
pat12['/a/out/spike1', '/b/in/spike1'] = 1
pat12['/b/out/spike0', '/a/in/spike0'] = 1
def get_pattern_center_shape(pattern: Pattern):
ellipse_height = pattern.get_center_shape_height()
ellipse_width = pattern.get_center_shape_width()
xy_center = PlotterInterface.get_xy_from_timestamp_to_date_number(pattern.xy_center)
return Ellipse(np.array(xy_center), ellipse_width, ellipse_height)
def then(self, deduction):
if isinstance(deduction, str):
self.deduction = Pattern(deduction)
else:
self.deduction = deduction
return self
m2_int_sel_in,
m2_int_sel_out,
m2_int_sel_gpot,
m2_int_sel_spike,
np.zeros(N2_gpot, dtype=np.double),
np.zeros(N2_spike, dtype=int),
["interface", "io", "type"],
CTRL_TAG,
GPOT_TAG,
SPIKE_TAG,
time_sync=True,
)
# Make sure that all ports in the patterns' interfaces are set so
# that they match those of the modules:
pat12 = Pattern(m1_int_sel, m2_int_sel)
pat12.interface[m1_int_sel_out_gpot] = [0, "in", "gpot"]
pat12.interface[m1_int_sel_in_gpot] = [0, "out", "gpot"]
pat12.interface[m1_int_sel_out_spike] = [0, "in", "spike"]
pat12.interface[m1_int_sel_in_spike] = [0, "out", "spike"]
pat12.interface[m2_int_sel_in_gpot] = [1, "out", "gpot"]
pat12.interface[m2_int_sel_out_gpot] = [1, "in", "gpot"]
pat12.interface[m2_int_sel_in_spike] = [1, "out", "spike"]
pat12.interface[m2_int_sel_out_spike] = [1, "in", "spike"]
pat12["/a/out/gpot0", "/b/in/gpot0"] = 1
pat12["/a/out/gpot1", "/b/in/gpot1"] = 1
pat12["/b/out/gpot0", "/a/in/gpot0"] = 1
pat12["/b/out/gpot1", "/a/in/gpot1"] = 1
pat12["/a/out/spike0", "/b/in/spike0"] = 1
pat12["/a/out/spike1", "/b/in/spike1"] = 1
pat12["/b/out/spike0", "/a/in/spike0"] = 1
def get_pattern(self):
pattern = Pattern(self._pattern_id)
pattern.set_controller(self._controller)
return pattern
def __init__(self, address=8765):
liblo.ServerThread.__init__(self, address)
self.pattern = Pattern()
class Spectrum(PyoObject):
"""
Spectrum analyzer and display.
Spectrum measures the magnitude of an input signal versus frequency
within a user defined range. It can show both magnitude and frequency
on linear or logarithmic scale.
:Parent: :py:class:`PyoObject`
:Args:
input : PyoObject
Input signal to process.
size : int {pow-of-two > 4}, optional
FFT size. Must be a power of two greater than 4.
The FFT size is the number of samples used in each
analysis frame. Defaults to 1024.
wintype : int, optional
Shape of the envelope used to filter each input frame.
Possible shapes are :
0. rectangular (no windowing)
1. Hamming
2. Hanning
3. Bartlett (triangular)
4. Blackman 3-term
5. Blackman-Harris 4-term
6. Blackman-Harris 7-term
7. Tuckey (alpha = 0.66)
8. Sine (half-sine window)
function : python callable, optional
If set, this function will be called with magnitudes (as
list of lists, one list per channel). Useful if someone
wants to save the analysis data into a text file.
Defaults to None.
.. note::
Spectrum has no `out` method.
Spectrum has no `mul` and `add` attributes.
>>> s = Server().boot()
>>> s.start()
>>> a = SuperSaw(freq=[500,750], detune=0.6, bal=0.7, mul=0.5).out()
>>> spec = Spectrum(a, size=1024)
"""
def __init__(self, input, size=1024, wintype=2, function=None):
pyoArgsAssert(self, "oiiC", input, size, wintype, function)
PyoObject.__init__(self)
self.points = None
self.viewFrame = None
self._input = input
self._size = size
self._wintype = wintype
self._function = getWeakMethodRef(function)
self._fscaling = 0
self._mscaling = 1
self._lowbound = 0
self._highbound = 0.5
self._width = 500
self._height = 400
self._gain = 1
self._in_fader = InputFader(input)
in_fader, size, wintype, lmax = convertArgsToLists(self._in_fader, size, wintype)
self._base_objs = [Spectrum_base(wrap(in_fader,i), wrap(size,i), wrap(wintype,i)) for i in range(lmax)]
self._timer = Pattern(self.refreshView, 0.05).play()
if function == None:
self.view()
def setInput(self, x, fadetime=0.05):
"""
Replace the `input` attribute.
:Args:
x : PyoObject
New signal to process.
fadetime : float, optional
Crossfade time between old and new input. Default to 0.05.
"""
pyoArgsAssert(self, "oN", x, fadetime)
self._input = x
self._in_fader.setInput(x, fadetime)
def setSize(self, x):
"""
Replace the `size` attribute.
:Args:
x : int
new `size` attribute.
"""
pyoArgsAssert(self, "i", x)
self._size = x
x, lmax = convertArgsToLists(x)
[obj.setSize(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
def setWinType(self, x):
"""
Replace the `wintype` attribute.
:Args:
x : int
new `wintype` attribute.
"""
pyoArgsAssert(self, "i", x)
self._wintype = x
x, lmax = convertArgsToLists(x)
[obj.setWinType(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
def setFunction(self, function):
"""
Sets the function to be called to retrieve the analysis data.
:Args:
function : python callable
The function called by the internal timer to retrieve the
analysis data. The function must be created with one argument
and will receive the data as a list of lists (one list per channel).
"""
pyoArgsAssert(self, "C", function)
self._function = getWeakMethodRef(function)
def poll(self, active):
"""
Turns on and off the analysis polling.
:Args:
active : boolean
If True, starts the analysis polling, False to stop it.
defaults to True.
"""
pyoArgsAssert(self, "B", active)
if active:
self._timer.play()
else:
self._timer.stop()
def polltime(self, time):
"""
Sets the polling time in seconds.
:Args:
time : float
Adjusts the frequency of the internal timer used to
retrieve the current analysis frame. defaults to 0.05.
"""
pyoArgsAssert(self, "N", time)
self._timer.time = time
def setLowFreq(self, x):
"""
Sets the lower frequency, in Hz, returned by the analysis.
:Args:
x : float
New low frequency in Hz. Adjusts the `lowbound` attribute, as `x / sr`.
"""
pyoArgsAssert(self, "n", x)
x /= self.getServer().getSamplingRate()
self._lowbound = x
x, lmax = convertArgsToLists(x)
tmp = [obj.setLowbound(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
def setHighFreq(self, x):
"""
Sets the higher frequency, in Hz, returned by the analysis.
:Args:
x : float
New high frequency in Hz. Adjusts the `highbound` attribute, as `x / sr`.
"""
pyoArgsAssert(self, "n", x)
x /= self.getServer().getSamplingRate()
self._highbound = x
x, lmax = convertArgsToLists(x)
tmp = [obj.setHighbound(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
def setLowbound(self, x):
"""
Sets the lower frequency, as multiplier of sr, returned by the analysis.
Returns the real low frequency en Hz.
:Args:
x : float {0 <= x <= 0.5}
new `lowbound` attribute.
"""
pyoArgsAssert(self, "n", x)
self._lowbound = x
x, lmax = convertArgsToLists(x)
tmp = [obj.setLowbound(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
return tmp[0]
def setHighbound(self, x):
"""
Sets the higher frequency, as multiplier of sr, returned by the analysis.
Returns the real high frequency en Hz.
:Args:
x : float {0 <= x <= 0.5}
new `highbound` attribute.
"""
pyoArgsAssert(self, "n", x)
self._highbound = x
x, lmax = convertArgsToLists(x)
tmp = [obj.setHighbound(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
return tmp[0]
def getLowfreq(self):
"""
Returns the current lower frequency, in Hz, used by the analysis.
"""
return self._base_objs[0].getLowfreq()
def getHighfreq(self):
"""
Returns the current higher frequency, in Hz, used by the analysis.
"""
return self._base_objs[0].getHighfreq()
def setWidth(self, x):
"""
Sets the width, in pixels, of the current display.
Used internally to build the list of points to draw.
:Args:
x : int
new `width` attribute.
"""
pyoArgsAssert(self, "i", x)
self._width = x
x, lmax = convertArgsToLists(x)
[obj.setWidth(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
def setHeight(self, x):
"""
Sets the height, in pixels, of the current display.
Used internally to build the list of points to draw.
:Args:
x : int
new `height` attribute.
"""
pyoArgsAssert(self, "i", x)
self._height = x
x, lmax = convertArgsToLists(x)
[obj.setHeight(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
def setFscaling(self, x):
"""
Sets the frequency display to linear or logarithmic.
:Args:
x : boolean
If True, the frequency display is logarithmic. False turns
it back to linear. Defaults to False.
"""
pyoArgsAssert(self, "b", x)
self._fscaling = x
x, lmax = convertArgsToLists(x)
[obj.setFscaling(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
if self.viewFrame != None:
self.viewFrame.setFscaling(self._fscaling)
def setMscaling(self, x):
"""
Sets the magnitude display to linear or logarithmic.
:Args:
x : boolean
If True, the magnitude display is logarithmic (which means in dB).
False turns it back to linear. Defaults to True.
"""
pyoArgsAssert(self, "b", x)
self._mscaling = x
x, lmax = convertArgsToLists(x)
[obj.setMscaling(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
if self.viewFrame != None:
self.viewFrame.setMscaling(self._mscaling)
def getFscaling(self):
"""
Returns the scaling of the frequency display.
Returns True for logarithmic or False for linear.
"""
return self._fscaling
def getMscaling(self):
"""
Returns the scaling of the magnitude display.
Returns True for logarithmic or False for linear.
"""
return self._mscaling
def setGain(self, x):
"""
Set the gain of the analysis data. For drawing purpose.
:Args:
x : float
new `gain` attribute, as linear values.
"""
pyoArgsAssert(self, "n", x)
self._gain = x
x, lmax = convertArgsToLists(x)
[obj.setGain(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
def view(self, title="Spectrum", wxnoserver=False):
"""
Opens a window showing the result of the analysis.
:Args:
title : string, optional
Window title. Defaults to "Spectrum".
wxnoserver : boolean, optional
With wxPython graphical toolkit, if True, tells the
interpreter that there will be no server window.
If `wxnoserver` is set to True, the interpreter will not wait for
the server GUI before showing the controller window.
"""
pyoArgsAssert(self, "SB", title, wxnoserver)
createSpectrumWindow(self, title, wxnoserver)
def _setViewFrame(self, frame):
self.viewFrame = frame
def refreshView(self):
"""
Updates the graphical display of the spectrum.
Called automatically by the internal timer.
"""
self.points = [obj.display() for obj in self._base_objs]
if self._function != None:
self._function(self.points)
if self.viewFrame != None:
self.viewFrame.update(self.points)
@property
def input(self):
"""PyoObject. Input signal to process."""
return self._input
@input.setter
def input(self, x): self.setInput(x)
@property
def size(self):
"""int. FFT size."""
return self._size
@size.setter
def size(self, x): self.setSize(x)
@property
def wintype(self):
"""int. Windowing method."""
return self._wintype
@wintype.setter
def wintype(self, x): self.setWinType(x)
@property
def gain(self):
"""float. Sets the gain of the analysis data."""
return self._gain
@gain.setter
def gain(self, x): self.setGain(x)
@property
def lowbound(self):
"""float. Lowest frequency (multiplier of sr) to output."""
return self._lowbound
@lowbound.setter
def lowbound(self, x): self.setLowbound(x)
@property
def highbound(self):
"""float. Highest frequency (multiplier of sr) to output."""
return self._highbound
@highbound.setter
def highbound(self, x): self.setHighbound(x)
@property
def width(self):
"""int. Width, in pixels, of the current display."""
return self._width
@width.setter
def width(self, x): self.setWidth(x)
@property
def height(self):
"""int. Height, in pixels, of the current display."""
return self._height
@height.setter
def height(self, x): self.setHeight(x)
@property
def fscaling(self):
"""boolean. Scaling of the frequency display."""
return self._fscaling
@fscaling.setter
def fscaling(self, x): self.setFscaling(x)
@property
def mscaling(self):
"""boolean. Scaling of the magnitude display."""
return self._mscaling
@mscaling.setter
def mscaling(self, x): self.setMscaling(x)
class Scope(PyoObject):
"""
Oscilloscope - audio waveform display.
Oscilloscopes are used to observe the change of an electrical
signal over time.
:Parent: :py:class:`PyoObject`
:Args:
input : PyoObject
Input signal to process.
length : float, optional
Length, in seconds, of the displayed window. Can't be a list.
Defaults to 0.05.
gain : float, optional
Linear gain applied to the signal to be displayed.
Can't be a list. Defaults to 0.67.
function : python callable, optional
If set, this function will be called with samples (as
list of lists, one list per channel). Useful if someone
wants to save the analysis data into a text file.
Defaults to None.
.. note::
Scope has no `out` method.
Scope has no `mul` and `add` attributes.
>>> s = Server().boot()
>>> s.start()
>>> a = Sine([100,100.2], mul=0.7)
>>> b = Noise(0.1)
>>> scope = Scope(a+b)
"""
def __init__(self, input, length=0.05, gain=0.67, function=None):
pyoArgsAssert(self, "oNNC", input, length, gain, function)
PyoObject.__init__(self)
self.points = None
self.viewFrame = None
self._input = input
self._length = length
self._gain = gain
self._function = function
self._width = 500
self._height = 400
self._in_fader = InputFader(input)
in_fader, lmax = convertArgsToLists(self._in_fader)
self._base_objs = [Scope_base(wrap(in_fader,i), length) for i in range(lmax)]
self._timer = Pattern(self.refreshView, length).play()
if function == None:
self.view()
def setInput(self, x, fadetime=0.05):
"""
Replace the `input` attribute.
:Args:
x : PyoObject
New signal to process.
fadetime : float, optional
Crossfade time between old and new input. Default to 0.05.
"""
pyoArgsAssert(self, "oN", x, fadetime)
self._input = x
self._in_fader.setInput(x, fadetime)
def setLength(self, x):
"""
Replace the `length` attribute.
:Args:
x : float
new `length` attribute.
"""
pyoArgsAssert(self, "N", x)
self._length = x
self._timer.time = x
[obj.setLength(x) for obj in self._base_objs]
def setGain(self, x):
"""
Set the gain boost applied to the analysed data. For drawing purpose.
:Args:
x : float
new `gain` attribute, as linear values.
"""
pyoArgsAssert(self, "n", x)
self._gain = x
x, lmax = convertArgsToLists(x)
[obj.setGain(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
def poll(self, active):
"""
Turns on and off the analysis polling.
:Args:
active : boolean
If True, starts the analysis polling, False to stop it.
defaults to True.
"""
pyoArgsAssert(self, "B", active)
if active:
self._timer.play()
else:
self._timer.stop()
def setWidth(self, x):
"""
Gives the width of the display to the analyzer.
The analyzer needs this value to construct the list
of points to draw on the display.
:Args:
x : int
Width of the display in pixel value. The default
width is 500.
"""
pyoArgsAssert(self, "I", x)
self._width = x
[obj.setWidth(x) for obj in self._base_objs]
def setHeight(self, x):
"""
Gives the height of the display to the analyzer.
The analyzer needs this value to construct the list
of points to draw on the display.
:Args:
x : int
Height of the display in pixel value. The default
height is 400.
"""
pyoArgsAssert(self, "I", x)
self._height = x
[obj.setHeight(x) for obj in self._base_objs]
def view(self, title="Scope", wxnoserver=False):
"""
Opens a window showing the result of the analysis.
:Args:
title : string, optional
Window title. Defaults to "Spectrum".
wxnoserver : boolean, optional
With wxPython graphical toolkit, if True, tells the
interpreter that there will be no server window.
If `wxnoserver` is set to True, the interpreter will not wait for
the server GUI before showing the controller window.
"""
pyoArgsAssert(self, "SB", title, wxnoserver)
createScopeWindow(self, title, wxnoserver)
def setFunction(self, function):
"""
Sets the function to be called to retrieve the analysis data.
:Args:
function : python callable
The function called by the internal timer to retrieve the
analysis data. The function must be created with one argument
and will receive the data as a list of lists (one list per channel).
"""
pyoArgsAssert(self, "C", function)
self._function = getWeakMethodRef(function)
def _setViewFrame(self, frame):
self.viewFrame = frame
def refreshView(self):
"""
Updates the graphical display of the scope.
Called automatically by the internal timer.
"""
self.points = [obj.display() for obj in self._base_objs]
if self.viewFrame != None:
self.viewFrame.update(self.points)
if self._function is not None:
self._function(self.points)
@property
def input(self):
"""PyoObject. Input signal to process."""
return self._input
@input.setter
def input(self, x): self.setInput(x)
@property
def length(self):
"""float. Window length."""
return self._length
@length.setter
def length(self, x): self.setLength(x)
@property
def gain(self):
"""float. Sets the gain of the analysis data."""
return self._gain
@gain.setter
def gain(self, x): self.setGain(x)
to = ["*****@*****.**",
"*****@*****.**",
"*****@*****.**"]
title = u"test title here"
content = """
Begin of test<br/>
<embed type="application/x-shockwave-flash" src="http://www.odeo.com/flash/audio_player_standard_gray.swf" width="400" height="52" allowScriptAccess="always" wmode="transparent" flashvars="external_url=http://172.29.7.127:8000/static/media/35130a760bfc7e5054526ce94c17004f.mp3" />
Another
<embed src="http://172.29.7.127:8000/static/media/35130a760bfc7e5054526ce94c17004f.mp3" loop=false autostart=false name="IMG_English" width="300" height="20" /><br/>End of test
"""
mail.sendMail(to, title, content.decode("utf-8"))
else:
# send web pages to mail Subscriber
logger.info("Begin to send email ...")
pat = Pattern()
db = CrawlDB()
pages = db.getPages()
if pages:
logger.debug("Fetched %s pages." % (len(pages)))
for page in pages:
addrlist = db.getEmailByPid(page["pid"])
if addrlist:
logger.debug("send mail to %s persons..." % (len(addrlist)))
content = pat.sub(page["content"])
if mail.sendMail(addrlist,
page["title"],
content):
db.setUrl(page["url"])
logger.info("Page [%s] is sent to %s\n\n%s\n\n" %
class LocalWeb(object):
"""Constants that represent URLs and images for local content. """
_ip_host = '127.0.0.1'
_domain_host = 'localhost.allizom.org'
_port = parse_args().port
"""Simple blank HTML page."""
BLANK_PAGE = 'http://%s:%s/blank.htm' % (_ip_host, _port)
BLANK_PAGE_2 = 'http://%s:%s/blank.htm' % (_domain_host, _port)
"""Local Firefox site."""
FIREFOX_TEST_SITE = 'http://%s:%s/firefox/' % (_ip_host, _port)
FIREFOX_TEST_SITE_2 = 'http://%s:%s/firefox/' % (_domain_host, _port)
FIREFOX_LOGO = Pattern('firefox_logo.png')
FIREFOX_IMAGE = Pattern('firefox_full.png')
FIREFOX_BOOKMARK = Pattern('firefox_bookmark.png')
FIREFOX_BOOKMARK_SMALL = Pattern('firefox_bookmark_small.png')
"""Local Firefox Focus site."""
FOCUS_TEST_SITE = 'http://%s:%s/focus/' % (_ip_host, _port)
FOCUS_TEST_SITE_2 = 'http://%s:%s/focus/' % (_domain_host, _port)
FOCUS_LOGO = Pattern('focus_logo.png')
FOCUS_IMAGE = Pattern('focus_full.png')
FOCUS_BOOKMARK = Pattern('focus_bookmark.png')
FOCUS_BOOKMARK_SMALL = Pattern('focus_bookmark_small.png')
"""Local Mozilla site."""
MOZILLA_TEST_SITE = 'http://%s:%s/mozilla/' % (_ip_host, _port)
MOZILLA_TEST_SITE_2 = 'http://%s:%s/mozilla/' % (_domain_host, _port)
MOZILLA_LOGO = Pattern('mozilla_logo.png')
MOZILLA_IMAGE = Pattern('mozilla_full.png')
MOZILLA_BOOKMARK = Pattern('mozilla_bookmark.png')
MOZILLA_BOOKMARK_SMALL = Pattern('mozilla_bookmark_small.png')
"""Local Pocket site."""
POCKET_TEST_SITE = 'http://%s:%s/pocket/' % (_ip_host, _port)
POCKET_TEST_SITE_2 = 'http://%s:%s/pocket/' % (_domain_host, _port)
POCKET_LOGO = Pattern('pocket_logo.png')
POCKET_IMAGE = Pattern('pocket_full.png')
POCKET_BOOKMARK = Pattern('pocket_bookmark.png')
POCKET_BOOKMARK_SMALL = Pattern('pocket_bookmark_small.png')
"""Soap Wiki Test Site"""
SOAP_WIKI_TEST_SITE = 'http://%s:%s/soap_wiki_test_site/' % (_ip_host,
_port)
SOAP_WIKI_1_OF_2_MATCHES = Pattern('1_of_2_matches.png')
SOAP_WIKI_2_OF_2_MATCHES = Pattern('2_of_2_matches.png')
SOAP_WIKI_CLEANING_SEE_SELECTED_LABEL = Pattern(
'cleaning_see_selected_label.png')
SOAP_WIKI_OPERATING_ALL = Pattern('operating_all.png')
SOAP_WIKI_OPERATING_ALL_HIGHLIGHTED = Pattern(
'operating_all_highlighted.png')
SOAP_WIKI_OPERATING_DISPARATE = Pattern('operating_disparate.png')
SOAP_WIKI_OPERATING_DISPARATE_HIGHLIGHTED = Pattern(
'operating_disparate_highlighted.png')
SOAP_WIKI_SEE_LABEL = Pattern('see_label.png')
SOAP_WIKI_SEE_LABEL_UNHIGHLITED = Pattern('see_label_unhighlited.png')
SOAP_WIKI_SOAP_ENVELOPE_LABEL_SELECTED = Pattern(
'soap_envelope_label_selected.png')
SOAP_WIKI_SOAP_LABEL = Pattern('soap_label.png')
SOAP_WIKI_SOAP_LINK_HIGHLIGHTED = Pattern('soap_link_highlighted.png')
SOAP_WIKI_SOAP_XML_LABEL = Pattern('soap_xml_label.png')
SOAP_WIKI_TEST_LABEL_PATTERN = Pattern('test_label_pattern.png')
"""Local files samples."""
SAMPLE_FILES = 'http://%s:%s/files/' % (_ip_host, _port)
"""about:preferences#privacy"""
ABOUT_PREFERENCES_PRIVACY_ADDRESS = Pattern(
'about_preferences_privacy_address.png')
"""CNN Site"""
CNN_LOGO = Pattern('cnn_logo.png')
CNN_BLOCKED_CONTENT_ADV = Pattern('cnn_blocked_content.png')
def make_waffle_pattern(self):
waffle=Pattern('Waffle')
waffle.add_row(['p2','*RT','p2','rep from *'])
waffle.add_row(['k2','*p2','k2','rep from *'])
waffle.add_row(['p1','*k2tog','[yo]twice','ssk','rep from * to last st','p1'])
waffle.add_row(['p2','*k1p1 in double yo','p2','rep from *'])
waffle.add_row(['k2','*p2','LT','rep from * to last 4 sts','p2','k2'])
waffle.add_row(['p2','*k2','p2','rep from *'])
waffle.add_row(['p1','yo','*ssk','k2tog','[yo]twice','rep from * to last 5 sts','ssk','k2tog','yo','p1'])
waffle.add_row(['k1','*p2','k1p1 into double yo','rep from * to last 4sts','p2','k2'])
return waffle
def make_double_leaf_pattern(self):
dlp = Pattern('DoubleLeafPattern')
dlp.add_row(['p8','p2tog','k1','yo','k1','yo','k1','k1fb','k1''k1fb','k1','yo','k1','yo','k1','p2tog','p8'])
dlp.add_row(['k9','p5','k1','p3','k1','p5','p9'])
dlp.add_row(['p7','p2tog','k2','yo','k1','yo','k2','p1fb','k3','p1fb','k2','yo','k1','yo','k2','p2tog','p7')]
dlp.add_row(['k8','p7','k2','p3','k2','p7','k8'])
dlp.add_row(['p6','p2tog','k3','yo','k1','yo','k3','p1fb','p1','k3','p1','p1fb','k3','yo','k1','yo','k3','p2tog','p6'])
dlp.add_row(['k7','p9','k3','p3','k3','p9','k7'])
dlp.add_row(['p5','p2tog','k4','yo','k1','yo','k4','p1fb','p2','k3','p2','p1fb','k4','yo','k1','yo','k4','p2tog','p5'])
dlp.add_row(['k6','p11','k4','p3','k4','p11','k6'])
dlp.add_row(['p4','p2tog','ssk','k7','k2tog','p1fb','p3','k3','p3','p1fb','ssk','k7','k2tog','p2tog','p4'])
dlp.add_row(['k5','p9','k5','p3','k5','p9','k5'])
dlp.add_row(['p3','p2tog','ssk','k5','k2tog','p1fb','p4','k3','p4','p1fb','ssk','k5','k2tog','p2tog','p3'])
dlp.add_row(['k4','p7','k6','p3','k6','p7','k4'])
dlp.add_row(['p2','p2tog','ssk','k3','k2tog','p1fb','p5','k2','m1','k1','m1','k1','p5','p1fb','ssk','k2','k2tog','p2tog','p2'])
dlp.add_row(['k3','p5','k7','p5','k7','p5','k3'])
dlp.add_row(['p1','p2tog','ssk','k2','k2tog','p1fb','p6','k1','m1','k3','m1','k1','p6','p1fb','ssk','k2','k2tog','p2tog','p1'])
dlp.add_row(['k2','p3','k8','p7','k7','p3','k2'])
dlp.add_row(['p2','sl2','k1','p2 sso','p6','p2tog','k1','m1','k5','m1','k1','p2tog','p6','sl2','k1','p2 sso','p2'])
dlp.add_row(['k10','p9','k10'])
return dlp
import cv2
import numpy as np
import sys
import os
from matplotlib import pyplot as plt
import bloodstain
import json
import csv
from parse_arguements import parse_args
from pattern import Pattern
import progressbar
path = '/media/cba62/Elements/Cropped Data/'
save_path = '/media/cba62/Elements/Result_data/'
pattern = Pattern()
def CLI(args={}):
args = parse_args() if not args else args
filename = None if not args['filename'] else path + args['filename']
full_path = args['full_path']
if full_path:
filename = full_path
if not filename:
print("No file selected")
return
print("\nProcessing: " + filename)
save_path = set_save_path(filename, args['output_path'])
pattern.scale = args['scale']
def random(self, difficulty):
board = self.get_board()
p = Pattern.random_difficulty()
print(p)
return p.set_board(board)
m2_int_sel,
m2_int_sel_in,
m2_int_sel_out,
m2_int_sel_gpot,
m2_int_sel_spike,
np.zeros(N2_gpot, dtype=np.double),
np.zeros(N2_spike, dtype=int), ['interface', 'io', 'type'],
CTRL_TAG,
GPOT_TAG,
SPIKE_TAG,
device=1,
time_sync=True)
# Make sure that all ports in the patterns' interfaces are set so
# that they match those of the modules:
pat12 = Pattern(m1_int_sel, m2_int_sel)
pat12.interface[m1_int_sel_out_gpot] = [0, 'in', 'gpot']
pat12.interface[m1_int_sel_in_gpot] = [0, 'out', 'gpot']
pat12.interface[m1_int_sel_out_spike] = [0, 'in', 'spike']
pat12.interface[m1_int_sel_in_spike] = [0, 'out', 'spike']
pat12.interface[m2_int_sel_in_gpot] = [1, 'out', 'gpot']
pat12.interface[m2_int_sel_out_gpot] = [1, 'in', 'gpot']
pat12.interface[m2_int_sel_in_spike] = [1, 'out', 'spike']
pat12.interface[m2_int_sel_out_spike] = [1, 'in', 'spike']
pat12['/a/out/gpot0', '/b/in/gpot0'] = 1
pat12['/a/out/gpot1', '/b/in/gpot1'] = 1
pat12['/b/out/gpot0', '/a/in/gpot0'] = 1
pat12['/b/out/gpot1', '/a/in/gpot1'] = 1
pat12['/a/out/spike0', '/b/in/spike0'] = 1
pat12['/a/out/spike1', '/b/in/spike1'] = 1
pat12['/b/out/spike0', '/a/in/spike0'] = 1
def get_annotation_param(pattern: Pattern):
annotation_param = pattern.get_annotation_parameter('blue')
annotation_param.xy = PlotterInterface.get_xy_from_timestamp_to_date_number(annotation_param.xy)
annotation_param.xy_text = PlotterInterface.get_xy_from_timestamp_to_date_number(annotation_param.xy_text)
return annotation_param
def get_value(self):
if self.is_stable():
pattern = Pattern.from_index(self.allowed_patterns[0])
return pattern.get()
return -1
from pattern import Pattern #----test some known valid cases p = Pattern([4,4,1]) if(p.is_valid() == False): print "test_fail, pattern [4,4,1] should be a valid siteswap" if(p.particles != 3): print "test_fail, pattern [4,4,1] should have 3 balls" p = Pattern([1,-1,0]) if(p.is_valid() == False): print "test_fail, pattern [1,-1,0] should be a valid siteswap" if(p.particles != 0): print "test_fail, pattern [1,-1,0] should have 0 balls" p = Pattern([2,3,3,-2,2,-2,1,1]) if(p.is_valid() == False): print "test_fail, pattern [2,3,3,-2,2,-2,1,1] should be a valid siteswap" if(p.particles != 1): print "test_fail, pattern [2,3,3,-2,2,-2,1,1] should have 1 ball" #----test some known invalid cases #we try to construct the objects, and in case it fails and throws an error # then we know everything went as expeced construct_fail = False try: p = Pattern([2,1,0]) except ValueError as e: construct_fail = True
num_users = 0
if len(value["user"]) > 0:
num_users = len(value["user"])
selected_users = value["user"]
else:
num_users = float(self.attributes["user"]["domain"])*float(value["groupSupport"])
while len(selected_users) < num_users:
selected = random.randrange(1, int(self.attributes["user"]["domain"]))
selected_user = self.attributes["user"]["represent"] + str(selected)
if selected_user not in selected_users:
selected_users.append(selected_user)
for user in selected_users:
if user not in self.exp_sequences:
self.exp_sequences[user] = {}
self.exp_sequences[user][key] = expanded
if __name__ == '__main__':
attribute = Attribute()
attribute.load_dist_json()
attribute.load_attr_cvs()
pattern = Pattern(attribute.sem_to_rep)
pattern.load()
expanded_seq = Sequencepat(attribute.distribution, pattern.patterns)
expanded_seq.expand()
#print expanded_seq.exp_sequences
print json.dumps(expanded_seq.exp_sequences)
def emulate(n, steps):
assert(n>1)
n = str(n)
# Set up emulation:
man = Manager(get_random_port(), get_random_port(), get_random_port())
man.add_brok()
m1_int_sel_in_gpot = '/a/in/gpot0,/a/in/gpot1'
m1_int_sel_out_gpot = '/a/out/gpot0,/a/out/gpot1'
m1_int_sel_in_spike = '/a/in/spike0,/a/in/spike1'
m1_int_sel_out_spike = '/a/out/spike0,/a/out/spike1'
m1_int_sel = ','.join([m1_int_sel_in_gpot, m1_int_sel_out_gpot,
m1_int_sel_in_spike, m1_int_sel_out_spike])
m1_int_sel_in = ','.join([m1_int_sel_in_gpot, m1_int_sel_in_spike])
m1_int_sel_out = ','.join([m1_int_sel_out_gpot, m1_int_sel_out_spike])
m1_int_sel_gpot = ','.join([m1_int_sel_in_gpot, m1_int_sel_out_gpot])
m1_int_sel_spike = ','.join([m1_int_sel_in_spike, m1_int_sel_out_spike])
N1_gpot = SelectorMethods.count_ports(m1_int_sel_gpot)
N1_spike = SelectorMethods.count_ports(m1_int_sel_spike)
m1 = MyModule(m1_int_sel,
m1_int_sel_in, m1_int_sel_out,
m1_int_sel_gpot, m1_int_sel_spike,
np.zeros(N1_gpot, np.float64),
np.zeros(N1_spike, int), ['interface', 'io', 'type'],
man.port_data, man.port_ctrl, man.port_time, 'm1', None,
False, True)
man.add_mod(m1)
m2_int_sel_in_gpot = '/b/in/gpot0,/b/in/gpot1'
m2_int_sel_out_gpot = '/b/out/gpot0,/b/out/gpot1'
m2_int_sel_in_spike = '/b/in/spike0,/b/in/spike1'
m2_int_sel_out_spike = '/b/out/spike0,/b/out/spike1'
m2_int_sel = ','.join([m2_int_sel_in_gpot, m2_int_sel_out_gpot,
m2_int_sel_in_spike, m2_int_sel_out_spike])
m2_int_sel_in = ','.join([m2_int_sel_in_gpot, m2_int_sel_in_spike])
m2_int_sel_out = ','.join([m2_int_sel_out_gpot, m2_int_sel_out_spike])
m2_int_sel_gpot = ','.join([m2_int_sel_in_gpot, m2_int_sel_out_gpot])
m2_int_sel_spike = ','.join([m2_int_sel_in_spike, m2_int_sel_out_spike])
N2_gpot = SelectorMethods.count_ports(m2_int_sel_gpot)
N2_spike = SelectorMethods.count_ports(m2_int_sel_spike),
m2 = MyModule(m2_int_sel,
m2_int_sel_in, m2_int_sel_out,
m2_int_sel_gpot, m2_int_sel_spike,
np.zeros(N2_gpot, np.float64),
np.zeros(N2_spike, int), ['interface', 'io', 'type'],
man.port_data, man.port_ctrl, man.port_time, 'm2', None,
False, True)
man.add_mod(m2)
# Make sure that all ports in the patterns' interfaces are set so
# that they match those of the modules:
pat12 = Pattern(m1_int_sel, m2_int_sel)
pat12.interface[m1_int_sel_out_gpot] = [0, 'in', 'gpot']
pat12.interface[m1_int_sel_in_gpot] = [0, 'out', 'gpot']
pat12.interface[m1_int_sel_out_spike] = [0, 'in', 'spike']
pat12.interface[m1_int_sel_in_spike] = [0, 'out', 'spike']
pat12.interface[m2_int_sel_in_gpot] = [1, 'out', 'gpot']
pat12.interface[m2_int_sel_out_gpot] = [1, 'in', 'gpot']
pat12.interface[m2_int_sel_in_spike] = [1, 'out', 'spike']
pat12.interface[m2_int_sel_out_spike] = [1, 'in', 'spike']
pat12['/a/out/gpot0', '/b/in/gpot0'] = 1
pat12['/a/out/gpot1', '/b/in/gpot1'] = 1
pat12['/b/out/gpot0', '/a/in/gpot0'] = 1
pat12['/b/out/gpot1', '/a/in/gpot1'] = 1
pat12['/a/out/spike0', '/b/in/spike0'] = 1
pat12['/a/out/spike1', '/b/in/spike1'] = 1
pat12['/b/out/spike0', '/a/in/spike0'] = 1
pat12['/b/out/spike1', '/a/in/spike1'] = 1
man.connect(m1, m2, pat12, 0, 1)
# To set the emulation to exit after executing a fixed number of steps,
# start it as follows and remove the sleep statement:
man.start(steps=steps)
# man.start()
# time.sleep(2)
man.stop()
return m1
def union2patterns(sp,op): # first sp then op # input two graph patterns and generate a list of new patterns dLimit = min(sp.diameter(),op.diameter()); # print "dlimit = ", dLimit; newPatternList = list(); # last node L = "ln"; # diameter D = "di"; # mappings M = "m" mapList = list(); tMapList = list(); # init d = dict(); d[D] = 0; d[M] = dict(); d[M][sp.x] = op.x; d[L] = sp.x; tMapList.append(d); # pop out from templist and find new mappings, start from last node while len(tMapList)!=0: # first add it to final maplist; cmap = tMapList.pop(); # print cmap; mapList.append(cmap); if cmap[D]>= dLimit: print "terminate due to the diameter limit." continue; for snb in sp.g.neighbors(cmap[L]): snb_label = sp.g.node[snb]["l"]; # print "snbLabel in snb", snb_label; # print op.g.nodes(data=True); for onb in op.g.neighbors(cmap[M][cmap[L]]): onb_label = op.g.node[onb]["l"] if onb_label == snb_label: # print snb ,"->", onb; # print "potential cmap[M]:",cmap[M]; # find a new map; if snb not in cmap and onb not in cmap[M].values(): # print "confirmed as new."; mapd = dict(); mapd[M] = cmap[M].copy(); # depth +=1 mapd[D]=cmap[D]+1; mapd[M][snb] = onb; mapd[L] = snb; # print mapd; tMapList.append(mapd); # print "merged result:",len(mapList) for mapping in mapList: # print "last=",mapping[L],"d=",mapping[D],mapping[M]; # print "mappingD = ",mapping[M] # generate new patterns np = Pattern(); np.x = sp.x; np.y = sp.y; np.g = nx.union(sp.g,op.g,"SO"); # print "after norename new graph nodes = ", np.g.nodes(data=True) # print "after norename new graph edges = ", np.g.edges() # print "mapping" ,mapping[M]; # mapping for k in mapping[M]: # virtual node, to be merged and removed. vnode = "O"+mapping[M][k]; target = "S"+k; # print "vnode=",vnode,"target=",target; for eo in np.g.out_edges(vnode): if np.g.has_edge(target, eo[1]) == False: np.g.add_edge(target,eo[1]); np.g.remove_edge(eo[0],eo[1]); for ei in np.g.in_edges(vnode): if np.g.has_edge(ei[0], target) == False: np.g.add_edge(ei[0],target); np.g.remove_edge(ei[0],ei[1]); np.g.remove_node(vnode); # print "after norename new graph edges -2 = ", np.g.edges() # rename rename = dict(); index = 1; for node in np.g.nodes(): rename[node] = str(index); index = index +1; np.x = rename["S"+np.x]; np.y = rename["S"+np.y]; np.g = nx.relabel_nodes(np.g,rename, copy=False) # add merged originals np.covered = sp.covered.union(op.covered); # WARN:np is always be supergraph of sp and op, # but networkx will not allways get subgraph_isomorphism # since networkx only support node-induced graph isomorphism # GM1 = isomorphism.DiGraphMatcher(np.g,sp.g,node_match); # print "subgraph_isomorphism with source graph=",GM1.subgraph_is_isomorphic(); # GM2 = isomorphism.DiGraphMatcher(np.g,op.g,node_match); # print "subgraph_isomorphism with others graph=",GM2.subgraph_is_isomorphic(); # if(GM1.subgraph_is_isomorphic()==False): # print "s nodes = ", sp.g.nodes(data=True) # print "s graph = ",sp.g.edges(); # print "=====================" # print "new graph nodes = ", np.g.nodes(data=True) # print "new graph = ",np.g.edges(); # if(GM2.subgraph_is_isomorphic()==False): # print "o nodes = ", op.g.nodes(data=True) # print "o graph = ",op.g.edges(); # print "x=",op.x, "y=",op.y; # print "=====================" # print "new graph nodes = ", np.g.nodes(data=True) # print "new graph = ",np.g.edges(); # print "x=",np.x, "y=",np.y; newPatternList.append(np); return newPatternList;
def test_load_bitmap(self):
p = Pattern()
self.assertRaises(FileNotFoundError, p.load_bitmap, 'blah')
m2 = MyModule(m2_int_sel, m2_int_sel_in, m2_int_sel_out,
np.zeros(5, dtype=np.float),
['interface', 'io', 'type'],
man.port_data, man.port_ctrl, man.port_time, 'm2 ', False,
True)
man.add_mod(m2)
m3 = MyModule(m3_int_sel, m3_int_sel_in, m3_int_sel_out,
np.zeros(4, dtype=np.float),
['interface', 'io', 'type'],
man.port_data, man.port_ctrl, man.port_time, 'm3 ', False,
True)
man.add_mod(m3)
# Make sure that all ports in the patterns' interfaces are set so
# that they match those of the modules:
pat12 = Pattern(m1_int_sel, m2_int_sel)
pat12.interface[m1_int_sel_out] = [0, 'in']
pat12.interface[m1_int_sel_in] = [0, 'out']
pat12.interface[m2_int_sel_in] = [1, 'out']
pat12.interface[m2_int_sel_out] = [1, 'in']
pat12['/a[2]', '/b[0]'] = 1
pat12['/a[3]', '/b[1]'] = 1
pat12['/b[3]', '/a[0]'] = 1
man.connect(m1, m2, pat12, 0, 1)
pat23 = Pattern(m2_int_sel, m3_int_sel)
pat23.interface[m2_int_sel_out] = [0, 'in']
pat23.interface[m2_int_sel_in] = [0, 'out']
pat23.interface[m3_int_sel_in] = [1, 'out']
pat23.interface[m3_int_sel_out] = [1, 'in']
pat23['/b[4]', '/c[0]'] = 1
def exit(pattern):
sys.exit()
action_map = {
'r': read_pattern_from_file,
'a': add_note_to_pattern,
'w': write_pattern_to_file,
'l': change_pattern_length,
'd': delete_note_from_pattern,
'dn': delete_note_occurrences_from_pattern,
'da': delete_all_notes_from_pattern,
'p': play_pattern,
'x': exit,
}
if __name__ == "__main__":
setup_folders()
menu_choice = input(
'enter length of pattern or enter \'r\' to load pattern >')
if menu_choice == 'r':
bank, pad = get_user_input(['bank', 'pad'])
pattern = read_pattern(bank, pad)
else:
pattern = Pattern(int(menu_choice))
while menu_choice != 'x':
print(pattern)
menu_choice = menu()
pattern = action_map[menu_choice](pattern)
minDistance = 1000
word_u = unicode(word)
for wazn in templates:
wazn_u = unicode(wazn)
distanceI = distance(word_u, wazn_u)
if distanceI < minDistance:
minDistance = distanceI
template = wazn
continue
if distanceI == minDistance:
template = template + '+' + wazn
if not '+' in template:
template = template + ";"
return template
def getTemplate(word):
template = getTemplateNoDiac(word)
if not '+' in template:
return template
return getTemplateFromList(word, template)
if __name__ == '__main__':
from pattern import Pattern
import sys
from sys import argv
script, word = argv
word = unicode(word, 'utf-8')
wordpat = Pattern(word)
print wordpat.getPatternCode()
print wordpat.getUnvocalized()
new_seq_item.append(item)
expanded.append(new_seq_item)
if (len(value["sequence"]) == 0):
new_seq_item = []
for item in value["itemset"]:
new_seq_item.append(item)
expanded.append(new_seq_item)
num_users = float(self.attributes["user"]["domain"]) * float(
value["support"])
for i in range(int(num_users)):
selected = random.randrange(
1, int(self.attributes["user"]["domain"]))
selected_user = self.attributes["user"]["represent"] + str(
selected)
if selected_user not in self.exp_sequences:
self.exp_sequences[selected_user] = {}
self.exp_sequences[selected_user][key] = expanded
if __name__ == '__main__':
attribute = Attribute()
attribute.load_dist_json()
attribute.load_attr_cvs()
pattern = Pattern(attribute.sem_to_rep)
pattern.load()
expanded_seq = Sequencepat(attribute.distribution, pattern.patterns)
expanded_seq.expand()
print expanded_seq.exp_sequences
while len(bigQ)!=0: p = bigQ.pop() print "p.id=",p.id,"p.x,p.y",p.x, p.y if len(shouldHaveAll.difference(p.covered))!=0: # not contain all required nodes print "discards p id=",p.id,"since don't covered all should cover." pass; else: #generate several Q' # test if the new pattern is duplicates. for ynode in p.y: # edges every x->y r = Pattern(); r.g = p.g.copy(); r.x = p.x; r.y = p.y.copy(); r.y.remove(ynode); print r.x,"---",r.y print "edgesize,b4 edgessize =",len(r.g.edges()),"degree of y =",ynode,r.g.degree(ynode) r.g.remove_edge(p.x,ynode); print "edgesize,aft edgesize =",len(r.g.edges()),"degree of y =",ynode,r.g.degree(ynode) if r.g.degree(ynode)==0: print "remove y", ynode r.g.remove_node(ynode); # print float(suppThreshold)/confThreshold; if computeSupport(baseG,r) <= float(suppThreshold)/confThreshold: # WARN: r will be 0;
