def buildParseTree(self, expression):
# Find all numbers and operators and put into list
fplist = re.findall(r"[+*-/()\^]| *(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?", expression)
tree = self.tree
current_branch = Branch()
for i in fplist:
if i == '(':
current_branch = Branch()
current_branch.insert_left('')
tree.set_parent(current_branch)
current_branch = current_branch.get_left_child()
elif i in ['+', '-', '*', '/']:
current_branch = Branch()
current_branch.set_root_value(i)
tree.set_parent(current_branch.tree)
tree.insert_right({})
current_branch = Branch()
elif i == ')':
current_branch = tree.get_parent()
elif i not in ['+', '-', '*', '/', ')']:
try:
current_branch = current_branch.set_root_value(int(i))
tree = current_branch
except ValueError:
raise ValueError("token '{}' is not a valid integer".format(i))
print self.tree.tree
return tree
def test_find_endpoint():
p = Point(0, 0)
b = Branch(p)
assert b.find_endpoint() == (0, -100)
b = Branch(p, dst=50)
assert b.find_endpoint() == (0, -50)
b = Branch(p, dst=50, angle=180)
assert b.find_endpoint() == (0, 50)
def main():
# Main loop
while True:
events = pygame.event.get()
for event in events:
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
# Draw on screen
screen.blit(bg, (0, 0))
draw_ground()
tam_br = 8
if main_br.get_len() > 5:
length = main_br.get_len()
# if length
branch = Branch(main_br.get_rect(length - 1).x,
main_br.get_rect(length - 1).y,
color=GREEN,
tam=8)
branch.set_direction(Branch.RIGHT)
tree.append(branch)
if main_br.get_len() > 5:
length = main_br.get_len()
branch = Branch(main_br.get_rect(length - 1).x,
main_br.get_rect(length - 1).y,
color=GREEN,
tam=8)
branch.set_direction(Branch.LEFT)
tree.append(branch)
# # Drawing branches and main
# if main_br.get_len() in [5, 15, 25, 35, 45]:
# length = main_br.get_len()
# branch = Branch(main_br.get_rect(length-1).x, main_br.get_rect(length-1).y, color=GREEN, tam=8)
# branch.set_direction(Branch.RIGHT)
# tree.append(branch)
# if main_br.get_len() in [10, 20, 30, 40, 50]:
# length = main_br.get_len()
# branch = Branch(main_br.get_rect(length-1).x, main_br.get_rect(length-1).y, color=GREEN, tam=8)
# branch.set_direction(Branch.LEFT)
# tree.append(branch)
for br in tree:
br.draw_branch(screen)
pygame.display.update()
sleep(0.1)
clock.tick(30)
def build_tree():
root = Branch()
branches = [root]
for _ in range(500):
new_branch = Branch()
branches.append(new_branch)
clear_branch = find_clear_branch(root)
clear_branch.attach(new_branch)
secret_branch = choice(branches)
secret_branch.has_kitten = True
root.show()
return root
def iteration(self, rule = [( + 85/180*np.pi, 1.5), (-85/180*np.pi, 1.5)], noise = True):
"""
This method is what differentiate an L-system form another. The necessary rules for the costruction are:
-1) number of child branch (n = 2,3)
-2) angle deviation of each child branch (+ alpha, - alpha)
-3) increasing/decreasing length ratio (l1 = l0 * R).
-4) Presence of noise on the angle in the ramification.
[It's greater and greater going on with the iterations (proportional to iter_lev)]
The current branch is used to create the new branch(es). The first three rules could be all condesed
in a list, like this one: [(+alpha, R), (-alpha, R)].
This rule create 2 new branches (list lenght) with the reported angular deviation al lenght ratio.
The origin and generation relationship shuold be update after every application of the rules.
"""
if self.branches != []:
for br in self.branches:
if br.iter_lev == self.n_iter:
l0, theta0 =cmath.polar(br.head - br.tail)
for gen in rule:
#The first iterations are made completely
if self.n_iter < 3:
ang_noise = noise*br.iter_lev*gen[0]/20
l1 = l0/gen[1]
theta1 = theta0 + gen[0]
theta1 = theta1 + random.uniform(-ang_noise, ang_noise) #Adding noise
travel = cmath.rect(l1, theta1)
new_branch = Branch(tail = br.head,
head = br.head + travel,
iter_lev = self.n_iter + 1,
origin = br)
br.generate.append(new_branch)
self.branches.append(new_branch)
#Further iterations are subjected to variations
elif np.random.uniform()> 0.1:
ang_noise = noise*br.iter_lev*gen[0]/20
l1 = l0/gen[1]
theta1 = theta0 + gen[0]
theta1 = theta1 + random.uniform(-ang_noise, ang_noise) #Adding noise
travel = cmath.rect(l1, theta1)
new_branch = Branch(tail = br.head,
head = br.head + travel,
iter_lev = self.n_iter + 1,
origin = br)
br.generate.append(new_branch)
self.branches.append(new_branch)
self.n_iter += 1 #updating n_iter
else:
raise Exception('Start your L_system before iteration.')
def start(self, branch = Branch()):
"""
Method that initialize/overwrite the previous drawing.
The default starting branch is the tail = (0,0), head = (0,1), iter_lev = 0, origin = None]
"""
self.n_iter = 0
self.branches = [branch]
def __getBranchMapFromRefList(self, aRefList):
"""
Retrieve the branch map for this manager for all local branches. The branch
map is a list of Branch objects, each mapping a ref path to a
healthy/aged/old status.
:param aRefList: A list of Reference objects that should be processed and
mapped to healthy statuses.
:return: A list of Branch objects, each of which maps one Reference in aRefList
to a health status.
"""
log = self.__mConfig.getLog()
branchMap = []
for branch in aRefList:
branchPath = branch.path
branchName = branchPath.split('/')[-1]
# Don't include branches that should be ignored.
shouldIgnore = False
for ignoredBranch in self.__getConfig().getIgnoredBranches():
if branchName == ignoredBranch:
shouldIgnore = True
break
if shouldIgnore:
continue
newBranch = Branch(branchPath, self.__getConfig())
branchMap.append(newBranch)
return branchMap
def cmd_checkout(branch):
b = Branch()
b.switch_branch(branch)
repo = Repository()
pre_entries = dict(repo.index.entries)
repo.rebuild_index_from_commit(repo.branch.head_commit)
repo.rebuild_working_tree(pre_entries)
def test_commit_once(self):
Command.cmd_commit('first ci')
commit = Commit(sha1=Branch().head_commit)
self.assertIsNone(commit.parent_sha1)
tree = Tree(sha1=commit.tree)
objects = tree.parse_objects()
self.assertEqual(objects[self.path]['sha1'], Blob(self.content).sha1)
def get_tactic_by_waves_forward(waves_forward):
branch = Branch()
for waves_forward in range(waves_forward, 0, -1):
best_basket = compute_best_basket(branch.player, waves_forward)
branch.buy_basket(best_basket)
yield branch.copy()
branch.next_wave()
def get_max_income_tactic():
branch = Branch()
while True:
best_basket = compute_best_basket(branch.player)
branch.buy_basket(best_basket)
yield branch.copy()
branch.next_wave()
def process_branch(branch_dict, repo):
""" Takes a dictionary that has branch names as keys. This method sets
branches for repo"""
for branch_name in branch_dict:
branch = branch_dict[branch_name]
repo.get_branches()[branch_name] = Branch(branch[BRANCH_HEAD],
branch_name)
def create_branch():
branch_name = input('Branch Name: ')
branch_code = input('Branch Code: ')
address = Address('', '', '', '', '', '', '', '')
address.input_address()
b = Branch(branch_code, branch_name, address)
global_branches[b.branch_code] = b
print('Branch created successfully!')
def test_reset_default(self):
Command.cmd_reset(self.first_commit, is_soft=False, is_hard=False)
self.assertEqual(Branch().head_commit, self.first_commit)
repo = Repository()
uncommitted_files = repo.get_uncommitted_files()
unstaged_files = repo.get_unstaged_files()
self.assertFalse(uncommitted_files['modified'])
self.assertIn(self.path, unstaged_files['modified'])
def test_get_colour():
c = Colours((0, 0, 0), (255, 255, 255))
p = Point(0, 0)
b = Branch(p)
c.assign_colour(b, 0)
assert c.palette[c.get_colour(b)] == (0, 0, 0)
c.assign_colour(b, 1023)
assert c.palette[c.get_colour(b)] == (0, 0, 0)
def lambda_handler(event, context):
if 'body' in event:
item = json.loads(event.pop('body', event))
else:
item = event
dto = Branch(item)
ret_val = dto.create()
response = {'statusCode': 200, 'body': json.dumps({'result': ret_val})}
return response
def run(self):
try:
self.load()
self.halted = False
except FileNotFoundError:
sys.exit()
branch_table = Branch()
branch_table.run(self.ram, self.pc, self.register)
print(self.register)
def create_branch(self, cid, branch_cells, end_point_ids):
'''Create a branch from the centerlines.
'''
points = self.geometry.GetPoints()
num_lines = self.geometry.GetNumberOfLines()
## Find ends of line.
#
branch_end_point_ids = []
branch_end_cell_ids = []
for cell_id in branch_cells[cid]:
cell = self.geometry.GetCell(cell_id)
cell_pids = cell.GetPointIds()
num_ids = cell_pids.GetNumberOfIds()
pid1 = cell_pids.GetId(0)
pid2 = cell_pids.GetId(1)
if pid1 in end_point_ids:
start_cell = cell_id
branch_end_point_ids.append(pid1)
branch_end_cell_ids.append(cell_id)
elif pid2 in end_point_ids:
branch_end_point_ids.append(pid2)
branch_end_cell_ids.append(cell_id)
## Create branch geometry.
#
branch_geom = vtk.vtkPolyData()
branch_geom.SetPoints(points)
branch_lines = vtk.vtkCellArray()
#
for cell_id in branch_cells[cid]:
cell = self.geometry.GetCell(cell_id)
cell_pids = cell.GetPointIds()
num_ids = cell_pids.GetNumberOfIds()
pid1 = cell_pids.GetId(0)
pid2 = cell_pids.GetId(1)
line = vtk.vtkLine()
line.GetPointIds().SetId(0, pid1)
line.GetPointIds().SetId(1, pid2)
branch_lines.InsertNextCell(line)
#
branch_geom.SetLines(branch_lines)
branch_end_normals = []
for pid in branch_end_point_ids:
pt = points.GetPoint(pid)
normal = self.surface.get_point_normal(pt)
branch_end_normals.append(normal)
#print("[centerlines] branch cid: {0:d}".format(cid))
#print("[centerlines] branch_end_point_ids: {0:s}".format(str(branch_end_point_ids)))
#print("[centerlines] branch_end_cell_ids: {0:s}".format(str(branch_end_cell_ids)))
return Branch(cid, branch_geom, branch_end_point_ids, branch_end_cell_ids, branch_end_normals,
self.clip_distance, self.clip_width_scale)
def cmd_branch(name, is_deleted=False):
b = Branch()
if not name:
for branch in b.get_all_branches():
print '* %s' % colored(
branch,
'green') if branch == b.head_name else ' %s' % branch
elif is_deleted:
b.delete_branch(name)
else:
b.add_branch(name)
def test_commit_twice(self):
Command.cmd_commit('first ci')
parent_sha1 = Branch().head_commit
second_content = '11\n'
write_to_file(self.path, second_content)
new_path = '2.txt'
new_content = '2\n'
write_to_file(new_path, new_content)
Command.cmd_add('.')
Command.cmd_commit('second ci')
commit = Commit(sha1=Branch().head_commit)
self.assertEqual(parent_sha1, commit.parent_sha1)
tree = Tree(sha1=commit.tree)
objects = tree.parse_objects()
self.assertEqual(objects[self.path]['sha1'], Blob(second_content).sha1)
self.assertEqual(objects[new_path]['sha1'], Blob(new_content).sha1)
def lambda_handler(event, context):
if 'queryStringParameters' in event:
item = event.pop('queryStringParameters')
if isinstance(item, str):
item = literal_eval(item)
else:
item = event
dto = Branch(item)
ret_val = dto.delete()
response = {'statusCode': 200, 'body': json.dumps({'result': ret_val})}
return response
def ConstructLELsForNode(self, leafNode):
nodes = leafNode.branchNodes
caseId = leafNode.caseId
branch = Branch(self.branchId, caseId, nodes)
self.branchId += 1
self.checkedLeafs.append(leafNode)
duplicated = []
if (len(self.eventLogsDic) == 0): # when its the first node to come
newLEL = []
newLEL.append(branch)
self.eventLogsDic[self.eventLogID] = newLEL
self.eventLogID += 1
# handle coming\ following cases
else:
currentEventLogIds = [
x for x in self.eventLogsDic.keys()
] #this line to avoid the error of being change in the iterator object :D
newLELs = []
for eLogID in currentEventLogIds:
if (self.eventLogsDic.get(eLogID) == None):
continue
branches = self.eventLogsDic[eLogID]
conflictBranches = self.checkRedundantBranches(
branch, branches) # do
if (len(conflictBranches) >
0): # if there are branches that violate the Checks
cb = self.getBranch(conflictBranches, caseId)
if (cb != None):
diff = set(branch.eventIdentifierList) - (
set(cb.eventIdentifierList)
) # what in the new branch not in the old branch
if (len(diff) == 0):
continue
if (set(branch.eventIdentifierList).issuperset(
set(cb.eventIdentifierList))):
self.eventLogsDic[eLogID].remove(cb)
self.eventLogsDic[eLogID].append(branch)
continue
elif (set(cb.eventIdentifierList).issuperset(
set(branch.eventIdentifierList))):
continue
newLEL = list(set(branches) - set(conflictBranches))
newLEL.append(branch)
newLELs.append(newLEL)
self.eventLogsDic[self.eventLogID] = newLEL
self.eventLogID += 1
else:
self.eventLogsDic[eLogID].append(branch)
duplicated = self.checkEventLogExistance(newLELs)
if (len(duplicated) > 0): #(not isdicclean):
for elogid in duplicated:
if (self.eventLogsDic.has_key(elogid)):
del self.eventLogsDic[elogid]
def add_branch():
data = request.get_json()
# data = json.loads(data2)
city = data["city"]
state = data['state']
branch_id = data['branch_id']
address = data['address']
new_branch = Branch(branch_id, address, city, state)
new_branch.save()
return "success"
def main():
pygame.init()
clock = pygame.time.Clock()
fps = 60
res = wid, hi = 1440, 870
d_surf = pygame.display.set_mode(res)
point = Point(wid / 2, hi / 2)
n = 7
max_dep = 5
cols = Colours((0, 0, 0), (255, 0, 0), (255, 165, 0), (255, 255, 0),
(0, 0, 0), (0, 0, 0), (0, 0, 40), (255, 255, 255))
col_spd = 2
branch_list = []
for i in range(n):
branch = Branch(point,
angle=360 / n * i,
dev=90 / n,
dst=150,
max_dep=max_dep)
branch_list.append(branch)
set_colours(branch_list, cols)
while True:
cols.inc_colours(col_spd)
d_surf.fill((0, 0, 0))
for branch in branch_list: # PH code to test methods: a better gen method reqd!
branch.push_angles()
branch.inc_tree_angle(
-0.4) # all works now, but order is important!
branch.inc_angle(4, 3)
branch.inc_angle(-2, 4) # push_angle first
branch.inc_tree_dev(0.08) # then angle ops, tree-wide first
branch.inc_dev(-0.8, 2) # then dev ops, tree-wide first.
branch.propagate() # then propagate.
# draw_circles(d_surf, branch, max_dep)
draw_branch(d_surf, branch, cols)
for e in pygame.event.get():
if e.type == QUIT or e.type == KEYDOWN and e.key == 27:
pygame.quit()
sys.exit()
pygame.display.update()
clock.tick(fps)
def setUp(self):
self.workspace = 'test_reset'
Command.cmd_init(self.workspace)
self.path, self.content = ('1.txt', '1\n')
write_to_file(self.path, self.content)
Command.cmd_add(self.path)
Command.cmd_commit('first ci')
self.first_commit = Branch().head_commit
write_to_file(self.path, '2.txt')
Command.cmd_add(self.path)
Command.cmd_commit('second ci')
def __init__(self, memoryFile):
self.nCycles = 0 # Used to hold number of clock cycles spent executing instructions
# Fetch
self.PCMux = Mux()
self.ProgramC = PC(long(0xbfc00200))
self.InstMem = InstructionMemory(memoryFile)
self.IFadder = Add()
self.JMux = Mux()
self.IFaddconst = Constant(4)
self.IF_ID_Wall = Wall()
self.fetchgroup = {}
# Decode
self.register = RegisterFile()
self.signext = SignExtender()
self.control = ControlElement()
self.jmpCalc = JumpCalc()
self.ID_EX_Wall = Wall()
# Execute
self.EXadder = Add()
self.shiftL = LeftShifter()
self.ALogicUnit = ALU()
self.ALUSrcMux = Mux()
self.RegDstMux = Mux()
self.ALUctrl = AluControl()
self.EX_MEM_Wall= Wall()
# Memory
self.storage = DataMemory(memoryFile)
self.brnch = Branch()
self.MEM_WB_Wall= Wall()
# Write Back
self.WBmux = Mux()
self.ProgramC
self.elements1 = [self.InstMem, self.IFaddconst, self.IFadder, self.PCMux, self.JMux]
self.elements2 = [self.control, self.register, self.signext, self.jmpCalc]
self.elements3 = [self.shiftL, self.ALUSrcMux, self.RegDstMux, self.ALUctrl, self.ALogicUnit, self.EXadder]
self.elements4 = [self.brnch, self.storage]
self.elementsboot = [self.IFaddconst, self.IFadder, self.InstMem,
self.IF_ID_Wall, self.register, self.signext, self.control, self.jmpCalc,
self.ID_EX_Wall, self.RegDstMux, self.shiftL, self.EXadder, self.ALUSrcMux, self.ALUctrl, self.ALogicUnit,
self.EX_MEM_Wall, self.brnch, self.storage,
self.MEM_WB_Wall, self.WBmux, self.PCMux, self.JMux]
self.walls = [self.MEM_WB_Wall, self.EX_MEM_Wall, self.ID_EX_Wall, self.IF_ID_Wall]
self._connectCPUElements()
def add_branch(self,
identifier,
caseId,
nodes,
confidenceLevel,
branchParent=None):
branch = Branch(identifier, caseId, nodes, confidenceLevel,
branchParent)
branch_identifier = branch.identifier
if branchParent is not None:
branchParent.add_child(branch)
else:
self[branch_identifier] = branch
return branch
def __init__(self):
self.branch = Branch()
self.job = Job()
self.post_receive_hook = PostReceiveHook()
self.project = Project()
self.pull_request = PullRequest()
self.sonar_qube = SonarQube()
self.__project_ops__ = {
'branch:set_default_permissions_for_project':
self.branch.set_default_permissions_for_project,
'post_receive_hook:configure_for_project':
self.post_receive_hook.configure_for_project,
'post_receive_hook:disable_for_project':
self.post_receive_hook.disable_for_project,
'post_receive_hook:enable_for_project':
self.post_receive_hook.enable_for_project,
'project:get_repos':
self.project.get_repos,
'pull_request:get_my_pull_requests':
self.pull_request.get_my_pull_requests,
'pull_request:set_pull_request_settings_for_project':
self.pull_request.set_pull_request_settings_for_project,
'sonar_qube:configure_for_project':
self.sonar_qube.configure_for_project
}
self.__ops__ = {
'branch:list_branches': self.branch.list_branches,
'branch:create_branch': self.branch.create_branch,
'branch:delete_branch': self.branch.delete_branch,
'branch:set_default_permissions':
self.branch.set_default_permissions,
'branch:set_default_branch': self.branch.set_default_branch,
'job:create_pipeline_job': self.job.create_pipeline_job,
'job:delete_pipeline_job': self.job.delete_pipeline_job,
'job:trigger_pipeline_branch_job':
self.job.trigger_pipeline_branch_job,
'job:trigger_pipeline_job': self.job.trigger_pipeline_job,
'post_receive_hook:configure': self.post_receive_hook.configure,
'post_receive_hook:disable': self.post_receive_hook.disable,
'post_receive_hook:enable': self.post_receive_hook.enable,
'pull_request:merge_pull_request':
self.pull_request.merge_pull_request,
'pull_request:set_pull_request_settings':
self.pull_request.set_pull_request_settings,
'pull_request:update_pull_request_status':
self.pull_request.update_pull_request_status,
'sonar_qube:configure': self.sonar_qube.configure
}
def span_trees(self):
"""
Span a tree for each battery with its houses.
For all nodes in the tree, determine all paths to
remaining houses and choose the cheapest path.
Add the new house to the tree and all nodes of
its path. Continue until all houses are in the tree.
"""
for battery in self.batteries:
mst = {}
tree = {battery: {}}
houses = copy.deepcopy(battery.houses)
for house in houses:
distance = get_distance(house, battery)
tree[battery][house] = distance
least_distance = {}
while houses:
for vertice in tree.keys():
distance_to_targets = tree[vertice]
house, distance = min(
distance_to_targets.items(), key=lambda x: x[1])
least_distance[vertice] = (house, distance)
link = min(least_distance.items(), key=lambda x: x[1][1])
from_vertice, new_vertice, distance = link[0], link[1][0], link[1][1]
new_nodes = pathfinder(from_vertice, new_vertice)[1:-1]
branch = Branch(from_vertice, new_vertice)
branch.load_path(new_nodes)
mst[branch] = distance
houses.remove(new_vertice)
for vertice in tree.keys():
del tree[vertice][new_vertice]
for node in new_nodes:
tree[node] = {}
for house in houses:
distance = get_distance(node, house)
tree[node][house] = distance
tree[new_vertice] = {}
for house in houses:
distance = get_distance(new_vertice, house)
tree[new_vertice][house] = distance
self.mst_container.append(mst)
def build_branches(self):
for idx, layer in enumerate(self._layers):
for neuron in layer.neurons:
# ENTRANCE layer only - create and set branches that connect into the neuron from each input
if layer.layer_id == 1:
for idx2 in range(self._num_inputs):
random_weight = random.uniform(self._weight_interval[0],self._weight_interval[1])
new_branch_id = str(idx2 + 1) + "" + str(neuron.neuron_id) + "" + str(layer.layer_id)
new_branch_in = Branch(new_branch_id, random_weight)
neuron.add_branch(new_branch_in, "in")
# HIDDEN layers only - create and set branches that leave the current neuron and connect into next layer's neuron
if layer.layer_id != len(self._layers):
for next_layer_neuron in self._layers[idx + 1].neurons:
random_weight = random.uniform(self._weight_interval[0],self._weight_interval[1])
new_branch_id = str(neuron.neuron_id) + "" + str(next_layer_neuron.neuron_id) + "" + str(next_layer_neuron.parent_layer.layer_id)
new_branch_out = Branch(new_branch_id, random_weight)
neuron.add_branch(new_branch_out, "out")
next_layer_neuron.add_branch(new_branch_out, "in")
