def computePossiblePartitions(matchingPartitions, profsPartitions,
maxCoordinates, weights, profsData, lecturesData,
absolMin, absolMax):
c = Coordinates(maxCoordinates, weights)
idx = 0
totalMatches = 0
while (c.maxWeight(idx) >= absolMin):
while c.up(idx):
weight = c.weight()
if absolMin <= weight <= absolMax:
partition = {"coords": clone(c.coords), "profs": []}
for prof in profsData:
if profsData[prof]["min"] <= weight <= profsData[prof][
"max"]:
partition["profs"] += [prof]
profsPartitions[prof] += [clone(c.coords)]
matchingPartitions += [clone(partition)]
totalMatches += 1
idx = c.downMax()
print("Done with idx =", idx - 1)
if not idx:
break
print("Found", totalMatches, "matches in total")
for prof in profsData:
print(" *", len(profsPartitions[prof]), "for", prof)
print("")
def test_no_mapping(self):
example = Example()
assert modify_example(clone(example), dict()) == example
example = Example("test")
assert modify_example(clone(example), dict()) == example
example = Example("test with $ARG")
assert modify_example(clone(example), dict()) == example
def test_no_replacement(self):
mapping = {"argument": "replaced"}
example = Example()
assert modify_example(clone(example), mapping) == example
example = Example("test")
assert modify_example(clone(example), mapping) == example
example = Example("test with $ARG")
assert modify_example(clone(example), mapping) == example
def testRotate(o): #ADD: check actual point values after a rotation
a = getBlock('Z').shift(7,7)
b = clone(a).rotate(clockwise).rotate(clockwise).rotate(clockwise)
c = clone(a).rotate(counterClockwise)
d = clone(a).rotate(clockwise).rotate(clockwise) \
.rotate(clockwise).rotate(clockwise)
e = clone(a).rotate(counterClockwise).rotate(clockwise)
o._checkRotate(b,c)
o._checkRotate(a,d)
o._checkRotate(a,e)
o.failUnless(rotBlock(a,4).rotation == 0 and rotBlock(a,1).rotation == 1
and rotBlock(a,2).rotation == 2 and rotBlock(a,3).rotation == 3)
def collect_and_upload_data(self):
# build the query/url
query = "%s?begin=%s&end=%s&period=%d" % (
localserver, self.start_datetime.strftime("%d%m%Y%H%M%S"),
self.end_datetime.strftime("%d%m%Y%H%M%S"), update_interval * 60)
# add all the variable names, we need to calculate our target variables
for each in self.config.dependents.keys():
query += "&var=%s.%s" % (self.config.source, each)
# make the request
response = requests.get(query)
# log
self.logger.log("data collected")
# parse the response data to records
# each record has different timestamp than others
records = re.split("(?:</record>)*(?:<record>)", response.text)
# remove the first one from the stack
# the first one contains no record but xml info.
records.pop(0)
# process each record
for record in records:
if self.stop:
break
# make a copy of target and dependents
targets = clone(self.config.targets)
dependents = clone(self.config.dependents)
# extract datetime from record
rid = re.search(r"<dateTime>(\d+)", record).group(1)
# format datetime to match server/database format
rid = datetime.datetime.strptime(
rid, "%d%m%Y%H%M%S").strftime("%Y-%m-%d %H:%M:%S")
# find all the values we requested
matches = re.findall(r"(\w+)</id><value>([^<]+)", record)
# convert the values to number and index/save them
for match in matches:
dependents[match[0]] = round(float(match[1]), 6)
# calculate target variables using values from dependents variables
for target in targets:
for i in range(len(targets[target])):
targets[target][i] = dependents[targets[target][i]]
targets[target] = sum(targets[target])
# upload data
# if server didnt get the data, abort
# aborting is imprtant. this way we wont
# have missing data in the middle
# rest of the data will be uploaded in
# the beginning of next transmission
ack = self.upload_data(rid, targets)
if not ack:
break
def updateData(profsDataRaw, lecturesDataRaw):
""" Update data from teachers' wishes """
profsData = clone(profsDataRaw)
lecturesData = clone(lecturesDataRaw)
for prof in profsDataRaw:
if profsDataRaw[prof]["wish"]:
for section in profsDataRaw[prof]["wish"]:
durationOfThis = findAndPop(lecturesData, section)
profsData[prof]["min"] = reround(profsData[prof]["min"] -
durationOfThis)
profsData[prof]["max"] = reround(profsData[prof]["max"] -
durationOfThis)
return [profsData, lecturesData]
def new_random_state(self): # will be used in random restart and genetic
new_state = clone(self)
# must clone last graph,otherwise our source graph will change,because it contains pointers to nodes,and we are
# -changing that same nodes colour
for node in new_state.graphStructure:
node.colour = randint(0, 3)
return new_state
def __call__(self, value):
"""When invoked, this will pass the given value through the configured set of transformations"""
result = clone(value)
for fn in reversed(self.__chain):
result = fn(result)
result["__raw"] = dumps(value)
return result
def test_str(self):
graph = Graph(clone(MINIMAL))
s = str(graph)
self.assertEqual(
s,
'\n[section1]\nproperty1=10\nproperty2=http://redhat.com\nproperty3=howdy'
)
def pattern(self):
def jn(trps, acc, ret):
if not trps:
ret.append(acc)
return ret
trp = trps.pop(0)
if not acc:
return jn(trps, [trp._from, trp._edge, ">", trp._to], ret)
else:
if trp._from == acc[0]:
acc[0:0] = [trp._to, "<", trp._edge]
elif trp._from == acc[-1]:
acc.extend([trp._edge, ">", trp._to])
elif trp._to == acc[0]:
acc[0:0] = [trp._from, trp._edge, ">"]
elif trp._to == acc[-1]:
acc.extend(["<", trp._edge, trp._from])
else:
ret.append(acc)
acc = [trp._from, trp._edge, ">", trp._to]
return jn(trps, acc, ret)
pass
if not self._pattern:
trps = clone(self.triples)
grps = jn(trps, [], [])
pats = []
for grp in grps:
pats.append("".join([
x.pattern() if not isinstance(x, str) else x for x in grp
]))
self._pattern = ", ".join(pats)
return self._pattern
def run(self):
if self.mct == None:
# if new tree then initialize that it came from the opposite player
self.mct = Tree(switch_turns(self.turn))
else:
# if the tree exists look for the node if it contains that
children = self.mct.get_root().get_children()
if len(children) != 0:
contained = False
node = children[0]
for n in children:
if n.get_move() == self._cloned_board.get_previous_move():
contained = True
node = n
if contained:
self.mct.set_root(node)
else:
# otherwise initialize new tree
self.mct = Tree(switch_turns(self.turn))
else:
# otherwise initialize new tree
self.mct = Tree(switch_turns(self.turn))
start_time = current_milli_time()
while current_milli_time() - start_time < self.timeout - self.before:
self._cloned_board = clone(
UltimateTicTacToe(board=self.board, last_turn=self.last_turn))
self.roll_out(self.expansion(self.selection(self.mct.get_root())))
return self.choose_best_next_move()
def _as(ent, alias):
"""Return copy of ent with As alias set."""
if isinstance(ent, T):
return ent
ret = clone(ent)
ret.As = alias
return ret
def freeze(self):
new = SymbolTable(self.scope, self.name, self.block)
new.frozen = True
new.local = clone(self.local)
new.mutables = self.mutables
new.args = self.args
return new
def _var(ent):
"""Return entity without label or type."""
ret = None
if isinstance(ent, (N, R)):
ret = clone(ent)
if hasattr(ret, "label"):
ret.label = None
if hasattr(ret, "Type"):
ret.Type = None
elif isinstance(ent, T):
ret = clone(ent)
ret._from.label = None
ret._to.label = None
# leave the edge type alone in a triple...
else:
return ent
return ret
def _plain(ent):
"""Return entity without properties."""
ret = None
if isinstance(ent, (N, R)):
ret = clone(ent)
ret.props = {}
elif isinstance(ent, P):
ret = clone(ent)
ret.value = None
elif isinstance(ent, T):
ret = clone(ent)
ret._from.props = {}
ret._to.props = {}
ret._edge.props = {}
else:
return ent
return ret
def clone(self):
other = Schematic(self.name)
other.blocks = {}
for name, block in self.blocks.items():
if hasattr(block, "bmp"):
bmptemp = block.bmp
block.bmp = None
other.blocks[name] = clone(block)
self.blocks[name].bmp = bmptemp
other.connectors = clone(self.connectors)
other.sim_settings = clone(self.sim_settings)
other.parameters = clone(self.parameters)
return other
def get_dataset(self,
tickers,
window_size=200,
roi_size=100,
start=None,
end=None,
features=None,
minus_features=[]):
# Default end value is yesterday and no higher
if end is None:
end = DataHandler.date_to_key(datetime.datetime.now()) - 1
elif end > DataHandler.date_to_key(datetime.datetime.now()) - 1:
raise ValueError(
"end value must be no higher than yesterday: ",
DataHandler.date_to_key(datetime.datetime.now()) - 1)
# Default start value is 2000 days prior to start and no earlier than Jan 1 2005
if start is None:
start = end - 2000
if start < 0:
start = 0
elif start < 0:
raise ValueError("end value must be later than the epoch: 0")
# Default features value is all features
if features is None or len(features) == 0:
features = clone(all_features)
# Remove duplicates
features = list(dict.fromkeys(features))
# Remove requested minus features
for feature in minus_features:
if feature in features:
del features[features.index(feature)]
# Important values
length = end - start
n_windows = math.floor((length - roi_size) / window_size)
print(length - roi_size, "/", window_size, "=", n_windows)
n_features = len(features)
n_instances = len(tickers) * n_windows
# Create dataset
data_x = np.empty([n_instances, window_size, n_features])
data_y = np.empty([n_instances, 1])
instance_idx = 0
for ticker in tickers:
ticker_data = self.get_data_for(ticker, start, end, features)
for i in range(n_windows):
data_x[instance_idx] = ticker_data[i * window_size:i *
window_size + window_size]
data_y[instance_idx] = self.get_roi(
ticker_data, features, i * window_size + window_size,
roi_size)
instance_idx += 1
return (data_x, data_y)
def test_get(self):
graph = Graph(clone(MINIMAL))
section = graph.section1
# found
p1 = section.property1
self.assertEqual(p1, MINIMAL['section1']['property1'])
# not found
p1 = section.foobar
self.assertTrue(p1 is None)
def sendMessage(self, m):
m.fromDir = m.LEFT
log.debug("Node %-17s | TRANSMIT | %-17s | to node %-17s" % (self.log(), m.log(), self.left.log()))
self.sendLeft(m)
m = clone(m)
m.fromDir = m.RIGHT
m.delay = randint(self.minDelay, self.maxDelay)
log.debug("Node %-17s | TRANSMIT | %-17s | to node %-17s" % (self.log(), m.log(), self.right.log()))
self.sendRight(m)
def test_get(self):
graph = Graph(clone(MINIMAL))
section = graph.section1
# found
p1 = section.property1
self.assertEqual(p1, MINIMAL['section1']['property1'])
# not found
p1 = section.foobar
self.assertTrue(p1 is None)
def possible_next_states(self, only_better_states=True):
possible_next_states = []
current_value = self.evaluate_value()
for i in range(len(self.graphStructure)):
# we must clone it
# otherwise we will be changing the source structure for ever and we'll only get one new state at the end
new_state = clone(self)
new_state2 = clone(self)
increase_node_color(new_state.graphStructure[i])
decrease_node_color(new_state2.graphStructure[i])
if only_better_states:
if new_state.evaluate_value() > current_value:
possible_next_states.append(new_state)
if new_state2.evaluate_value() > current_value:
possible_next_states.append(new_state2)
else:
possible_next_states.extend([new_state, new_state2])
return possible_next_states
def test_accessing(self):
graph = Graph(clone(MINIMAL))
# property: found
self.assertEqual(graph.section1.property1, '10')
# property: not found
self.assertEqual(graph.section1.propertyXX, None)
self.assertEqual(graph.section10.property1, None)
# section: found
self.assertEqual(repr(graph.section1), repr(MINIMAL['section1']))
# section: not found
self.assertEqual(repr(graph.section100), repr({}))
def test_accessing(self):
graph = Graph(clone(MINIMAL))
# property: found
self.assertEqual(graph.section1.property1, '10')
# property: not found
self.assertEqual(graph.section1.propertyXX, None)
self.assertEqual(graph.section10.property1, None)
# section: found
self.assertEqual(repr(graph.section1), repr(MINIMAL['section1']))
# section: not found
self.assertEqual(repr(graph.section100), repr({}))
def graph_idfs(graph_city_details_dictionary):
i = 1
while True:
new_graph_city_details_dictionary = clone(
graph_city_details_dictionary)
start_node = new_graph_city_details_dictionary["Arad"]
destination_node = new_graph_city_details_dictionary["Bucharest"]
graph_ldfs(start_node, destination_node, i)
if destination_node.parent is not None:
return new_graph_city_details_dictionary
else:
i += 1
def flatten(self):
"""Flattens all the subcircuits recursively to the main subcircuit.
:return: None
"""
# now loop through and grab all the subcircuit instances and remove from
# device list:
for x_name, x_device in self.devices.items():
if x_name[0] == "X": # if subckt instance device:
subckt_name = x_device.subckt
if subckt_name in self.subckts: # if subckt def found:
subckt = self.subckts[subckt_name]
# loop through the subckt devices, clone them for the
# subckt instance, and mangle the names to prevent
# collisions:
for sub_name, sub_device in subckt.devices.items():
mangled_name = "{0}_{1}".format(x_name, sub_name)
new_device = clone(sub_device)
# replace subckt instance device node names with
# external node names & mangle the internal node names:
new_device.nodes = list(new_device.nodes)
for i, node in enumerate(new_device.nodes):
if node == 0 or node == 'ground' or node == 'gnd':
new_device.nodes[i] = 0
elif node in x_device.port2node:
new_device.nodes[i] = x_device.port2node[node]
else:
mangled_port = "{0}_{1}".format(x_name, node)
new_device.nodes[i] = mangled_port
# add device to top level:
self.device(mangled_name, new_device)
# delete the X device (which has now been replaced with
# actual device instances and is no longer needed):
del self.devices[x_name]
else: # if subckt definition not found:
msg = "Subcircuit {0} not defined for device {1}."
msg.format(x_device.subckt, x_name)
raise SubCircuitError(msg)
def test_strict_get(self):
graph = Graph(clone(MINIMAL), strict=True)
section = graph.section1
# found
p1 = section.property1
self.assertEqual(p1, MINIMAL['section1']['property1'])
# not found
try:
unused = section.foobar
self.assertTrue(False, msg='AttributeError not raised')
except AttributeError:
pass
def test_strict_get(self):
graph = Graph(clone(MINIMAL), strict=True)
section = graph.section1
# found
p1 = section.property1
self.assertEqual(p1, MINIMAL['section1']['property1'])
# not found
try:
unused = section.foobar
self.assertTrue(False, msg='AttributeError not raised')
except AttributeError:
pass
def execute_method(node, args=None):
global LAST_EVALUATED, LAST_RETURNED, FROZEN_TABLES, CALL_STACK
definition = node
if not isinstance(node, (Definition, function)):
definition = evaluate(node.value)
if type(definition) is function:
return definition(node)
if type(definition) is not Definition:
loc = None
if is_node(definition):
loc = node.value.location
else:
loc = CURRENT_LOCATION
return EX.throw(
loc,
'Cannot make call to to type of `{}\''.format(to_type(definition)))
if definition is None:
return EX.throw(CURRENT_LOCATION, 'Cannot make empty call.')
if args is None:
args = list(map(evaluate, node.operands))
else:
print("Artificial args")
FROZEN_TABLES = definition.frozen
added = definition.table.scope == CURRENT_SCOPES[-1]
if not added:
CURRENT_SCOPES.append(definition.table.scope)
call_table = clone(definition.table)
call_table.clean()
call_table.give_args(args)
CALL_STACK.append(call_table)
# Aaaaand, then we finally, make the call...
result = definition.call()
# Back to cleaning up our Symbol tables.
definition.table.clean()
FROZEN_TABLES = []
if not added:
CURRENT_SCOPES.pop()
CALL_STACK[-1].clean()
CALL_STACK.pop()
del call_table
LAST_EVALUATED = result
LAST_RETURNED = LAST_EVALUATED
return LAST_RETURNED
def withTitle(self, title):
"""
Creates a copy of the menu with a different title.
Args:
title (str): Title
Returns:
Menu: Cloned Menu with a different title.
"""
newme = clone(self)
newme.setTitle(title)
return newme
def begin(self):
self.state = self.INITIATOR
if self.state == StageNode.INITIATOR: # For Initiators, need process first compare here or it will miss these messages
self.state = StageNode.CANDIDATE
#print("Initiator Node %d has changed to Candidate." % self.id)
log.debug("Initiator Node %d has changed to Candidate." % self.id)
m = StageMessage()
m.id = self.id
m.type = StageMessage.INFO
m.delay = randint(StageNode.minDelay, StageNode.maxDelay)
self.sendRight(m)
message = clone(m)
message.dir = 3
self.sendStageLeft(message)
def colorMap(nodes):
nodes = sorted(nodes)
for node in nodes:
if node.color is not None:
break
colors = sample(node.colors, k=len(node.colors))
node.updatePossibleColors()
for color in colors:
node.setColor(color)
res = colorMap(clone(nodes))
if res is not None:
return res
node.color = None
return None
def getRouletteWheel(population, SCORES, scorefunc, scoreparams):
""" Return a fitness-proportional roulette wheel for the population"""
from population import functify
wheel={}
top = 0.0
for p in population:
if functify(p) not in SCORES: SCORES[functify(p)] = scorefunc(p, *scoreparams)
totalscore = abs(sum((SCORES[functify(p)] for p in population)))
for p in population:
fit = SCORES[functify(p)]/totalscore
wheel[(top, top+fit)] = clone(p)
top += fit
# print 'returning wheel' ##
return wheel
def __init__(self,
board,
last_turn,
turn=Turns.X.value,
timeout=100,
before=1):
self._cloned_board = UltimateTicTacToe(board=board,
last_turn=last_turn)
self._moves = self._cloned_board.get_free_moves()
games = []
for move in self._moves:
_cloned_board = clone(self._cloned_board)
board = _cloned_board.move(turn, *move)
if board:
board_list = _cloned_board.get_board_list()
games.append(
(board_list, last_turn, turn, timeout, before, move))
self.games = games
def test_strict_accessing(self):
graph = Graph(clone(MINIMAL), strict=True)
# property: found
self.assertEqual(graph.section1.property1, '10')
# property: not found
try:
unused = graph.section1.propertyXX
self.assertTrue(False, msg='AttributeError not raised')
except AttributeError:
pass
# section: found
self.assertEqual(repr(graph.section1), repr(MINIMAL['section1']))
# section: not found
try:
unused = graph.section100
self.assertTrue(False, msg='AttributeError not raised')
except AttributeError:
pass
def test_strict_accessing(self):
graph = Graph(clone(MINIMAL), strict=True)
# property: found
self.assertEqual(graph.section1.property1, '10')
# property: not found
try:
unused = graph.section1.propertyXX
self.assertTrue(False, msg='AttributeError not raised')
except AttributeError:
pass
# section: found
self.assertEqual(repr(graph.section1), repr(MINIMAL['section1']))
# section: not found
try:
unused = graph.section100
self.assertTrue(False, msg='AttributeError not raised')
except AttributeError:
pass
def EVCentrality(self, maxit=100):
"""
returns a dict of all Eigen Vector Centrality values
"""
nodes = self.getNodes()
V = defaultdict(lambda: 1)
for i in range(0, maxit):
W = defaultdict(lambda: 0)
for node in nodes:
for neighbour in self.next(node):
W[neighbour] = W[neighbour] + V[node]
V = clone(W)
S = 0
for _, i in V.items():
S += i
for key, value in V.items():
V[key] = float(value) / float(S)
return V
def __crossover(first_chromosome, second_chromosome):
child_chromosome = clone(
first_chromosome) # first initiate the child chromosome values
child_chromosome_similarity_to_first_chromosome = randint(
0, 10) # child's possible similarity to first parent
for i in range(len(child_chromosome.graphStructure)
): # or len(parents_chromosome.graphStructure)
# skip parent's common value
if first_chromosome.graphStructure[
i].colour == second_chromosome.graphStructure[i].colour:
continue
# child must have some of non common value from both parent's
else:
winner_parent = __apply_child_similarity_dosage(
child_chromosome_similarity_to_first_chromosome)
if winner_parent == 1:
continue
else:
child_chromosome.graphStructure[
i].colour = second_chromosome.graphStructure[i].colour
return child_chromosome
def get_attr_to_suggest(dict_attr_from_graph):
random.shuffle(mining_results)
max_num_match_attr = 0
chosen_key, chosen_val = None, None
used_attr = None
used_rules = None
for dct in mining_results:
mining_dict = clone(dct)
is_suitable = False
current_num_match_attr = 0
temp_attr = dict()
mining_keys = list(mining_dict.keys())
random.shuffle(mining_keys)
for mining_key in mining_keys:
mining_val = mining_dict[mining_key]
if mining_key in dict_attr_from_graph.keys():
graph_val = dict_attr_from_graph[mining_key]
if (isinstance(graph_val, list) and mining_val in graph_val) or mining_val==graph_val:
temp_attr[mining_key] = mining_val
current_num_match_attr +=1
is_suitable = True
mining_dict.pop(mining_key)
mining_dict_keys = set(mining_dict.keys()).difference(set(dict_attr_from_graph['ignore_attr']))
if is_suitable and len(mining_dict_keys) > 0 and current_num_match_attr > max_num_match_attr:
if len(mining_dict_keys)==1 and list(mining_dict_keys)[0]=="potential" and mining_dict["potential"] not in MAPPING_POTENTIAL.keys():
continue
while (True):
chosen_key = random.choice(list(mining_dict_keys))
chosen_val = mining_dict[chosen_key]
if not chosen_key=="potential" or chosen_val in MAPPING_POTENTIAL.keys():
break
max_num_match_attr = current_num_match_attr
used_attr = temp_attr
used_rules = dct
logger.info('\n MINING-SUGGESTOR:\nRULES: ' + str(used_rules) + "\nUSED ATTR: " + str(used_attr) + "\nCHOSEN: " + str({chosen_key: chosen_val}))
return used_rules, used_attr, chosen_key, chosen_val
def roll_out(self, node):
# second approach, use neural net to predict
old_board = self._cloned_board.get_board_list()
if not self._cloned_board.is_game_done():
move = choice(self._cloned_board.get_free_moves())
new_board = clone(old_board)
new_board[move[0]][move[1]] = 1
feature = np.concatenate(
(old_board.flatten(), new_board.flatten()),
axis=0).reshape(18, 9, 1)
score = self.nn.predict(np.array([feature]))[0]
if score[0] > score[1]:
self.backpropogate(GameState.WIN, node)
elif score[1] > score[0]:
self.backpropogate(GameState.LOSE, node)
else:
self.backpropogate(GameState.DRAW, node)
else:
if self._cloned_board.get_winner() == None:
self.backpropogate(GameState.DRAW, node)
else:
self.backpropogate(
GameState.WIN if node.get_turn() == Turns.X.value else
GameState.LOSE, node)
def test_iter(self):
graph = Graph(clone(MINIMAL))
properties = list(graph.section1)
self.assertEqual(properties, MINIMAL['section1'].items())
def test_repr(self):
graph = Graph(clone(MINIMAL))
s = repr(graph.section1)
self.assertEqual(s, repr(MINIMAL['section1']))
def test_str(self):
graph = Graph(clone(MINIMAL))
s = str(graph.section1)
self.assertEqual(s, 'property1=10\nproperty2=http://redhat.com\nproperty3=howdy')
def __add__(self, r):
''' new sum dict '''
sum = clone(self)
sum.update(r)
return sum
def copy(self):
''' dict deep copy '''
return clone(self)
def test_set(self):
graph = Graph(clone(MINIMAL))
section = graph.section1
self.assertTrue(section.thing is None)
section.thing = 100
self.assertEqual(section.thing, 100)
def test_repr(self):
graph = Graph(clone(MINIMAL))
s = repr(graph)
self.assertEqual(s, repr(MINIMAL))
def test_unicode(self):
graph = Graph(clone(MINIMAL))
s = unicode(graph)
self.assertEqual(s, '\n[section1]\nproperty1=10\nproperty2=http://redhat.com\nproperty3=howdy')
def test_iter(self):
graph = Graph(clone(VALID))
sections = list(graph)
self.assertEqual(len(sections), len(VALID))
self.assertEqual(sections[0], (VALID.items()[0]))
self.assertEqual(sections[1], (VALID.items()[1]))
def getBlock(kind): return clone(tstBlk[kind]) def rotBlock(block,rotations):
def __add__(self, r):
""" new sum dict """
sum = clone(self)
sum.update(r)
return sum
def copy(self):
""" dict deep copy """
return clone(self)
#def reroute((V,E), paths, a, u, n): # ''' Reroute agent a through node n to node u''' # best = '', None # cost, path # for r in n.residents: # path = paths[r] # cost = sum((e.weight for e in path)) + min((e.weight for e in E if (u in e and n in e) )) # if cost < best[0]: # best = cost, path+[min((e for e in E if (u in e and n in e) ), key=lambda x : x.weight)] # # paths[a] = best[1] # return (V,E), paths, a, u, n def getNeighbor((VV,EE), paths, dist, rerouts): """ rerouts = [(terminal node, rerouted through)]""" # print 'getNeighbor' ## V,E = clone(VV), clone(EE) u, n = None, None while u is None: try: us = [v for v in V if v.residents and (rerouts and v.id not in [r[0] for r in rerouts]) and \ any( (e for e in E if v in e and e.capacity==inf and \ routable(e.src if v==e.dest else e.dest, paths) and \ e.weight <= dist) ) ] U = max(paths, key=lambda a: sum((e.weight for e in paths[a])) ) for v in V: if U in v.residents: u = v break else: u = choose(us)
def rotBlock(block,rotations): b = clone(block) for x in range(rotations): b.rotate(clockwise) return b
def processMessage(self:Node, message:StageMessage): # message can be from left or right
#log.debug("Node %17s | PROCESS | %-17s" %(self.log(), message.log())) ##
#print("-" * 60)
#print("Message queue for node %s" % self.log())
#print("-" * 30 + "Right")
#for m in self.messageQueue:
# print(m.log())
#print("-" * 30 + "Left")
#for mLeft in self.messageQueueLeft:
# print(mLeft.log())
#print("-" * 30)
if self.state != StageNode.LEADER and message.type == message.LEADER: #if Non-Leader received LEADER's msg
#print("Node id " + str(self.id) + " is processing Leader's notice! ")
log.debug("Node id " + str(self.id) + " is processing Leader's notice! ")
self.messageQueue = []
self.messageQueueLeft = []
self.state = self.FOLLOWER
#log.info("Node %17s | TRANSMIT | %-17s | to Node %03d" % (self.log(), message.log(), self.right.id)) ##
self.sendRight(message) # Leader notification forward
elif self.state == StageNode.CANDIDATE: # candidates processing # algorithm terminates,
if (message):
if message.id == self.id and message.stage == self.stage:
if message.type != message.LEADER: #Check the termination condition
self.state = self.LEADER
self.messageQueue = []
self.messageQueueLeft = []
m = StageMessage()
m.type = m.LEADER
m.id = self.id
m.delay = randint(StageNode.minDelay, StageNode.maxDelay)
m.stage = self.stage
#log.info("Node %17s | TRANSMIT | %-17s | to Right Node %03d" % (self.log(), m.log(), self.right.id)) ##
#print("Node id " + str(self.id) + " is Leader!")
log.debug("Node id " + str(self.id) + " is Leader!")
self.sendRight(m) # Leader notification
else: # clean msg queue for leader notification back to leader node
self.messageQueue = []
self.messageQueueLeft = []
elif (self.messageQueueLeft) and self.messageQueueLeft[0].type != message.LEADER and self.messageQueueLeft[0].id == self.id: #Check the termination condition
self.state = self.LEADER
self.messageQueue = []
self.messageQueueLeft = []
m = StageMessage()
m.type = m.LEADER
m.id = self.id
m.delay = randint(StageNode.minDelay, StageNode.maxDelay)
m.stage = self.stage
#log.info("Node %17s | TRANSMIT | %-17s | to Right Node %03d" % (self.log(), m.log(), self.right.id)) ##
#print("Node id " + str(self.id) + " is Leader from left!")
log.debug("Node id " + str(self.id) + " is Leader from left!")
self.sendRight(m) # Leader notification
if self.id != message.id and self.id < message.id: # become waiting to process another side, don't need send msg now, set processedMsg ...
# 3 steps: Pop msg / set node to Waiting / set processedMsg to 0 or 1
self.state = StageNode.WAITING
if message.dir == 2:
m = self.messageQueue.pop(0)
self.processedMsg = 0
#print("Candidate Node id " + str(self.id) + " is processing Node " + str(
# message.id) + " and became Waiting! ")
elif message.dir == 3:
m = self.messageQueueLeft.pop(0)
self.processedMsg = 1
#print("Candidate Node id " + str(self.id) + " is processing Left Node " + str(
# message.id) + " and became Waiting! ")
elif self.id != message.id: # failed, set state to WAITING for processing.
# 3 steps: Pop msg / set node to Waiting / set processedMsg to 0 or 1/ set self.fail
self.fail = True
self.state = StageNode.WAITING
if message.dir == 2:
m = self.messageQueue.pop(0)
self.processedMsg = 0
#print("Node id " + str(self.id) + " is failed by Right Node " + str(message.id))
elif message.dir == 3:
m = self.messageQueueLeft.pop(0)
self.processedMsg = 1
#print("Candidate Node id " + str(self.id) + " is processing Left Node " + str(
# message.id) + " and became Waiting! ")
elif self.state == StageNode.DEFEATED: # DEFEATED node only forward.
#print("Defeated Node id " + str(self.id) + " is forwarding! ")
log.debug("Defeated Node id " + str(self.id) + " is forwarding! ")
# steps: forward in two sides one time, pop messages which have been processed in 2 queues
if message.dir == 2: # check if it is sent from right
m = self.messageQueue.pop(0)
self.sendRight(message) # forward to right if from my left neighbour
if self.messageQueueLeft: # sent right, then check left
messageLeft = self.messageQueueLeft.pop(0)
if messageLeft.dir == 2:
self.sendRight(messageLeft)
else:
self.sendStageLeft(messageLeft)
else:
self.sendStageLeft(message) # forward to left if sent from left neighbour
messageLeft = self.messageQueueLeft.pop(0)
if self.messageQueue: # sent left, then check right
m = self.messageQueue.pop(0)
if messageLeft.dir == 2:
self.sendRight(m)
else:
self.sendStageLeft(m)
elif self.state == StageNode.WAITING: #
if self.processedMsg == 0: # processed right, message from left, then process
#remove message.dir ==3 because: elif self.processedMsg == 0 and message.dir ==2: # 2 sent to 3's right before 3 processed previous left msg
if self.messageQueueLeft:
messageLeft = self.messageQueueLeft.pop(0)
if (not self.fail) and self.id < messageLeft.id: # waiting processing
# steps: set self.state to Candidate / stage + 1 / send msg to 2 sides
self.state = StageNode.CANDIDATE
self.stage += 1
m = StageMessage()
m.type = m.INFO #self.CANDIDATE # should set to message's type not node's state....
m.id = self.id
m.delay = randint(StageNode.minDelay, StageNode.maxDelay)
m.stage = self.stage
self.sendRight(m)
message = clone(m)
message.dir = 3
self.sendStageLeft(message)
#print("Waiting Node id " + str(self.id) + " is processing Left Node " + str(messageLeft.id))
log.debug("Waiting Node id " + str(self.id) + " is processing Left Node " + str(messageLeft.id))
else: # Defeated, set state.
self.state = self.DEFEATED
#print("Waiting Node id " + str(self.id) + " is DEFEATED!")
log.debug("Waiting Node id " + str(self.id) + " is DEFEATED!")
else:
return
elif self.processedMsg == 1: # processed Left, message from right, then process
if self.messageQueue:
mRight = self.messageQueue.pop(0)
if (not self.fail) and self.id < mRight.id: # waiting processing
# steps: set self.state to Candidate / stage + 1 / send msg to 2 sides
self.state = StageNode.CANDIDATE
self.stage += 1
m = StageMessage()
m.type = m.INFO #self.CANDIDATE # should set to message's type not node's state....
m.id = self.id
m.delay = randint(StageNode.minDelay, StageNode.maxDelay)
m.stage = self.stage
self.sendRight(m)
message = clone(m)
message.dir = 3
self.sendStageLeft(message)
#print("Waiting Node id " + str(self.id) + " is processing Right Node " + str(message.id))
log.debug("Waiting Node id " + str(self.id) + " is processing Right Node " + str(message.id))
else: # Defeated, set state.
self.state = self.DEFEATED
#print("Waiting Node id " + str(self.id) + " is DEFEATED!")
log.debug("Waiting Node id " + str(self.id) + " is DEFEATED!")
else:
return
elif self.state == StageNode.LEADER:
self.messageQueue = []
self.messageQueueLeft = []
else:
#log.info("Node %17s | TRANSMIT | %-17s | to Node %03d" % (self.log(), message.log(), self.right.id)) ##
#print("last else, there is error if this line is printed!!!!")
sys.stderr.write("last else, there is error if this line is printed!!!!")
def get_data_for(self, ticker, start=None, end=None, features=None):
# Default end value is yesterday and no higher
if end is None:
end = DataHandler.date_to_key(datetime.datetime.now()) - 1
elif end > DataHandler.date_to_key(datetime.datetime.now()) - 1:
raise ValueError(
"end value must be no higher than yesterday: ",
DataHandler.date_to_key(datetime.datetime.now()) - 1)
# Default start value is 2000 days prior to start and no earlier than Jan 1 2005
if start is None:
start = end - 2000
if start < 0:
start = 0
elif start < 0:
raise ValueError("end value must be later than the epoch: 0")
# Default features value is all features
if features is None or len(features) == 0:
features = clone(all_features)
# Remove duplicates
features = list(dict.fromkeys(features))
print("Getting data for ", ticker, "with a start of", start,
"and an end of", end, "with the features:", features)
# Load the full stored dataset of the ticker
data = self.load_dataset(ticker)
# Fill missing values with previous value, if no previous value, then the first value that appears
for feature in features:
if feature not in data:
raise ValueError("feature " + feature +
" does not exist in the " + ticker + "data")
elif len(data[feature]) == 0:
raise ValueError("feature " + feature + " is empty for " +
ticker)
prev_value = None
back_idx = None
for i in range(len(data[feature])):
if data[feature][i] is None:
data[feature][i] = prev_value
elif back_idx is None:
back_idx = i
prev_value = data[feature][i]
if back_idx is not None:
for i in range(back_idx):
data[feature][i] = data[feature][back_idx]
if data[feature][0] is None:
raise ValueError("feature " + feature + " is empty for " +
ticker)
# Prune the unwanted features and date range
keys = data.keys()
for feature in list(keys):
if feature in features:
if len(data[feature]) >= end:
data[feature] = data[feature][start:end]
else:
DataHandler.extend_list_to(data[feature], end)
data[feature] = data[feature][start:end]
else:
del data[feature]
# Check that all features are there
for feature in features:
if feature not in data:
raise ValueError("feature " + feature +
" does not exist in the " + ticker + "data")
#print(data)
# Return the desired data
return DataHandler.convert_data_to_numpy(data, start, end, features)
def get_node_clone(node):
if node not in node_map:
node_map[node] = clone(node)
graph.add_node(node_map[node])
return node_map[node]
