def __init__(self, infoRun, data = ''):
self.infoRun = infoRun
self.SetEnvironment(self.infoRun)
self.data = data
counter = 0
# Apply selection cut
for bck in self.backgrounds:
self.listOfSelectors.append(Selector(bck, self.savepath))
counter += 1
if (self.data != ''): self.dataSelector = Selector(self.data, self.savepath)
# == Draw histograms
# Parse selectors and other parameters to the Plotter class
p = Plotter(self.listOfSelectors, self.dataSelector, self.Histos, self.colors)
p.SetSavePath(self.savepath)
p.SetAnnotations(self.Annotations)
p.DrawHistos()
# ===== Compute the cross-section
# == Set attributes and parameters and compute the final result
self.SetParameters('MuonPt')
self.PrintXsection('MuonPt')
return
def __init__(self, core_file_name):
super(Listener, self).__init__()
self.core_file_name = core_file_name
self.setup_ui()
self.setup_timers()
port = SERIAL_PORT
self.serial = serial.Serial(port, BAUDE_RATE, timeout=0)
self.incoming_data = []
self.imu = IMU(PLATFORM_SPECIFIC_QUOTIENTS['stm'])
self.stroke = Stroke()
self.selector = Selector(self.core_file_name)
self.acceleration_filter = AperiodicFilter(ACCELERATION_TIME_CONST)
self.stroke.widget = self.display
self.stroke.on_done = self.get_stroke
self.previous_time = None
self.data_buffer = ''
self.init_selector()
def __init__(self, body, url='', meta=None, status=-1):
self._status = int(status)
self._url = url
self._body = body
self._selector = Selector(body)
self._meta = meta or {}
self._id = -1
def test_RunsForever(self):
"""main - Run with no messages, keeps running"""
S = Selector()
S.activate()
for i in xrange(1,100):
try:
S.next()
except StopIteration:
self.fail("Component should run until told to stop. Failed on iteration: "+str(i))
def test_list(self):
event = Event(0)
event.the_list = range(10)
cfg_ana = cfg.Analyzer(Selector,
output='filtered',
input_objects='the_list',
filter_func=lambda x: x % 2 == 0)
cfg_comp = cfg.Component('test', files=[])
filter = Selector(cfg_ana, cfg_comp, self.outdir)
filter.process(event)
self.assertItemsEqual(event.filtered, [0, 2, 4, 6, 8])
def test_dict(self):
event = Event(0)
event.the_dict = dict([(x, x**2) for x in range(10)])
cfg_ana = cfg.Analyzer(Selector,
output='filtered',
input_objects='the_dict',
filter_func=lambda x: x == 9)
cfg_comp = cfg.Component('test', files=[])
filter = Selector(cfg_ana, cfg_comp, self.outdir)
filter.process(event)
self.assertDictEqual(event.filtered, {3: 9})
def start(self):
self.input_controller.fault_tolerance_request()
self.input_controller.initial_groups_request()
self.input_controller.blocked_vector_request()
tested_faults = len(max(self.input_controller.initial_groups, key=len))
processors = Processors(self.input_controller.initial_groups)
generator = FormulasGenerator(processors,
self.input_controller.fault_tolerance)
selector = Selector(self.input_controller.blocked_vectors)
tester = PrTester(processors)
blocker = Blocker(self.input_controller.blocked_vectors, tester,
selector, processors)
'''
For original formulas
'''
generator.generate(self.input_controller.initial_groups,
self.original_formulas_file)
optimizer_original = Optimizer(self.input_controller.fault_tolerance,
processors,
self.optimized_original_file)
optimizer_original.optimize(generator.origin_formulas_arr)
blocking_original_formulas = blocker.block_original(
selector.select_group(optimizer_original.result_formulas))
tester.test(self.result_of_testing_original_file,
blocking_original_formulas, tested_faults,
self.input_controller.fault_tolerance)
'''
For researched formulas
'''
self.input_controller.researched_way_request()
if self.input_controller.researched_way:
generator.generate(
processors.form_groups_according_to_blocked_vector(
self.input_controller.blocked_vectors),
self.researched_formulas_file)
optimizer_researched = Optimizer(
self.input_controller.fault_tolerance, processors,
self.optimized_researched_file)
optimizer_researched.optimize(generator.origin_formulas_arr)
#selector.select_group(optimizer_researched.result_formulas)
blocking_researched_formulas = blocker.block_researched(
selector.select_group(optimizer_researched.result_formulas))
tester.test(self.result_of_testing_researched_file,
blocking_researched_formulas, tested_faults,
self.input_controller.fault_tolerance)
self.input_controller.repeat_request()
return self.input_controller.repeat
def __init__(self, processes, hist_list, colors):
''' Initialize a new plotter... give a list with all names of MC samples and the name of the data sample '''
#self.ResetVariables()
for p in processes:
if processes[p] == "data":
self.data = Selector(hist_list, processes[p])
elif "+" in processes[p]:
self.signal = Selector(hist_list, processes[p])
else:
self.backgrounds.append(Selector(hist_list, processes[p]))
return
class Response(object):
def __init__(self, body, url='', meta=None, status=-1):
self._status = int(status)
self._url = url
self._body = body
self._selector = Selector(body)
self._meta = meta or {}
self._id = -1
@property
def url(self):
return self._url
@property
def body(self):
return self._body
@property
def meta(self):
return self._meta
@property
def status(self):
return self._status
def dumps(self):
return cPickle.dumps(
dict(url=self.url,
status=self.status,
body=self.body,
meta=self.meta))
@classmethod
def loads(cls, s):
if isinstance(s, unicode):
s = s.encode('utf-8')
dct = cPickle.loads(s)
return cls(**dct)
def xpath(self, query, **kwargs):
return self._selector.xpath(query, **kwargs)
def re(self, regex):
return self._selector.re(regex)
def re_first(self, regex):
try:
return self._selector.re(regex)[0]
except:
return ''
def test_list(self):
event = Event(0)
event.the_list = range(10)
cfg_ana = cfg.Analyzer(
Selector,
output = 'filtered',
input_objects = 'the_list',
filter_func = lambda x : x%2 == 0
)
cfg_comp = cfg.Component(
'test',
files = []
)
filter = Selector(cfg_ana, cfg_comp, self.outdir)
filter.process(event)
self.assertItemsEqual(event.filtered, [0,2,4,6,8])
def test_dict(self):
event = Event(0)
event.the_dict = dict( [ (x, x**2) for x in range(10) ] )
cfg_ana = cfg.Analyzer(
Selector,
output = 'filtered',
input_objects = 'the_dict',
filter_func = lambda x : x == 9
)
cfg_comp = cfg.Component(
'test',
files = []
)
filter = Selector(cfg_ana, cfg_comp, self.outdir)
filter.process(event)
self.assertDictEqual(event.filtered, {3:9})
def __init__(self, director):
Scene.__init__(self, director)
self.rueda = Selector(self.director.screen, (WIDTH / 2, HEIGHT / 2))
self.rueda.asociateEvent(0, colorear, self.director.screen,
(255, 0, 0))
self.rueda.asociateEvent(1, colorear, self.director.screen,
(0, 0, 255))
self.rueda.asociateEvent(2, colorear, self.director.screen,
(0, 255, 0))
self.rueda.asociateEvent(3, colorear, self.director.screen, (0, 0, 0))
self.rueda.setIcon(0, "images/icon1.png")
self.rueda.setIcon(1, "images/icon2.png")
self.rueda.setIcon(2, "images/icon3.png")
self.rueda.setIcon(3, "images/icon4.png")
def selector(self, **kwds):
from Selector import Selector
control = Selector(**kwds)
from FormField import FormField
field = FormField(control)
self.contents.append(field)
return control
def setupCSA(self, sock):
"""\
setupCSA(sock) -> new ConnectedSocketAdapter component
Creates a ConnectedSocketAdapter component for the socket, and wires up to
it. Also sends the CSA to the "selector" service.
"""
selectorService, selectorShutdownService, newSelector = Selector.getSelectorServices(
self.tracker)
if newSelector:
self.addChildren(newSelector)
CSA = ConnectedSocketAdapter(
sock, selectorService,
sendTo=self.remote) # self.createConnectedSocket(sock)
self.addChildren(CSA)
self.link((self, "_selectorSignal"), selectorService)
self.link((CSA, "CreatorFeedback"), (self, "_socketFeedback"))
self.link((CSA, "outbox"), (self, "outbox"), passthrough=2)
self.link((self, "inbox"), (CSA, "inbox"), passthrough=1)
self.link((self, "control"), (CSA, "control"),
passthrough=1) # propagate shutdown msgs
self.send(newReader(CSA, ((CSA, "ReadReady"), sock)),
"_selectorSignal")
self.send(newWriter(CSA, ((CSA, "SendReady"), sock)),
"_selectorSignal")
self.CSA = CSA # We need this for shutdown later
return self.childComponents()
def setupCSA(self, sock):
"""\
setupCSA(sock) -> new ConnectedSocketAdapter component
Creates a ConnectedSocketAdapter component for the socket, and wires up to
it. Also sends the CSA to the "selector" service.
"""
selectorService, selectorShutdownService, newSelector = Selector.getSelectorServices(self.tracker)
if newSelector:
self.addChildren(newSelector)
CSA = ConnectedSocketAdapter(sock, selectorService, sendTo=self.remote) # self.createConnectedSocket(sock)
self.addChildren(CSA)
self.link((self, "_selectorSignal"),selectorService)
self.link((CSA, "CreatorFeedback"),(self,"_socketFeedback"))
self.link((CSA, "outbox"), (self, "outbox"), passthrough=2)
self.link((self, "inbox"), (CSA, "inbox"), passthrough=1)
self.link((self, "control"), (CSA, "control"), passthrough=1) # propagate shutdown msgs
self.send(newReader(CSA, ((CSA, "ReadReady"), sock)), "_selectorSignal")
self.send(newWriter(CSA, ((CSA, "SendReady"), sock)), "_selectorSignal")
self.CSA = CSA # We need this for shutdown later
return self.childComponents()
def Selector1():
selector = Selector()
dataProcessor = DataProcessor()
#abil = selector.getAbilityWithId(3)
passed = selector.runSelector()
print(passed)
selector.setCharacterStats(15, 15)
passed = selector.runSelector()
print(passed)
print(selector.HP)
print(selector.getAuraWithId(selector.getAbilityWithId(2)['auraOne']))
def __init__(self, parent=None, name='', f=0):
QWidget.__init__(self, parent, name, f)
self.setFixedWidth(1024)
self.setFixedHeight(768)
## UPPER PANEL
self.upperPanel = QFrame(self)
self.upperPanel.setFixedWidth(self.width())
self.upperPanel.setFixedHeight(self.height() / 2)
UpperLayout = QHBoxLayout(self.upperPanel)
# Main SampleGroup
self.mainSampleGroup = SampleGroup(self.upperPanel)
self.mainSampleGroup.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
UpperLayout.addWidget(self.mainSampleGroup)
## LOWER PANEL
self.lowerPanel = QFrame(self)
self.lowerPanel.setGeometry(0,
self.height() / 2,
self.width(),
self.height() / 2)
LowerLayout = QHBoxLayout(self.lowerPanel)
# WidgetStack
self.widgetStack = Widgets.WidgetStack(self.lowerPanel)
self.widgetStack.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
LowerLayout.addWidget(self.widgetStack)
for i in range(NUM_SAMPLE_GROUPS):
group = SampleGroup(None)
self.widgetStack.addWidget(group)
# Selector
self.selector = Selector(self.lowerPanel)
self.selector.addPath(os.path.join(os.environ['HOME'], 'wav'))
self.selector.setFixedWidth(SELECTOR_WIDTH)
self.selector.setFixedHeight(SELECTOR_HEIGHT)
self.selector.move(self.width()-SELECTOR_WIDTH,
self.height()-SELECTOR_HEIGHT)
self.selector.openAll()
QObject.connect(self.selector, PYSIGNAL('selected'),
self.slotSelected)
LowerLayout.addWidget(self.selector)
## SAMPLES
self.freeSamples = Queue.Queue()
self.busySamples = []
for i in range(CACHED_SAMPLES):
self.newSample()
def test_SendingAReadableMessageResultsInItBeingSelectedAgainst(self):
"main - If we send a newReader message to the notify inbox, it results in the selectable reader being selected on in the readers set"
MOCKSELECTORMODULE = MockSelect()
SELECTORMODULE.select = MOCKSELECTORMODULE
S = Selector()
S.activate()
for i in xrange(100):
S.next()
dummyservice = (Axon.Component.component(), "inbox")
S._deliver(newReader(S, (dummyservice, "LOOKINGFORTHIS")), "notify")
for i in xrange(100):
S.next()
func, args = MOCKSELECTORMODULE.log[0]
self.assertEqual("select", func, "select was called in the main loop")
self.assertEqual(["LOOKINGFORTHIS"], args[0],
"The selectable was added to the list of readables")
self.assertEqual([], args[1], "Writable set should be empty")
self.assertEqual([], args[2], "Exception set should be empty")
self.assertEqual(0, args[3], "The select should be non-blocking")
def start(self):
self.input_controller.fault_tolerance_request()
self.input_controller.initial_groups_request()
self.input_controller.blocked_vector_request()
tested_faults = len(max(self.input_controller.initial_groups, key=len))
processors = Processors(self.input_controller.initial_groups)
generator = FormulasGenerator(processors, self.input_controller.fault_tolerance)
selector = Selector(self.input_controller.blocked_vectors)
tester = PrTester(processors)
blocker = Blocker(self.input_controller.blocked_vectors, tester, selector, processors)
'''
For original formulas
'''
generator.generate(self.input_controller.initial_groups, self.original_formulas_file)
optimizer_original = Optimizer(self.input_controller.fault_tolerance, processors, self.optimized_original_file)
optimizer_original.optimize(generator.origin_formulas_arr)
blocking_original_formulas = blocker.block_original(selector.select_group(optimizer_original.result_formulas))
tester.test(self.result_of_testing_original_file, blocking_original_formulas, tested_faults, self.input_controller.fault_tolerance)
'''
For researched formulas
'''
self.input_controller.researched_way_request()
if self.input_controller.researched_way:
generator.generate(processors.form_groups_according_to_blocked_vector(self.input_controller.blocked_vectors), self.researched_formulas_file)
optimizer_researched = Optimizer(self.input_controller.fault_tolerance, processors, self.optimized_researched_file)
optimizer_researched.optimize(generator.origin_formulas_arr)
#selector.select_group(optimizer_researched.result_formulas)
blocking_researched_formulas = blocker.block_researched(selector.select_group(optimizer_researched.result_formulas))
tester.test(self.result_of_testing_researched_file,blocking_researched_formulas, tested_faults, self.input_controller.fault_tolerance)
self.input_controller.repeat_request()
return self.input_controller.repeat
def test_SendingAReadableMessageResultsInItBeingSelectedAgainst(self):
"main - If we send a newReader message to the notify inbox, it results in the selectable reader being selected on in the readers set"
MOCKSELECTORMODULE = MockSelect()
SELECTORMODULE.select = MOCKSELECTORMODULE
S = Selector()
S.activate()
for i in xrange(100): S.next()
dummyservice = (Axon.Component.component(), "inbox")
S._deliver(newReader(S,( dummyservice, "LOOKINGFORTHIS")),"notify")
for i in xrange(100): S.next()
func, args = MOCKSELECTORMODULE.log[0]
self.assertEqual("select", func, "select was called in the main loop")
self.assertEqual(["LOOKINGFORTHIS"], args[0], "The selectable was added to the list of readables")
self.assertEqual([], args[1], "Writable set should be empty")
self.assertEqual([], args[2], "Exception set should be empty")
self.assertEqual(0, args[3], "The select should be non-blocking")
def test_WeSendTheSelectorAServiceAndSelectableOnlySelectsTheSelectable(self):
"main - When we send the newReader message, it also includes a service upon which the selector can talk back to us. The selector only selects on the selectable part of the newReader message"
MOCKSELECTORMODULE = MockSelect()
SELECTORMODULE.select = MOCKSELECTORMODULE
S = Selector()
S.activate()
for i in xrange(100): S.next()
dummyservice = (Axon.Component.component(), "inbox")
S._deliver(newReader(S,( dummyservice, "LOOKINGFORTHIS") ),"notify")
for i in xrange(100): S.next()
func, args = MOCKSELECTORMODULE.log[0]
self.assertEqual("select", func, "select was called in the main loop")
self.assertEqual(["LOOKINGFORTHIS"], args[0])#, "The selectable was added to the list of readables")
self.assertEqual([], args[1], "Writable set should be empty")
self.assertEqual([], args[2], "Exception set should be empty")
self.assertEqual(0, args[3], "The select should be non-blocking")
def __init__(self, editor): GObject.__init__(self) from Selector import Selector Selector(self, editor) from TextInserter import Inserter Inserter(self, editor) from CaseProcessor import Processor Processor(self, editor) from TextExtractor import Extractor Extractor(self, editor) from Marker import Marker Marker(self, editor)
def test_WeSendTheSelectorAServiceAndSelectableOnlySelectsTheSelectable(
self):
"main - When we send the newReader message, it also includes a service upon which the selector can talk back to us. The selector only selects on the selectable part of the newReader message"
MOCKSELECTORMODULE = MockSelect()
SELECTORMODULE.select = MOCKSELECTORMODULE
S = Selector()
S.activate()
for i in xrange(100):
S.next()
dummyservice = (Axon.Component.component(), "inbox")
S._deliver(newReader(S, (dummyservice, "LOOKINGFORTHIS")), "notify")
for i in xrange(100):
S.next()
func, args = MOCKSELECTORMODULE.log[0]
self.assertEqual("select", func, "select was called in the main loop")
self.assertEqual(
["LOOKINGFORTHIS"],
args[0]) #, "The selectable was added to the list of readables")
self.assertEqual([], args[1], "Writable set should be empty")
self.assertEqual([], args[2], "Exception set should be empty")
self.assertEqual(0, args[3], "The select should be non-blocking")
def gui():
global inpt
global active
global stdscr
global inptwin
global dirwin
global selector
if active:
selector = Selector(
[Item('num1'),
Item('num2'),
Item('num3'),
Item('num4')])
selector.updateSelectorDisplay(dirwin)
#dirwin.addstr(selector.getDisplayString())
dirwin.refresh()
inptwin.addstr('x>')
inptwin.refresh()
start()
def test_shutdownMessageCausesShutdown(self):
"""main - If the component recieves a shutdown() message, the component shuts down"""
S = Selector()
S.activate()
S._deliver(shutdown(), "control")
componentExit = False
for i in xrange(2000):
try:
S.next()
except StopIteration:
componentExit = True
break
if not componentExit:
self.fail(
"When sent a shutdown message, the component should shutdown")
def test_ActivityOnReaderResultsInMessageOnReadersService(self):
"main - Activity on the selectable results in a message appearing in the service provided to the selector"
MOCKSELECTORMODULE = MockSelect()
SELECTORMODULE.select = MOCKSELECTORMODULE
S = Selector()
S.activate()
for i in xrange(100):
S.next()
D = Axon.Component.component()
dummyservice = (D, "inbox")
S._deliver(newReader(S, (dummyservice, "LOOKINGFORTHIS")), "notify")
for i in xrange(100):
S.next()
try:
S.postoffice.next()
except:
pass
self.assert_(not (D.inboxes["inbox"] == []))
selectable = D.recv("inbox")
self.assertEqual(
selectable, "LOOKINGFORTHIS"
) #, "The value returned should be the selectable we originally asked for")
def __init__(self):
self.state = 0
self.elements = {
0: [
Button("Start Game", 1, ["centered", 300]),
Button("Quit", "quit", ["centered", 450])
],
1: [
Button("Step By Step", "any", ["centered", 300]),
Button("Any Level", 2, ["centered", 450]),
Button("Back", 0, ["centered", 600])
],
2: [Selector(), Button("Back", 1, ["centered", 800])]
}
def test_ActivityOnReaderResultsInMessageOnReadersService(self):
"main - Activity on the selectable results in a message appearing in the service provided to the selector"
MOCKSELECTORMODULE = MockSelect()
SELECTORMODULE.select = MOCKSELECTORMODULE
S = Selector()
S.activate()
for i in xrange(100): S.next()
D = Axon.Component.component()
dummyservice = (D, "inbox")
S._deliver(newReader(S,( dummyservice, "LOOKINGFORTHIS") ),"notify")
for i in xrange(100):
S.next();
try:
S.postoffice.next()
except:
pass
self.assert_(not ( D.inboxes["inbox"] == [] ) )
selectable = D.recv("inbox")
self.assertEqual(selectable,"LOOKINGFORTHIS")#, "The value returned should be the selectable we originally asked for")
def test_RunsForever(self):
"""main - Run with no messages, keeps running"""
S = Selector()
S.activate()
for i in xrange(1, 100):
try:
S.next()
except StopIteration:
self.fail(
"Component should run until told to stop. Failed on iteration: "
+ str(i))
def test_shutdownMessageCausesShutdown(self):
"""main - If the component recieves a shutdown() message, the component shuts down"""
S = Selector()
S.activate()
S._deliver(shutdown(),"control")
componentExit = False
for i in xrange(2000):
try:
S.next()
except StopIteration:
componentExit = True
break
if not componentExit:
self.fail("When sent a shutdown message, the component should shutdown")
def __init__(self, editor):
Signal.__init__(self)
from Feedback import Feedback
Feedback(self, editor)
from UndoManager import Manager
Manager(self, editor)
from Selector import Selector
Selector(self, editor)
from QuoteCharacterMatcher import Matcher
Matcher(self, editor)
from RangeChecker import Checker
Checker(self, editor)
from PairCharacterMatcher import Matcher
Matcher(self, editor)
from OpenCharacterSearcher import Searcher
Searcher(self, editor)
from SelectionChecker import Checker
Checker(self, editor)
def __init__(self):
_ = Colour.BLACK
W = Colour.WHITE
self.board = [
[_, _, W, _, _, W, _, _],
[_, _, W, _, _, W, _, _],
[W, W, W, W, W, W, W, W],
[_, _, W, _, _, W, _, _],
[_, _, W, _, _, W, _, _],
[W, W, W, W, W, W, W, W],
[_, _, W, _, _, W, _, _],
[_, _, W, _, _, W, _, _],
]
self.state = State()
self.selector = Selector()
def __init__(self, editor): GObject.__init__(self) from Selector import Selector Selector(self, editor) from TextInserter import Inserter Inserter(self, editor) from SelectionProcessor import Processor Processor(self, editor) from IndentationProcessor import Processor Processor(self, editor) from IndentationCharacter import Character Character(self, editor) from TextExtractor import Extractor Extractor(self, editor) from Marker import Marker Marker(self, editor) from OffsetExtractor import Extractor Extractor(self, editor) from Refresher import Refresher Refresher(self, editor)
def test_ActivityOnAnyExceptionalResultsInMessageOnThatExceptionalsService(self):
"main - Activity on a selectable results in a message appearing in the service provided to the selector for that selectable"
MOCKSELECTORMODULE = MockSelect(results=[ ([],[],["LOOKINGFORTHIS"]),
([],[],["THENFORTHIS"]),
([],[],["ANDTHENFORTHIS"]) ])
SELECTORMODULE.select = MOCKSELECTORMODULE
S = Selector()
S.activate()
for i in xrange(5): S.next()
D = Axon.Component.component()
E = Axon.Component.component()
F = Axon.Component.component()
dummyservice1 = (D, "inbox")
S._deliver(newExceptional(S,( dummyservice1, "LOOKINGFORTHIS") ),"notify")
dummyservice2 = (E, "inbox")
S._deliver(newExceptional(S,( dummyservice2, "THENFORTHIS") ),"notify")
dummyservice3 = (F, "inbox")
S._deliver(newExceptional(S,( dummyservice3, "ANDTHENFORTHIS") ),"notify")
for i in xrange(5):
S.next();
try:
S.postoffice.next()
except:
pass
selectable = D.recv("inbox")
self.assertEqual(selectable,"LOOKINGFORTHIS")#, "The value returned should be the selectable we originally asked for")
selectable = E.recv("inbox")
self.assertEqual(selectable,"THENFORTHIS")#, "The value returned should be the selectable we originally asked for")
selectable = F.recv("inbox")
self.assertEqual(selectable,"ANDTHENFORTHIS")#, "The value returned should be the selectable we originally asked for")
def test_SendingMultipleReadersResultsInAllSelected(self):
"main - Sending multiple newReader messages results in all being select()ed"
MOCKSELECTORMODULE = MockSelect()
SELECTORMODULE.select = MOCKSELECTORMODULE
S = Selector()
S.activate()
for i in xrange(100): S.next()
dummyservice = (Axon.Component.component(), "inbox")
S._deliver(newReader(S,( dummyservice, "LOOKINGFORTHIS") ),"notify")
S._deliver(newReader(S,( dummyservice, "LOOKINGFORTHISTOO") ),"notify")
S._deliver(newReader(S,( dummyservice, "LOOKINGFORANDTHIS") ),"notify")
for i in xrange(100):
S.next()
lastfunc, lastargs = None, None
i = 0
func, args = MOCKSELECTORMODULE.log[i]
while not( (lastfunc, lastargs) == (func, args)): # Search for quiescent state
i = i + 1
lastfunc, lastargs = func, args
func, args = MOCKSELECTORMODULE.log[i]
self.assertEqual("select", func, "select was called in the main loop")
self.assertEqual(["LOOKINGFORTHIS","LOOKINGFORTHISTOO","LOOKINGFORANDTHIS"], args[0])#, "The selectable was added to the list of readables")
def __init__(self, editor): GObject.__init__(self) from Selector import Selector Selector(self, editor)
def visualize(DE, iterations, title='Differential Evolution'):
results, time = DE.run(iterations)
fig, ax = plt.subplots(figsize=(8, 8))
for x in range(10):
plt.plot(results[:, x], label='Vector' + str(x))
ax.ticklabel_format(style='plain')
plt.ylabel("Profit/Fitness")
plt.xlabel("Iteration")
print('Time needed:', time)
plt.legend()
plt.show()
# Parameter:
np = 10 #Populationsize
problemnumber = 1
F = 0.5 #Scale Factor
Cr = 0.3 #Crossover probability
ppp = PPP(problemnumber)
initializer = Initializer(ppp, np)
donorgenerator = DonorGenerator(F)
trialgenerator = TrialGenerator(Cr, problemnumber)
selector = Selector(ppp)
de = DE
DifferentialEvolution = de(ppp, initializer, donorgenerator, trialgenerator,
selector)
visualize(DifferentialEvolution, 500)
def generate_selector(self, number, basis):
selector = Selector(number, basis)
return selector
def selector():
from Selector import Selector
return Selector()
def addPreProcess(self):
steps = []
for preProcessMethod in self.preProcessingList:
# MRMR args :
# feature_correlations is the precomputed correlation matrix between the features, can't grid search on it
# => set it once and for all
# target_correlations is the precomputed correlation matrix between the features and the target,
# can't grid search on it => set it once and for all
# n_components, number of components with highest correlation with target, default to 20
# thresh, the threshold for the correlation above which we have to remove one feature, default to 1.0
if preProcessMethod == 'mrmr':
feature_corr = self.feature_correlations.copy()
target_corr = self.target_correlations.copy()
steps.append(('mrmr', MRMR(feature_corr, target_corr,
self.keys)))
elif preProcessMethod == 'select_corr':
steps.append(('select_corr',
Selector(score_func=np.corrcoef,
labels=self.keys,
info_vector=self.target_correlations,
random_state=self.seed)))
# MutualInfoSelection args :
# n_components, the number of components with the highest mutual info to keep, default to 20
elif preProcessMethod == 'select_mut':
steps.append(('select_mut',
Selector(score_func=mutual_info_regression,
labels=self.keys,
info_vector=self.target_muInf,
random_state=self.seed)))
# Whitening is equivalent to applying PCA on all the variables and scaling the variables to unit variance
# Whitening args :
# n_components, number of components to identify with PCA, default to all components
elif preProcessMethod == 'whitening':
steps.append(
('whitening', PCA(whiten=True, random_state=self.seed)))
# No args
elif preProcessMethod == 'standardization':
steps.append(('standardization', StandardScaler()))
# PCA args :
# n_components, number of components to identify with PCA, default to all components
elif preProcessMethod == 'PCA':
steps.append(('PCA', PCA(random_state=self.seed)))
# No args
elif preProcessMethod == 'outliers':
steps.append(
('outliers', FunctionSampler(func=remove_outliers)))
# No args
elif preProcessMethod == 'upsample':
steps.append(
('upsampling', UpSampling(random_state=self.seed)))
# No args
elif preProcessMethod == 'downsample':
steps.append(
('downsampling', DownSampling(random_state=self.seed)))
# other pre-processing steps ?
else:
continue
steps.append(('regression', self.model))
self.model = Pipeline(steps=steps)
def Selector2():
selector = Selector()
dataProcessor = DataProcessor()
selector.auraTick(dataProcessor.getAuraWithId(2))
def test_PausesUntilFirstMessage(self):
"""main - Before we recieve any messages telling us what to watch for, the system should pause and yield"""
S = Selector()
S.activate()
V = S.next()
self.assert_(S._isRunnable() is not True)
def selector(**kwds):
from Selector import Selector
return Selector(**kwds)
def test_RemoveExceptional_ResultsInExceptionalNoLongerBeingSelectedOrWiredIn(self):
"main - Sending a remove exceptional message unwires/links a component, and also removes it's selectable from the exceptionals list"
MOCKSELECTORMODULE = MockSelect(results=[ ([], [], [] )])
SELECTORMODULE.select = MOCKSELECTORMODULE
S = Selector()
S.activate()
for i in xrange(100): S.next()
D = Axon.Component.component()
dummyservice = (D, "inbox")
S._deliver(newExceptional(S,( dummyservice, "LOOKINGFORTHIS") ),"notify")
S._deliver(removeExceptional(S,"LOOKINGFORTHIS"),"notify")
for i in xrange(100):
S.next();
try:
S.postoffice.next()
except:
pass
self.assert_( D.inboxes["inbox"] == [] )
