input
stringlengths 2.65k
237k
| output
stringclasses 1
value |
|---|---|
cardsLeftString = list(map(str, cardsLeft))
# print("Cards left as list of strings: ",cardsLeftString)
# return cardsLeftString
def show_cards_left_buttons(cardsLefts):
print(cardsLefts)
cardsLefts = update_left_cards_in_deck(cardsLefts)
print(cardsLefts)
for i in range(0,len(cardsLefts),1):
# print("Thats the input to add",select_counter(cardsLeft[i]))
buttonCal = tk.Button(MainWindow, text=(cardsLefts[i].rank.name +' ' + cardsLefts[i].suit.name), command=lambda i = i:add(select_counter(cardsLefts[i]))).grid(row=13, column=i)
return
def pick_random_card_from_left_cards(cardsLeft):
global RANDOMLYPICKEDCARDCOUNTER ##### this variable is for future use to calculate points with random cards
print(counterRandomCardsToPick.get())
for i in range(0,counterRandomCardsToPick.get(),1):
RANDOMLYPICKEDCARDCOUNTER = RANDOMLYPICKEDCARDCOUNTER + 1
Random_card_from_left_cards = cardsLeft[random.randint(0, (len(cardsLeft)-1))]
print(Random_card_from_left_cards)
# buttonCal = tk.Button(MainWindow, text=(Random_card_from_left_cards.rank.name +' ' + Random_card_from_left_cards.suit.name), command=lambda Random_card_from_left_cards = Random_card_from_left_cards:add(select_counter(Random_card_from_left_cards))).grid(row=15, column=RANDOMLYPICKEDCARDCOUNTER)
cardsLeft.remove(Random_card_from_left_cards)
pickedRandomCards.append(Random_card_from_left_cards)
show_card_as_button_with_add_counter_when_clicked(pickedRandomCards)
return
previously_clicked=None
def show_card_as_button_with_add_counter_when_clicked(cards):
for i, card in enumerate(cards, 2):
btn = tk.Button(MainWindow, text=(card.rank.name + ' ' + card.suit.name))
u=select_counter(card)
btn.config(command=lambda u=u:add(u))
btn.grid(row=15, column=i, sticky='w')
return
def show_card_as_button_with_add_counter_when_clicked_with_highlight(cards):
for i, card in enumerate(cards, 2):
btn = tk.Button(MainWindow, text=(card.rank.name + ' ' + card.suit.name))
u=select_counter(card)
btn.config(command=lambda u=u,arg=btn:add_with_button_highlight_after_click(u,arg))
btn.grid(row=15, column=i, sticky='w')
return
###################### POINTS MEASURE
def calculate_single_points(Hand):
singlesum = 0
for i in range(0,len(Hand),1):
singlesum = singlesum + Hand[i].rank.value + PreferencePoints[Hand[i].suit.value]
print("Single points: ",singlesum)
return singlesum
def calculate_pair_points(Hand):
pairsum = 0
if is_pair(Hand) == True:
pairsum = pairsum + PAIRPOINTS
print("Pair points: ",pairsum)
return pairsum
def calculate_double_pair_points(Hand):
doublepairsum = 0
if is_two_pair(Hand) == True:
doublepairsum = doublepairsum + DOUBLEPAIRPOINTS
print("Double pair points: ",doublepairsum)
return doublepairsum
def calculate_trio_points(Hand):
triosum = 0
if is_three_of_kind(Hand) == True:
triosum = triosum + TRIOPOINTS
print("Trio points: ",triosum)
return triosum
def calculate_straight_points(Hand):
straightsum = 0
if is_straight(Hand) == True:
straightsum = straightsum + STRAIGHTPOINTS
print("Straight points: ",straightsum)
return straightsum
def calculate_flush_points(Hand):
flushsum = 0
if is_flush(Hand) == True:
flushsum = flushsum + FLUSHPOINTS
print("Flush points: ",flushsum)
return flushsum
def calculate_full_house_points(Hand):
fullhousesum = 0
if is_full_house(Hand) == True:
fullhousesum = fullhousesum + FULLHOUSEPOINTS
print("Full house points: ",fullhousesum)
return fullhousesum
def calculate_four_points(Hand):
foursum = 0
if is_four_of_kind(Hand) == True:
foursum = foursum + FOURPOINTS
print("Four points: ",foursum)
return foursum
def calculate_straight_flush_points(Hand):
straightflushsum = 0
if is_straightflush(Hand) == True:
straightflushsum = straightflushsum + STRAIGHTFLUSHPOINTS
print("Straight flush points: ",straightflushsum)
return straightflushsum
def calculate_royal_flush_points(Hand):
royalflushsum = 0
if is_royalflush(Hand) == True:
royalflushsum = royalflushsum + ROYALFLUSHPOINTS
print("Royal flush points: ",royalflushsum)
return royalflushsum
##################### Scores, label results here to avoid partial
def show_single_points(singleSum,labelRow = 7, labelColumn = 2):
singleResultLabel = tk.Label(MainWindow)
singleResultLabel.grid(row=labelRow, column=labelColumn)
print("Single points: ",singleSum)
singleResultLabel.config(text="Result from single points %d" %singleSum)
return
def show_pair_points(pairSum, labelRow = 8, labelColumn = 2):
pairResultLabel = tk.Label(MainWindow)
pairResultLabel.grid(row=8, column=2)
print("Pair points: ",pairSum)
pairResultLabel.config(text="Result from pair points %d" %pairSum)
return
def show_double_pair_points(doublePairSum, labelRow = 9, labelColumn = 2):
doublepairResultLabel = tk.Label(MainWindow)
doublepairResultLabel.grid(row=9, column=2)
print("Doble pair points: ",doublePairSum)
doublepairResultLabel.config(text="Result from doublepair points %d" %doublePairSum)
return
def show_trio_points(trioSum, labelRow = 10, labelColumn = 2):
trioResultLabel = tk.Label(MainWindow)
trioResultLabel.grid(row=10, column=2)
print("Trio points: ",trioSum)
trioResultLabel.config(text="Result from trio points %d" %trioSum)
return
def call_result(label_result, n1, n2):
num1 = (n1.get())
num2 = (n2.get())
result = int(num1)+int(num2)
label_result.config(text="Result is %d" % result)
print(label_result,n1,n2)
return
def substract_one(label_result, n1):
num1 = (n1.get())
result = int(num1)-1
label_result.config(text="Result is %d" % result)
return
def check_value(label_result, stringVariable):
value = stringVariable.get()
value = int(value)
label_result.config(text="Value = %d" % value)
return
def add(intVariable):
intVariable.set(intVariable.get() + 1)
return
def add(intVariable,maximum=1):
if intVariable.get() < maximum:
intVariable.set(intVariable.get() + 1)
return
def add_with_button_highlight_after_click(intVariable,widget):
intVariable.set(intVariable.get() + 1)
global previously_clicked
if previously_clicked:
previously_clicked['bg'] = widget['bg']
previously_clicked['activebackground'] = widget['activebackground']
previously_clicked['relief'] = widget['relief']
widget['bg'] = 'green'
widget['activebackground'] = 'green'
widget['relief'] = 'sunken'
previously_clicked = widget
return
def sub(intVariable):
if intVariable.get() >0:
intVariable.set(intVariable.get() - 1)
################### FUZZY LOGIC BRO
def calculate_fuzzy_scope():
global PreferencePoints
fSuits = ctrl.Antecedent(np.arange(0, 4.5, 0.001), 'fSuits')
pointsMaximum=20
fPoints = ctrl.Consequent(np.arange(0, pointsMaximum, 0.1), 'fPoints')
#### fuzzy inputs
fPoints['poor'] = fuzz.gbellmf(fPoints.universe, 0.025, 0.95, pointsMaximum/5)
fPoints['mediocre'] = fuzz.gbellmf(fPoints.universe, 0.025, 0.95, pointsMaximum*2/5)
fPoints['average'] = fuzz.gbellmf(fPoints.universe, 0.025, 0.95, pointsMaximum*3/5)
fPoints['decent'] = fuzz.gbellmf(fPoints.universe, 0.025, 0.95, pointsMaximum*4/5)
#### fuzzy outputs
fSuits['hearts'] = fuzz.gbellmf(fSuits.universe, 0.025, 0.95, 1)
fSuits['tiles'] = fuzz.gbellmf(fSuits.universe, 0.025, 0.95, 2)
fSuits['clovers'] = fuzz.gbellmf(fSuits.universe, 0.025, 0.95, 3)
fSuits['pikes'] = fuzz.gbellmf(fSuits.universe, 0.025, 0.95, 4)
# fPoints.automf(5)
orderedFInput = list(fSuits.terms.values())
orderedFOutput = list(fPoints.terms.values())
rulez=[]
for i,name in enumerate(orderedFInput):
if any(i==x for x in prefered):
rulez.append(ctrl.Rule(orderedFInput[i], orderedFOutput[3]))
print(i)
else:
rulez.append(ctrl.Rule(orderedFInput[i], orderedFOutput[0]))
rule1 = ctrl.Rule(fSuits['hearts'], orderedFOutput[0])
rule2 = ctrl.Rule(fSuits['tiles'], orderedFOutput[0])
rule3 = ctrl.Rule(fSuits['clovers'], orderedFOutput[0])
rule4 = ctrl.Rule(fSuits['pikes'], orderedFOutput[0])
rules = [rule1, rule2, rule3, rule4]
suitsPreferencesRulebase = ctrl.ControlSystem(rulez)
suitsPreferences = ctrl.ControlSystemSimulation(suitsPreferencesRulebase)
for i in range(1,5):
suitsPreferences.input['fSuits'] = i
suitsPreferences.compute()
PreferencePoints[i] = int(suitsPreferences.output['fPoints'])
return
def save_preferences_and_close_window():
global prefered
preferedLocal = []
for i in range(0,4):
if box_preferences_counter[i].get() == 1:
preferedLocal = preferedLocal +[i]
prefered = list(set(preferedLocal))
window.destroy()
return
def save_preferences_and_close_window_and_calculate_fuzzy_scope():
global prefered
preferedLocal = []
for i in range(0,4):
if box_preferences_counter[i].get() == 1:
preferedLocal = preferedLocal +[i]
prefered = list(set(preferedLocal))
window.destroy()
calculate_fuzzy_scope()
return
def create_window():
global window
window = tk.Toplevel(MainWindow)
labelTitle = tk.Label(window, text="Preferences").grid(row=0, column=2)
labelNum9 = tk.Label(window, text="Hearts").grid(row=1, column=0)
labelNum10 = tk.Label(window, text="Tiles").grid(row=2, column=0)
labelNumJ = tk.Label(window, text="Clovers").grid(row=3, column=0)
labelNumQ = tk.Label(window, text="Pikes").grid(row=4, column=0)
for i,name in enumerate(box_preferences_counter):
maximum=1
entryNumH9 = tk.Entry(window, textvariable=name, width = 4).grid(row=i+1, column=2)
buttonCal = tk.Button(window, text="+", command=lambda name=name:add(name,maximum)).grid(row=i+1, column=3)
buttonCal = tk.Button(window, text="-", command=lambda name = name:sub(name)).grid(row=i+1, column=4)
buttonCal = tk.Button(window, text="save&quit", command=save_preferences_and_close_window_and_calculate_fuzzy_scope).grid(row=5, column=2)
return
## text signs near buttons HEARTS $$$$$$$$$$$$$$$$$$$
labelTitle = tk.Label(MainWindow, text="Hearts").grid(row=0, column=2)
labelNum9 = tk.Label(MainWindow, text="9").grid(row=1, column=0)
labelNum10 = tk.Label(MainWindow, text="10").grid(row=2, column=0)
labelNumJ = tk.Label(MainWindow, text="J").grid(row=3, column=0)
labelNumQ = tk.Label(MainWindow, text="Q").grid(row=4, column=0)
labelNumK = tk.Label(MainWindow, text="K").grid(row=5, column=0)
labelNumA = tk.Label(MainWindow, text="A").grid(row=6, column=0)
##############################
## text signs near buttons TILES ^^^^^^^^^^^^^^^^^^
labelTitle = tk.Label(MainWindow, text="TILES").grid(row=0, column=2 + SHIFTBETWEENCARDS)
labelNum9 = tk.Label(MainWindow, text="9").grid(row=1, column=0 + SHIFTBETWEENCARDS + SHIFTADJUSTMENT, padx = PADXBETWEENCARDNAMES)
labelNum10 = tk.Label(MainWindow, text="10").grid(row=2, column=0 + SHIFTBETWEENCARDS + SHIFTADJUSTMENT, padx = PADXBETWEENCARDNAMES )
labelNumJ = tk.Label(MainWindow, text="J").grid(row=3, column=0 + SHIFTBETWEENCARDS + SHIFTADJUSTMENT, padx = PADXBETWEENCARDNAMES)
labelNumQ = tk.Label(MainWindow, text="Q").grid(row=4, column=0 + SHIFTBETWEENCARDS + SHIFTADJUSTMENT, padx = PADXBETWEENCARDNAMES)
labelNumK = tk.Label(MainWindow, text="K").grid(row=5, column=0 + SHIFTBETWEENCARDS + SHIFTADJUSTMENT, padx = PADXBETWEENCARDNAMES)
labelNumA = tk.Label(MainWindow, text="A").grid(row=6, column=0 + SHIFTBETWEENCARDS + SHIFTADJUSTMENT, padx = PADXBETWEENCARDNAMES)
##############################
## text signs near buttons CLOVERS &&&&&&&&&&&&&&&&&&&
labelTitle = tk.Label(MainWindow, text="CLOVERS").grid(row=0, column=2 + SHIFTBETWEENCARDS * 2)
labelNum9 = tk.Label(MainWindow, text="9").grid(row=1, column=0 + SHIFTBETWEENCARDS * 2 + SHIFTADJUSTMENT, padx = PADXBETWEENCARDNAMES)
CnineEntry = tk.Entry(MainWindow)
labelNum10 = tk.Label(MainWindow, text="10").grid(row=2, column=0 + SHIFTBETWEENCARDS * 2 + SHIFTADJUSTMENT, padx = PADXBETWEENCARDNAMES)
CtenEntry = tk.Entry(MainWindow)
labelNumJ = tk.Label(MainWindow, text="J").grid(row=3, column=0 + SHIFTBETWEENCARDS * 2 + SHIFTADJUSTMENT, padx = PADXBETWEENCARDNAMES)
CjackEntry = tk.Entry(MainWindow)
labelNumQ = tk.Label(MainWindow, text="Q").grid(row=4, column=0 + SHIFTBETWEENCARDS * 2 + SHIFTADJUSTMENT, padx = PADXBETWEENCARDNAMES)
CquuenEntry = tk.Entry(MainWindow)
labelNumK = tk.Label(MainWindow, text="K").grid(row=5, column=0 + SHIFTBETWEENCARDS * 2 + SHIFTADJUSTMENT, padx = PADXBETWEENCARDNAMES)
CkingEntry = tk.Entry(MainWindow)
labelNumA = tk.Label(MainWindow, text="A").grid(row=6, column=0 + SHIFTBETWEENCARDS * 2 + SHIFTADJUSTMENT, padx = PADXBETWEENCARDNAMES)
CaceEntry = tk.Entry(MainWindow)
##############################
## text signs near buttons PIKES **********************
labelTitle = tk.Label(MainWindow, text="PIKES").grid(row=0, column=2 + SHIFTBETWEENCARDS * 3)
labelNum9 = tk.Label(MainWindow, text="9").grid(row=1, column=0 + SHIFTBETWEENCARDS * 3 + SHIFTADJUSTMENT, padx = PADXBETWEENCARDNAMES)
nineEntry = tk.Entry(MainWindow)
labelNum10 = tk.Label(MainWindow, text="10").grid(row=2, column=0 + SHIFTBETWEENCARDS * 3 + SHIFTADJUSTMENT, padx = PADXBETWEENCARDNAMES)
CtenEntry = tk.Entry(MainWindow)
labelNumJ = tk.Label(MainWindow, text="J").grid(row=3, column=0 + SHIFTBETWEENCARDS * 3 + SHIFTADJUSTMENT, padx = PADXBETWEENCARDNAMES)
CjackEntry = tk.Entry(MainWindow)
labelNumQ = tk.Label(MainWindow, text="Q").grid(row=4, column=0 + SHIFTBETWEENCARDS * 3 + SHIFTADJUSTMENT, padx = PADXBETWEENCARDNAMES)
CquuenEntry = tk.Entry(MainWindow)
labelNumK = tk.Label(MainWindow, text="K").grid(row=5, column=0 + SHIFTBETWEENCARDS * 3 + SHIFTADJUSTMENT, padx = PADXBETWEENCARDNAMES)
CkingEntry = tk.Entry(MainWindow)
labelNumA = tk.Label(MainWindow, text="A").grid(row=6, column=0 + SHIFTBETWEENCARDS * 3 + SHIFTADJUSTMENT, padx = PADXBETWEENCARDNAMES)
CaceEntry = tk.Entry(MainWindow)
##############################
#### text sign for RANDOM CARDS AMOUNT
labelTitle = tk.Label(MainWindow, text="Random Cards Amount").grid(row=0, column=2 + SHIFTBETWEENCARDS * 4)
labelTitle = tk.Label(MainWindow, text="User actions?").grid(row=0, column=2 + SHIFTBETWEENCARDS * 6)
labelTitle = tk.Label(MainWindow, text="Possible hands check").grid(row=0, column=2 + SHIFTBETWEENCARDS * 7)
labelTitle = tk.Label(MainWindow, text="++ as multitask").grid(row=0, column=2 + SHIFTBETWEENCARDS * 5)
labelTitle = tk.Label(MainWindow, text="Combo checking").grid(row=0, column=2 + SHIFTBETWEENCARDS * 8)
## space to set amount of HEARTS $$$$$$$$$$$$
entryNumH9 = tk.Entry(MainWindow, textvariable=counterH9, width = 4).grid(row=1, column=2)
entryNumH10 = tk.Entry(MainWindow, textvariable=counterH10, width = 4).grid(row=2, column=2)
entryNumHJ = tk.Entry(MainWindow, textvariable=counterHJ, width = 4).grid(row=3, column=2)
entryNumHQ = tk.Entry(MainWindow, textvariable=counterHQ, width = 4).grid(row=4, column=2)
entryNumHK = tk.Entry(MainWindow, textvariable=counterHK, width | |
self._test_everything(self.hitX.strict_can_append, default=True)
def test_strict_can_prepend(self):
self._test_everything(self.hitX.strict_can_prepend, default=True)
def test_hitX_0(self):
"""PartInXEnsemble treatment of zero-length trajectory"""
assert_equal(self.hitX(paths.Trajectory([])), False)
assert_equal(self.hitX.can_append(paths.Trajectory([])), True)
assert_equal(self.hitX.can_prepend(paths.Trajectory([])), True)
def test_hitX_str(self):
volstr = "{x|Id(x) in [0.1, 0.5]}"
assert_equal(self.hitX.__str__(),
"exists t such that x[t] in "+volstr)
class TestSequentialEnsemble(EnsembleTest):
def setup(self):
self.inX = AllInXEnsemble(vol1)
self.outX = AllOutXEnsemble(vol1)
self.hitX = PartInXEnsemble(vol1)
self.leaveX = PartOutXEnsemble(vol1)
self.inInterface = AllInXEnsemble(vol2)
self.leaveX0 = PartOutXEnsemble(vol2)
self.inX0 = AllInXEnsemble(vol2)
self.length1 = LengthEnsemble(1)
# pseudo_tis and pseudo_minus assume that the interface is equal to
# the state boundary
self.pseudo_tis = SequentialEnsemble( [
self.inX & self.length1,
self.outX,
self.inX & self.length1 ]
)
self.pseudo_minus = SequentialEnsemble( [
self.inX & self.length1,
self.outX,
self.inX,
self.outX,
self.inX & self.length1 ]
)
self.tis = SequentialEnsemble([
self.inX & self.length1,
self.outX & self.leaveX0,
self.inX & self.length1,
])
@raises(ValueError)
def test_maxminoverlap_size(self):
"""SequentialEnsemble errors if max/min overlap sizes different"""
SequentialEnsemble([self.inX, self.outX, self.inX], (0,0), (0,0,0))
@raises(ValueError)
def test_maxoverlap_ensemble_size(self):
"""SequentialEnsemble errors if overlap sizes don't match ensemble size"""
SequentialEnsemble([self.inX, self.outX, self.inX], (0,0,0), (0,0,0))
@raises(ValueError)
def test_minmax_order(self):
"""SequentialEnsemble errors if min_overlap > max_overlap"""
SequentialEnsemble([self.inX, self.outX, self.inX], (0,1), (0,0))
def test_allowed_initializations(self):
"""SequentialEnsemble initializes correctly with defaults"""
A = SequentialEnsemble([self.inX, self.outX, self.inX], (0,0), (0,0))
B = SequentialEnsemble([self.inX, self.outX, self.inX],0,0)
C = SequentialEnsemble([self.inX, self.outX, self.inX])
assert_equal(A.min_overlap,B.min_overlap)
assert_equal(A.min_overlap,C.min_overlap)
assert_equal(A.max_overlap,B.max_overlap)
assert_equal(A.max_overlap,C.max_overlap)
def test_overlap_max(self):
"""SequentialEnsemble allows overlaps up to overlap max, no more"""
raise SkipTest
def test_overlap_min(self):
"""SequentialEnsemble requires overlaps of at least overlap min"""
raise SkipTest
def test_overlap_max_inf(self):
"""SequentialEnsemble works if max overlap in infinite"""
raise SkipTest
def test_overlap_min_gap(self):
"""SequentialEnsemble works in mix overlap is negative (gap)"""
raise SkipTest
def test_overlap_max_gap(self):
"""SequentialEnsemble works if max overlap is negative (gap)"""
raise SkipTest
def test_seqens_order_combo(self):
# regression test for #229
import numpy as np
op = paths.FunctionCV(name="x", f=lambda snap : snap.xyz[0][0])
bigvol = paths.CVDefinedVolume(collectivevariable=op,
lambda_min=-100.0, lambda_max=100.0)
traj = paths.Trajectory([
paths.engines.toy.Snapshot(
coordinates=np.array([[-0.5, 0.0]]),
velocities=np.array([[0.0,0.0]])
)
])
vol_ens = paths.AllInXEnsemble(bigvol)
len_ens = paths.LengthEnsemble(5)
combo1 = vol_ens & len_ens
combo2 = len_ens & vol_ens
seq1 = SequentialEnsemble([combo1])
seq2 = SequentialEnsemble([combo2])
logger.debug("Checking combo1")
assert_equal(combo1.can_append(traj), True)
logger.debug("Checking combo2")
assert_equal(combo2.can_append(traj), True)
logger.debug("Checking seq1")
assert_equal(seq1.can_append(traj), True)
logger.debug("Checking seq2")
assert_equal(seq2.can_append(traj), True)
def test_can_append_tis(self):
"""SequentialEnsemble as TISEnsemble knows when it can append"""
results = { 'upper_in_out' : True,
'lower_in_out' : True,
'upper_in_out_in' : False,
'lower_in_out_in' : False,
'upper_in' : True,
'lower_in' : True,
'upper_in_in_in' : False,
'lower_in_in_in' : False,
'upper_out_out_out' : True,
'lower_out_out_out' : True,
'upper_out_in' : False,
'lower_out_in' : False,
'upper_out' : True,
'lower_out' : True,
'upper_in_out_in_in' : False,
'lower_in_out_in_in' : False,
'upper_in_out_in_out_in' : False,
'lower_in_out_in_out_in' : False
}
for test in list(results.keys()):
failmsg = "Failure in "+test+"("+str(ttraj[test])+"): "
self._single_test(self.pseudo_tis.can_append,
ttraj[test], results[test], failmsg)
def test_strict_can_append_tis(self):
results = {
'upper_in_out' : True,
'lower_in_out' : True,
'upper_in_out_in' : False,
'lower_in_out_in' : False,
'upper_in' : True,
'lower_in' : True,
'upper_in_in_in' : False,
'lower_in_in_in' : False,
'upper_out_out_out' : False,
'lower_out_out_out' : False,
'upper_out_in' : False,
'lower_out_in' : False,
'upper_out' : False,
'lower_out' : False,
'upper_in_out_in_in' : False,
'lower_in_out_in_in' : False,
'upper_in_out_in_out_in' : False,
'lower_in_out_in_out_in' : False
}
for test in list(results.keys()):
failmsg = "Failure in "+test+"("+str(ttraj[test])+"): "
self._single_test(self.pseudo_tis.strict_can_append,
ttraj[test], results[test], failmsg)
def test_can_append_pseudominus(self):
"""SequentialEnsemble as Pseudo-MinusEnsemble knows when it can append"""
results = {
'upper_in_out' : True,
'lower_in_out' : True,
'upper_in_out_in' : True,
'lower_in_out_in' : True,
'upper_in' : True,
'lower_in' : True,
'upper_in_in_in' : True,
'lower_in_in_in' : True,
'upper_out_out_out' : True,
'lower_out_out_out' : True,
'upper_out_in' : True,
'lower_out_in' : True,
'upper_out' : True,
'lower_out' : True,
'upper_in_out_in_in' : True,
'lower_in_out_in_in' : True,
'upper_in_out_in_out_in' : False,
'lower_in_out_in_out_in' : False,
'upper_in_out_in_in_out' : True,
'lower_in_out_in_in_out' : True,
'upper_out_in_out' : True,
'lower_out_in_out' : True,
'upper_out_in_in_out' : True,
'lower_out_in_in_out' : True,
'upper_out_in_out_in': False,
'lower_out_in_out_in': False,
'upper_out_in_in_out_in' : False,
'lower_out_in_in_out_in' : False,
'upper_in_cross_in' : True,
'lower_in_cross_in' : True,
'upper_in_cross_in_cross' : True,
'lower_in_cross_in_cross' : True,
'upper_cross_in_cross_in' : False,
'lower_cross_in_cross_in' : False,
'upper_in_cross_in_cross_in' : False,
'lower_in_cross_in_cross_in' : False
}
for test in list(results.keys()):
failmsg = "Failure in "+test+"("+str(ttraj[test])+"): "
self._single_test(self.pseudo_minus.can_append,
ttraj[test], results[test], failmsg)
def test_strict_can_append_pseudominus(self):
results = {
'upper_in_out' : True,
'lower_in_out' : True,
'upper_in_out_in' : True,
'lower_in_out_in' : True,
'upper_in' : True,
'lower_in' : True,
'upper_in_in_in' : False,
'lower_in_in_in' : False,
'upper_out_out_out' : False,
'lower_out_out_out' : False,
'upper_out_in' : False,
'lower_out_in' : False,
'upper_out' : False,
'lower_out' : False,
'upper_in_out_in_in' : True,
'lower_in_out_in_in' : True,
'upper_in_out_in_out_in' : False,
'lower_in_out_in_out_in' : False,
'upper_in_out_in_in_out' : True,
'lower_in_out_in_in_out' : True,
'upper_out_in_out' : False,
'lower_out_in_out' : False,
'upper_out_in_in_out' : False,
'lower_out_in_in_out' : False,
'upper_out_in_out_in': False,
'lower_out_in_out_in': False,
'upper_out_in_in_out_in' : False,
'lower_out_in_in_out_in' : False,
'upper_in_cross_in' : True,
'lower_in_cross_in' : True,
'upper_in_cross_in_cross' : True,
'lower_in_cross_in_cross' : True,
'upper_cross_in_cross_in' : False,
'lower_cross_in_cross_in' : False,
'upper_in_cross_in_cross_in' : False,
'lower_in_cross_in_cross_in' : False
}
for test in list(results.keys()):
failmsg = "Failure in "+test+"("+str(ttraj[test])+"): "
self._single_test(self.pseudo_minus.strict_can_append,
ttraj[test], results[test], failmsg)
def test_can_prepend_pseudo_tis(self):
"""SequentialEnsemble as Pseudo-TISEnsemble knows when it can prepend"""
results = {
'upper_in_out' : False,
'lower_in_out' : False,
'upper_in_out_in' : False,
'lower_in_out_in' : False,
'upper_in' : True,
'lower_in' : True,
'upper_in_in_in' : False,
'lower_in_in_in' : False,
'upper_out_out_out' : True,
'lower_out_out_out' : True,
'upper_out_in' : True,
'lower_out_in' : True,
'upper_out' : True,
'lower_out' : True,
'upper_in_out_in_in' : False,
'lower_in_out_in_in' : False,
'upper_in_out_in_out_in' : False,
'lower_in_out_in_out_in' : False
}
for test in list(results.keys()):
failmsg = "Failure in "+test+"("+str(ttraj[test])+"): "
self._single_test(self.pseudo_tis.can_prepend,
ttraj[test], results[test], failmsg)
def test_strict_can_prepend_pseudo_tis(self):
results = {
'upper_in_out' : False,
'lower_in_out' : False,
'upper_in_out_in' : False,
'lower_in_out_in' : False,
'upper_in' : True,
'lower_in' : True,
'upper_in_in_in' : False,
'lower_in_in_in' : False,
'upper_out_out_out' : False,
'lower_out_out_out' : False,
'upper_out_in' : True,
'lower_out_in' : True,
'upper_out' : False,
'lower_out' : False,
'upper_in_out_in_in' : False,
'lower_in_out_in_in' : False,
'upper_in_out_in_out_in' : False,
'lower_in_out_in_out_in' : False
}
for test in list(results.keys()):
failmsg = "Failure in "+test+"("+str(ttraj[test])+"): "
self._single_test(self.pseudo_tis.strict_can_prepend,
ttraj[test], results[test], failmsg)
def test_can_prepend_pseudo_minus(self):
results = {
'upper_in_out' : True,
'lower_in_out' : True,
'upper_in_out_in' : True,
'lower_in_out_in' : True,
'upper_in' : True,
'lower_in' : True,
'upper_in_in_in' : True,
'lower_in_in_in' : True,
'upper_out_out_out' : True,
'lower_out_out_out' : True,
'upper_out_in' : True,
'lower_out_in' : True,
'upper_out' : True,
'lower_out' : True,
'upper_in_out_in_in' : False,
'lower_in_out_in_in' : False,
'upper_in_out_in_out_in' : False,
'lower_in_out_in_out_in' : False,
'upper_in_out_in_in_out' : False,
'lower_in_out_in_in_out' : False,
'upper_out_in_out' : True,
'lower_out_in_out' : True,
'upper_out_in_in_out' : True,
'lower_out_in_in_out' : True,
'upper_out_in_out_in': True,
'lower_out_in_out_in': True,
'upper_out_in_in_out_in' : True,
'lower_out_in_in_out_in' : True
}
for test in list(results.keys()):
failmsg = "Failure in "+test+"("+str(ttraj[test])+"): "
self._single_test(self.pseudo_minus.can_prepend,
ttraj[test], results[test], failmsg)
def test_strict_can_prepend_pseudo_minus(self):
results = {
'upper_in_out' : False,
'lower_in_out' : False,
'upper_in_out_in' : True,
'lower_in_out_in' : True,
'upper_in' : True,
'lower_in' : True,
'upper_in_in_in' : False,
'lower_in_in_in' : False,
'upper_out_out_out' : False,
'lower_out_out_out' : False,
'upper_out_in' : True,
'lower_out_in' : True,
'upper_out' : False,
'lower_out' : False,
'upper_in_out_in_in' : False,
'lower_in_out_in_in' : False,
'upper_in_out_in_out_in' : False,
'lower_in_out_in_out_in' : False,
'upper_in_out_in_in_out' : False,
'lower_in_out_in_in_out' : False,
'upper_out_in_out' : False,
'lower_out_in_out' : False,
'upper_out_in_in_out' : False,
'lower_out_in_in_out' : False,
'upper_out_in_out_in': True,
'lower_out_in_out_in': True,
'upper_out_in_in_out_in' : True,
'lower_out_in_in_out_in' : True
}
for test in list(results.keys()):
failmsg = "Failure in "+test+"("+str(ttraj[test])+"): "
self._single_test(self.pseudo_minus.strict_can_prepend,
ttraj[test], results[test], failmsg)
def test_sequential_transition_frames(self):
"""SequentialEnsemble identifies transitions frames correctly"""
ensemble = SequentialEnsemble([self.inX, self.outX])
results = {'upper_in_in_in' : [3],
'upper_out_out_out' : [],
'upper_in_out_in' : [1,2],
'upper_in_out' : [1,2]
}
for test in list(results.keys()):
failmsg = "Failure in "+test+"("+str(ttraj[test])+"): "
self._single_test(ensemble.transition_frames,
ttraj[test], results[test], failmsg)
def test_sequential_simple_in_out_call(self):
"""Simplest sequential ensemble identifies correctly"""
ensemble = SequentialEnsemble([self.inX, self.outX])
results = {'upper_in_in_in' : False,
'upper_out_out_out' : False,
'upper_in_out_in' : False,
'upper_in_out' : True
}
for test in list(results.keys()):
failmsg = "Failure in "+test+"("+str(ttraj[test])+"): "
self._single_test(ensemble,
ttraj[test], results[test], failmsg)
def test_sequential_in_out(self):
"""SequentialEnsembles based on In/AllOutXEnsemble"""
# idea: for each ttraj, use the key name to define in/out behavior,
# dynamically construct a SequentialEnsemble
ens_dict = {'in' : self.inX, 'out' : self.outX }
for test in list(ttraj.keys()):
ens_list = in_out_parser(test)
ens = []
# how to pick ensembles is specific to this test
for ens_type in ens_list:
ens.append(ens_dict[ens_type])
ensemble = SequentialEnsemble(ens)
failmsg = "Failure in "+test+"("+str(ttraj[test])+"): "
self._single_test(ensemble, ttraj[test], True, failmsg)
def test_sequential_pseudo_tis(self):
"""SequentialEnsemble as Pseudo-TISEnsemble identifies paths"""
results = {}
for test | |
# Copyright 2019 The TensorFlow Probability Authors.
# Copyright 2019 OpenAI (http://openai.com).
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ============================================================================
"""The Pixel CNN++ distribution class."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import functools
import numpy as np
import tensorflow.compat.v2 as tf
from tensorflow_probability.python.bijectors import shift
from tensorflow_probability.python.distributions import categorical
from tensorflow_probability.python.distributions import distribution
from tensorflow_probability.python.distributions import independent
from tensorflow_probability.python.distributions import logistic
from tensorflow_probability.python.distributions import mixture_same_family
from tensorflow_probability.python.distributions import quantized_distribution
from tensorflow_probability.python.distributions import transformed_distribution
from tensorflow_probability.python.internal import prefer_static
from tensorflow_probability.python.internal import reparameterization
from tensorflow_probability.python.internal import tensorshape_util
from tensorflow_probability.python.layers import weight_norm
class PixelCNN(distribution.Distribution):
"""The Pixel CNN++ distribution.
Pixel CNN++ [(Salimans et al., 2017)][1] models a distribution over image
data, parameterized by a neural network. It builds on Pixel CNN and
Conditional Pixel CNN, as originally proposed by [(van den Oord et al.,
2016)][2, 3]. The model expresses the joint distribution over pixels as
the product of conditional distributions:
`p(x|h) = prod{ p(x[i] | x[0:i], h) : i=0, ..., d }`,
in which `p(x[i] | x[0:i], h) : i=0, ..., d` is the
probability of the `i`-th pixel conditional on the pixels that preceded it in
raster order (color channels in RGB order, then left to right, then top to
bottom). `h` is optional additional data on which to condition the image
distribution, such as class labels or VAE embeddings. The Pixel CNN++
network enforces the dependency structure among pixels by applying a mask to
the kernels of the convolutional layers that ensures that the values for each
pixel depend only on other pixels up and to the left (see
`tfd.PixelCnnNetwork`).
Pixel values are modeled with a mixture of quantized logistic distributions,
which can take on a set of distinct integer values (e.g. between 0 and 255
for an 8-bit image).
Color intensity `v` of each pixel is modeled as:
`v ~ sum{q[i] * quantized_logistic(loc[i], scale[i]) : i = 0, ..., k }`,
in which `k` is the number of mixture components and the `q[i]` are the
Categorical probabilities over the components.
#### Sampling
Pixels are sampled one at a time, in raster order. This enforces the
autoregressive dependency structure, in which the sample of pixel `i` is
conditioned on the samples of pixels `1, ..., i-1`. A single color image is
sampled as follows:
```python
samples = random_uniform([image_height, image_width, image_channels])
for i in image_height:
for j in image_width:
component_logits, locs, scales, coeffs = pixel_cnn_network(samples)
components = Categorical(component_logits).sample()
locs = gather(locs, components)
scales = gather(scales, components)
coef_count = 0
channel_samples = []
for k in image_channels:
loc = locs[k]
for m in range(k):
loc += channel_samples[m] * coeffs[coef_count]
coef_count += 1
channel_samp = Logistic(loc, scales[k]).sample()
channel_samples.append(channel_samp)
samples[i, j, :] = tf.stack(channel_samples, axis=-1)
samples = round(samples)
```
#### Examples
```python
# Build a small Pixel CNN++ model to train on MNIST.
import tensorflow as tf
import tensorflow_datasets as tfds
import tensorflow_probability as tfp
tfd = tfp.distributions
tfk = tf.keras
tfkl = tf.keras.layers
tf.enable_v2_behavior()
# Load MNIST from tensorflow_datasets
data = tfds.load('mnist')
train_data, test_data = data['train'], data['test']
def image_preprocess(x):
x['image'] = tf.cast(x['image'], tf.float32)
return (x['image'],) # (input, output) of the model
batch_size = 16
train_it = train_data.map(image_preprocess).batch(batch_size).shuffle(1000)
image_shape = (28, 28, 1)
# Define a Pixel CNN network
dist = tfd.PixelCNN(
image_shape=image_shape,
num_resnet=1,
num_hierarchies=2,
num_filters=32,
num_logistic_mix=5,
dropout_p=.3,
)
# Define the model input
image_input = tfkl.Input(shape=image_shape)
# Define the log likelihood for the loss fn
log_prob = dist.log_prob(image_input)
# Define the model
model = tfk.Model(inputs=image_input, outputs=log_prob)
model.add_loss(-tf.reduce_mean(log_prob))
# Compile and train the model
model.compile(
optimizer=tfk.optimizers.Adam(.001),
metrics=[])
model.fit(train_it, epochs=10, verbose=True)
# sample five images from the trained model
samples = dist.sample(5)
```
To train a class-conditional model:
```python
data = tfds.load('mnist')
train_data, test_data = data['train'], data['test']
def image_preprocess(x):
x['image'] = tf.cast(x['image'], tf.float32)
# return model (inputs, outputs): inputs are (image, label) and there are no
# outputs
return ((x['image'], x['label']),)
batch_size = 16
train_ds = train_data.map(image_preprocess).batch(batch_size).shuffle(1000)
optimizer = tfk.optimizers.Adam()
image_shape = (28, 28, 1)
label_shape = ()
dist = tfd.PixelCNN(
image_shape=image_shape,
conditional_shape=label_shape,
num_resnet=1,
num_hierarchies=2,
num_filters=32,
num_logistic_mix=5,
dropout_p=.3,
)
image_input = tfkl.Input(shape=image_shape)
label_input = tfkl.Input(shape=label_shape)
log_prob = dist.log_prob(image_input, conditional_input=label_input)
class_cond_model = tfk.Model(
inputs=[image_input, label_input], outputs=log_prob)
class_cond_model.add_loss(-tf.reduce_mean(log_prob))
class_cond_model.compile(
optimizer=tfk.optimizers.Adam(),
metrics=[])
class_cond_model.fit(train_ds, epochs=10)
# Take 10 samples of the digit '5'
samples = dist.sample(10, conditional_input=5.)
# Take 4 samples each of the digits '1', '2', '3'.
# Note that when a batch of conditional input is passed, the sample shape
# (the first argument of `dist.sample`) must have its last dimension(s) equal
# the batch shape of the conditional input (here, (3,)).
samples = dist.sample((4, 3), conditional_input=[1., 2., 3.])
```
Note: PixelCNN may also be trained using tfp.layers.DistributionLambda;
however, as of this writing, that method is much slower and has the
disadvantage of calling `sample()` upon construction, which causes the
`PixelCnnNetwork` to be initialized with random data (if data-dependent
initialization is used).
#### References
[1]: <NAME>, <NAME>, <NAME>, and <NAME>.
PixelCNN++: Improving the PixelCNN with Discretized Logistic Mixture
Likelihood and Other Modifications. In _International Conference on
Learning Representations_, 2017.
https://pdfs.semanticscholar.org/9e90/6792f67cbdda7b7777b69284a81044857656.pdf
Additional details at https://github.com/openai/pixel-cnn
[2]: <NAME>, <NAME>, <NAME>, <NAME>,
<NAME>, and <NAME>. Conditional Image Generation with
PixelCNN Decoders. In _Neural Information Processing Systems_, 2016.
https://arxiv.org/abs/1606.05328
[3]: <NAME>, <NAME>, and <NAME>. Pixel
Recurrent Neural Networks. In _International Conference on Machine
Learning_, 2016. https://arxiv.org/pdf/1601.06759.pdf
"""
def __init__(self,
image_shape,
conditional_shape=None,
num_resnet=5,
num_hierarchies=3,
num_filters=160,
num_logistic_mix=10,
receptive_field_dims=(3, 3),
dropout_p=0.5,
resnet_activation='concat_elu',
use_weight_norm=True,
use_data_init=True,
high=255,
low=0,
dtype=tf.float32,
name='PixelCNN'):
"""Construct Pixel CNN++ distribution.
Args:
image_shape: 3D `TensorShape` or tuple for the `[height, width, channels]`
dimensions of the image.
conditional_shape: `TensorShape` or tuple for the shape of the
conditional input, or `None` if there is no conditional input.
num_resnet: `int`, the number of layers (shown in Figure 2 of [2]) within
each highest-level block of Figure 2 of [1].
num_hierarchies: `int`, the number of hightest-level blocks (separated by
expansions/contractions of dimensions in Figure 2 of [1].)
num_filters: `int`, the number of convolutional filters.
num_logistic_mix: `int`, number of components in the logistic mixture
distribution.
receptive_field_dims: `tuple`, height and width in pixels of the receptive
field of the convolutional layers above and to the left of a given
pixel. The width (second element of the tuple) should be odd. Figure 1
(middle) of [2] shows a receptive field of (3, 5) (the row containing
the current pixel is included in the height). The default of (3, 3) was
used to produce the results in [1].
dropout_p: `float`, the dropout probability. Should be between 0 and 1.
resnet_activation: `string`, the type of activation to use in the resnet
blocks. May be 'concat_elu', 'elu', or 'relu'.
use_weight_norm: `bool`, if `True` then use weight normalization (works
only in Eager mode).
use_data_init: `bool`, if `True` then use data-dependent initialization
(has no effect if `use_weight_norm` is `False`).
high: `int`, the maximum value of the input data (255 for an 8-bit image).
low: `int`, the minimum value of the input data.
dtype: Data type of the `Distribution`.
name: `string`, the name of the `Distribution`.
"""
parameters = dict(locals())
with tf.name_scope(name) as name:
super(PixelCNN, self).__init__(
dtype=dtype,
reparameterization_type=reparameterization.NOT_REPARAMETERIZED,
validate_args=False,
allow_nan_stats=True,
parameters=parameters,
name=name)
if not tensorshape_util.is_fully_defined(image_shape):
raise ValueError('`image_shape` must be fully defined.')
if (conditional_shape is not None and
not tensorshape_util.is_fully_defined(conditional_shape)):
raise ValueError('`conditional_shape` must be fully defined`')
if tensorshape_util.rank(image_shape) != 3:
raise ValueError('`image_shape` must have length 3, representing '
'[height, width, channels] dimensions.')
self._high = tf.cast(high, self.dtype)
self._low = tf.cast(low, self.dtype)
self._num_logistic_mix = num_logistic_mix
self.network = _PixelCNNNetwork(
dropout_p=dropout_p,
num_resnet=num_resnet,
num_hierarchies=num_hierarchies,
num_filters=num_filters,
num_logistic_mix=num_logistic_mix,
receptive_field_dims=receptive_field_dims,
resnet_activation=resnet_activation,
use_weight_norm=use_weight_norm,
use_data_init=use_data_init,
dtype=dtype)
image_shape = tensorshape_util.constant_value_as_shape(image_shape)
conditional_shape = (None if conditional_shape is None
else tensorshape_util.constant_value_as_shape(
conditional_shape))
image_input_shape = tensorshape_util.concatenate([None], image_shape)
| |
<reponame>YuanYunshuang/OpenCOOD<filename>opencood/utils/box_utils.py
# -*- coding: utf-8 -*-
# Author: <NAME> <<EMAIL>>, <NAME> <<EMAIL>>,
# License: TDG-Attribution-NonCommercial-NoDistrib
"""
Bounding box related utility functions
"""
import sys
import numpy as np
import torch
import torch.nn.functional as F
import opencood.utils.common_utils as common_utils
from opencood.utils.transformation_utils import x1_to_x2
def corner_to_center(corner3d, order='lwh'):
"""
Convert 8 corners to x, y, z, dx, dy, dz, yaw.
Parameters
----------
corner3d : np.ndarray
(N, 8, 3)
order : str
'lwh' or 'hwl'
Returns
-------
box3d : np.ndarray
(N, 7)
"""
assert corner3d.ndim == 3
batch_size = corner3d.shape[0]
xyz = np.mean(corner3d[:, [0, 3, 5, 6], :], axis=1)
h = abs(np.mean(corner3d[:, 4:, 2] - corner3d[:, :4, 2], axis=1,
keepdims=True))
l = (np.sqrt(np.sum((corner3d[:, 0, [0, 1]] - corner3d[:, 3, [0, 1]]) ** 2,
axis=1, keepdims=True)) +
np.sqrt(np.sum((corner3d[:, 2, [0, 1]] - corner3d[:, 1, [0, 1]]) ** 2,
axis=1, keepdims=True)) +
np.sqrt(np.sum((corner3d[:, 4, [0, 1]] - corner3d[:, 7, [0, 1]]) ** 2,
axis=1, keepdims=True)) +
np.sqrt(np.sum((corner3d[:, 5, [0, 1]] - corner3d[:, 6, [0, 1]]) ** 2,
axis=1, keepdims=True))) / 4
w = (np.sqrt(
np.sum((corner3d[:, 0, [0, 1]] - corner3d[:, 1, [0, 1]]) ** 2, axis=1,
keepdims=True)) +
np.sqrt(np.sum((corner3d[:, 2, [0, 1]] - corner3d[:, 3, [0, 1]]) ** 2,
axis=1, keepdims=True)) +
np.sqrt(np.sum((corner3d[:, 4, [0, 1]] - corner3d[:, 5, [0, 1]]) ** 2,
axis=1, keepdims=True)) +
np.sqrt(np.sum((corner3d[:, 6, [0, 1]] - corner3d[:, 7, [0, 1]]) ** 2,
axis=1, keepdims=True))) / 4
theta = (np.arctan2(corner3d[:, 1, 1] - corner3d[:, 2, 1],
corner3d[:, 1, 0] - corner3d[:, 2, 0]) +
np.arctan2(corner3d[:, 0, 1] - corner3d[:, 3, 1],
corner3d[:, 0, 0] - corner3d[:, 3, 0]) +
np.arctan2(corner3d[:, 5, 1] - corner3d[:, 6, 1],
corner3d[:, 5, 0] - corner3d[:, 6, 0]) +
np.arctan2(corner3d[:, 4, 1] - corner3d[:, 7, 1],
corner3d[:, 4, 0] - corner3d[:, 7, 0]))[:,
np.newaxis] / 4
if order == 'lwh':
return np.concatenate([xyz, l, w, h, theta], axis=1).reshape(
batch_size, 7)
elif order == 'hwl':
return np.concatenate([xyz, h, w, l, theta], axis=1).reshape(
batch_size, 7)
else:
sys.exit('Unknown order')
def boxes_to_corners2d(boxes3d, order):
"""
0 -------- 1
| |
| |
| |
3 -------- 2
Parameters
__________
boxes3d: np.ndarray or torch.Tensor
(N, 7) [x, y, z, dx, dy, dz, heading], (x, y, z) is the box center.
order : str
'lwh' or 'hwl'
Returns:
corners2d: np.ndarray or torch.Tensor
(N, 4, 3), the 4 corners of the bounding box.
"""
corners3d = boxes_to_corners_3d(boxes3d, order)
corners2d = corners3d[:, :4, :]
return corners2d
def boxes2d_to_corners2d(boxes2d, order="lwh"):
"""
0 -------- 1
| |
| |
| |
3 -------- 2
Parameters
__________
boxes2d: np.ndarray or torch.Tensor
(..., 5) [x, y, dx, dy, heading], (x, y) is the box center.
order : str
'lwh' or 'hwl'
Returns:
corners2d: np.ndarray or torch.Tensor
(..., 4, 2), the 4 corners of the bounding box.
"""
assert order == "lwh", \
"boxes2d_to_corners_2d only supports lwh order for now."
boxes2d, is_numpy = common_utils.check_numpy_to_torch(boxes2d)
template = boxes2d.new_tensor((
[1, -1], [1, 1], [-1, 1], [-1, -1]
)) / 2
input_shape = boxes2d.shape
boxes2d = boxes2d.view(-1, 5)
corners2d = boxes2d[:, None, 2:4].repeat(1, 4, 1) * template[None, :, :]
corners2d = common_utils.rotate_points_along_z_2d(corners2d.view(-1, 2),
boxes2d[:,
4].repeat_interleave(
4)).view(-1, 4,
2)
corners2d += boxes2d[:, None, 0:2]
corners2d = corners2d.view(*(input_shape[:-1]), 4, 2)
return corners2d
def boxes_to_corners_3d(boxes3d, order):
"""
4 -------- 5
/| /|
7 -------- 6 .
| | | |
. 0 -------- 1
|/ |/
3 -------- 2
Parameters
__________
boxes3d: np.ndarray or torch.Tensor
(N, 7) [x, y, z, dx, dy, dz, heading], (x, y, z) is the box center.
order : str
'lwh' or 'hwl'
Returns:
corners3d: np.ndarray or torch.Tensor
(N, 8, 3), the 8 corners of the bounding box.
"""
# ^ z
# |
# |
# | . x
# |/
# +-------> y
boxes3d, is_numpy = common_utils.check_numpy_to_torch(boxes3d)
boxes3d_ = boxes3d
if order == 'hwl':
boxes3d_ = boxes3d[:, [0, 1, 2, 5, 4, 3, 6]]
template = boxes3d_.new_tensor((
[1, -1, -1], [1, 1, -1], [-1, 1, -1], [-1, -1, -1],
[1, -1, 1], [1, 1, 1], [-1, 1, 1], [-1, -1, 1],
)) / 2
corners3d = boxes3d_[:, None, 3:6].repeat(1, 8, 1) * template[None, :, :]
corners3d = common_utils.rotate_points_along_z(corners3d.view(-1, 8, 3),
boxes3d_[:, 6]).view(-1, 8,
3)
corners3d += boxes3d_[:, None, 0:3]
return corners3d.numpy() if is_numpy else corners3d
def box3d_to_2d(box3d):
"""
Convert 3D bounding box to 2D.
Parameters
----------
box3d : np.ndarray
(n, 8, 3)
Returns
-------
box2d : np.ndarray
(n, 4, 2), project 3d to 2d.
"""
box2d = box3d[:, :4, :2]
return box2d
def corner2d_to_standup_box(box2d):
"""
Find the minmaxx, minmaxy for each 2d box. (N, 4, 2) -> (N, 4)
x1, y1, x2, y2
Parameters
----------
box2d : np.ndarray
(n, 4, 2), four corners of the 2d bounding box.
Returns
-------
standup_box2d : np.ndarray
(n, 4)
"""
N = box2d.shape[0]
standup_boxes2d = np.zeros((N, 4))
standup_boxes2d[:, 0] = np.min(box2d[:, :, 0], axis=1)
standup_boxes2d[:, 1] = np.min(box2d[:, :, 1], axis=1)
standup_boxes2d[:, 2] = np.max(box2d[:, :, 0], axis=1)
standup_boxes2d[:, 3] = np.max(box2d[:, :, 1], axis=1)
return standup_boxes2d
def corner_to_standup_box_torch(box_corner):
"""
Find the minmax x and y for each bounding box.
Parameters
----------
box_corner : torch.Tensor
Shape: (N, 8, 3) or (N, 4)
Returns
-------
standup_box2d : torch.Tensor
(n, 4)
"""
N = box_corner.shape[0]
standup_boxes2d = torch.zeros((N, 4))
standup_boxes2d = standup_boxes2d.to(box_corner.device)
standup_boxes2d[:, 0] = torch.min(box_corner[:, :, 0], dim=1).values
standup_boxes2d[:, 1] = torch.min(box_corner[:, :, 1], dim=1).values
standup_boxes2d[:, 2] = torch.max(box_corner[:, :, 0], dim=1).values
standup_boxes2d[:, 3] = torch.max(box_corner[:, :, 1], dim=1).values
return standup_boxes2d
def project_box3d(box3d, transformation_matrix):
"""
Project the 3d bounding box to another coordinate system based on the
transfomration matrix.
Parameters
----------
box3d : torch.Tensor or np.ndarray
3D bounding box, (N, 8, 3)
transformation_matrix : torch.Tensor or np.ndarray
Transformation matrix, (4, 4)
Returns
-------
projected_box3d : torch.Tensor
The projected bounding box, (N, 8, 3)
"""
assert transformation_matrix.shape == (4, 4)
box3d, is_numpy = \
common_utils.check_numpy_to_torch(box3d)
transformation_matrix, _ = \
common_utils.check_numpy_to_torch(transformation_matrix)
# (N, 3, 8)
box3d_corner = box3d.transpose(1, 2)
# (N, 1, 8)
torch_ones = torch.ones((box3d_corner.shape[0], 1, 8))
torch_ones = torch_ones.to(box3d_corner.device)
# (N, 4, 8)
box3d_corner = torch.cat((box3d_corner, torch_ones),
dim=1)
# (N, 4, 8)
projected_box3d = torch.matmul(transformation_matrix,
box3d_corner)
# (N, 8, 3)
projected_box3d = projected_box3d[:, :3, :].transpose(1, 2)
return projected_box3d if not is_numpy else projected_box3d.numpy()
def project_points_by_matrix_torch(points, transformation_matrix):
"""
Project the points to another coordinate system based on the
transfomration matrix.
Parameters
----------
points : torch.Tensor
3D points, (N, 3)
transformation_matrix : torch.Tensor
Transformation matrix, (4, 4)
Returns
-------
projected_points : torch.Tensor
The projected points, (N, 3)
"""
# convert to homogeneous coordinates via padding 1 at the last dimension.
# (N, 4)
points_homogeneous = F.pad(points, (0, 1), mode="constant", value=1)
# (N, 4)
projected_points = torch.einsum("ik, jk->ij", points_homogeneous,
transformation_matrix)
return projected_points[:, :3]
def get_mask_for_boxes_within_range_torch(boxes):
"""
Generate mask to remove the bounding boxes
outside the range.
Parameters
----------
boxes : torch.Tensor
Groundtruth bbx, shape: N,8,3 or N,4,2
Returns
-------
mask: torch.Tensor
The mask for bounding box -- True means the
bbx is within the range and False means the
bbx is outside the range.
"""
from opencood.data_utils.datasets import GT_RANGE
# mask out the gt bounding box out fixed range (-140, -40, -3, 140, 40 1)
device = boxes.device
boundary_lower_range = \
torch.Tensor(GT_RANGE[:2]).reshape(1, 1, -1).to(device)
boundary_higher_range = \
torch.Tensor(GT_RANGE[3:5]).reshape(1, 1, -1).to(device)
mask = torch.all(
torch.all(boxes[:, :, :2] >= boundary_lower_range,
dim=-1) & \
torch.all(boxes[:, :, :2] <= boundary_higher_range,
dim=-1), dim=-1)
return mask
def mask_boxes_outside_range_numpy(boxes, limit_range, order,
min_num_corners=8, return_mask=False):
"""
Parameters
----------
boxes: np.ndarray
(N, 7) [x, y, z, dx, dy, dz, heading], (x, y, z) is the box center
limit_range: list
[minx, miny, minz, maxx, maxy, maxz]
min_num_corners: int
The required minimum number of corners to be considered as in range.
order : str
'lwh' or 'hwl'
return_mask : bool
Whether return the mask.
Returns
-------
boxes: np.ndarray
The filtered boxes.
"""
assert boxes.shape[1] == 8 or boxes.shape[1] == 7
new_boxes = boxes.copy()
if boxes.shape[1] == 7:
new_boxes = boxes_to_corners_3d(new_boxes, order)
mask = ((new_boxes >= limit_range[0:3]) &
(new_boxes <= limit_range[3:6])).all(axis=2)
mask = mask.sum(axis=1) >= min_num_corners # (N)
if return_mask:
return boxes[mask], mask
return boxes[mask]
def create_bbx(extent):
"""
Create bounding box with 8 corners under obstacle vehicle | |
<gh_stars>0
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# Copyright 2008-2011 Zuza Software Foundation
#
# This file is part of translate.
#
# translate is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# translate is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, see <http://www.gnu.org/licenses/>.
#
"""
Interface to the Xapian indexing engine for the Translate Toolkit
Xapian v1.0 or higher is supported.
If you are interested in writing an interface for Xapian 0.x, then
you should checkout the following::
svn export -r 7235 https://translate.svn.sourceforge.net/svnroot/translate/src/branches/translate-search-indexer-generic-merging/translate/search/indexer/
It is not completely working, but it should give you a good start.
"""
# xapian module versions before 1.0.13 hangs apache under mod_python
import sys
import re
# detect if running under apache
if 'apache' in sys.modules or '_apache' in sys.modules or 'mod_wsgi' in sys.modules:
def _str2version(version):
return [int(i) for i in version.split('.')]
import subprocess
# even checking xapian version leads to deadlock under apache, must figure version from command line
try:
command = subprocess.Popen(['xapian-check', '--version'], stdout=subprocess.PIPE)
stdout, stderr = command.communicate()
if _str2version(re.match('.*([0-9]+\.[0-9]+\.[0-9]+).*', stdout).groups()[0]) < [1, 0, 13]:
raise ImportError("Running under apache, can't load xapain")
except:
#FIXME: report is xapian-check command is missing?
raise ImportError("Running under apache, can't load xapian")
import CommonIndexer
import xapian
import os
import time
import logging
def is_available():
return xapian.major_version() > 0
# in xapian there is a length restriction for term strings
# see http://osdir.com/ml/search.xapian.general/2006-11/msg00210.html
# a maximum length of around 240 is described there - but we need less anyway
_MAX_TERM_LENGTH = 128
class XapianDatabase(CommonIndexer.CommonDatabase):
"""Interface to the `Xapian indexer <http://xapian.org>`_."""
QUERY_TYPE = xapian.Query
INDEX_DIRECTORY_NAME = "xapian"
def __init__(self, basedir, analyzer=None, create_allowed=True):
"""Initialize or open a Xapian database.
:raise ValueError: the given location exists, but the database type
is incompatible (e.g. created by a different indexing engine)
:raise OSError: the database failed to initialize
:param basedir: the parent directory of the database
:type basedir: str
:param analyzer: Bitwise combination of possible analyzer flags
to be used as the default analyzer for this
database. Leave it empty to use the system default
analyzer (self.ANALYZER_DEFAULT).
See self.ANALYZER_TOKENIZE, self.ANALYZER_PARTIAL, ...
:type analyzer: int
:param create_allowed: create the database, if necessary; default: True
:type create_allowed: bool
"""
# call the __init__ function of our parent
super(XapianDatabase, self).__init__(basedir, analyzer=analyzer,
create_allowed=create_allowed)
self.reader = None
self.writer = None
if os.path.exists(self.location):
# try to open an existing database
try:
self.reader = xapian.Database(self.location)
except xapian.DatabaseOpeningError, err_msg:
raise ValueError("Indexer: failed to open xapian database " \
+ "(%s) - maybe it is not a xapian database: %s" \
% (self.location, str(err_msg)))
else:
# create a new database
if not create_allowed:
raise OSError("Indexer: skipping database creation")
try:
# create the parent directory if it does not exist
parent_path = os.path.dirname(self.location)
if not os.path.isdir(parent_path):
# recursively create all directories up to parent_path
os.makedirs(parent_path)
except IOError, err_msg:
raise OSError("Indexer: failed to create the parent " \
+ "directory (%s) of the indexing database: %s" \
% (parent_path, str(err_msg)))
try:
self.writer = xapian.WritableDatabase(self.location,
xapian.DB_CREATE_OR_OPEN)
self.flush()
except xapian.DatabaseOpeningError, err_msg:
raise OSError("Indexer: failed to open or create a xapian " \
+ "database (%s): %s" % (self.location, str(err_msg)))
def __del__(self):
self.reader = None
self._writer_close()
def flush(self, optimize=False):
"""force to write the current changes to disk immediately
:param optimize: ignored for xapian
:type optimize: bool
"""
# write changes to disk (only if database is read-write)
if self._writer_is_open():
self._writer_close()
self._index_refresh()
def make_query(self, *args, **kwargs):
try:
return super(XapianDatabase, self).make_query(*args, **kwargs)
except xapian.DatabaseModifiedError:
self._index_refresh()
return super(XapianDatabase, self).make_query(*args, **kwargs)
def _create_query_for_query(self, query):
"""generate a query based on an existing query object
basically this function should just create a copy of the original
:param query: the original query object
:type query: xapian.Query
:return: the resulting query object
:rtype: xapian.Query
"""
# create a copy of the original query
return xapian.Query(query)
def _create_query_for_string(self, text, require_all=True,
analyzer=None):
"""generate a query for a plain term of a string query
basically this function parses the string and returns the resulting
query
:param text: the query string
:type text: str
:param require_all: boolean operator
(True -> AND (default) / False -> OR)
:type require_all: bool
:param analyzer: Define query options (partial matching, exact matching,
tokenizing, ...) as bitwise combinations of
*CommonIndexer.ANALYZER_???*.
This can override previously defined field
analyzer settings.
If analyzer is None (default), then the configured
analyzer for the field is used.
:type analyzer: int
:return: resulting query object
:rtype: xapian.Query
"""
qp = xapian.QueryParser()
qp.set_database(self.reader)
if require_all:
qp.set_default_op(xapian.Query.OP_AND)
else:
qp.set_default_op(xapian.Query.OP_OR)
if analyzer is None:
analyzer = self.analyzer
if analyzer & self.ANALYZER_PARTIAL > 0:
match_flags = xapian.QueryParser.FLAG_PARTIAL
return qp.parse_query(text, match_flags)
elif analyzer == self.ANALYZER_EXACT:
# exact matching -
return xapian.Query(text)
else:
# everything else (not partial and not exact)
match_flags = 0
return qp.parse_query(text, match_flags)
def _create_query_for_field(self, field, value, analyzer=None):
"""generate a field query
this functions creates a field->value query
:param field: the fieldname to be used
:type field: str
:param value: the wanted value of the field
:type value: str
:param analyzer: Define query options (partial matching, exact
matching, tokenizing, ...) as bitwise combinations of
*CommonIndexer.ANALYZER_???*.
This can override previously defined field
analyzer settings.
If analyzer is None (default), then the configured
analyzer for the field is used.
:type analyzer: int
:return: the resulting query object
:rtype: xapian.Query
"""
if analyzer is None:
analyzer = self.analyzer
if analyzer == self.ANALYZER_EXACT:
# exact matching -> keep special characters
return xapian.Query("%s%s" % (field.upper(), value))
# other queries need a parser object
qp = xapian.QueryParser()
qp.set_database(self.reader)
if (analyzer & self.ANALYZER_PARTIAL > 0):
# partial matching
match_flags = xapian.QueryParser.FLAG_PARTIAL
return qp.parse_query(value, match_flags, field.upper())
else:
# everything else (not partial and not exact)
match_flags = 0
return qp.parse_query(value, match_flags, field.upper())
def _create_query_combined(self, queries, require_all=True):
"""generate a combined query
:param queries: list of the original queries
:type queries: list of xapian.Query
:param require_all: boolean operator
(True -> AND (default) / False -> OR)
:type require_all: bool
:return: the resulting combined query object
:rtype: xapian.Query
"""
if require_all:
query_op = xapian.Query.OP_AND
else:
query_op = xapian.Query.OP_OR
return xapian.Query(query_op, queries)
def _create_empty_document(self):
"""create an empty document to be filled and added to the index later
:return: the new document object
:rtype: xapian.Document
"""
return xapian.Document()
def _add_plain_term(self, document, term, tokenize=True):
"""add a term to a document
:param document: the document to be changed
:type document: xapian.Document
:param term: a single term to be added
:type term: str
:param tokenize: should the term be tokenized automatically
:type tokenize: bool
"""
if tokenize:
term_gen = xapian.TermGenerator()
term_gen.set_document(document)
term_gen.index_text(term)
else:
document.add_term(_truncate_term_length(term))
def _add_field_term(self, document, field, term, tokenize=True):
"""add a field term to a document
:param document: the document to be changed
:type document: xapian.Document
:param field: name of the field
:type field: str
:param term: term to be associated to the field
:type term: str
:param tokenize: should the term be tokenized automatically
:type tokenize: bool
"""
if tokenize:
term_gen = xapian.TermGenerator()
term_gen.set_document(document)
term_gen.index_text(term, 1, field.upper())
else:
document.add_term(_truncate_term_length("%s%s" % \
(field.upper(), term)))
def _add_document_to_index(self, document):
"""add a prepared document to the index database
:param document: the document to be added
:type document: xapian.Document
"""
# open the database for writing
self._writer_open()
self.writer.add_document(document)
def begin_transaction(self):
"""Begin a transaction.
Xapian supports transactions to group multiple database modifications.
This avoids intermediate flushing and therefore increases performance.
"""
self._writer_open()
self.writer.begin_transaction()
def cancel_transaction(self):
"""cancel an ongoing transaction
no changes since the last execution of 'begin_transcation' are written
"""
self.writer.cancel_transaction()
self._writer_close()
def commit_transaction(self):
"""Submit the changes of an ongoing transaction.
All changes since the last execution of 'begin_transaction'
are written.
"""
self.writer.commit_transaction()
self._writer_close()
def get_query_result(self, query):
"""Return an object containing the results of a query.
:param query: a pre-compiled xapian query
:type query: xapian.Query
:return: | |
continue
start = Util.current_time_in_millis ()
other_graph = Util.read_object (path_2)
load_time = Util.current_time_in_millis () - start
start = Util.current_time_in_millis ()
other_nodes = other_graph.get('nodes', [])
other_map = { n['id'] : n for n in other_nodes }
other_keys = set(other_map.keys())
intersection = [ v for v in graph_keys if v in other_keys ]
difference = list(set(other_keys) - set(graph_keys))
scope_time = Util.current_time_in_millis () - start
start = Util.current_time_in_millis ()
for i in intersection:
self.merge_nodes (graph_map[i], other_map[i])
other_graph['nodes'] = [ other_map[i] for i in difference ]
merge_time = Util.current_time_in_millis () - start
start = Util.current_time_in_millis ()
Util.write_object (other_graph, path_2.replace ('kgx', 'merge'))
write_time = Util.current_time_in_millis () - start
log.debug ("merged {:>45} load:{:>5} scope:{:>7} merge:{:>3}".format(
Util.trunc(path_2, 45), load_time, scope_time, merge_time))
total_merge_time += load_time + scope_time + merge_time + write_time
start = Util.current_time_in_millis ()
Util.write_object (graph, new_path)
rewrite_time = Util.current_time_in_millis () - start
log.info (f"{path} rewrite: {rewrite_time}. total merge time: {total_merge_time}")
def format_keys (self, keys, schema_type : SchemaType):
""" Format schema keys. Make source and destination first in edges. Make
id first in nodes. Remove keys for fields we can't yet represent.
:param keys: List of keys.
:param schema_type: Type of schema to conform to.
"""
""" Sort keys. """
k_list = sorted(keys)
if schema_type == SchemaType.PREDICATE:
""" Rename subject and object to src and dest """
k_list.remove ('subject')
k_list.remove ('object')
k_list.insert (0, 'src')
k_list.insert (1, 'dest')
elif schema_type == SchemaType.CATEGORY:
""" Make id the first field. Remove smiles. It causes ast parse errors.
TODO: update bulk loader to ignore AST on selected fields.
"""
k_list.remove ('id')
if 'simple_smiles' in k_list:
k_list.remove ('simple_smiles')
k_list.insert (0, 'id')
return k_list
def load (self):
""" Use KGX to load a data set into Redisgraph """
input_format = "json"
uri = f"redis://{config['redisgraph']['host']}:{config['redisgraph']['ports']['http']}/"
username = config['redisgraph']['username']
password = config['redisgraph']['password']
log.info (f"connecting to redisgraph: {uri}")
for subgraph in glob.glob (f"{kgx_repo}/**.json"):
redisgraph_upload(inputs=[ subgraph ],
input_format=input_format,
input_compression=None,
uri=uri,
username=username,
password=password,
node_filters=[],
edge_filters=[])
class BiolinkModel:
""" Programmatic model of Biolink. """
def to_camel_case(self, snake_str):
""" Convert a snake case string to camel case. """
components = snake_str.split('_')
return ''.join(x.title() for x in components)
def get_class(self, name):
""" Get a Python class from a string name. """
return getattr(sys.modules["biolink.model"], name)
def is_derived (self, a_class_name, classes):
""" Return true if the class derives from any of the provided classes. """
for c in classes:
if isinstance (self.get_class(self.to_camel_case(a_class_name)), c):
return True
return False
def get_leaf_class (self, names):
""" Return the leaf classes in the provided list of names. """
classes = [ self.get_class(self.to_camel_case(n)) for n in names ]
leaves = [ n for n in names if not self.is_derived (n, classes) ]
return leaves [0]
class BulkLoad:
""" Tools for creating a Redisgraph bulk load dataset. """
def __init__(self, biolink):
self.biolink = biolink
def tables_up_to_date (self):
return Util.is_up_to_date (
source=[
Util.schema_path (f"{SchemaType.PREDICATE.value}-schema.json"),
Util.schema_path (f"{SchemaType.PREDICATE.value}-schema.json")
] + Util.merged_objects (),
targets=glob.glob (Util.bulk_path ("nodes/**.csv")) + \
glob.glob (Util.bulk_path ("edges/**.csv")))
def create (self):
""" Check source times. """
if self.tables_up_to_date ():
log.info ("up to date.")
return
""" Format the data for bulk load. """
predicates_schema = Util.read_schema (SchemaType.PREDICATE)
categories_schema = Util.read_schema (SchemaType.CATEGORY)
bulk_path = Util.bulk_path("")
if os.path.exists(bulk_path):
shutil.rmtree(bulk_path)
state = defaultdict(lambda:None)
for subgraph in Util.merged_objects ():
log.info (f"processing {subgraph}")
graph = Util.read_object (subgraph)
""" Write node data for bulk load. """
categories = defaultdict(lambda: [])
for node in graph['nodes']:
index = self.biolink.get_leaf_class (node['category'])
categories[index].append (node)
self.write_bulk (Util.bulk_path("nodes"), categories, categories_schema,
state=state, f=subgraph)
""" Write predicate data for bulk load. """
predicates = defaultdict(lambda: [])
for edge in graph['edges']:
predicates[edge['edge_label']].append (edge)
edge['src'] = edge.pop ('subject')
edge['dest'] = edge.pop ('object')
self.write_bulk (Util.bulk_path("edges"), predicates, predicates_schema)
def cleanup (self, v):
""" Filter problematic text.
:param v: A value to filter and clean.
"""
if isinstance(v, list):
v = [ self.cleanup(val) for val in v ]
elif isinstance (v, str):
""" Some values contain the CSV separator character. 'fix' that. """
if len(v) > 1 and v[0] == '[' and v[-1] == ']':
v = v.replace ("[", "@").replace ("]", "@") #f" {v}"
v = v.replace ("|","^")
return v
def write_bulk (self, bulk_path, obj_map, schema, state={}, f=None):
""" Write a bulk load group of objects.
:param bulk_path: Path to the bulk loader object to write.
:param obj_map: A map of biolink type to list of objects.
:param schema: The schema (nodes or predicates) containing identifiers.
:param state: Track state of already written objects to avoid duplicates.
"""
os.makedirs (bulk_path, exist_ok=True)
for key, objects in obj_map.items ():
out_file = f"{bulk_path}/{key}.csv"
if len(objects) == 0:
continue
new_file = not os.path.exists (out_file)
all_keys = schema[key]
with open (out_file, "a") as stream:
if new_file:
log.info (f" --creating {out_file}")
stream.write ("|".join (all_keys))
stream.write ("\n")
""" Make all objects conform to the schema. """
for obj in objects:
for akey in all_keys:
if not akey in obj:
obj[akey] = ""
""" Write fields, skipping duplicate objects. """
for obj in objects:
oid = str(obj['id'])
if oid in state:
continue
state[oid] = oid
values = [ self.cleanup(obj[k]) for k in all_keys if not 'smiles' in k ]
clean = list(map(str, values))
s = "|".join (clean)
stream.write (s)
stream.write ("\n")
def insert (self):
redisgraph = config.get('redisgraph', {})
bulk_loader = config.get('bulk_loader', {})
nodes = sorted(glob.glob (Util.bulk_path ("nodes/**.csv")))
edges = sorted(glob.glob (Util.bulk_path ("edges/**.csv")))
graph = redisgraph['graph']
log.info (f"bulk loading \n nodes: {nodes} \n edges: {edges}")
print (f"bulk loading \n nodes: {nodes} \n edges: {edges}")
try:
log.info (f"deleting graph {graph} in preparation for bulk load.")
db = self.get_redisgraph (redisgraph)
db.redis_graph.delete ()
except redis.exceptions.ResponseError:
log.info ("no graph to delete")
log.info (f"bulk loading graph: {graph}")
args = []
if len(nodes) > 0:
args.extend (("-n " + " -n ".join (nodes)).split ())
if len(edges) > 0:
args.extend (("-r " + " -r ".join (edges)).split ())
args.extend ([ "--separator=|" ])
args.extend ([ redisgraph['graph'] ])
""" standalone_mode=False tells click not to sys.exit() """
bulk_insert (args, standalone_mode=False)
def get_redisgraph (self, redisgraph):
return RedisGraph (host=redisgraph['host'],
port=redisgraph['ports']['http'],
graph=redisgraph['graph'])
def validate (self):
redisgraph = config.get('redisgraph', {})
print (f"config:{json.dumps(redisgraph, indent=2)}")
db = self.get_redisgraph (redisgraph)
validation_queries = config.get('validation', {}).get('queries', [])
for key, query in validation_queries.items ():
text = query['query']
name = query['name']
args = query.get('args', [{}])
for arg in args:
start = Util.current_time_in_millis ()
instance = Template (text).safe_substitute (arg)
db.query (instance)
duration = Util.current_time_in_millis () - start
log.info (f"Query {key}:{name} ran in {duration}ms: {instance}")
class Roger:
""" Consolidate Roger functionality for a cleaner interface. """
def __init__(self, to_string=False):
""" Initialize.
:param to_string: Log messages to a string, available as self.log_stream.getvalue()
after execution completes.
"""
import logging
if to_string:
""" Add a stream handler to enable to_string. """
self.log_stream = StringIO()
self.string_handler = logging.StreamHandler (self.log_stream)
log.addHandler (self.string_handler)
self.biolink = BiolinkModel ()
self.kgx = KGXModel (self.biolink)
self.bulk = BulkLoad (self.biolink)
def __enter__(self):
""" Implement Python's Context Manager interface. """
return self
def __exit__(self, exception_type, exception_value, traceback):
""" Implement Python's Context Manager interface. We use this finalizer
to detach the stream handler appended in the constructor.
:param exception_type: Type of exception, if one occurred.
:param exception_value: The exception, if one occurred.
:param traceback: The stack trace explaining the exception.
"""
if exception_type or exception_value or traceback:
log.error ("{} {} {}".format (exception_type, exception_value, traceback))
log.removeHandler (self.string_handler)
class RogerUtil:
""" An interface abstracting Roger's inner workings to make it easier to
incorporate into external tools like workflow engines. """
@staticmethod
def get_kgx (to_string=False):
output = None
with Roger (to_string) as roger:
roger.kgx.get ()
output = roger.log_stream.getvalue () if to_string else None
return output
@staticmethod
def create_schema (to_string=False):
output = None
with Roger (to_string) as roger:
roger.kgx.create_schema ()
output = roger.log_stream.getvalue () if to_string else None
return output
@staticmethod
def merge_nodes (to_string=False):
output = None
with Roger (to_string) as roger:
roger.kgx.merge ()
output = roger.log_stream.getvalue () if to_string else None
return output
@staticmethod
def create_bulk_load (to_string=False):
output = None
with Roger (to_string) as roger:
roger.bulk.create ()
output = roger.log_stream.getvalue () if | |
from __future__ import print_function
import os
import sys
import time
import traceback
from unittest import TestResult, TextTestResult
from unittest.result import failfast
from jinja2 import Template
DEFAULT_TEMPLATE = os.path.join(os.path.dirname(__file__), "template", "report_template.html")
def load_template(template):
""" Try to read a file from a given path, if file
does not exist, load default one. """
file = None
try:
if template:
with open(template, "r") as f:
file = f.read()
except Exception as err:
print("Error: Your Template wasn't loaded", err,
"Loading Default Template", sep="\n")
finally:
if not file:
with open(DEFAULT_TEMPLATE, "r") as f:
file = f.read()
return file
def render_html(template, **kwargs):
template_file = load_template(template)
if template_file:
template = Template(template_file)
return template.render(**kwargs)
def testcase_name(test_method):
testcase = type(test_method)
module = testcase.__module__ + "."
if module == "__main__.":
module = ""
result = module + testcase.__name__
return result
def strip_module_names(testcase_names):
"""Examine all given test case names and strip them the minimal
names needed to distinguish each. This prevents cases where test
cases housed in different files but with the same names cause clashes."""
result = list(testcase_names)
for i, testcase in enumerate(testcase_names):
classname = testcase.split(".")[-1]
duplicate_found = False
testcase_names_ = list(testcase_names)
del testcase_names_[i]
for testcase_ in testcase_names_:
classname_ = testcase_.split(".")[-1]
if classname_ == classname:
duplicate_found = True
if not duplicate_found:
result[i] = classname
return result
class _TestInfo(object):
"""" Keeps information about the execution of a test method. """
(SUCCESS, FAILURE, ERROR, SKIP) = range(4)
def __init__(self, test_result, test_method, outcome=SUCCESS,
err=None, subTest=None):
self.test_result = test_result
self.outcome = outcome
self.elapsed_time = 0
self.err = err
self.stdout = test_result._stdout_data
self.stderr = test_result._stderr_data
self.is_subtest = subTest is not None
self.test_description = self.test_result.getDescription(test_method)
self.test_exception_info = (
'' if outcome in (self.SUCCESS, self.SKIP)
else self.test_result._exc_info_to_string(
self.err, test_method))
self.test_name = testcase_name(test_method)
if not self.is_subtest:
self.test_id = test_method.id()
else:
self.test_id = subTest.id()
def id(self):
return self.test_id
def test_finished(self):
self.elapsed_time = self.test_result.stop_time - self.test_result.start_time
def get_description(self):
return self.test_description
def get_error_info(self):
return self.test_exception_info
class _SubTestInfos(object):
# TODO: make better: inherit _TestInfo?
(SUCCESS, FAILURE, ERROR, SKIP) = range(4)
def __init__(self, test_id, subtests):
self.subtests = subtests
self.test_id = test_id
self.outcome = self.check_outcome()
def check_outcome(self):
outcome = _TestInfo.SUCCESS
for subtest in self.subtests:
if subtest.outcome != _TestInfo.SUCCESS:
outcome = _TestInfo.FAILURE
break
return outcome
class HtmlTestResult(TextTestResult):
""" A test result class that express test results in Html. """
start_time = None
stop_time = None
default_prefix = "TestResults_"
def __init__(self, stream, descriptions, verbosity):
TextTestResult.__init__(self, stream, descriptions, verbosity)
self.buffer = True
self._stdout_data = None
self._stderr_data = None
self.successes = []
self.subtests = {}
self.callback = None
self.infoclass = _TestInfo
self.report_files = []
def _prepare_callback(self, test_info, target_list, verbose_str,
short_str):
""" Appends a 'info class' to the given target list and sets a
callback method to be called by stopTest method."""
target_list.append(test_info)
def callback():
""" Print test method outcome to the stream and elapsed time too."""
test_info.test_finished()
if self.showAll:
self.stream.writeln(
"{} ({:3f}s)".format(verbose_str, test_info.elapsed_time))
elif self.dots:
self.stream.write(short_str)
self.callback = callback
def getDescription(self, test):
""" Return the test description if not have test name. """
return str(test)
def startTest(self, test):
""" Called before execute each method. """
self.start_time = time.time()
TestResult.startTest(self, test)
if self.showAll:
self.stream.write(" " + self.getDescription(test))
self.stream.write(" ... ")
def _save_output_data(self):
try:
self._stdout_data = sys.stdout.getvalue()
self._stderr_data = sys.stderr.getvalue()
except AttributeError:
pass
def stopTest(self, test):
""" Called after excute each test method. """
self._save_output_data()
TextTestResult.stopTest(self, test)
self.stop_time = time.time()
if self.callback and callable(self.callback):
self.callback()
self.callback = None
def addSuccess(self, test):
""" Called when a test executes successfully. """
self._save_output_data()
self._prepare_callback(self.infoclass(self, test), self.successes, "OK", ".")
@failfast
def addFailure(self, test, err):
""" Called when a test method fails. """
self._save_output_data()
testinfo = self.infoclass(self, test, self.infoclass.FAILURE, err)
self._prepare_callback(testinfo, self.failures, "FAIL", "F")
@failfast
def addError(self, test, err):
"""" Called when a test method raises an error. """
self._save_output_data()
testinfo = self.infoclass(self, test, self.infoclass.ERROR, err)
self._prepare_callback(testinfo, self.errors, 'ERROR', 'E')
def addSubTest(self, testcase, test, err):
""" Called when a subTest completes. """
self._save_output_data()
# TODO: should ERROR cases be considered here too?
if err is None:
testinfo = self.infoclass(self, testcase, self.infoclass.SUCCESS, err, subTest=test)
self._prepare_callback(testinfo, self.successes, "OK", ".")
else:
testinfo = self.infoclass(self, testcase, self.infoclass.FAILURE, err, subTest=test)
self._prepare_callback(testinfo, self.failures, "FAIL", "F")
test_id_components = str(testcase).rstrip(')').split(' (')
test_id = test_id_components[1] + '.' + test_id_components[0]
if test_id not in self.subtests:
self.subtests[test_id] = []
self.subtests[test_id].append(testinfo)
def addSkip(self, test, reason):
"""" Called when a test method was skipped. """
self._save_output_data()
testinfo = self.infoclass(self, test, self.infoclass.SKIP, reason)
self._prepare_callback(testinfo, self.skipped, "SKIP", "S")
def printErrorList(self, flavour, errors):
"""
Writes information about the FAIL or ERROR to the stream.
"""
for test_info in errors:
self.stream.writeln(self.separator1)
self.stream.writeln(
'{} [{:3f}s]: {}'.format(flavour, test_info.elapsed_time,
test_info.test_id)
)
self.stream.writeln(self.separator2)
self.stream.writeln('%s' % test_info.get_error_info())
def _get_info_by_testcase(self):
""" Organize test results by TestCase module. """
tests_by_testcase = {}
subtest_names = set(self.subtests.keys())
for test_name, subtests in self.subtests.items():
subtest_info = _SubTestInfos(test_name, subtests)
testcase_name = ".".join(test_name.split(".")[:-1])
if testcase_name not in tests_by_testcase:
tests_by_testcase[testcase_name] = []
tests_by_testcase[testcase_name].append(subtest_info)
for tests in (self.successes, self.failures, self.errors, self.skipped):
for test_info in tests:
# subtests will be contained by _SubTestInfos objects but there is also the
# case where all subtests pass and the method is added as a success as well
# which must be filtered out
if test_info.is_subtest or test_info.test_id in subtest_names:
continue
if isinstance(test_info, tuple): # TODO: does this ever occur?
test_info = test_info[0]
testcase_name = ".".join(test_info.test_id.split(".")[:-1])
if testcase_name not in tests_by_testcase:
tests_by_testcase[testcase_name] = []
tests_by_testcase[testcase_name].append(test_info)
# unittest tests in alphabetical order based on test name so re-assert this
for testcase in tests_by_testcase.values():
testcase.sort(key=lambda x: x.test_id)
return tests_by_testcase
@staticmethod
def _format_duration(elapsed_time):
"""Format the elapsed time in seconds, or milliseconds if the duration is less than 1 second."""
if elapsed_time > 1:
duration = '{:2.2f} s'.format(elapsed_time)
else:
duration = '{:d} ms'.format(int(elapsed_time * 1000))
return duration
def get_results_summary(self, tests):
"""Create a summary of the outcomes of all given tests."""
failures = errors = skips = successes = 0
for test in tests:
outcome = test.outcome
if outcome == test.ERROR:
errors += 1
elif outcome == test.FAILURE:
failures += 1
elif outcome == test.SKIP:
skips += 1
elif outcome == test.SUCCESS:
successes += 1
elapsed_time = 0
for testinfo in tests:
if not isinstance(testinfo, _SubTestInfos):
elapsed_time += testinfo.elapsed_time
else:
for subtest in testinfo.subtests:
elapsed_time += subtest.elapsed_time
results_summary = {
"total": len(tests),
"error": errors,
"failure": failures,
"skip": skips,
"success": successes,
"duration": self._format_duration(elapsed_time)
}
return results_summary
def _get_header_info(self, tests, start_time):
results_summary = self.get_results_summary(tests)
header_info = {
"start_time": start_time,
"status": results_summary
}
return header_info
def _get_report_summaries(self, all_results, testRunner):
""" Generate headers and summaries for all given test cases."""
summaries = {}
for test_case_class_name, test_case_tests in all_results.items():
summaries[test_case_class_name] = self.get_results_summary(test_case_tests)
return summaries
def generate_reports(self, testRunner):
""" Generate report(s) for all given test cases that have been run. """
status_tags = ('success', 'danger', 'warning', 'info')
all_results = self._get_info_by_testcase()
summaries = self._get_report_summaries(all_results, testRunner)
if not testRunner.combine_reports:
for test_case_class_name, test_case_tests in all_results.items():
header_info = self._get_header_info(test_case_tests, testRunner.start_time)
html_file = render_html(
testRunner.template,
title=testRunner.report_title,
header_info=header_info,
all_results={test_case_class_name: test_case_tests},
status_tags=status_tags,
summaries=summaries,
**testRunner.template_args
)
# append test case name if multiple reports to be generated
if testRunner.report_name is None:
report_name_body = self.default_prefix + test_case_class_name
else:
report_name_body = "{}_{}".format(testRunner.report_name, test_case_class_name)
self.generate_file(testRunner, report_name_body, html_file)
else:
header_info = self._get_header_info(
[item for sublist in all_results.values() for item in sublist],
testRunner.start_time
)
html_file = render_html(
testRunner.template,
title=testRunner.report_title,
header_info=header_info,
all_results=all_results,
status_tags=status_tags,
summaries=summaries,
**testRunner.template_args
)
# if available, use user report name
if testRunner.report_name is not None:
report_name_body = testRunner.report_name
else:
report_name_body = self.default_prefix + "_".join(strip_module_names(list(all_results.keys())))[:128]
self.generate_file(testRunner, report_name_body, html_file)
def generate_file(self, testRunner, report_name, report):
""" Generate the report file in the given path. """
dir_to = testRunner.output
if not os.path.exists(dir_to):
os.makedirs(dir_to)
if testRunner.timestamp:
report_name += "_" + testRunner.timestamp
report_name += ".html"
path_file = os.path.abspath(os.path.join(dir_to, report_name))
self.stream.writeln(os.path.relpath(path_file))
self.report_files.append(path_file)
with open(path_file, 'w') as report_file:
report_file.write(report)
def _exc_info_to_string(self, err, test):
""" Converts a sys.exc_info()-style tuple of values into a string."""
# if six.PY3:
# # It works fine in python 3
# try:
# return super(_HTMLTestResult, self)._exc_info_to_string(
# err, test)
# except AttributeError:
# # We keep going using the legacy python <= 2 way
# pass
# This comes directly from python2 unittest
exctype, value, tb = err
# Skip test runner traceback levels
while tb and self._is_relevant_tb_level(tb):
tb = tb.tb_next
if | |
fid == 3:
if ftype == TType.STRUCT:
self.auth = TimAuth()
self.auth.read(iprot)
else:
iprot.skip(ftype)
else:
iprot.skip(ftype)
iprot.readFieldEnd()
iprot.readStructEnd()
def write(self, oprot):
if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
return
oprot.writeStructBegin('timRemoteUserAuth_args')
if self.tid is not None:
oprot.writeFieldBegin('tid', TType.STRUCT, 1)
self.tid.write(oprot)
oprot.writeFieldEnd()
if self.pwd is not None:
oprot.writeFieldBegin('pwd', TType.STRING, 2)
oprot.writeString(self.pwd)
oprot.writeFieldEnd()
if self.auth is not None:
oprot.writeFieldBegin('auth', TType.STRUCT, 3)
self.auth.write(oprot)
oprot.writeFieldEnd()
oprot.writeFieldStop()
oprot.writeStructEnd()
def validate(self):
return
def __hash__(self):
value = 17
value = (value * 31) ^ hash(self.tid)
value = (value * 31) ^ hash(self.pwd)
value = (value * 31) ^ hash(self.auth)
return value
def __repr__(self):
L = ['%s=%r' % (key, value)
for key, value in self.__dict__.iteritems()]
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
def __eq__(self, other):
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
def __ne__(self, other):
return not (self == other)
class timRemoteUserAuth_result:
"""
Attributes:
- success
"""
thrift_spec = (
(0, TType.STRUCT, 'success', (TimRemoteUserBean, TimRemoteUserBean.thrift_spec), None, ), # 0
)
def __init__(self, success=None,):
self.success = success
def read(self, iprot):
if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
return
iprot.readStructBegin()
while True:
(fname, ftype, fid) = iprot.readFieldBegin()
if ftype == TType.STOP:
break
if fid == 0:
if ftype == TType.STRUCT:
self.success = TimRemoteUserBean()
self.success.read(iprot)
else:
iprot.skip(ftype)
else:
iprot.skip(ftype)
iprot.readFieldEnd()
iprot.readStructEnd()
def write(self, oprot):
if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
return
oprot.writeStructBegin('timRemoteUserAuth_result')
if self.success is not None:
oprot.writeFieldBegin('success', TType.STRUCT, 0)
self.success.write(oprot)
oprot.writeFieldEnd()
oprot.writeFieldStop()
oprot.writeStructEnd()
def validate(self):
return
def __hash__(self):
value = 17
value = (value * 31) ^ hash(self.success)
return value
def __repr__(self):
L = ['%s=%r' % (key, value)
for key, value in self.__dict__.iteritems()]
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
def __eq__(self, other):
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
def __ne__(self, other):
return not (self == other)
class timRemoteUserGet_args:
"""
Attributes:
- tid
- auth
"""
thrift_spec = (
None, # 0
(1, TType.STRUCT, 'tid', (Tid, Tid.thrift_spec), None, ), # 1
(2, TType.STRUCT, 'auth', (TimAuth, TimAuth.thrift_spec), None, ), # 2
)
def __init__(self, tid=None, auth=None,):
self.tid = tid
self.auth = auth
def read(self, iprot):
if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
return
iprot.readStructBegin()
while True:
(fname, ftype, fid) = iprot.readFieldBegin()
if ftype == TType.STOP:
break
if fid == 1:
if ftype == TType.STRUCT:
self.tid = Tid()
self.tid.read(iprot)
else:
iprot.skip(ftype)
elif fid == 2:
if ftype == TType.STRUCT:
self.auth = TimAuth()
self.auth.read(iprot)
else:
iprot.skip(ftype)
else:
iprot.skip(ftype)
iprot.readFieldEnd()
iprot.readStructEnd()
def write(self, oprot):
if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
return
oprot.writeStructBegin('timRemoteUserGet_args')
if self.tid is not None:
oprot.writeFieldBegin('tid', TType.STRUCT, 1)
self.tid.write(oprot)
oprot.writeFieldEnd()
if self.auth is not None:
oprot.writeFieldBegin('auth', TType.STRUCT, 2)
self.auth.write(oprot)
oprot.writeFieldEnd()
oprot.writeFieldStop()
oprot.writeStructEnd()
def validate(self):
return
def __hash__(self):
value = 17
value = (value * 31) ^ hash(self.tid)
value = (value * 31) ^ hash(self.auth)
return value
def __repr__(self):
L = ['%s=%r' % (key, value)
for key, value in self.__dict__.iteritems()]
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
def __eq__(self, other):
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
def __ne__(self, other):
return not (self == other)
class timRemoteUserGet_result:
"""
Attributes:
- success
"""
thrift_spec = (
(0, TType.STRUCT, 'success', (TimRemoteUserBean, TimRemoteUserBean.thrift_spec), None, ), # 0
)
def __init__(self, success=None,):
self.success = success
def read(self, iprot):
if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
return
iprot.readStructBegin()
while True:
(fname, ftype, fid) = iprot.readFieldBegin()
if ftype == TType.STOP:
break
if fid == 0:
if ftype == TType.STRUCT:
self.success = TimRemoteUserBean()
self.success.read(iprot)
else:
iprot.skip(ftype)
else:
iprot.skip(ftype)
iprot.readFieldEnd()
iprot.readStructEnd()
def write(self, oprot):
if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
return
oprot.writeStructBegin('timRemoteUserGet_result')
if self.success is not None:
oprot.writeFieldBegin('success', TType.STRUCT, 0)
self.success.write(oprot)
oprot.writeFieldEnd()
oprot.writeFieldStop()
oprot.writeStructEnd()
def validate(self):
return
def __hash__(self):
value = 17
value = (value * 31) ^ hash(self.success)
return value
def __repr__(self):
L = ['%s=%r' % (key, value)
for key, value in self.__dict__.iteritems()]
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
def __eq__(self, other):
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
def __ne__(self, other):
return not (self == other)
class timRemoteUserEdit_args:
"""
Attributes:
- tid
- ub
- auth
"""
thrift_spec = (
None, # 0
(1, TType.STRUCT, 'tid', (Tid, Tid.thrift_spec), None, ), # 1
(2, TType.STRUCT, 'ub', (TimUserBean, TimUserBean.thrift_spec), None, ), # 2
(3, TType.STRUCT, 'auth', (TimAuth, TimAuth.thrift_spec), None, ), # 3
)
def __init__(self, tid=None, ub=None, auth=None,):
self.tid = tid
self.ub = ub
self.auth = auth
def read(self, iprot):
if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
return
iprot.readStructBegin()
while True:
(fname, ftype, fid) = iprot.readFieldBegin()
if ftype == TType.STOP:
break
if fid == 1:
if ftype == TType.STRUCT:
self.tid = Tid()
self.tid.read(iprot)
else:
iprot.skip(ftype)
elif fid == 2:
if ftype == TType.STRUCT:
self.ub = TimUserBean()
self.ub.read(iprot)
else:
iprot.skip(ftype)
elif fid == 3:
if ftype == TType.STRUCT:
self.auth = TimAuth()
self.auth.read(iprot)
else:
iprot.skip(ftype)
else:
iprot.skip(ftype)
iprot.readFieldEnd()
iprot.readStructEnd()
def write(self, oprot):
if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
return
oprot.writeStructBegin('timRemoteUserEdit_args')
if self.tid is not None:
oprot.writeFieldBegin('tid', TType.STRUCT, 1)
self.tid.write(oprot)
oprot.writeFieldEnd()
if self.ub is not None:
oprot.writeFieldBegin('ub', TType.STRUCT, 2)
self.ub.write(oprot)
oprot.writeFieldEnd()
if self.auth is not None:
oprot.writeFieldBegin('auth', TType.STRUCT, 3)
self.auth.write(oprot)
oprot.writeFieldEnd()
oprot.writeFieldStop()
oprot.writeStructEnd()
def validate(self):
return
def __hash__(self):
value = 17
value = (value * 31) ^ hash(self.tid)
value = (value * 31) ^ hash(self.ub)
value = (value * 31) ^ hash(self.auth)
return value
def __repr__(self):
L = ['%s=%r' % (key, value)
for key, value in self.__dict__.iteritems()]
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
def __eq__(self, other):
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
def __ne__(self, other):
return not (self == other)
class timRemoteUserEdit_result:
"""
Attributes:
- success
"""
thrift_spec = (
(0, TType.STRUCT, 'success', (TimRemoteUserBean, TimRemoteUserBean.thrift_spec), None, ), # 0
)
def __init__(self, success=None,):
self.success = success
def read(self, iprot):
if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
return
iprot.readStructBegin()
while True:
(fname, ftype, fid) = iprot.readFieldBegin()
if ftype == TType.STOP:
break
if fid == 0:
if ftype == TType.STRUCT:
self.success = TimRemoteUserBean()
self.success.read(iprot)
else:
iprot.skip(ftype)
else:
iprot.skip(ftype)
iprot.readFieldEnd()
iprot.readStructEnd()
def write(self, oprot):
if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
return
oprot.writeStructBegin('timRemoteUserEdit_result')
if self.success is not None:
oprot.writeFieldBegin('success', TType.STRUCT, 0)
self.success.write(oprot)
oprot.writeFieldEnd()
oprot.writeFieldStop()
oprot.writeStructEnd()
def validate(self):
return
def __hash__(self):
value = 17
value = (value * 31) ^ hash(self.success)
return value
def __repr__(self):
L = ['%s=%r' % (key, value)
for key, value in self.__dict__.iteritems()]
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
def __eq__(self, other):
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
def __ne__(self, other):
return not (self == other)
class timResponsePresence_args:
"""
Attributes:
- pbean
- auth
"""
thrift_spec = (
None, # 0
(1, TType.STRUCT, 'pbean', (TimPBean, TimPBean.thrift_spec), None, ), # 1
(2, TType.STRUCT, 'auth', (TimAuth, TimAuth.thrift_spec), None, ), # 2
)
def __init__(self, pbean=None, auth=None,):
self.pbean = pbean
self.auth = auth
def read(self, iprot):
if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
return
iprot.readStructBegin()
while True:
(fname, ftype, fid) = iprot.readFieldBegin()
if ftype == TType.STOP:
break
if fid == 1:
if ftype == TType.STRUCT:
self.pbean = TimPBean()
self.pbean.read(iprot)
else:
iprot.skip(ftype)
elif fid == 2:
if ftype == TType.STRUCT:
self.auth = TimAuth()
self.auth.read(iprot)
else:
iprot.skip(ftype)
else:
iprot.skip(ftype)
iprot.readFieldEnd()
iprot.readStructEnd()
def write(self, oprot):
if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
return
oprot.writeStructBegin('timResponsePresence_args')
if self.pbean is not None:
oprot.writeFieldBegin('pbean', TType.STRUCT, 1)
self.pbean.write(oprot)
oprot.writeFieldEnd()
if self.auth is not None:
oprot.writeFieldBegin('auth', TType.STRUCT, | |
``val``.
:param Optional[str] val:
:rtype: LookupError
"""
return cls('malformed_path', val)
def is_malformed_path(self):
"""
Check if the union tag is ``malformed_path``.
:rtype: bool
"""
return self._tag == 'malformed_path'
def is_not_found(self):
"""
Check if the union tag is ``not_found``.
:rtype: bool
"""
return self._tag == 'not_found'
def is_not_file(self):
"""
Check if the union tag is ``not_file``.
:rtype: bool
"""
return self._tag == 'not_file'
def is_not_folder(self):
"""
Check if the union tag is ``not_folder``.
:rtype: bool
"""
return self._tag == 'not_folder'
def is_restricted_content(self):
"""
Check if the union tag is ``restricted_content``.
:rtype: bool
"""
return self._tag == 'restricted_content'
def is_unsupported_content_type(self):
"""
Check if the union tag is ``unsupported_content_type``.
:rtype: bool
"""
return self._tag == 'unsupported_content_type'
def is_other(self):
"""
Check if the union tag is ``other``.
:rtype: bool
"""
return self._tag == 'other'
def get_malformed_path(self):
"""
The given path does not satisfy the required path format. Please refer
to the `Path formats documentation
<https://www.dropbox.com/developers/documentation/http/documentation#path-formats>`_
for more information.
Only call this if :meth:`is_malformed_path` is true.
:rtype: Optional[str]
"""
if not self.is_malformed_path():
raise AttributeError("tag 'malformed_path' not set")
return self._value
def _process_custom_annotations(self, annotation_type, field_path, processor):
super(LookupError, self)._process_custom_annotations(annotation_type, field_path, processor)
def __repr__(self):
return 'LookupError(%r, %r)' % (self._tag, self._value)
LookupError_validator = bv.Union(LookupError)
class MediaInfo(bb.Union):
"""
This class acts as a tagged union. Only one of the ``is_*`` methods will
return true. To get the associated value of a tag (if one exists), use the
corresponding ``get_*`` method.
:ivar files.MediaInfo.pending: Indicate the photo/video is still under
processing and metadata is not available yet.
:ivar MediaMetadata MediaInfo.metadata: The metadata for the photo/video.
"""
_catch_all = None
# Attribute is overwritten below the class definition
pending = None
@classmethod
def metadata(cls, val):
"""
Create an instance of this class set to the ``metadata`` tag with value
``val``.
:param MediaMetadata val:
:rtype: MediaInfo
"""
return cls('metadata', val)
def is_pending(self):
"""
Check if the union tag is ``pending``.
:rtype: bool
"""
return self._tag == 'pending'
def is_metadata(self):
"""
Check if the union tag is ``metadata``.
:rtype: bool
"""
return self._tag == 'metadata'
def get_metadata(self):
"""
The metadata for the photo/video.
Only call this if :meth:`is_metadata` is true.
:rtype: MediaMetadata
"""
if not self.is_metadata():
raise AttributeError("tag 'metadata' not set")
return self._value
def _process_custom_annotations(self, annotation_type, field_path, processor):
super(MediaInfo, self)._process_custom_annotations(annotation_type, field_path, processor)
def __repr__(self):
return 'MediaInfo(%r, %r)' % (self._tag, self._value)
MediaInfo_validator = bv.Union(MediaInfo)
class MediaMetadata(bb.Struct):
"""
Metadata for a photo or video.
:ivar files.MediaMetadata.dimensions: Dimension of the photo/video.
:ivar files.MediaMetadata.location: The GPS coordinate of the photo/video.
:ivar files.MediaMetadata.time_taken: The timestamp when the photo/video is
taken.
"""
__slots__ = [
'_dimensions_value',
'_dimensions_present',
'_location_value',
'_location_present',
'_time_taken_value',
'_time_taken_present',
]
_has_required_fields = False
def __init__(self,
dimensions=None,
location=None,
time_taken=None):
self._dimensions_value = None
self._dimensions_present = False
self._location_value = None
self._location_present = False
self._time_taken_value = None
self._time_taken_present = False
if dimensions is not None:
self.dimensions = dimensions
if location is not None:
self.location = location
if time_taken is not None:
self.time_taken = time_taken
@property
def dimensions(self):
"""
Dimension of the photo/video.
:rtype: Dimensions
"""
if self._dimensions_present:
return self._dimensions_value
else:
return None
@dimensions.setter
def dimensions(self, val):
if val is None:
del self.dimensions
return
self._dimensions_validator.validate_type_only(val)
self._dimensions_value = val
self._dimensions_present = True
@dimensions.deleter
def dimensions(self):
self._dimensions_value = None
self._dimensions_present = False
@property
def location(self):
"""
The GPS coordinate of the photo/video.
:rtype: GpsCoordinates
"""
if self._location_present:
return self._location_value
else:
return None
@location.setter
def location(self, val):
if val is None:
del self.location
return
self._location_validator.validate_type_only(val)
self._location_value = val
self._location_present = True
@location.deleter
def location(self):
self._location_value = None
self._location_present = False
@property
def time_taken(self):
"""
The timestamp when the photo/video is taken.
:rtype: datetime.datetime
"""
if self._time_taken_present:
return self._time_taken_value
else:
return None
@time_taken.setter
def time_taken(self, val):
if val is None:
del self.time_taken
return
val = self._time_taken_validator.validate(val)
self._time_taken_value = val
self._time_taken_present = True
@time_taken.deleter
def time_taken(self):
self._time_taken_value = None
self._time_taken_present = False
def _process_custom_annotations(self, annotation_type, field_path, processor):
super(MediaMetadata, self)._process_custom_annotations(annotation_type, field_path, processor)
def __repr__(self):
return 'MediaMetadata(dimensions={!r}, location={!r}, time_taken={!r})'.format(
self._dimensions_value,
self._location_value,
self._time_taken_value,
)
MediaMetadata_validator = bv.StructTree(MediaMetadata)
class RelocationBatchArgBase(bb.Struct):
"""
:ivar files.RelocationBatchArgBase.entries: List of entries to be moved or
copied. Each entry is :class:`RelocationPath`.
:ivar files.RelocationBatchArgBase.autorename: If there's a conflict with
any file, have the Dropbox server try to autorename that file to avoid
the conflict.
"""
__slots__ = [
'_entries_value',
'_entries_present',
'_autorename_value',
'_autorename_present',
]
_has_required_fields = True
def __init__(self,
entries=None,
autorename=None):
self._entries_value = None
self._entries_present = False
self._autorename_value = None
self._autorename_present = False
if entries is not None:
self.entries = entries
if autorename is not None:
self.autorename = autorename
@property
def entries(self):
"""
List of entries to be moved or copied. Each entry is
:class:`RelocationPath`.
:rtype: list of [RelocationPath]
"""
if self._entries_present:
return self._entries_value
else:
raise AttributeError("missing required field 'entries'")
@entries.setter
def entries(self, val):
val = self._entries_validator.validate(val)
self._entries_value = val
self._entries_present = True
@entries.deleter
def entries(self):
self._entries_value = None
self._entries_present = False
@property
def autorename(self):
"""
If there's a conflict with any file, have the Dropbox server try to
autorename that file to avoid the conflict.
:rtype: bool
"""
if self._autorename_present:
return self._autorename_value
else:
return False
@autorename.setter
def autorename(self, val):
val = self._autorename_validator.validate(val)
self._autorename_value = val
self._autorename_present = True
@autorename.deleter
def autorename(self):
self._autorename_value = None
self._autorename_present = False
def _process_custom_annotations(self, annotation_type, field_path, processor):
super(RelocationBatchArgBase, self)._process_custom_annotations(annotation_type, field_path, processor)
def __repr__(self):
return 'RelocationBatchArgBase(entries={!r}, autorename={!r})'.format(
self._entries_value,
self._autorename_value,
)
RelocationBatchArgBase_validator = bv.Struct(RelocationBatchArgBase)
class MoveBatchArg(RelocationBatchArgBase):
"""
:ivar files.MoveBatchArg.allow_ownership_transfer: Allow moves by owner even
if it would result in an ownership transfer for the content being moved.
This does not apply to copies.
"""
__slots__ = [
'_allow_ownership_transfer_value',
'_allow_ownership_transfer_present',
]
_has_required_fields = True
def __init__(self,
entries=None,
autorename=None,
allow_ownership_transfer=None):
super(MoveBatchArg, self).__init__(entries,
autorename)
self._allow_ownership_transfer_value = None
self._allow_ownership_transfer_present = False
if allow_ownership_transfer is not None:
self.allow_ownership_transfer = allow_ownership_transfer
@property
def allow_ownership_transfer(self):
"""
Allow moves by owner even if it would result in an ownership transfer
for the content being moved. This does not apply to copies.
:rtype: bool
"""
if self._allow_ownership_transfer_present:
return self._allow_ownership_transfer_value
else:
return False
@allow_ownership_transfer.setter
def allow_ownership_transfer(self, val):
val = self._allow_ownership_transfer_validator.validate(val)
self._allow_ownership_transfer_value = val
self._allow_ownership_transfer_present = True
@allow_ownership_transfer.deleter
def allow_ownership_transfer(self):
self._allow_ownership_transfer_value = None
self._allow_ownership_transfer_present = False
def _process_custom_annotations(self, annotation_type, field_path, processor):
super(MoveBatchArg, self)._process_custom_annotations(annotation_type, field_path, processor)
def __repr__(self):
return 'MoveBatchArg(entries={!r}, autorename={!r}, allow_ownership_transfer={!r})'.format(
self._entries_value,
self._autorename_value,
self._allow_ownership_transfer_value,
)
MoveBatchArg_validator = bv.Struct(MoveBatchArg)
class PhotoMetadata(MediaMetadata):
"""
Metadata for a photo.
"""
__slots__ = [
]
_has_required_fields = False
def __init__(self,
dimensions=None,
location=None,
time_taken=None):
super(PhotoMetadata, self).__init__(dimensions,
location,
time_taken)
def _process_custom_annotations(self, annotation_type, field_path, processor):
super(PhotoMetadata, self)._process_custom_annotations(annotation_type, field_path, processor)
def __repr__(self):
return 'PhotoMetadata(dimensions={!r}, location={!r}, time_taken={!r})'.format(
self._dimensions_value,
self._location_value,
self._time_taken_value,
)
PhotoMetadata_validator = bv.Struct(PhotoMetadata)
class PreviewArg(bb.Struct):
"""
:ivar files.PreviewArg.path: The path of the file to preview.
:ivar files.PreviewArg.rev: Please specify revision in ``path`` instead.
"""
__slots__ = [
'_path_value',
'_path_present',
'_rev_value',
'_rev_present',
]
_has_required_fields = True
def __init__(self,
path=None,
rev=None):
self._path_value = None
self._path_present = False
self._rev_value = None
self._rev_present = False
if path is not None:
self.path = path
if rev is not None:
self.rev = rev
@property
def path(self):
"""
The path of the file to preview.
:rtype: str
"""
if self._path_present:
return self._path_value
else:
raise AttributeError("missing required field 'path'")
@path.setter
def path(self, val):
val = self._path_validator.validate(val)
self._path_value = val
self._path_present = True
@path.deleter
def path(self):
self._path_value = None
self._path_present = False
@property
def rev(self):
"""
Please specify revision in ``path`` instead.
:rtype: str
"""
if self._rev_present:
return self._rev_value
else:
return None
@rev.setter
def rev(self, val):
if val is None:
del self.rev
return
val = self._rev_validator.validate(val)
self._rev_value = val
self._rev_present = True
@rev.deleter
def rev(self):
self._rev_value = None
self._rev_present = False
def _process_custom_annotations(self, annotation_type, field_path, processor):
super(PreviewArg, self)._process_custom_annotations(annotation_type, field_path, processor)
def __repr__(self):
return 'PreviewArg(path={!r}, rev={!r})'.format(
self._path_value,
self._rev_value,
)
PreviewArg_validator = bv.Struct(PreviewArg)
class PreviewError(bb.Union):
"""
This class acts as a tagged union. Only one of the ``is_*`` methods will
return true. To get the associated value of a tag (if one exists), use the
corresponding ``get_*`` method.
:ivar LookupError PreviewError.path: An error occurs when downloading
metadata for the file.
:ivar files.PreviewError.in_progress: This preview generation is still in
progress and the file is not ready for preview yet.
:ivar files.PreviewError.unsupported_extension: The file extension is not
supported preview generation.
:ivar files.PreviewError.unsupported_content: The file content is | |
<gh_stars>10-100
import os
import sys
import json
import argparse
sys.path.append('../')
import numpy as np
import pandas as pd
from aser.extract.eventuality_extractor import SeedRuleEventualityExtractor
from tqdm import tqdm
from utils.atomic_utils import SUBJ2POSS, PP_SINGLE
from itertools import permutations
from itertools import chain
from utils.utils import *
from multiprocessing import Pool
def prepare_atomic2020():
omcs_relations = ['Causes', 'HasSubEvent', 'xReason',]
atomic_new_relations = ['isAfter', 'isBefore', 'HinderedBy']
event_relations = omcs_relations + atomic_new_relations
atomic_2020 = {
"trn": pd.read_csv("../data/atomic2020_data-feb2021/train.tsv", sep="\t"),
"dev": pd.read_csv("../data/atomic2020_data-feb2021/dev.tsv", sep="\t"),
"tst": pd.read_csv("../data/atomic2020_data-feb2021/test.tsv", sep="\t"),
}
atomic_2020_events = {
"trn":[(atomic_2020["trn"].loc[i][0], atomic_2020["trn"].loc[i][1], atomic_2020["trn"].loc[i][2])\
for i in range(len(atomic_2020["trn"])) \
if atomic_2020["trn"].loc[i][1] in event_relations],
"dev":[(atomic_2020["dev"].loc[i][0], atomic_2020["dev"].loc[i][1], atomic_2020["dev"].loc[i][2])\
for i in range(len(atomic_2020["dev"])) \
if atomic_2020["dev"].loc[i][1] in event_relations],
"tst":[(atomic_2020["tst"].loc[i][0], atomic_2020["tst"].loc[i][1], atomic_2020["tst"].loc[i][2])\
for i in range(len(atomic_2020["tst"])) \
if atomic_2020["tst"].loc[i][1] in event_relations],
}
new_atomic_tuples = {"trn":[], "tst":[], "dev":[]}
for r in ["trn", "dev", "tst"]:
for head, rel, tail in tqdm(atomic_2020_events[r]):
if rel in atomic_new_relations:
new_atomic_tuples[r].append((head, rel, tail))
return new_atomic_tuples
def simple_parse(sent):
"""
Deal with possessive cases only.
"""
strs = sent.split()
new_tokens = []
for token in strs:
if token.endswith("'s") and token != "'s":
new_tokens.append(token[:-2])
new_tokens.append("'s")
else:
new_tokens.append(token)
return new_tokens
def instantiate_ppn(head, tail):
"""
Input: Head and Tail in the original CSKG.
e.g., head = "PersonX takes PersonY's phone",
tail = "PersonY is sad"
Output: list(tuple())
A list of tuples with concrete personal pronouns.
[(he takes her phone, she is sad), (he takes my phone, i am sad), ...]
"""
# 1. Manually process possessive cases, the most common parsing issue in the dataset.
head_strs = simple_parse(head)
tail_strs = simple_parse(tail)
if not (len(head_strs) > 0 and len(tail_strs) > 0):
return []
# 2. dictionary that stores the indecies of "PersonX", "PersonY", and "PersonZ"
# Personal pronoun dict
pp_dict = {"head":{}, "tail":{}}
for key, strs in {"head":head_strs, "tail":tail_strs}.items():
for i, word in enumerate(strs):
if word in ["PersonX", "PersonY", "PersonZ"]:
pp_dict[key][word] = pp_dict[key].get(word, []) + [i]
# 3. get the PersonX -> he/she permutation
all_cs_pp = set(pp_dict["head"].keys()) | set(pp_dict["tail"].keys())
# commonsense PPs, PersonX/Y
num_special_pp = len(all_cs_pp)
# number of personal pronoun placeholders.
perm_pp = list(permutations(PP_SINGLE, num_special_pp))
# print(perm_pp)
# 4. Replace
result_tuples = []
for perm in perm_pp:
if len(set(perm)) < num_special_pp :
# Make sure the permutation contains distinct PPs
continue
to_pp_single_dict = {cs_pp:perm[i] for i, cs_pp in enumerate(all_cs_pp)}
result_tuple = {"head":"", "tail":""}
for key, strs in {"head":head_strs, "tail":tail_strs}.items():
replacements = [to_pp_single_dict.get(token, token)\
for i, token in enumerate(strs)]
# 4.1 Possessive case processing
if "'s" in strs:
# Convert I 's -> my, he 's -> his
for cs_pp in pp_dict[key]: #PersonX/Y/Z
for idx in pp_dict[key][cs_pp]:
# if this pp need to be substitute
if replacements[idx] in SUBJ2POSS and \
replacements[min(idx+1, len(replacements)-1)] == "'s":
replacements[idx] = SUBJ2POSS[replacements[idx]]
replacements[idx+1] = "\REMOVE"
while "\REMOVE" in replacements:
replacements.remove("\REMOVE")
# 4.2 dealing with singular formats
if "is" in replacements:
for i in range(len(replacements)-1):
if replacements[i] == "i" and replacements[i+1] == "is":
replacements[i+1] = "am"
if replacements[i] == "you" and replacements[i+1] == "is":
replacements[i+1] = "are"
# if no need to deal with possessive case
# simply replace PersonX/Y/Z with he/she.
result_tuple[key] = " ".join(replacements)
result_tuples.append((result_tuple["head"], result_tuple["tail"]))
return result_tuples
def fill_sentence(sent, r, has_subject):
if r in ['xEffect']:
# + subject
if has_subject:
return [sent]
else:
return [' '.join(["PersonX", sent])]
elif r in ['oEffect']:
if has_subject:
return [sent]
else:
return [' '.join(["PersonY", sent])]
elif r in ['oReact', 'xReact']:
# + subject / + subject is
if has_subject:
return [sent]
else:
if r == "oReact":
return [' '.join(["PersonY", sent])] + \
[' '.join(["PersonY", 'is', sent])]
else:
return [' '.join(["PersonX", sent])] + \
[' '.join(["PersonX", 'is', sent])]
elif r in ['xAttr']:
# + subject is
if has_subject:
return [sent]
else:
return [' '.join(["PersonX", 'is', sent])]
elif r in ['oWant', 'xWant']:
# + subject want / + subject
if has_subject:
return [sent]
else:
# if start with 'to'
if r == "oWant":
if sent.lower().split()[0] == 'to':
return [' '.join(["PersonY", 'want', sent])] \
+ [' '.join(["PersonY", " ".join(sent.lower().split()[1:]) ]) ]
else:
return [' '.join(["PersonY", 'want to', sent])] \
+ [' '.join(["PersonY", sent]) ]
else:
if sent.lower().split()[0] == 'to':
return [' '.join(["PersonX", 'want', sent])] \
+ [' '.join(["PersonX", " ".join(sent.lower().split()[1:]) ]) ]
else:
return [' '.join(["PersonX", 'want to', sent])] \
+ [' '.join(["PersonX", sent]) ]
elif r in ['xIntent']:
# + subject intent / + subject
if has_subject:
return [sent]
else:
# if start with 'to'
if sent.lower().split()[0] == 'to':
return [' '.join(["PersonX", 'intent', sent]) ] \
+ [' '.join(["PersonX", " ".join(sent.lower().split()[1:]) ]) ]
else:
return [' '.join(["PersonX", 'intent to', sent]) ]\
+ [' '.join(["PersonX", sent]) ]
elif r in ['xNeed']:
# + subject need / + subject
if has_subject:
return [sent]
else:
# if start with 'to'
if sent.lower().split()[0] == 'to':
return [' '.join(["PersonX", 'need', sent]) ]\
+ [' '.join(["PersonX", " ".join(sent.lower().split()[1:]) ]) ]
else:
return [' '.join(["PersonX", 'need to', sent]) ]\
+ [' '.join(["PersonX", sent]) ]
def unfold_parse_results(e):
# return the words of the extractor results
if len(e) == 0:
return ""
if len(e[0]) == 0:
return ""
return " ".join(e[0][0].words)
def contain_subject(dependencies):
return any(dep in [item[1] for item in dependencies] for dep in ['nsubj', 'nsubjpass'])
def process_pp(sent):
"""
Deal with the situation of "person x", "person y", "personx", "persony"
"""
fill_words = {"person x":"PersonX", "person y":"PersonY",
"personx":"PersonX", "persony":"PersonY",}
single_word_filter = {"x":"PersonX", "y": "PersonY"}
for strs in PP_filter_list:
if strs in sent:
sent = sent.replace(strs, fill_words[strs])
sent_split = sent.split()
if "x" in sent_split or "y" in sent_split:
sent = " ".join([single_word_filter.get(item, item) for item in sent_split])
return sent
def parse(atomic_data, r, idx):
extracted_event_list = [[] for i in range(len(atomic_data))]
parse_cache = {}
for i in tqdm(range(idx, len(atomic_data), num_thread)):
if i in wc_idx or i in clause_idx:
continue
tmp_node = []
head = atomic_data["event"][i]
for tail_raw in json.loads(atomic_data[r][i]):
if tail_raw == 'none':
continue
# filter the text
tail_raw = tail_raw.lower()
tail_raw = process_pp(tail_raw)
parsed_result = e_extractor.parse_text(tail_raw)[0]
filled_sentences = fill_sentence(tail_raw, r,
tail_raw.startswith("PersonX") or tail_raw.startswith("PersonY"))
# or contain_subject(parsed_result['dependencies']))
candi_tuples = list(chain(*[instantiate_ppn(head, tail) for tail in filled_sentences]))
head_dict = {h:"" for h, _ in candi_tuples}
tail_dict = {t:"" for _, t in candi_tuples}
for h in head_dict:
if not h in parse_cache:
parse_cache[h] = unfold_parse_results(e_extractor.extract_from_text(h))
head_dict[h] = parse_cache[h]
for t in tail_dict:
if not t in parse_cache:
parse_cache[t] = unfold_parse_results(e_extractor.extract_from_text(t))
tail_dict[t] = parse_cache[t]
tmp_node.append([
(
head_dict[h],
tail_dict[t],
) for h, t in candi_tuples])
extracted_event_list[i] = tmp_node
return extracted_event_list
def parse_cn(tuples, idx):
extracted_event_list = [[] for i in range(len(tuples))]
parse_cache = {}
for i in tqdm(range(idx, len(tuples), num_thread)):
head, rel, tail = tuples[i]
if not isinstance(head, str) or not isinstance(tail, str):
continue
if dataset == "conceptnet":
head = "PersonX " + head.lower()
tail = "PersonX " + tail.lower()
# filter the text
tail_raw = process_pp(tail)
candi_tuples = instantiate_ppn(head, tail)
head_dict = {h:"" for h, _ in candi_tuples}
tail_dict = {t:"" for _, t in candi_tuples}
for h in head_dict:
if not h in parse_cache:
parse_cache[h] = unfold_parse_results(e_extractor.extract_from_text(h))
head_dict[h] = parse_cache[h]
for t in tail_dict:
if not t in parse_cache:
parse_cache[t] = unfold_parse_results(e_extractor.extract_from_text(t))
tail_dict[t] = parse_cache[t]
tmp_node= [
(
head_dict[h],
tail_dict[t],
) for h, t in candi_tuples]
extracted_event_list[i] = [tmp_node, rel]
return extracted_event_list
parser = argparse.ArgumentParser()
parser.add_argument("--relation", default='xWant', type=str, required=False,
choices=['oEffect', 'oReact', 'oWant', 'xAttr',
'xEffect', 'xIntent', 'xNeed', 'xReact', 'xWant'],
help="choose which relation to process")
parser.add_argument("--dataset", default='atomic', type=str, required=False,
choices=['atomic', 'atomic2020', 'conceptnet'],
help="dataset")
parser.add_argument("--port", default=14000, type=int, required=False,
help="port of stanford parser")
args = parser.parse_args()
e_extractor = SeedRuleEventualityExtractor(
corenlp_path = "/data/aser/stanford-corenlp-full-2018-02-27",
corenlp_port= args.port)
PP_filter_list = ["person x", "person y", "personx", "persony"]
dataset = args.dataset
if dataset == "atomic":
atomic_data = pd.read_csv('../data/v4_atomic_all_agg.csv')
clause_idx = np.load('../data/clause_idx.npy', allow_pickle=True)
wc_idx = np.load('../data/wildcard_idx.npy', allow_pickle=True)
num_thread = 5
relation = args.relation
# all_results = parse(atomic_data, args.relation, 0)
num_thread = 5
workers = Pool(num_thread)
all_results = []
for i in range(num_thread):
tmp_result = workers.apply_async(
parse,
args=(atomic_data, relation, i))
all_results.append(tmp_result)
workers.close()
workers.join()
all_results = [tmp_result.get() for tmp_result in all_results]
all_results = [list(chain(*item)) for item in zip(*all_results)]
if not os.path.exists('../data/new_matching'):
os.mkdir('../data/new_matching')
if not os.path.exists('../data/new_matching/ASER-format-words'):
os.mkdir('../data/new_matching/ASER-format-words')
np.save('../data/new_matching/ASER-format-words/ATOMIC_'+relation, all_results)
elif dataset == "conceptnet":
omcs_tuples = np.load("../data/omcs_tuples.npy", allow_pickle=True)[()]
for spl in ["trn", "dev", "tst"]:
num_thread = 5
| |
<gh_stars>0
# -*- coding: utf-8 -*-
import uqra, unittest,warnings,os, sys
from tqdm import tqdm
import numpy as np, scipy as sp
from uqra.solver.PowerSpectrum import PowerSpectrum
from uqra.environment import Kvitebjorn as Kvitebjorn
from sklearn import datasets
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import KFold
import pickle
warnings.filterwarnings(action="ignore", module="scipy", message="^internal gelsd")
sys.stdout = uqra.utilities.classes.Logger()
data_dir = '/Users/jinsongliu/BoxSync/MUSELab/uqra/examples/JupyterNotebook'
class BasicTestSuite(unittest.TestCase):
"""Basic test cases."""
def test_mPCE(self):
foo = lambda x: x**3 + 0.5*x + np.random.randn(*x.shape)
dist = cp.Normal()
x = dist.sample(1000).reshape(1,-1)
print(x.shape)
y = np.squeeze(np.array([foo(x), foo(x)]).T)
print(y.shape)
# basis = cp.orth_ttr(5, dist)
foo_hat = uqra.PCE(5, dist)
foo_hat.fit(x, y, method='OLS')
y_pred = foo_hat.predict(x)
print(y_pred.shape)
foo_hat = uqra.mPCE(5, dist)
foo_hat.fit(x, y, method='OLS')
y_pred = foo_hat.predict(x)
print(y_pred.shape)
def test_moments(self):
# np.set_printoptions(precision=3)
data_dir = '/Volumes/External/MUSE_UQ_DATA/Ishigami/Data'
y = []
for r in range(10):
filename = 'DoE_McsE6R{:d}.npy'.format(r)
data_set = np.load(os.path.join(data_dir, filename))
y.append(data_set[-1,:])
moments = uqra.metrics.moment(np.array(y),moment=[1,2,3,4], axis=1, multioutput='raw_values')
print(np.mean(moments, axis=1))
print(np.std(moments, axis=1))
print('--> GLK')
y = []
for r in range(10):
filename = 'DoE_McsE6R{:d}_PCE6_GLK.npy'.format(r)
data_set = np.load(os.path.join(data_dir, filename))
y.append(data_set)
moments = uqra.metrics.moment(np.array(y),moment=[1,2,3,4], axis=1, multioutput='raw_values')
print(np.mean(moments, axis=1))
print(np.std(moments, axis=1))
print('--> OLS')
y = []
for r in range(10):
filename = 'DoE_McsE6R{:d}_PCE9_OLS.npy'.format(r)
data_set = np.load(os.path.join(data_dir, filename))
y.append(data_set)
moments = uqra.metrics.moment(np.array(y),moment=[1,2,3,4], axis=1, multioutput='raw_values')
print(np.mean(moments, axis=1))
print(np.std(moments, axis=1))
print('--> OLSLARS')
y = []
for r in range(10):
filename = 'DoE_McsE6R{:d}_PCE9_OLSLARS.npy'.format(r)
data_set = np.load(os.path.join(data_dir, filename))
y.append(data_set)
moments = uqra.metrics.moment(np.array(y),moment=[1,2,3,4], axis=1, multioutput='raw_values')
print(np.mean(moments, axis=1))
print(np.std(moments, axis=1))
print('--> LASSOLARS')
y = []
for r in range(10):
filename = 'DoE_McsE6R{:d}_PCE9_LASSOLARS.npy'.format(r)
data_set = np.load(os.path.join(data_dir, filename))
y.append(data_set)
moments = uqra.metrics.moment(np.array(y),moment=[1,2,3,4], axis=1, multioutput='raw_values')
print(np.mean(moments, axis=1))
print(np.std(moments, axis=1))
def test_loo(self):
# Loading some example data
X, y = datasets.load_boston(return_X_y=True)
# X = X[:100,:2]
# y = y[:100]
# X = np.array([[0, 0], [1, 1], [2, 2]])
# y = np.array([0, 1, 2])
# print(X.shape)
print(y[:5])
# Training classifiers
reg1 = LinearRegression()
reg1.fit(X,y)
y1 = reg1.predict(X)
# print(reg1.coef_)
print(y1[:5])
# b = np.linalg.lstsq(X,y)[0]
# # print(b)
# y2 = np.dot(X, np.array(b))
# print(y2[:5])
mse = []
kf = KFold(n_splits=X.shape[0])
residual = []
for train_index, test_index in kf.split(X):
X_train, X_test = X[train_index], X[test_index]
y_train, y_test = y[train_index], y[test_index]
# H1 = np.linalg.inv(np.dot(X_train.T, X_train))
# H2 = np.dot(H1, X_train.T)
# H3 = np.dot(H2, y_train)
# y_hat = np.dot(X_test, H3)
# residual.append(y_test[0]- y_hat[0])
reg1.fit(X_train, y_train)
y_pred = reg1.predict(X_test)
residual.append(y_test[0] - y_pred[0])
# mse.append(uqra.metrics.mean_squared_error(y_test, y_pred))
Q, R = np.linalg.qr(X)
H = np.dot(Q, Q.T)
h = np.diagonal(H)
y_hat = np.dot(H, y)
e = (y-y_hat)/(1-h)
print(y_hat[:5])
print('e:')
print(np.mean(np.array(residual)**2))
print(np.mean(np.array(e)**2))
# print(uqra.metrics.leave_one_out_error(X,y,is_adjusted=False))
# print(np.mean(mse))
def test_QuadratureDesign(self):
print('>>> 1D quadrature design:')
p = 4
doe = uqra.QuadratureDesign(p, ndim=1, dist_names=['uniform',])
doe.samples()
print(' Legendre:')
print(' {:<15s} : {}'.format('Abscissa', np.around(doe.u, 2)))
print(' {:<15s} : {}'.format('Weights' , np.around(doe.w, 2)))
doe = uqra.QuadratureDesign(p, ndim=1, dist_names=['normal',])
doe.samples()
print(' Hermite:')
print(' {:<15s} : {}'.format('Abscissa', np.around(doe.u, 2)))
print(' {:<15s} : {}'.format('Weights' , np.around(doe.w, 2)))
print('>>> 1D quadrature design: Changing interval ')
a = -np.pi
b = np.pi
loc = a
scale = b - loc
print(' Legendre ({},{})'.format(np.around(a,2), np.around(b,2)))
doe = uqra.QuadratureDesign(p, ndim=1, dist_names=['uniform',])
doe.samples()
print(' From chaning inverval after uqra.doe:')
print(' {:<15s} : {}'.format('Abscissa', np.around((b-a)/2*doe.u + (a+b)/2, 2)))
print(' {:<15s} : {}'.format('Weights' , np.around((b-a)/2*doe.w, 2)))
doe = uqra.QuadratureDesign(p, ndim=1, dist_names=['uniform',], dist_theta=[(loc, scale)])
doe.samples()
print(' Directly from uqra.doe:')
print(' {:<15s} : {}'.format('Abscissa', np.around(doe.u, 2)))
print(' {:<15s} : {}'.format('Weights' , np.around(doe.w, 2)))
print('>>> 2D quadrature design:')
p = 4
doe = uqra.QuadratureDesign(p, ndim=2, dist_names=['uniform',])
doe.samples()
print(' Legendre:')
print(' {:<15s} :\n {}'.format('Abscissa', np.around(doe.u, 2)))
print(' {:<15s} :\n {}'.format('Weights' , np.around(doe.w, 2)))
doe = uqra.QuadratureDesign(p, ndim=2, dist_names=['normal',])
doe.samples()
print(' Hermite:')
print(' {:<15s} :\n {}'.format('Abscissa', np.around(doe.u, 2)))
print(' {:<15s} :\n {}'.format('Weights' , np.around(doe.w, 2)))
def test_RandomDesign(self):
doe = uqra.RandomDesign('MCS', n_samples=1e6, ndim=3, dist_names='uniform', dist_theta=[(-np.pi, 2*np.pi),]*3)
doe.samples()
def test_LatinHyperCube(self):
doe = uqra.LHS(distributions=[sp.stats.norm,]*2)
doe_u, doe_x = doe.samples(2000)
print(doe_x.shape)
print(np.mean(doe_x, axis=1))
print(np.std(doe_x, axis=1))
np.save('/Users/jinsongliu/BoxSync/PhD_UT/Working_Papers/AdaptiveSparsePCE_OED/Data/LHS_Normal_2000', doe_x)
# doe = uqra.LHS(n_samples=1e3,dist_names=['uniform', 'norm'],ndim=2,dist_theta=[(-1, 2*2), (2,1)])
# doe.samples()
# print(np.mean(doe.x, axis=1))
# print(np.std(doe.x, axis=1))
def test_OptimalDesign(self):
"""
Optimal Design
"""
### Ishigami function
# data_dir = '/Users/jinsongliu/External/MUSE_UQ_DATA/Ishigami/Data'
### SDOF system
data_dir = '/Users/jinsongliu/External/MUSE_UQ_DATA/linear_oscillator/Data'
# data_dir = 'E:\Run_MUSEUQ'
np.random.seed(100)
# dist_x = cp.Normal()
dist_u= cp.Iid(cp.Normal(),2)
u_samples = dist_u.sample(100)
basis = cp.orth_ttr(10,dist_u)
X = basis(*u_samples).T
doe = uqra.OptimalDesign('D', n_samples=10)
doe_index = doe.samples(X, is_orth=True)
doe_index = doe.adaptive(X, n_samples=10)
print(doe_index)
doe_index = doe.adaptive(X, n_samples=10)
print(doe_index)
### 2D
# quad_orders = range(4,11)
# alpha = [1.0, 1.1, 1.3, 1.5, 2.0,2.5, 3.0,3.5, 5]
# dist_u= cp.Iid(cp.Normal(),2)
# for iquad_orders in quad_orders:
# basis = cp.orth_ttr(iquad_orders-1,dist_u)
# for r in range(10):
# filename = 'DoE_McsE6R{:d}_stats.npy'.format(r)
# data_set = np.load(os.path.join(data_dir, filename))
# samples_y = np.squeeze(data_set[:,4,:]).T
# filename = 'DoE_McsE6R{:d}.npy'.format(r)
# data_set = np.load(os.path.join(data_dir, filename))
# samples_u = data_set[0:2, :]
# samples_x = data_set[2:4, :]
# # samples_y = data_set[6 , :].reshape(1,-1)
# print('Quadrature Order: {:d}'.format(iquad_orders))
# print('Candidate samples filename: {:s}'.format(filename))
# print(' >> Candidate sample set shape: {}'.format(samples_u.shape))
# design_matrix = basis(*samples_u).T
# print(' >> Candidate Design matrix shape: {}'.format(design_matrix.shape))
# for ia in alpha:
# print(' >> Oversampling rate : {:.2f}'.format(ia))
# doe_size = min(int(len(basis)*ia), 10000)
# doe = uqra.OptimalDesign('S', n_samples = doe_size )
# doe.samples(design_matrix, u=samples_u, is_orth=True)
# data = np.concatenate((doe.I.reshape(1,-1),doe.u,samples_x[:,doe.I], samples_y[:,doe.I]), axis=0)
# filename = os.path.join(data_dir, 'DoE_McsE6R{:d}_p{:d}_OptS{:d}'.format(r,iquad_orders,doe_size))
# np.save(filename, data)
# for ia in alpha:
# print(' >> Oversampling rate : {:.2f}'.format(ia))
# doe_size = min(int(len(basis)*ia), 10000)
# doe = uqra.OptimalDesign('D', n_samples = doe_size )
# doe.samples(design_matrix, u=samples_u, is_orth=True)
# data = np.concatenate((doe.I.reshape(1,-1),doe.u,samples_x[:,doe.I], samples_y[:,doe.I]), axis=0)
# filename = os.path.join(data_dir, 'DoE_McsE6R{:d}_p{:d}_OptD{:d}'.format(r,iquad_orders,doe_size))
# np.save(filename, data)
def test_gauss_quadrature(self):
"""
https://keisan.casio.com/exec/system/1329114617
"""
print('========================TESTING: 1D GAUSS QUADRATURE=======================')
dists2test = [cp.Uniform(-1,1), cp.Normal(), cp.Gamma(1,1), cp.Beta(1,1)]
rules2test = ['leg', 'hem', 'lag', 'jacobi']
order2test = [2,3,4,5,6,7,8]
for idist2test, irule2test in zip(dists2test, rules2test):
print('-'*50)
print('>>> Gauss Quadrature with polynominal: {}'.format(const.DOE_RULE_FULL_NAMES[irule2test.lower()]))
uqra.blockPrint()
quad_doe = uqra.DoE('QUAD', irule2test, order2test, idist2test)
uqra_samples = quad_doe.get_samples()
# quad_doe.disp()
uqra.enablePrint()
if irule2test == 'hem':
for i, iorder in enumerate(order2test):
print('>>> order : {}'.format(iorder))
coord1d_e, weight1d_e = np.polynomial.hermite_e.hermegauss(iorder)
print('{:<15s}: {}'.format('probabilist', np.around(coord1d_e,2)))
coord1d, weight1d = np.polynomial.hermite.hermgauss(iorder)
print('{:<15s}: {}'.format('physicist', np.around(coord1d,2)))
print('{:<15s}: {}'.format('uqra', np.around(np.squeeze(uqra_samples[i][:-1,:]),2)))
elif irule2test == 'leg':
for i, iorder in enumerate(order2test):
print('>>> order : {}'.format(iorder))
coord1d, weight1d = np.polynomial.legendre.leggauss(iorder)
print('{:<15s}: {}'.format('numpy ', np.around(coord1d,2)))
print('{:<15s}: {}'.format('uqra', np.around(np.squeeze(uqra_samples[i][:-1,:]),2)))
elif irule2test == 'lag':
for i, iorder in enumerate(order2test):
print('>>> order : {}'.format(iorder))
coord1d, weight1d = np.polynomial.laguerre.laggauss(iorder)
print('{:<15s}: {}'.format('numpy ', np.around(coord1d,2)))
print('{:<15s}: {}'.format('uqra', np.around(np.squeeze(uqra_samples[i][:-1,:]),2)))
elif irule2test == 'jacobi':
print('NOT TESTED YET')
print('Compared results here: https://keisan.casio.com/exec/system/1329114617')
def test_gpce(self):
print('==================TESTING: Generalized PCE (Not using SurrogateModel) ===================')
gpce_dist_to_test = [cp.Normal(), cp.Normal(2,3), cp.Gamma(1,1), cp.Beta(1,1)]
gpce_opt_dist = [cp.Normal(), cp.Normal(), cp.Gamma(1,1), cp.Beta(1,1)]
gpce_opt_rule = ['hem', 'hem', 'lag', 'jacobi']
npoly_orders = range(2,5)
dist_zeta0 = cp.Normal()
for i, igpce_dist in enumerate(gpce_dist_to_test):
dist_zeta1 = gpce_opt_dist[i]
print('>>> Testing # {:d}: gpce: {}, zeta0: {} , zeta1: {}'.format(i, igpce_dist, dist_zeta0, dist_zeta1 ))
for ipoly_order in npoly_orders:
print(' Polynomial order: {:d}'.format(ipoly_order))
## gPCE with hermite chaos
uqra.blockPrint()
quad_doe = uqra.DoE('QUAD', 'hem', [ipoly_order+1], dist_zeta0)
samples_zeta= quad_doe.get_samples()
zeta_cor, zeta_weight = samples_zeta[0]
zeta_cor = zeta_cor.reshape((len(dist_zeta0),-1))
x_cor = igpce_dist.inv(dist_zeta0.cdf(zeta_cor))
zeta_poly, zeta_norms = cp.orth_ttr(ipoly_order, dist_zeta0, retall=True)
x_hat,coeffs = cp.fit_quadrature(zeta_poly, zeta_cor, zeta_weight,np.squeeze(x_cor),retall=True)
uqra.enablePrint()
print('\t Hermite: {}'.format( np.around(coeffs,4)))
## gPCE with optimal chaos
uqra.blockPrint()
quad_doe = uqra.DoE('QUAD', gpce_opt_rule[i], [ipoly_order+1], dist_zeta1)
samples_zeta= quad_doe.get_samples()
zeta_cor, zeta_weight = samples_zeta[0]
zeta_cor = zeta_cor.reshape((len(dist_zeta1),-1))
x_cor = igpce_dist.inv(dist_zeta1.cdf(zeta_cor))
zeta_poly, zeta_norms = cp.orth_ttr(ipoly_order, dist_zeta1, retall=True)
x_hat,coeffs = cp.fit_quadrature(zeta_poly, zeta_cor, zeta_weight, np.squeeze(x_cor), retall=True)
uqra.enablePrint()
print('\t Optimal: {}'.format( np.around(coeffs,4)))
def test_PowerSpectrum(self):
print('========================TESTING: Power Spectrum =======================')
powerspecturms2test = ['jonswap']
powerspecturms_args = [(8, 10)]
df = 0.00001
f = np.arange(0, 10, df)
for psd_name, psd_args in zip(powerspecturms2test, powerspecturms_args):
psd = PowerSpectrum(psd_name, *psd_args)
psd_f, psd_pxx = psd.get_pxx(f)
psd_area = np.sum(psd_pxx * df)
np.save(os.path.join(data_dir,psd_name+'_psd_f'), psd_f)
np.save(os.path.join(data_dir,psd_name+'_psd_pxx'), psd_pxx)
tau, acf = psd.get_acf()
np.save(os.path.join(data_dir,psd_name+'_tau'), tau)
np.save(os.path.join(data_dir,psd_name+'_acf'), acf)
t, eta = psd.gen_process()
np.save(os.path.join(data_dir,psd_name+'_t'), t)
np.save(os.path.join(data_dir,psd_name+'_eta'), eta)
print(t, eta)
# t, eta = psd._gen_process_sum()
print('PSD name: {:s}, args: {}, Area: {:.2f}, 4*std:{}'.format(psd_name, psd_args, psd_area, 4*np.std(eta)))
def test_weighted_exceedance(self):
print('========================TESTING: Weighted Exceedance =======================')
# x = np.random.normal(size=1000).reshape(1,-1)
# res1 = stats.cumfreq(x)
# cdf_x = res1.lowerlimit + np.linspace(0, res1.binsize*res1.cumcount.size, res1.cumcount.size)
# cdf_y = res1.cumcount/x.size
# ecdf_y = 1- cdf_y
# ecdf_x = cdf_x
# print(np.around(ecdf_x,2))
# print(np.around(ecdf_y,2))
# res2 = uqhelpers.get_weighted_exceedance(x)
# print(res2.shape)
# print(np.around(res2[0],2))
# print(np.around(res2[1],2))
# orders = [4] ## mcs
orders = range(3,10) ## quad
| |
registry_secret)
assert mount_path == path
if 'v1' in registry_api_versions:
assert get_plugin(plugins, "postbuild_plugins",
"pulp_push")
assert plugin_value_get(plugins, "postbuild_plugins", "pulp_push",
"args", "pulp_registry_name") == pulp_env
else:
with pytest.raises(NoSuchPluginException):
get_plugin(plugins, "postbuild_plugins",
"pulp_push")
if 'v2' in registry_api_versions:
assert get_plugin(plugins, "postbuild_plugins", "pulp_sync")
env = plugin_value_get(plugins, "postbuild_plugins", "pulp_sync",
"args", "pulp_registry_name")
assert env == pulp_env
pulp_secret = plugin_value_get(plugins, "postbuild_plugins",
"pulp_sync", "args",
"pulp_secret_path")
docker_registry = plugin_value_get(plugins, "postbuild_plugins",
"pulp_sync", "args",
"docker_registry")
# pulp_sync config must have the scheme part to satisfy pulp.
assert docker_registry == 'http://registry2.example.com:5000'
else:
with pytest.raises(NoSuchPluginException):
get_plugin(plugins, "postbuild_plugins", "pulp_sync")
if scratch:
with pytest.raises(NoSuchPluginException):
get_plugin(plugins, "postbuild_plugins", "compress")
with pytest.raises(NoSuchPluginException):
get_plugin(plugins, "postbuild_plugins", "tag_from_config")
with pytest.raises(NoSuchPluginException):
get_plugin(plugins, "postbuild_plugins", "import_image")
with pytest.raises(NoSuchPluginException):
get_plugin(plugins, "postbuild_plugins", "pulp_pull")
with pytest.raises(NoSuchPluginException):
get_plugin(plugins, "exit_plugins", "koji_promote")
with pytest.raises(NoSuchPluginException):
get_plugin(plugins, "exit_plugins", "koji_tag_build")
else:
assert get_plugin(plugins, "postbuild_plugins", "compress")
assert get_plugin(plugins, "postbuild_plugins", "tag_from_config")
assert get_plugin(plugins, "postbuild_plugins", "pulp_pull")
assert get_plugin(plugins, "exit_plugins", "koji_promote")
assert get_plugin(plugins, "exit_plugins", "koji_tag_build")
assert (get_plugin(plugins, "postbuild_plugins", "tag_by_labels")
.get('args', {}).get('unique_tag_only', False) == scratch)
@pytest.mark.parametrize(('extra_kwargs', 'expected_name'), (
({'isolated': True, 'release': '1.1'}, TEST_ISOLATED_BUILD_NAME),
({'scratch': True}, TEST_SCRATCH_BUILD_NAME),
({}, TEST_BUILD_CONFIG),
))
def test_render_build_name(self, tmpdir, extra_kwargs, expected_name):
build_request = BuildRequest(INPUTS_PATH)
kwargs = get_sample_prod_params()
kwargs.update(extra_kwargs)
build_request.set_params(**kwargs)
build_json = build_request.render()
assert fnmatch.fnmatch(build_json['metadata']['name'], expected_name)
def test_render_with_yum_repourls(self):
kwargs = {
'git_uri': TEST_GIT_URI,
'git_ref': TEST_GIT_REF,
'git_branch': TEST_GIT_BRANCH,
'user': "john-foo",
'component': TEST_COMPONENT,
'base_image': 'fedora:latest',
'name_label': 'fedora/resultingimage',
'registry_uri': "registry.example.com",
'openshift_uri': "http://openshift/",
'builder_openshift_url': "http://openshift/",
'koji_target': "koji-target",
'kojiroot': "http://root/",
'kojihub': "http://hub/",
'sources_command': "make",
'vendor': "Foo Vendor",
'authoritative_registry': "registry.example.com",
'distribution_scope': "authoritative-source-only",
'registry_api_versions': ['v1'],
'build_from': 'image:buildroot:latest',
'osbs_api': MockOSBSApi(),
}
build_request = BuildRequest(INPUTS_PATH)
# Test validation for yum_repourls parameter
kwargs['yum_repourls'] = 'should be a list'
with pytest.raises(OsbsValidationException):
build_request.set_params(**kwargs)
# Use a valid yum_repourls parameter and check the result
kwargs['yum_repourls'] = ['http://example.com/repo1.repo', 'http://example.com/repo2.repo']
build_request.set_params(**kwargs)
build_json = build_request.render()
plugins = get_plugins_from_build_json(build_json)
repourls = None
for d in plugins['prebuild_plugins']:
if d['name'] == 'add_yum_repo_by_url':
repourls = d['args']['repourls']
assert repourls is not None
assert len(repourls) == 2
assert 'http://example.com/repo1.repo' in repourls
assert 'http://example.com/repo2.repo' in repourls
with pytest.raises(NoSuchPluginException):
get_plugin(plugins, "prebuild_plugins", "check_and_set_rebuild")
with pytest.raises(NoSuchPluginException):
get_plugin(plugins, "prebuild_plugins",
"stop_autorebuild_if_disabled")
assert plugin_value_get(plugins, "prebuild_plugins", "bump_release",
"args", "hub") == "http://hub/"
with pytest.raises(NoSuchPluginException):
get_plugin(plugins, "prebuild_plugins", "koji")
with pytest.raises(NoSuchPluginException):
get_plugin(plugins, "postbuild_plugins", "pulp_push")
with pytest.raises(NoSuchPluginException):
get_plugin(plugins, "postbuild_plugins", "pulp_sync")
with pytest.raises(NoSuchPluginException):
get_plugin(plugins, "postbuild_plugins", "pulp_pull")
assert get_plugin(plugins, "postbuild_plugins", "import_image")
@pytest.mark.parametrize('odcs_insecure', [False, True, None])
@pytest.mark.parametrize('pdc_insecure', [False, True, None])
@pytest.mark.parametrize('odcs_openidc_secret', [None, "odcs-openidc"])
@pytest.mark.parametrize('compose_ids', (None, [], [42], [42, 2]))
def test_render_prod_flatpak(self, odcs_insecure, pdc_insecure,
odcs_openidc_secret, compose_ids):
build_request = BuildRequest(INPUTS_PATH)
kwargs = {
'git_uri': TEST_GIT_URI,
'git_ref': TEST_GIT_REF,
'git_branch': TEST_GIT_BRANCH,
'flatpak': True,
'compose_ids': compose_ids,
'flatpak_base_image': TEST_FLATPAK_BASE_IMAGE,
'odcs_url': "https://odcs.fedoraproject.org/odcs/1",
'pdc_url': "https://pdc.fedoraproject.org/rest_api/v1",
'user': "john-foo",
'base_image': TEST_FLATPAK_BASE_IMAGE,
'name_label': 'fedora/resultingimage',
'registry_uri': "registry.example.com",
'openshift_uri': "http://openshift/",
'builder_openshift_url': "http://openshift/",
'koji_target': "koji-target",
'kojiroot': "http://root/",
'kojihub': "http://hub/",
'sources_command': "make",
'vendor': "Foo Vendor",
'authoritative_registry': "registry.example.com",
'distribution_scope': "authoritative-source-only",
'registry_api_versions': ['v2'],
'build_from': 'image:buildroot:latest',
'osbs_api': MockOSBSApi(),
}
if odcs_insecure is not None:
kwargs['odcs_insecure'] = odcs_insecure
if pdc_insecure is not None:
kwargs['pdc_insecure'] = pdc_insecure
if odcs_openidc_secret is not None:
kwargs['odcs_openidc_secret'] = odcs_openidc_secret
build_request.set_params(**kwargs)
build_json = build_request.render()
plugins = get_plugins_from_build_json(build_json)
plugin = get_plugin(plugins, "prebuild_plugins", "resolve_module_compose")
assert plugin
args = plugin['args']
if compose_ids:
assert args['compose_ids'] == compose_ids
else:
assert 'compose_ids' not in args
assert args['odcs_url'] == kwargs['odcs_url']
assert args['odcs_insecure'] == (False if odcs_insecure is None else odcs_insecure)
assert args['pdc_url'] == kwargs['pdc_url']
assert args['pdc_insecure'] == (False if pdc_insecure is None else pdc_insecure)
if odcs_openidc_secret:
mount_path = get_secret_mountpath_by_name(build_json, odcs_openidc_secret)
assert args['odcs_openidc_secret_path'] == mount_path
else:
assert 'odcs_openid_secret_path' not in args
plugin = get_plugin(plugins, "prebuild_plugins", "flatpak_create_dockerfile")
assert plugin
args = plugin['args']
assert args['base_image'] == TEST_FLATPAK_BASE_IMAGE
plugin = get_plugin(plugins, "prebuild_plugins", "koji")
assert plugin
args = plugin['args']
assert args['target'] == "koji-target"
plugin = get_plugin(plugins, "prebuild_plugins", "bump_release")
assert plugin
args = plugin['args']
assert args['append'] is True
assert get_plugin(plugins, "prepublish_plugins", "flatpak_create_oci")
with pytest.raises(NoSuchPluginException):
assert get_plugin(plugins, "prepublish_plugins", "squash")
with pytest.raises(NoSuchPluginException):
assert get_plugin(plugins, "postbuild_plugins", "import_image")
def test_render_prod_not_flatpak(self):
build_request = BuildRequest(INPUTS_PATH)
kwargs = {
'git_uri': TEST_GIT_URI,
'git_ref': TEST_GIT_REF,
'git_branch': TEST_GIT_BRANCH,
'flatpak': False,
'user': "john-foo",
'base_image': 'fedora:latest',
'name_label': 'fedora/resultingimage',
'registry_uri': "registry.example.com",
'openshift_uri': "http://openshift/",
'builder_openshift_url': "http://openshift/",
'koji_target': "koji-target",
'kojiroot': "http://root/",
'kojihub': "http://hub/",
'sources_command': "make",
'vendor': "Foo Vendor",
'authoritative_registry': "registry.example.com",
'distribution_scope': "authoritative-source-only",
'registry_api_versions': ['v2'],
'build_from': 'image:buildroot:latest',
'osbs_api': MockOSBSApi(),
}
build_request.set_params(**kwargs)
build_json = build_request.render()
plugins = get_plugins_from_build_json(build_json)
with pytest.raises(NoSuchPluginException):
get_plugin(plugins, "prebuild_plugins", "resolve_module_compose")
with pytest.raises(NoSuchPluginException):
get_plugin(plugins, "prebuild_plugins", "flatpak_create_dockerfile")
with pytest.raises(NoSuchPluginException):
get_plugin(plugins, "prepublish_plugins", "flatpak_create_oci")
assert get_plugin(plugins, "prepublish_plugins", "squash")
assert get_plugin(plugins, "postbuild_plugins", "import_image")
@pytest.mark.parametrize(('hub', 'disabled', 'release'), (
('http://hub/', False, None),
('http://hub/', True, '1.2.1'),
(None, True, None),
(None, True, '1.2.1'),
))
@pytest.mark.parametrize('flatpak', (True, False))
def test_render_bump_release(self, hub, disabled, release, flatpak):
kwargs = {
'git_uri': TEST_GIT_URI,
'git_ref': TEST_GIT_REF,
'user': "john-foo",
'component': TEST_COMPONENT,
'base_image': 'fedora:latest',
'name_label': 'fedora/resultingimage',
'registry_uri': "registry.example.com",
'openshift_uri': "http://openshift/",
'sources_command': "make",
'vendor': "Foo Vendor",
'authoritative_registry': "registry.example.com",
'distribution_scope': "authoritative-source-only",
'registry_api_versions': ['v1'],
'build_from': 'image:buildroot:latest',
'osbs_api': MockOSBSApi(),
}
if hub:
kwargs['kojihub'] = hub
if release:
kwargs['release'] = release
if flatpak:
kwargs['flatpak'] = flatpak
build_request = BuildRequest(INPUTS_PATH)
build_request.set_params(**kwargs)
build_json = build_request.render()
plugins = get_plugins_from_build_json(build_json)
labels = plugin_value_get(plugins, "prebuild_plugins", "add_labels_in_dockerfile",
"args", "labels")
assert labels.get('release') == release
if disabled:
with pytest.raises(NoSuchPluginException):
get_plugin(plugins, "prebuild_plugins", "bump_release")
return
plugin_args = plugin_value_get(plugins, "prebuild_plugins", "bump_release", "args")
assert plugin_args['hub'] == hub
assert plugin_args.get('append', False) == flatpak
@pytest.mark.parametrize(('hub', 'root', 'disabled'), [
('http://hub/', 'http://root/', False),
(None, None, True),
])
@pytest.mark.parametrize(('allowed_domains'), [
[],
['spam.com'],
['spam', 'bacon.com'],
])
def test_render_fetch_maven_artifacts(self, hub, root, disabled, allowed_domains):
kwargs = {
'git_uri': TEST_GIT_URI,
'git_ref': TEST_GIT_REF,
'user': "john-foo",
'component': TEST_COMPONENT,
'base_image': 'fedora:latest',
'name_label': 'fedora/resultingimage',
'registry_uri': "registry.example.com",
'openshift_uri': "http://openshift/",
'sources_command': "make",
'vendor': "Foo Vendor",
'authoritative_registry': "registry.example.com",
'distribution_scope': "authoritative-source-only",
'registry_api_versions': ['v1'],
'build_from': 'image:buildroot:latest',
'osbs_api': MockOSBSApi(),
}
if hub:
kwargs['kojihub'] = hub
if root:
kwargs['kojiroot'] = root
if allowed_domains:
kwargs['artifacts_allowed_domains'] = allowed_domains
build_request = BuildRequest(INPUTS_PATH)
build_request.set_params(**kwargs)
build_json = build_request.render()
plugins = get_plugins_from_build_json(build_json)
if disabled:
with pytest.raises(NoSuchPluginException):
get_plugin(plugins, "prebuild_plugins", "fetch_maven_artifacts")
else:
assert plugin_value_get(plugins, "prebuild_plugins", "fetch_maven_artifacts",
"args", "koji_hub") == hub
assert plugin_value_get(plugins, "prebuild_plugins", "fetch_maven_artifacts",
"args", "koji_root") == root
if allowed_domains:
assert plugin_value_get(plugins, "prebuild_plugins", "fetch_maven_artifacts",
"args", "allowed_domains") == allowed_domains
else:
with pytest.raises(KeyError):
plugin_value_get(plugins, "prebuild_plugins", "fetch_maven_artifacts",
"args", "allowed_domains")
@pytest.mark.parametrize(('extra_kwargs', 'has_platform_tag', 'extra_tags', 'primary_tags'), (
# Worker build cases
({'build_type': BUILD_TYPE_WORKER, 'platform': 'x86_64'},
True, (), ()),
({'build_type': BUILD_TYPE_WORKER, 'platform': 'x86_64'},
True, ('tag1', 'tag2'), ()),
({'build_type': BUILD_TYPE_WORKER, 'platform': 'x86_64', 'scratch': True},
True, (), ()),
({'build_type': BUILD_TYPE_WORKER, 'platform': 'x86_64', 'isolated': True,
'release': '1.1'},
True, (), ()),
# Orchestrator build cases
({'build_type': BUILD_TYPE_ORCHESTRATOR, 'platforms': ['x86_64']},
False, ('tag1', 'tag2'), ('latest', '{version}', '{version}-{release}', 'tag1', 'tag2')),
({'build_type': BUILD_TYPE_ORCHESTRATOR, 'platforms': ['x86_64']},
False, (), ('latest', '{version}', '{version}-{release}')),
({'build_type': BUILD_TYPE_ORCHESTRATOR, 'platforms': ['x86_64'], 'scratch': True},
False, ('tag1', 'tag2'), ()),
({'build_type': BUILD_TYPE_ORCHESTRATOR, 'platforms': ['x86_64'], 'isolated': True,
'release': '1.1'},
False, ('tag1', 'tag2'), ('{version}-{release}',)),
# When build_type is not specified, no primary tags are set
({}, False, (), ()),
({}, False, ('tag1', 'tag2'), ()),
({'scratch': True}, False, (), ()),
({'isolated': True, 'release': '1.1'}, False, (), ()),
))
def test_render_tag_from_config(self, tmpdir, extra_kwargs, has_platform_tag, extra_tags,
primary_tags):
kwargs = get_sample_prod_params()
kwargs.pop('platforms', None)
kwargs.pop('platform', None)
kwargs.update(extra_kwargs)
kwargs['arrangement_version'] = 4
expected_primary = set(primary_tags)
if extra_tags:
self._mock_addional_tags_config(str(tmpdir), extra_tags)
repo_info = RepoInfo(additional_tags=AdditionalTagsConfig(dir_path=str(tmpdir)))
build_json = self._render_tag_from_config_build_request(kwargs, repo_info)
plugins = get_plugins_from_build_json(build_json)
assert get_plugin(plugins, 'postbuild_plugins', 'tag_from_config')
tag_suffixes = plugin_value_get(plugins, 'postbuild_plugins', 'tag_from_config',
'args', 'tag_suffixes')
assert len(tag_suffixes['unique']) == 1
if has_platform_tag:
unique_tag_suffix = tag_suffixes['unique'][0]
assert unique_tag_suffix.endswith('-' + kwargs.get('platform', '')) == has_platform_tag
assert len(tag_suffixes['primary']) == len(expected_primary)
assert set(tag_suffixes['primary']) == expected_primary
def test_render_tag_from_container_yaml(self):
kwargs = get_sample_prod_params()
kwargs.pop('platform', None)
kwargs['platforms'] = ['x86_64', 'ppc64le']
kwargs['build_type'] = BUILD_TYPE_ORCHESTRATOR
kwargs['arrangement_version'] = 3
tags = set(['spam', 'bacon', 'eggs'])
expected_primary = set(['{version}-{release}', 'spam', 'bacon', 'eggs'])
repo_info = RepoInfo(additional_tags=AdditionalTagsConfig(tags=tags))
build_json = self._render_tag_from_config_build_request(kwargs, repo_info=repo_info)
plugins = get_plugins_from_build_json(build_json)
tag_suffixes = plugin_value_get(plugins, 'postbuild_plugins', 'tag_from_config',
'args', 'tag_suffixes')
assert len(tag_suffixes['primary']) == len(expected_primary)
assert set(tag_suffixes['primary']) == expected_primary
def test_render_tag_from_container_yaml_contains_bad_tag(self):
kwargs = get_sample_prod_params()
kwargs.pop('platform', None)
kwargs['platforms'] = ['x86_64', 'ppc64le']
kwargs['build_type'] = BUILD_TYPE_ORCHESTRATOR
kwargs['arrangement_version'] = 3
expected_primary = set(['{version}-{release}', 'bacon', 'eggs'])
repo_info = RepoInfo(additional_tags=AdditionalTagsConfig(tags=expected_primary))
build_json = self._render_tag_from_config_build_request(kwargs, repo_info=repo_info)
plugins = get_plugins_from_build_json(build_json)
tag_suffixes = plugin_value_get(plugins, 'postbuild_plugins', 'tag_from_config',
'args', 'tag_suffixes')
assert len(tag_suffixes['primary']) == len(expected_primary)
assert set(tag_suffixes['primary']) == expected_primary
def test_render_tag_from_config_unmodified(self):
kwargs = get_sample_prod_params()
kwargs.pop('platform', None)
kwargs['platforms'] = ['x86_64', 'ppc64le']
kwargs['build_type'] = BUILD_TYPE_ORCHESTRATOR
kwargs['arrangement_version'] = 3
expected_primary = set(['spam', 'bacon', 'eggs'])
tag_suffixes = {'primary': ['spam', 'bacon', 'eggs']}
build_json = self._render_tag_from_config_build_request(kwargs, tag_suffixes=tag_suffixes)
plugins = get_plugins_from_build_json(build_json)
assert get_plugin(plugins, 'postbuild_plugins', 'tag_from_config')
tag_suffixes = plugin_value_get(plugins, 'postbuild_plugins', 'tag_from_config',
'args', 'tag_suffixes')
assert len(tag_suffixes['primary']) == len(expected_primary)
assert set(tag_suffixes['primary']) == expected_primary
def _render_tag_from_config_build_request(self, kwargs, repo_info=None,
tag_suffixes='{{TAG_SUFFIXES}}'):
build_request = BuildRequest(INPUTS_PATH)
build_request.set_params(**kwargs)
repo_info = repo_info or RepoInfo()
build_request.set_repo_info(repo_info)
build_request.customize_conf['enable_plugins'].append(
{
"plugin_type": 'postbuild_plugins',
"plugin_name": 'tag_from_config',
"plugin_args": {
'tag_suffixes': tag_suffixes,
},
}
)
return build_request.render()
def _mock_addional_tags_config(self, dir_path, tags):
with open(os.path.join(dir_path, ADDITIONAL_TAGS_FILE), | |
# Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from __future__ import print_function
import unittest
import itertools
import numpy as np
import math
from op_test import OpTest
# numpy.round has different behavior in comparision to c++ round function
# so we use round_c instead of numpy.round to align the output data
def round_c_single_element(val):
dtype = type(val)
if val >= 0:
return dtype(np.floor(val + 0.5))
return dtype(np.ceil(val - 0.5))
round_c = np.vectorize(round_c_single_element)
def get_compute_type(dtype):
assert dtype in [np.float16, np.float32, np.float64]
if dtype == np.float16:
return np.float32
return dtype
class TestFakeQuantizeAbsMaxOp(OpTest):
def setUp(self):
self.op_type = 'fake_quantize_abs_max'
self.attrs = {'bit_length': 8}
def _fake_quantize_abs_max(self, dtype, input_shape, distribution):
input_data = distribution(input_shape).astype(dtype)
compute_type = get_compute_type(dtype)
scale = np.max(np.abs(input_data))
bnt = (1 << (self.attrs['bit_length'] - 1)) - 1
inv_scale = 1.0 / (scale + 1e-6) if scale < 1e-30 else 1.0 / scale
output_data = round_c(input_data.astype(compute_type) * inv_scale * bnt)
self.inputs = {'X': input_data}
self.outputs = {'Out': output_data, 'OutScale': scale}
self.dtype = dtype
self.check_output()
def test_fake_quantize_abs_max(self):
self._fake_quantize_abs_max(np.float32, (124, 240), np.random.random)
def test_fake_quantize_abs_max_float16(self):
self._fake_quantize_abs_max(np.float16, (124, 240), np.random.random)
def test_fake_quantize_abs_max_underflow(self):
self._fake_quantize_abs_max(np.float32, (10, 10), np.zeros)
def test_fake_quantize_abs_max_underflow2(self):
self._fake_quantize_abs_max(np.float32, (10, 10),
lambda shape: np.full(shape, 1e-40))
class TestFakeChannelWiseQuantizeAbsMaxOp(OpTest):
def setUp(self):
self.op_type = 'fake_channel_wise_quantize_abs_max'
self.attrs = {'bit_length': 8}
def _fake_channel_wise_quantize_abs_max(self, dtype, input_shape,
quant_axis, distribution):
assert quant_axis in [0, 1], 'quant_axis should be 0 or 1.'
input_data = distribution(input_shape).astype(dtype)
compute_type = get_compute_type(dtype)
bnt = (1 << (self.attrs['bit_length'] - 1)) - 1
compute_axis = tuple(i for i in range(len(input_shape))
if i != quant_axis)
scale_broadcast = np.amax(input_data, axis=compute_axis, keepdims=True)
output_data = round_c(bnt * input_data.astype(compute_type) /
scale_broadcast)
if quant_axis == 1:
scale_broadcast = np.transpose(scale_broadcast,
(1, ) + compute_axis)
scale = scale_broadcast.reshape(input_shape[quant_axis], -1)[:, 0]
self.inputs = {'X': input_data}
self.outputs = {'Out': output_data, 'OutScale': scale}
self.dtype = dtype
self.attrs['quant_axis'] = quant_axis
self.check_output()
def test_fake_channel_wise_quantize_abs_max(self):
dtype_options = [np.float32, np.float16]
input_shape_quant_axis_options = [[(20, 15, 6, 6), 0],
[(15, 20, 5, 5), 1], [(30, 15), 0],
[(30, 15), 1]]
for dtype, input_shape_quant_axis in itertools.product(
dtype_options, input_shape_quant_axis_options):
input_shape, quant_axis = input_shape_quant_axis
with self.subTest(dtype=dtype,
input_shape=input_shape,
quant_axis=quant_axis):
self._fake_channel_wise_quantize_abs_max(
dtype, input_shape, quant_axis, np.random.random)
class TestFakeQuantizeRangeAbsMaxOp(OpTest):
def setUp(self):
self.op_type = 'fake_quantize_range_abs_max'
self.attrs = {'bit_length': 5, 'window_size': 1}
def _fake_quantize_range_abs_max(self,
dtype,
input_shape,
distribution,
is_test=False):
input_data = distribution(input_shape).astype(dtype)
compute_type = get_compute_type(dtype)
bnt = (1 << (self.attrs['bit_length'] - 1)) - 1
in_scale = np.zeros(1).astype(dtype)
out_scale = np.zeros(self.attrs['window_size']).astype(dtype)
out_scale[0] = np.max(np.abs(input_data))
if is_test:
out_scale[0] = in_scale[0] = out_scale[0] - 1.0
clip_data = np.clip(input_data, -in_scale, in_scale)
else:
clip_data = input_data
output_data = round_c(
clip_data.astype(compute_type) / out_scale[0] * bnt)
self.inputs = {
'X': input_data,
'Iter': np.zeros(1).astype(np.int64),
'InScale': in_scale
}
self.outputs = {
'Out': output_data,
'OutScale': out_scale[0],
'OutScales': out_scale
}
self.dtype = dtype
self.attrs['is_test'] = is_test
self.check_output()
def test_fake_quantize_range_abs_max(self):
dtype_options = [np.float32, np.float16]
is_test_options = [False, True]
for dtype, is_test in itertools.product(dtype_options, is_test_options):
self.attrs['bit_length'] = 8 if is_test else 5
with self.subTest(dtype=dtype, is_test=is_test):
self._fake_quantize_range_abs_max(
dtype, (8, 16, 7, 7),
lambda shape: (np.random.random(shape) - 0.5) * 10,
is_test=is_test)
class TestMovingAverageAbsMaxScaleOp(OpTest):
def setUp(self):
self.op_type = 'moving_average_abs_max_scale'
self.attrs = {'moving_rate': float(0.9), 'is_test': False}
def _moving_average_abs_max_scale(self, dtype, input_shape, distribution):
input_data = distribution(input_shape).astype(dtype)
in_accum = np.ones(1).astype(dtype)
in_state = np.ones(1).astype(dtype)
out_accum = self.attrs['moving_rate'] * in_accum[0] + np.max(
np.abs(input_data))
out_state = self.attrs['moving_rate'] * in_state[0] + 1.0
out_scale = out_accum / out_state
self.inputs = {
'X': input_data,
'InAccum': in_accum,
'InState': in_state
}
self.outputs = {
'Out': input_data,
'OutAccum': out_accum,
'OutState': out_state,
'OutScale': out_scale
}
self.dtype = dtype
self.check_output()
def test_moving_average_abs_max(self):
self._moving_average_abs_max_scale(np.float32, (8, 16, 7, 7),
np.random.random)
class TestFakeQuantizeMovingAverageAbsMaxOp(OpTest):
def setUp(self):
self.op_type = 'fake_quantize_moving_average_abs_max'
self.attrs = {'bit_length': 5, 'moving_rate': 0.9, 'is_test': False}
def _fake_quantize_moving_average_abs_max(self,
dtype,
input_shape,
distribution,
dequantize=False,
with_gradient=False):
input_data = distribution(input_shape).astype(dtype)
compute_type = get_compute_type(dtype)
bnt = (1 << (self.attrs['bit_length'] - 1)) - 1
in_accum = np.ones(1).astype(dtype)
in_state = np.ones(1).astype(dtype)
in_scale = np.array([0.001]).astype(dtype)
out_accum = np.zeros(1).astype(dtype)
out_state = np.zeros(1).astype(dtype)
out_scale = np.zeros(1).astype(dtype)
out_accum[0] = self.attrs['moving_rate'] * in_accum[0] + np.max(
np.abs(input_data))
out_state[0] = self.attrs['moving_rate'] * in_state[0] + 1.0
out_scale = out_accum / out_state
round_data = round_c(input_data.astype(compute_type) / out_scale * bnt)
if dequantize:
output_data = (round_data * out_scale / bnt).astype(dtype)
self.op_type = 'fake_quantize_dequantize_moving_average_abs_max'
else:
output_data = round_data.astype(dtype)
self.inputs = {
'X': input_data,
'InScale': in_scale,
'InAccum': in_accum,
'InState': in_state
}
self.outputs = {
'Out': output_data,
'OutAccum': out_accum,
'OutState': out_state,
'OutScale': out_scale
}
self.dtype = dtype
self.check_output()
if with_gradient:
gradient = [
np.ones(input_data.shape) / np.product(input_data.shape)
]
self.check_grad(['X'], 'Out', user_defined_grads=gradient)
def test_fake_quantize_moving_average_abs_max(self):
self._fake_quantize_moving_average_abs_max(np.float32, (8, 16, 7, 7),
np.random.random)
def test_fake_quantize_moving_average_abs_max_float16(self):
self._fake_quantize_moving_average_abs_max(np.float16, (8, 16, 7, 7),
np.random.random)
def test_fake_quantize_dequantize_moving_average_abs_max(self):
self._fake_quantize_moving_average_abs_max(np.float32, (8, 16, 7, 7),
np.random.random,
dequantize=True,
with_gradient=True)
class TestFakeQuantizeDequantizeAbsMaxOp(OpTest):
def setUp(self):
self.op_type = 'fake_quantize_dequantize_abs_max'
self.attrs = {'bit_length': 8}
def _fake_quantize_dequantize_abs_max(self, dtype, input_shape,
distribution):
input_data = distribution(input_shape).astype(dtype)
scale = np.max(np.abs(input_data)).astype(dtype)
bnt = (1 << (self.attrs['bit_length'] - 1)) - 1
output_data = round_c(input_data / scale * bnt) * scale / bnt
self.inputs = {'X': input_data}
self.outputs = {
'Out': output_data,
'OutScale': np.array(scale).astype(dtype)
}
self.dtype = dtype
self.check_output()
gradient = [np.ones(input_data.shape) / np.product(input_data.shape)]
self.check_grad(['X'], 'Out', user_defined_grads=gradient)
def test_fake_quantize_dequantize_abs_max(self):
self._fake_quantize_dequantize_abs_max(np.float32, (124, 240),
np.random.random)
class TestChannelWiseFakeQuantizeDequantizeAbsMaxOp(OpTest):
def setUp(self):
self.op_type = 'fake_channel_wise_quantize_dequantize_abs_max'
self.attrs = {'bit_length': 8}
def _fake_channel_wise_quantize_dequantize_abs_max(self, dtype, input_shape,
quant_axis,
distribution):
assert quant_axis in [0, 1], 'quant_axis should be 0 or 1.'
input_data = distribution(input_shape).astype(dtype)
compute_type = get_compute_type(dtype)
bnt = (1 << (self.attrs['bit_length'] - 1)) - 1
output_data = input_data.copy().astype(compute_type)
compute_axis = tuple(i for i in range(len(input_shape))
if i != quant_axis)
scale_broadcast = np.amax(input_data, axis=compute_axis, keepdims=True)
output_data = round_c(
bnt * output_data / scale_broadcast) * scale_broadcast / bnt
if quant_axis == 1:
scale_broadcast = np.transpose(scale_broadcast,
(1, ) + compute_axis)
scale = scale_broadcast.reshape(input_shape[quant_axis], -1)[:, 0]
self.inputs = {'X': input_data}
self.outputs = {'Out': output_data, 'OutScale': scale}
self.dtype = dtype
self.attrs['quant_axis'] = quant_axis
self.check_output()
gradient = [np.ones(input_data.shape) / np.product(input_data.shape)]
self.check_grad(['X'], 'Out', user_defined_grads=gradient)
def test_channel_wise_fake_quant_dequant_abs_max(self):
input_shape_quant_axis_options = [[(3, 4, 64, 64), 0],
[(15, 20, 5, 5), 1], [(30, 15), 0],
[(30, 15), 1]]
for input_shape, quant_axis in input_shape_quant_axis_options:
with self.subTest(input_shape=input_shape, quant_axis=quant_axis):
self._fake_channel_wise_quantize_dequantize_abs_max(
np.float32, input_shape, quant_axis, np.random.random)
def quantize_max_abs(x, max_range):
scale = np.max(np.abs(x).flatten())
y = np.round(x / scale * max_range)
return y, scale
def channel_wise_quantize_max_abs(x, quant_bit=8, quant_axis=0):
assert quant_axis in [0, 1], "The quant_axis should be 0 or 1."
scales = []
y = x.copy()
max_range = math.pow(2, quant_bit - 1) - 1
if quant_axis == 0:
for i in range(x.shape[0]):
scale = np.max(np.abs(x[i])).astype("float32")
scales.append(scale)
y[i] = np.round(x[i] * max_range / scale)
elif quant_axis == 1:
for i in range(x.shape[1]):
scale = np.max(np.abs(x[:, i])).astype("float32")
scales.append(scale)
y[:, i] = np.round(x[:, i] * max_range / scale)
return y, scales
class TestChannelWiseQuantizeOp(OpTest):
def set_args(self):
self.bit_length = 8
self.data_type = "float32"
self.quant_axis = 0
def setUp(self):
self.set_args()
self.op_type = "quantize_linear"
x = np.random.randn(4, 3, 64, 64).astype(self.data_type)
yq, scale = channel_wise_quantize_max_abs(x, self.bit_length,
self.quant_axis)
scale = np.array(scale).astype(self.data_type)
zero_point = np.zeros(scale.shape, dtype="int32")
self.inputs = {'X': x, 'Scale': scale, 'ZeroPoint': zero_point}
self.attrs = {
'bit_length': self.bit_length,
'quant_axis': self.quant_axis
}
self.outputs = {'Y': yq}
def test_check_output(self):
self.check_output()
class TestChannelWiseQuantizeOp1(TestChannelWiseQuantizeOp):
def set_args(self):
self.bit_length = 8
self.data_type = "float32"
self.quant_axis = 1
class TestChannelWiseQuantizeOpTrain(OpTest):
def set_args(self):
self.bit_length = 8
self.data_type = "float32"
self.quant_axis = 0
self.is_test = False
def setUp(self):
self.set_args()
self.op_type = "quantize_linear"
x = np.random.randn(4, 3, 64, 64).astype(self.data_type)
yq, scale = channel_wise_quantize_max_abs(x, self.bit_length,
self.quant_axis)
scale = np.array(scale).astype(self.data_type)
zero_point = np.zeros(scale.shape, dtype="int32")
self.inputs = {'X': x, 'Scale': scale, 'ZeroPoint': zero_point}
self.attrs = {
'bit_length': self.bit_length,
'quant_axis': self.quant_axis,
'is_test': self.is_test
}
self.outputs = {'Y': yq, 'OutScale': scale}
def test_check_output(self):
self.check_output()
class TestquantizeOp(OpTest):
def set_args(self):
self.bit_length = 8
self.quant_axis = -1
self.max_range = math.pow(2, self.bit_length - 1) - 1
self.data_type = "float32"
def setUp(self):
self.set_args()
self.op_type = "quantize_linear"
x = np.random.randn(31, 65).astype(self.data_type)
yq, scale = quantize_max_abs(x, self.max_range)
scale = np.array(scale).astype(self.data_type)
zero_point = np.zeros(scale.shape, dtype="int32")
self.inputs = {'X': x, 'Scale': scale, 'ZeroPoint': zero_point}
self.attrs = {
'bit_length': self.bit_length,
'quant_axis': self.quant_axis,
}
self.outputs = {'Y': yq}
def test_check_output(self):
self.check_output()
class | |
<gh_stars>1-10
import titration_class as ts
"""pK values and names taken from http://www.periodensystem-online.de/index.php (tyty)"""
acidic_water = ts.Compound(name="Water", acidic=True, pKas=[14.0])
basic_water = ts.Compound(name="Water", acidic=False, pKas=[14.0])
# Acids
Hydrochloric = ts.Compound(name="HCl", acidic=True, pKas=[-6.5])
Hydroiodic = ts.Compound(name="HI", acidic=True, pKas=[-10])
Nitric = ts.Compound(name="HNO3", acidic=True, pKas=[-1.4])
Hydrobromic = ts.Compound(name="HBr", acidic=True, pKas=[-8.7])
Hydroperchloric = ts.Compound(name="Perchloric Acid", acidic=True, pKas=[-8])
P_Toluenesulfonic = ts.Compound(name="p-Toluenesolfonic Acid", acidic=True, pKas=[-2.8])
Propane1sulfonic = ts.Compound(name="1-propanesulfonic Acid", acidic=True, pKas=[-1.49])
Propane2sulfonic = ts.Compound(name="2-propanesulfonic Acid", acidic=True, pKas=[-1.79])
Amidosulfonic = ts.Compound(name="Amidosulfonic", acidic=True, pKas=[0.99])
Benzenesulfonic = ts.Compound(name="Benzenesulfonic", acidic=True, pKas=[-2.5])
Bromic = ts.Compound(name="Bromic", acidic=True, pKas=[0.0])
Butanesulfonic = ts.Compound(name="Butanesulfonic", acidic=True, pKas=[-1.68])
Chlorous = ts.Compound(name="Chlorous", acidic=True, pKas=[1.97])
Chlorosulfonic = ts.Compound(name="Chlorosulfonic", acidic=True, pKas=[-10.43])
Chloric = ts.Compound(name="Chloric", acidic=True, pKas=[-2.7])
Chromic = ts.Compound(name="Chromic", acidic=True, pKas=[-0.61])
Dibromoacetic = ts.Compound(name="Dibromoacetic", acidic=True, pKas=[1.39])
Dichloroacetic = ts.Compound(name="Dichloroacetic", acidic=True, pKas=[1.29])
Dichromic = ts.Compound(name="Dichromic", acidic=True, pKas=[-4.5])
Difluoroacetic = ts.Compound(name="Difluoroacetic", acidic=True, pKas=[1.24])
Difluorophosphoric = ts.Compound(name="Difluorophosphoric", acidic=True, pKas=[-1.5])
Diiodoacetic = ts.Compound(name="Diiodoacetic", acidic=True, pKas=[1.49])
Dimethylphosphonic = ts.Compound(name="Dimethylphosphonic", acidic=True, pKas=[1.29])
Disulfuric = ts.Compound(name="Disulfuric", acidic=True, pKas=[-12.0])
Dithionic = ts.Compound(name="Dithionic", acidic=True, pKas=[-3.4, 0.35])
Ethanesulfonic = ts.Compound(name="Ethanesulfonic", acidic=True, pKas=[-1.68])
Fluorosulfonic = ts.Compound(name="Fluorosulfonic", acidic=True, pKas=[-14.0])
Heptafluoropropanesulfonic = ts.Compound(name="Heptafluoropropanesulfonic", acidic=True, pKas=[-5.0])
EDTA = ts.Compound(name="EDTA", acidic=True, pKas=[0.0, 1.5, 2.00, 2.69, 6.13, 10.37]) # Pg 268 QCA
Citric = ts.Compound(name="Citric Acid", acidic=True, pKas=[3.13, 4.76, 6.40])
Carbonic = ts.Compound(name="Carbonic Acid", acidic=True, pKas=[6.37, 10.25])
Acetic = ts.Compound(name="Acetic Acid", acidic=True, pKas=[4.75])
Ammonium = ts.Compound(name="Phenol", acidic=True, pKas=[9.2])
Malic = ts.Compound(name="Malic", acidic=True, pKas=[3.46])
Enanthic = ts.Compound(name="Enanthic", acidic=True, pKas=[4.89])
Acrylic = ts.Compound(name="Acrylic", acidic=True, pKas=[4.23])
Adipic = ts.Compound(name="Adipic", acidic=True, pKas=[4.43])
Alanine = ts.Compound(name="Alanine", acidic=True, pKas=[9.87])
Formic = ts.Compound(name="Formic", acidic=True, pKas=[3.75])
Amidophosphonic = ts.Compound(name="Amidophosphonic", acidic=True, pKas=[2.74])
Arsenic = ts.Compound(name="Arsenic", acidic=True, pKas=[2.25])
Azelaic = ts.Compound(name="Azelaic", acidic=True, pKas=[4.53])
Benzoic = ts.Compound(name="Benzoic", acidic=True, pKas=[4.21])
Succinic = ts.Compound(name="Succinic", acidic=True, pKas=[4.16])
Hydrocyanic = ts.Compound(name="Hydrocyanic", acidic=True, pKas=[9.21])
Bromoacetic = ts.Compound(name="Bromoacetic", acidic=True, pKas=[2.87])
Brominous = ts.Compound(name="Brominous", acidic=True, pKas=[2.85])
Butanethiol = ts.Compound(name="Butanethiol", acidic=True, pKas=[10.66])
Butyric = ts.Compound(name="Butyric", acidic=True, pKas=[4.82])
Butylarsonic = ts.Compound(name="Butylarsonic", acidic=True, pKas=[4.23])
Butylphosphinic = ts.Compound(name="Butylphosphinic", acidic=True, pKas=[3.41])
Butylphosphonic = ts.Compound(name="Butylphosphonic", acidic=True, pKas=[2.79])
Capric = ts.Compound(name="Capric", acidic=True, pKas=[4.9])
Caproic = ts.Compound(name="Caproic", acidic=True, pKas=[4.88])
Caprylic = ts.Compound(name="Caprylic", acidic=True, pKas=[4.89])
Chloroacetic = ts.Compound(name="Chloroacetic", acidic=True, pKas=[2.83])
Crotonic = ts.Compound(name="Crotonic", acidic=True, pKas=[4.69])
Cyanic = ts.Compound(name="Cyanic", acidic=True, pKas=[3.46])
Diamidophosphonic = ts.Compound(name="Diamidophosphonic", acidic=True, pKas=[4.83])
Dihydrogenperoxodiphosphate = ts.Compound(name="Dihydrogenperoxodiphosphate", acidic=True, pKas=[5.18])
Disulfane = ts.Compound(name="Disulfane", acidic=True, pKas=[5.0])
Dithioarsenic = ts.Compound(name="Dithioarsenic", acidic=True, pKas=[2.4])
Iron_VI = ts.Compound(name="Iron_VI_", acidic=True, pKas=[3.5])
Ethanethiol = ts.Compound(name="Ethanethiol", acidic=True, pKas=[10.5])
Ethylarsonic = ts.Compound(name="Ethylarsonic", acidic=True, pKas=[3.89])
Ethylhydroperoxide = ts.Compound(name="Ethylhydroperoxide", acidic=True, pKas=[11.8])
Ethylphosphinic = ts.Compound(name="Ethylphosphinic", acidic=True, pKas=[3.29])
Ethylphosphonic = ts.Compound(name="Ethylphosphonic", acidic=True, pKas=[2.43])
Fluoroacetic = ts.Compound(name="Fluoroacetic", acidic=True, pKas=[2.57])
Hydrofluoric = ts.Compound(name="Hydrofluoric", acidic=True, pKas=[3.14])
Glycine = ts.Compound(name="Glycine", acidic=True, pKas=[9.6])
Glycolic = ts.Compound(name="Glycolic", acidic=True, pKas=[3.83])
Hexafluoroantimonic = ts.Compound(name="Hexafluoroantimonic", acidic=True, pKas=[-17.0])
Hexafluoroarsenic = ts.Compound(name="Hexafluoroarsenic", acidic=True, pKas=[-13.0])
Hexafluorophosphoric = ts.Compound(name="Hexafluorophosphoric", acidic=True, pKas=[-10.0])
Hexafluorotitan_IV = ts.Compound(name="Hexafluorotitan_IV_", acidic=True, pKas=[2.14])
Hexafluorosilicic = ts.Compound(name="Hexafluorosilicic", acidic=True, pKas=[-3.0])
Hexasulfane = ts.Compound(name="Hexasulfane", acidic=True, pKas=[3.2])
Hydrazidosulfonic = ts.Compound(name="Hydrazidosulfonic", acidic=True, pKas=[3.85])
Hydrogenperoxodiphosphate = ts.Compound(name="Hydrogenperoxodiphosphate", acidic=True, pKas=[7.67])
Hypobromous = ts.Compound(name="Hypobromous", acidic=True, pKas=[8.68])
Hypochlorous = ts.Compound(name="Hypochlorous", acidic=True, pKas=[7.54])
Hypodiphosphoric = ts.Compound(name="Hypodiphosphoric", acidic=True, pKas=[2.22])
Hypoiodous = ts.Compound(name="Hypoiodous", acidic=True, pKas=[10.64])
Hypophosphorous = ts.Compound(name="Hypophosphorous", acidic=True, pKas=[2.23])
Hypo_nitrous = ts.Compound(name="Hypo-nitrousacid", acidic=True, pKas=[7.21])
Hypothiocyanitic = ts.Compound(name="Hypothiocyanitic", acidic=True, pKas=[5.3])
Imidodiphosphoric = ts.Compound(name="Imidodiphosphoric", acidic=True, pKas=[2.0])
Iodic = ts.Compound(name="Iodic", acidic=True, pKas=[0.804])
Iodoacetic = ts.Compound(name="Iodoacetic", acidic=True, pKas=[3.13])
Isocyanic = ts.Compound(name="Isocyanic", acidic=True, pKas=[3.92])
Isopropylhydroperoxide = ts.Compound(name="Isopropylhydroperoxide", acidic=True, pKas=[12.1])
Isopropyloxonium = ts.Compound(name="Isopropyloxonium", acidic=True, pKas=[-3.2])
Isothiocyanic = ts.Compound(name="Isothiocyanic", acidic=True, pKas=[-1.28])
Suberic = ts.Compound(name="Suberic", acidic=True, pKas=[4.51])
Malonic = ts.Compound(name="Malonic", acidic=True, pKas=[2.83])
Manganese_VI = ts.Compound(name="Manganese_VI_", acidic=True, pKas=[5.0])
Mellitic = ts.Compound(name="Mellitic", acidic=True, pKas=[1.4])
Metaarsenous = ts.Compound(name="Metaarsenous", acidic=True, pKas=[9.28])
Metaboric = ts.Compound(name="Metaboric", acidic=True, pKas=[9.12])
Metagermanic = ts.Compound(name="Metagermanic", acidic=True, pKas=[8.59])
Metasilicic = ts.Compound(name="Metasilicic", acidic=True, pKas=[9.51])
Metaniobic = ts.Compound(name="Metaniobic", acidic=True, pKas=[7.4])
Metaperiodic = ts.Compound(name="Metaperiodic", acidic=True, pKas=[1.64])
Metatantalic = ts.Compound(name="Metatantalic", acidic=True, pKas=[9.6])
Metavanadium_V = ts.Compound(name="Metavanadium_V_", acidic=True, pKas=[3.8])
Methanal = ts.Compound(name="Methanal", acidic=True, pKas=[13.3])
Methaneselenol = ts.Compound(name="Methaneselenol", acidic=True, pKas=[5.2])
Methanesulfonic = ts.Compound(name="Methanesulfonic", acidic=True, pKas=[-1.92])
Methanethiol = ts.Compound(name="Methanethiol", acidic=True, pKas=[10.4])
Methylarsonic = ts.Compound(name="Methylarsonic", acidic=True, pKas=[3.41])
Methylhydroperoxide = ts.Compound(name="Methylhydroperoxide", acidic=True, pKas=[11.5])
Methylphosphinic = ts.Compound(name="Methylphosphinic", acidic=True, pKas=[3.08])
Methylphosphonic = ts.Compound(name="Methylphosphonic", acidic=True, pKas=[2.38])
Methylsulfinic = ts.Compound(name="Methylsulfinic", acidic=True, pKas=[2.28])
Lactic = ts.Compound(name="Lactic", acidic=True, pKas=[3.9])
Molybdic = ts.Compound(name="Molybdic", acidic=True, pKas=[3.7])
Monofluorophosphoric = ts.Compound(name="Monofluorophosphoric", acidic=True, pKas=[0.5])
Nitramine = ts.Compound(name="Nitramine", acidic=True, pKas=[6.6])
Nitromethane = ts.Compound(name="Nitromethane", acidic=True, pKas=[10.2])
Octanesulfonic = ts.Compound(name="Octanesulfonic", acidic=True, pKas=[-1.41])
Ortho_periodic = ts.Compound(name="Ortho-periodicacid", acidic=True, pKas=[3.29])
Orthoantimonic = ts.Compound(name="Orthoantimonic", acidic=True, pKas=[2.55])
Orthoboric = ts.Compound(name="Orthoboric", acidic=True, pKas=[9.25])
Orthogermanic = ts.Compound(name="Orthogermanic", acidic=True, pKas=[8.68])
Orthosilicic = ts.Compound(name="Orthosilicic", acidic=True, pKas=[9.66])
Orthotelluric = ts.Compound(name="Orthotelluric", acidic=True, pKas=[7.7])
Orthovanadic = ts.Compound(name="Orthovanadic", acidic=True, pKas=[2.6])
Oxalic = ts.Compound(name="Oxalic", acidic=True, pKas=[1.23])
Pelargonic = ts.Compound(name="Pelargonic", acidic=True, pKas=[4.95])
Pentacarbonylmanganese = ts.Compound(name="Pentacarbonylmanganese", acidic=True, pKas=[7.1])
Pentafluoroethanesulfonic = ts.Compound(name="Pentafluoroethanesulfonic", acidic=True, pKas=[-5.1])
Pentasulfane = ts.Compound(name="Pentasulfane", acidic=True, pKas=[3.5])
Perchlorylamide = ts.Compound(name="Perchlorylamide", acidic=True, pKas=[8.6])
Perchlorylamine = ts.Compound(name="Perchlorylamine", acidic=True, pKas=[3.7])
Perchromic = ts.Compound(name="Perchromic", acidic=True, pKas=[4.95])
Permanganic = ts.Compound(name="Permanganic", acidic=True, pKas=[-2.25])
Perosmic = ts.Compound(name="Perosmic", acidic=True, pKas=[7.2])
Peroxoformic = ts.Compound(name="Peroxoformic", acidic=True, pKas=[7.1])
Peroxobutyric = ts.Compound(name="Peroxobutyric", acidic=True, pKas=[8.2])
Peroxodiphosphoric = ts.Compound(name="Peroxodiphosphoric", acidic=True, pKas=[-3.0])
Peroxodisulfuric = ts.Compound(name="Peroxodisulfuric", acidic=True, pKas=[-3.5])
Peroxyacetic = ts.Compound(name="Peroxyacetic", acidic=True, pKas=[8.2])
Peroxohypositrous = ts.Compound(name="Peroxohypositrous", acidic=True, pKas=[2.51])
Peroxopropionic = ts.Compound(name="Peroxopropionic", acidic=True, pKas=[8.1])
Peroxonitric = ts.Compound(name="Peroxonitric", acidic=True, pKas=[-5.0])
Peroxo_nitrous = ts.Compound(name="Peroxo-nitrousacid", acidic=True, pKas=[6.8])
Peroxosulphuric = ts.Compound(name="Peroxosulphuric", acidic=True, pKas=[0.8])
Perrhenic = ts.Compound(name="Perrhenic", acidic=True, pKas=[-1.25])
Perruthenic = ts.Compound(name="Perruthenic", acidic=True, pKas=[11.2])
Pertechnetic = ts.Compound(name="Pertechnetic", acidic=True, pKas=[0.3])
Phenol = ts.Compound(name="Phenol", acidic=True, pKas=[9.99])
Phenylphosphonic = ts.Compound(name="Phenylphosphonic", acidic=True, pKas=[1.83])
Phenylsulfinic = ts.Compound(name="Phenylsulfinic", acidic=True, pKas=[1.84])
Phosphorous = ts.Compound(name="Phosphorous", acidic=True, pKas=[1.92])
Phosphoric = ts.Compound(name="Phosphoric", acidic=True, pKas=[2.13])
Pimelic = ts.Compound(name="Pimelic", acidic=True, pKas=[4.47])
Poly = ts.Compound(name="Poly", acidic=True, pKas=[4.09])
Propanethiol = ts.Compound(name="Propanethiol", acidic=True, pKas=[10.65])
Propionic = ts.Compound(name="Propionic", acidic=True, pKas=[4.87])
Propylarsonic = ts.Compound(name="Propylarsonic", acidic=True, pKas=[4.21])
Propylphosphinic = ts.Compound(name="Propylphosphinic", acidic=True, pKas=[3.46])
Propylphosphonic = ts.Compound(name="Propylphosphonic", acidic=True, pKas=[2.49])
Salicylic = ts.Compound(name="Salicylic", acidic=True, pKas=[2.75])
Nitrous = ts.Compound(name="Nitrous", acidic=True, pKas=[3.35])
Sulfuric = ts.Compound(name="Sulfuric", acidic=True, pKas=[-3.0])
Hydrogensulfide = ts.Compound(name="Hydrogensulfide", acidic=True, pKas=[7.06])
Sulphurous = ts.Compound(name="Sulphurous", acidic=True, pKas=[1.92])
Seaborgium_VI = ts.Compound(name="Seaborgium_VI_", acidic=True, pKas=[3.75])
Sebacic = ts.Compound(name="Sebacic", acidic=True, pKas=[4.72])
Selenous = ts.Compound(name="Selenous", acidic=True, pKas=[2.62])
Selenophenol = ts.Compound(name="Selenophenol", acidic=True, pKas=[5.9])
Selenophosphoric = ts.Compound(name="Selenophosphoric", acidic=True, pKas=[0.02])
Selenic = ts.Compound(name="Selenic", acidic=True, pKas=[-3.0])
Hydroselenic = ts.Compound(name="Hydroselenic", acidic=True, pKas=[3.73])
Hydrazoic = ts.Compound(name="Hydrazoic", acidic=True, pKas=[4.76])
Tartronic = ts.Compound(name="Tartronic", acidic=True, pKas=[2.3])
Telluric = ts.Compound(name="Telluric", acidic=True, pKas=[2.64, 2.7])
Tetracarbonyliron = ts.Compound(name="Tetracarbonyliron", acidic=True, pKas=[4.4])
Tetrafluoroboric = ts.Compound(name="Tetrafluoroboric", acidic=True, pKas=[-0.4])
Tetraphosphoric = ts.Compound(name="Tetraphosphoric", acidic=True, pKas=[0.5])
Tetrasulfane = ts.Compound(name="Tetrasulfane", acidic=True, pKas=[3.8])
Tetrathiophosphoric = ts.Compound(name="Tetrathiophosphoric", acidic=True, pKas=[1.5])
Thioarsenic = ts.Compound(name="Thioarsenic", acidic=True, pKas=[3.3])
Thiocyanic = ts.Compound(name="Thiocyanic", acidic=True, pKas=[-1.85])
Thiophenol = ts.Compound(name="Thiophenol", acidic=True, pKas=[6.52])
Thiophosphoric = ts.Compound(name="Thiophosphoric", acidic=True, pKas=[1.79])
Thiosulfuric = ts.Compound(name="Thiosulfuric", acidic=True, pKas=[0.6])
Thioselenic = ts.Compound(name="Thioselenic", acidic=True, pKas=[0.99])
Tribromoacetic = ts.Compound(name="Tribromoacetic", acidic=True, pKas=[0.72])
Trichloroacetic = ts.Compound(name="Trichloroacetic", acidic=True, pKas=[0.65])
Trifluoroacetic = ts.Compound(name="Trifluoroacetic", acidic=True, pKas=[0.23])
Trifluoromethanesulfonic = ts.Compound(name="Trifluoromethanesulfonic", acidic=True, pKas=[-5.21])
Trihydrogenperoxodiphosphate = ts.Compound(name="Trihydrogenperoxodiphosphate", acidic=True, pKas=[0.5])
Triiodoacetic = ts.Compound(name="Triiodoacetic", acidic=True, pKas=[0.9])
Trioxide = ts.Compound(name="Trioxide", acidic=True, pKas=[9.5])
Triphosphoric = ts.Compound(name="Triphosphoric", acidic=True, pKas=[1.0])
Triselenocarbonic = ts.Compound(name="Triselenocarbonic", acidic=True, pKas=[1.16])
Trisulfane = ts.Compound(name="Trisulfane", acidic=True, pKas=[4.2])
Trithiocarbonic = ts.Compound(name="Trithiocarbonic", acidic=True, pKas=[2.68])
Valeric = ts.Compound(name="Valeric", acidic=True, pKas=[4.84])
HydrogenHyperoxide = ts.Compound(name="Hydrogenhyperoxide", acidic=True, pKas=[4.7])
HydrogenOzonide = ts.Compound(name="Hydrogenozonide", acidic=True, pKas=[8.2])
HydrogenPeroxide = ts.Compound(name="Hydrogenperoxide", acidic=True, pKas=[11.62])
Tartaric = ts.Compound(name="Tartaric", acidic=True, pKas=[2.98])
Tungstic = ts.Compound(name="Tungstic", acidic=True, pKas=[3.8])
Xenon_VI = ts.Compound(name="Xenon_VI_", acidic=True, pKas=[10.5])
Xenon_VIII = ts.Compound(name="Xenon_VIII_", acidic=True, pKas=[2.0])
# Bases
CesiumHydroxide = ts.Compound(name="CsOH", acidic=False, pKas=[15.76])
FranciumHydroxide = ts.Compound(name="FrOH", acidic=False, pKas=[15.7])
RubidiumHydroxide = ts.Compound(name="RbOH", acidic=False, pKas=[15.4])
LithiumHydroxide = ts.Compound(name="LiOH", acidic=False, pKas=[14.36])
CalciumHydroxide = ts.Compound(name="calcium_hydroxide", acidic=False, pKas=[12.6, 11.57])
RadiumHydroxide = ts.Compound(name="Radiumhydroxide", acidic=False, pKas=[14.0])
BariumHydroxide = ts.Compound(name="Bariumhydroxide", acidic=False, pKas=[13.85])
SodiumHydroxide = ts.Compound(name="NaOH", acidic=False, pKas=[13.8])
StrontiumHydroxide = ts.Compound(name="Strontiumhydroxide", acidic=False, pKas=[13.7])
PotassiumHydroxide = ts.Compound(name="KOH", acidic=False, pKas=[13.5])
Thallium_I_Hydroxide = ts.Compound(name="Thallium_I_hydroxide", acidic=False, pKas=[13.36])
MagnesiumHydroxide = ts.Compound(name="Magnesiumhydroxide", acidic=False, pKas=[12.2])
Manganese_II_Hydroxide = ts.Compound(name="Manganese_II_hydroxide", acidic=False, pKas=[12.0])
Indium_I_Hydroxide = ts.Compound(name="Indium_I_hydroxide_InOH", acidic=False, pKas=[11.83])
SilverHydroxide = ts.Compound(name="Silverhydroxide", acidic=False, pKas=[11.5])
Neptunyl_V_Hydroxide = ts.Compound(name="Neptunyl_V_hydroxide", acidic=False, pKas=[11.3])
Protactinyl_V_Hydroxide = ts.Compound(name="Protactinyl_V_hydroxide", acidic=False, pKas=[11.19])
ActiniumHydroxide = ts.Compound(name="Actiniumhydroxide", acidic=False, pKas=[11.1])
Americium_III_Hydroxide = ts.Compound(name="Americium_III_hydroxide", acidic=False, pKas=[11.1])
Curium_III_Hydroxide = ts.Compound(name="Curium_III_hydroxide", acidic=False, pKas=[11.1])
Plutonium_III_Hydroxide = ts.Compound(name="Plutonium_III_hydroxide", acidic=False, pKas=[11.1])
Iron_II_Hydroxide = ts.Compound(name="Iron_II_hydroxide", acidic=False, pKas=[11.07])
Triethylamine = ts.Compound(name="Triethylamine", acidic=False, pKas=[11.01])
Dipropylamine = ts.Compound(name="Dipropylamine", acidic=False, pKas=[10.91])
ethylamine = ts.Compound(name="ethylamine", acidic=False, pKas=[10.75])
Dimethylamine = ts.Compound(name="Dimethylamine", acidic=False, pKas=[10.73])
Methylamine = ts.Compound(name="Methylamine", acidic=False, pKas=[10.66])
Tripropylamine = ts.Compound(name="Tripropylamine", acidic=False, pKas=[10.66])
Propylamine = ts.Compound(name="Propylamine", acidic=False, pKas=[10.57])
Hydrogenxenonate_VIII_ = ts.Compound(name="Hydrogenxenonate_VIII_", acidic=False, pKas=[10.5])
Diethylamine = ts.Compound(name="Diethylamine", acidic=False, pKas=[10.49])
CadmiumHydroxide = ts.Compound(name="Cadmiumhydroxide", acidic=False, pKas=[10.4])
Nickel_II_Hydroxide = ts.Compound(name="Nickel_II_hydroxide", acidic=False, pKas=[10.22])
Trimethylamine = ts.Compound(name="Trimethylamine", acidic=False, pKas=[9.81])
LanthanumHydroxide = ts.Compound(name="Lanthanumhydroxide", acidic=False, pKas=[9.8])
Plutonyl_V_Hydroxide = ts.Compound(name="Plutonyl_V_hydroxide", acidic=False, pKas=[9.7])
Cobalt_II_Hydroxide = ts.Compound(name="Cobalt_II_hydroxide", acidic=False, pKas=[9.63])
Lead_II_Hydroxide = ts.Compound(name="Lead_II_hydroxide", acidic=False, pKas=[9.62])
Cerium_III_Hydroxide = ts.Compound(name="Cerium_III_hydroxide", acidic=False, pKas=[9.6])
YttriumHydroxide = ts.Compound(name="Yttriumhydroxide", acidic=False, pKas=[9.6])
Neodymium_III_Hydroxide = ts.Compound(name="Neodymium_III_hydroxide", acidic=False, pKas=[9.5])
Praseodymium_III_Hydroxide = ts.Compound(name="Praseodymium_III_hydroxide", acidic=False, pKas=[9.4])
Promethium_III_Hydroxide = ts.Compound(name="Promethium_III_hydroxide", acidic=False, pKas=[9.4])
Samarium_III_Hydroxide = ts.Compound(name="Samarium_III_hydroxide", acidic=False, pKas=[9.4])
ammonia = ts.Compound(name="ammonia", acidic=False, pKas=[9.25])
Platinum_II_Hydroxide = ts.Compound(name="Platinum_II_hydroxide", acidic=False, pKas=[9.2])
ZincHydroxide = ts.Compound(name="Zinchydroxide", acidic=False, pKas=[8.99])
Europium_III_Hydroxide = ts.Compound(name="Europium_III_hydroxide", acidic=False, pKas=[8.8])
Terbium_III_Hydroxide = ts.Compound(name="Terbium_III_hydroxide", acidic=False, pKas=[8.8])
Trimethylphosphine = ts.Compound(name="Trimethylphosphine", acidic=False, pKas=[8.65])
BerylliumHydroxide = ts.Compound(name="Berylliumhydroxide", acidic=False, pKas=[8.6])
Perchlorylimide = ts.Compound(name="Perchlorylimide", acidic=False, pKas=[8.6])
Dysprosium_III_Hydroxide = ts.Compound(name="Dysprosium_III_hydroxide", acidic=False, pKas=[8.5])
Copper_II_Hydroxide = ts.Compound(name="Copper_II_hydroxide", acidic=False, pKas=[8.5])
Holmium_III_Hydroxide = ts.Compound(name="Holmium_III_hydroxide", acidic=False, pKas=[8.4])
Erbium_III_Hydroxide = ts.Compound(name="Erbium_III_hydroxide", acidic=False, pKas=[8.3])
GadoliniumHydroxide = ts.Compound(name="Gadoliniumhydroxide", acidic=False, pKas=[8.3])
Thulium_III_Hydroxide = ts.Compound(name="Thulium_III_hydroxide", acidic=False, pKas=[8.3])
Ytterbium_III_Hydroxide = ts.Compound(name="Ytterbium_III_hydroxide", acidic=False, pKas=[8.3])
Hydroxylamine = ts.Compound(name="Hydroxylamine", acidic=False, pKas=[8.2])
LutetiumHydroxide = ts.Compound(name="Lutetiumhydroxide", acidic=False, pKas=[8.2])
Ethylhydrazine = ts.Compound(name="Ethylhydrazine", acidic=False, pKas=[7.99])
Hydrazine = ts.Compound(name="Hydrazine", acidic=False, pKas=[7.93])
Methylhydrazine = ts.Compound(name="Methylhydrazine", acidic=False, pKas=[7.87])
Peroxodiphosphate = ts.Compound(name="Peroxodiphosphate", acidic=False, pKas=[7.67])
Iron_III_Hydroxide = ts.Compound(name="Iron_III_hydroxide", acidic=False, pKas=[6.89])
Uranyl_VI_Hydroxide = ts.Compound(name="Uranyl_VI_hydroxide", acidic=False, pKas=[6.8])
Plutonium_IV_Hydroxide = ts.Compound(name="Plutonium_IV_hydroxide", acidic=False, pKas=[6.7])
ScandiumHydroxide = ts.Compound(name="Scandiumhydroxide", acidic=False, pKas=[6.4])
Bismuth_III_Hydroxide = ts.Compound(name="Bismuth_III_hydroxide", acidic=False, pKas=[6.38])
Vanadyl_IV_hydroxide_VO = ts.Compound(name="Vanadyl_IV_hydroxide_VO", acidic=False, pKas=[6.34])
AluminumHydroxide = ts.Compound(name="Aluminumhydroxide", acidic=False, pKas=[5.86])
Thorium_IV_Hydroxide = ts.Compound(name="Thorium_IV_hydroxide", acidic=False, pKas=[5.8])
Chromium_III_Hydroxide = ts.Compound(name="Chromium_III_hydroxide", acidic=False, pKas=[5.7])
Uranium_IV_Hydroxide = ts.Compound(name="Uranium_IV_hydroxide", acidic=False, pKas=[5.65])
Neptunium_IV_Hydroxide = ts.Compound(name="Neptunium_IV_hydroxide", acidic=False, pKas=[5.3])
Rutherfordium_IV_Hydroxide = ts.Compound(name="Rutherfordium_IV_hydroxide", acidic=False, pKas=[5.3])
Phenylhydrazine = ts.Compound(name="Phenylhydrazine", acidic=False, pKas=[5.21])
Indium_III_hydroxide_In = ts.Compound(name="Indium_III_hydroxide_In", acidic=False, pKas=[5.16])
GalliumHydroxide = ts.Compound(name="Galliumhydroxide", acidic=False, pKas=[4.75])
aniline = ts.Compound(name="aniline", acidic=False, pKas=[4.6])
Vanadium_III_hydroxide_V = ts.Compound(name="Vanadium_III_hydroxide_V", acidic=False, pKas=[4.1])
Plutonyl_VI_Hydroxide = ts.Compound(name="Plutonyl_VI_hydroxide", acidic=False, pKas=[4.05])
Gold_I_Hydroxide = ts.Compound(name="Gold_I_hydroxide", acidic=False, pKas=[3.8])
Tin_II_Hydroxide = ts.Compound(name="Tin_II_hydroxide", acidic=False, pKas=[3.66])
Tin_IV_Hydroxide = ts.Compound(name="Tin_IV_hydroxide", acidic=False, pKas=[3.32])
Triphenylphosphine = ts.Compound(name="Triphenylphosphine", acidic=False, pKas=[2.73])
Methylphosphine = ts.Compound(name="Methylphosphine", acidic=False, pKas=[2.7])
Mercury_II_Hydroxide = ts.Compound(name="Mercury_II_hydroxide", acidic=False, pKas=[2.5])
Palladium_II_Hydroxide = ts.Compound(name="Palladium_II_hydroxide", acidic=False, pKas=[2.46])
Technetyl_IV_Hydroxide = ts.Compound(name="Technetyl_IV_hydroxide", acidic=False, pKas=[2.43])
Titanyl_IV_dihydroxide = ts.Compound(name="Titanyl_IV_dihydroxide", acidic=False, pKas=[2.4])
Cerium_IV_Hydroxide = ts.Compound(name="Cerium_IV_hydroxide", acidic=False, pKas=[2.29])
Thallium_III_Hydroxide = ts.Compound(name="Thallium_III_hydroxide", acidic=False, pKas=[1.9])
Astatine_I_Hydroxide = ts.Compound(name="Astatine_I_hydroxide", acidic=False, pKas=[1.5])
Antimony_III_Hydroxide = ts.Compound(name="Antimony_III_hydroxide", acidic=False, pKas=[1.42])
Protactinium_IV_Hydroxide = ts.Compound(name="Protactinium_IV_hydroxide", acidic=False, pKas=[1.25])
Diphenylamine = ts.Compound(name="Diphenylamine", acidic=False, pKas=[0.78])
Hafnium_IV_Hydroxide = ts.Compound(name="Hafnium_IV_hydroxide", acidic=False, pKas=[0.52])
Zirconium_IV_Hydroxide = ts.Compound(name="Zirconium_IV_hydroxide", acidic=False, pKas=[0.5])
# Lists of compound
acids = [
| |
str(d.mouseX) + "," + str(d.mouseY) + ")"
i.dl().text(txt, (10,i.height / 2), color=col)
txt = "color: " + str(i.getPixel(d.mouseX,d.mouseY))
i.dl().text(txt, (10,(i.height / 2) + 10), color=col)
print "coord: (" + str(d.mouseX) + "," + str(d.mouseY) + "), color: " + str(i.getPixel(d.mouseX,d.mouseY))
if elapsed_time > 0 and elapsed_time < 5:
i.dl().text("In live mode", (10,10), color=col)
i.dl().text("Left click will show mouse coordinates and color", (10,20), color=col)
i.dl().text("Right click will kill the live image", (10,30), color=col)
i.save(d)
if d.mouseRight:
print "Closing Window"
d.done = True
pg.quit()
class Camera(FrameSource):
"""
**SUMMARY**
The Camera class is the class for managing input from a basic camera. Note
that once the camera is initialized, it will be locked from being used
by other processes. You can check manually if you have compatible devices
on linux by looking for /dev/video* devices.
This class wrappers OpenCV's cvCapture class and associated methods.
Read up on OpenCV's CaptureFromCAM method for more details if you need finer
control than just basic frame retrieval
"""
capture = "" #cvCapture object
thread = ""
pygame_camera = False
pygame_buffer = ""
prop_map = {"width": cv.CV_CAP_PROP_FRAME_WIDTH,
"height": cv.CV_CAP_PROP_FRAME_HEIGHT,
"brightness": cv.CV_CAP_PROP_BRIGHTNESS,
"contrast": cv.CV_CAP_PROP_CONTRAST,
"saturation": cv.CV_CAP_PROP_SATURATION,
"hue": cv.CV_CAP_PROP_HUE,
"gain": cv.CV_CAP_PROP_GAIN,
"exposure": cv.CV_CAP_PROP_EXPOSURE}
#human readable to CV constant property mapping
def __init__(self, camera_index = -1, prop_set = {}, threaded = True, calibrationfile = ''):
global _cameras
global _camera_polling_thread
"""
**SUMMARY**
In the camera constructor, camera_index indicates which camera to connect to
and props is a dictionary which can be used to set any camera attributes
Supported props are currently: height, width, brightness, contrast,
saturation, hue, gain, and exposure.
You can also specify whether you want the FrameBufferThread to continuously
debuffer the camera. If you specify True, the camera is essentially 'on' at
all times. If you specify off, you will have to manage camera buffers.
**PARAMETERS**
* *camera_index* - The index of the camera, these go from 0 upward, and are system specific.
* *prop_set* - The property set for the camera (i.e. a dict of camera properties).
.. Warning::
For most web cameras only the width and height properties are supported. Support
for all of the other parameters varies by camera and operating system.
* *threaded* - If True we constantly debuffer the camera, otherwise the user
must do this manually.
* *calibrationfile* - A calibration file to load.
"""
#This is to add support for XIMEA cameras.
if isinstance(camera_index, str):
if camera_index.lower() == 'ximea':
camera_index = 1100
self.capture = cv.CaptureFromCAM(camera_index) #This fixes bug with opencv not being able to grab frames from webcams on linux
if "delay" in prop_set:
time.sleep(prop_set['delay'])
if platform.system() == "Linux" and (prop_set.has_key("height") or cv.GrabFrame(self.capture) == False):
import pygame.camera
pygame.camera.init()
threaded = True #pygame must be threaded
if camera_index == -1:
camera_index = 0
if(prop_set.has_key("height") and prop_set.has_key("width")):
self.capture = pygame.camera.Camera("/dev/video" + str(camera_index), (prop_set['width'], prop_set['height']))
else:
self.capture = pygame.camera.Camera("/dev/video" + str(camera_index))
try:
self.capture.start()
except:
logger.warning("SimpleCV can't seem to find a camera on your system, or the drivers do not work with SimpleCV.")
return
time.sleep(0)
self.pygame_buffer = self.capture.get_image()
self.pygame_camera = True
else:
self.threaded = False
if (platform.system() == "Windows"):
threaded = False
if (not self.capture):
return None
#set any properties in the constructor
for p in prop_set.keys():
if p in self.prop_map:
cv.SetCaptureProperty(self.capture, self.prop_map[p], prop_set[p])
if (threaded):
self.threaded = True
_cameras.append(self)
if (not _camera_polling_thread):
_camera_polling_thread = FrameBufferThread()
_camera_polling_thread.daemon = True
_camera_polling_thread.start()
time.sleep(0) #yield to thread
if calibrationfile:
self.loadCalibration(calibrationfile)
#todo -- make these dynamic attributes of the Camera class
def getProperty(self, prop):
"""
**SUMMARY**
Retrieve the value of a given property, wrapper for cv.GetCaptureProperty
.. Warning::
For most web cameras only the width and height properties are supported. Support
for all of the other parameters varies by camera and operating system.
**PARAMETERS**
* *prop* - The property to retrive.
**RETURNS**
The specified property. If it can't be found the method returns False.
**EXAMPLE**
>>> cam = Camera()
>>> prop = cam.getProperty("width")
"""
if self.pygame_camera:
if prop.lower() == 'width':
return self.capture.get_size()[0]
elif prop.lower() == 'height':
return self.capture.get_size()[1]
else:
return False
if prop in self.prop_map:
return cv.GetCaptureProperty(self.capture, self.prop_map[prop])
return False
def getAllProperties(self):
"""
**SUMMARY**
Return all properties from the camera.
**RETURNS**
A dict of all the camera properties.
"""
if self.pygame_camera:
return False
props = {}
for p in self.prop_map:
props[p] = self.getProperty(p)
return props
def getImage(self):
"""
**SUMMARY**
Retrieve an Image-object from the camera. If you experience problems
with stale frames from the camera's hardware buffer, increase the flushcache
number to dequeue multiple frames before retrieval
We're working on how to solve this problem.
**RETURNS**
A SimpleCV Image from the camera.
**EXAMPLES**
>>> cam = Camera()
>>> while True:
>>> cam.getImage().show()
"""
if self.pygame_camera:
return Image(self.pygame_buffer.copy())
if (not self.threaded):
cv.GrabFrame(self.capture)
self.capturetime = time.time()
else:
self.capturetime = self._threadcapturetime
frame = cv.RetrieveFrame(self.capture)
newimg = cv.CreateImage(cv.GetSize(frame), cv.IPL_DEPTH_8U, 3)
cv.Copy(frame, newimg)
return Image(newimg, self)
class VirtualCamera(FrameSource):
"""
**SUMMARY**
The virtual camera lets you test algorithms or functions by providing
a Camera object which is not a physically connected device.
Currently, VirtualCamera supports "image", "imageset" and "video" source types.
**USAGE**
* For image, pass the filename or URL to the image
* For the video, the filename
* For imageset, you can pass either a path or a list of [path, extension]
"""
source = ""
sourcetype = ""
def __init__(self, s, st, start=1):
"""
**SUMMARY**
The constructor takes a source, and source type.
**PARAMETERS**
* *s* - the source of the imagery.
* *st* - the type of the virtual camera. Valid strings include:
* *start* - the number of the frame that you want to start with.
* "image" - a single still image.
* "video" - a video file.
* "imageset" - a SimpleCV image set.
**EXAMPLE**
>>> vc = VirtualCamera("img.jpg", "image")
>>> vc = VirtualCamera("video.mpg", "video")
>>> vc = VirtualCamera("./path_to_images/", "imageset")
>>> vc = VirtualCamera("video.mpg", "video", 300)
"""
self.source = s
self.sourcetype = st
self.counter = 0
if start==0:
start=1
self.start = start
if not (self.sourcetype == "video" or self.sourcetype == "image" or self.sourcetype == "imageset"):
print 'Error: In VirtualCamera(), Incorrect Source option. "%s" \nUsage:' % self.sourcetype
print '\tVirtualCamera("filename","video")'
print '\tVirtualCamera("filename","image")'
print '\tVirtualCamera("./path_to_images","imageset")'
return None
if (type(self.source) == list):
for source_file in self.source:
if not os.path.exists(source_file):
print 'Error: In VirtualCamera()\n\t"%s" was not found.' % source_file
return None
else:
if not os.path.exists(self.source):
print 'Error: In VirtualCamera()\n\t"%s" was not found.' % self.source
return None
if (self.sourcetype == "imageset"):
self.source = ImageSet()
if (type(s) == list):
self.source.load(*s)
else:
self.source.load(s)
if (self.sourcetype == 'video'):
self.capture = cv.CaptureFromFile(self.source)
cv.SetCaptureProperty(self.capture, cv.CV_CAP_PROP_POS_FRAMES, self.start-1)
def getImage(self):
"""
**SUMMARY**
Retrieve an Image-object from the virtual camera.
**RETURNS**
A SimpleCV Image from the camera.
**EXAMPLES**
>>> cam = VirtualCamera()
>>> while True:
>>> cam.getImage().show()
"""
if (self.sourcetype == 'image'):
return Image(self.source, self)
if (self.sourcetype == 'imageset'):
img = self.source[self.counter % len(self.source)]
self.counter = self.counter + 1
return img
if (self.sourcetype == 'video'):
return Image(cv.QueryFrame(self.capture), self)
def rewind(self, start=None):
"""
**SUMMARY**
Rewind the Video source back to the given frame.
Available for only video sources.
**PARAMETERS**
start - the number of the frame that you want to rewind to.
if not provided, the video source would be rewound
to the starting frame number you provided or rewound
to the beginning.
**RETURNS**
None
**EXAMPLES**
>>> cam = VirtualCamera("filename.avi", "video", 120)
>>> i=0
>>> while i<60:
... cam.getImage().show()
... i+=1
>>> cam.rewind()
"""
if (self.sourcetype == 'video'):
if not start:
cv.SetCaptureProperty(self.capture, cv.CV_CAP_PROP_POS_FRAMES, self.start-1)
else:
if start==0:
start=1
cv.SetCaptureProperty(self.capture, cv.CV_CAP_PROP_POS_FRAMES, start-1)
def getFrame(self, frame):
"""
**SUMMARY**
Get the provided numbered | |
Calculate overfill
start_mismatch[j].append((time_list[tseg_start] - time_list[pseg_start]).total_seconds())
for ts, (tseg_start, tseg_stop) in enumerate(truth_segs):
ps = _find_overlap_seg(pred_segs, tseg_stop)
if ps == -1:
# potential underfill or deletion
ps = _find_seg_end_within(pred_segs, tseg_start, tseg_stop)
if ps != -1:
pseg_stop = pred_segs[ps][1]
offset = (time_list[tseg_stop] - time_list[pseg_stop]).total_seconds()
if tseg_stop != pseg_stop and abs(offset) < 18000:
stop_mismatch[j].append(offset)
else:
pseg_stop = pred_segs[ps][1]
# Check the end of previous truth
if ts < len(truth_segs) - 1 and truth_segs[ts-1][0] <= pseg_stop:
continue
else:
offset = (time_list[tseg_stop] - time_list[pseg_stop]).total_seconds()
if abs(offset) < 18000:
# Calculate overfill
stop_mismatch[j].append(offset)
# print("class: %d" % j)
# print("pred_segs: %d %s" % (len(pred_segs), str(pred_segs)))
# print("truth_segs: %d %s" % (len(truth_segs), str(truth_segs)))
# print("start_mismatch: %s" % start_mismatch)
# print("stop_mismatch: %s" % stop_mismatch)
return start_mismatch, stop_mismatch
def _get_timeliness_measures(classes, truth, prediction, time_list):
num_classes = len(classes)
start_mismatch = [list([]) for i in range(num_classes)]
stop_mismatch = [list([]) for i in range(num_classes)]
# Processing segmentation first!
for j in range(num_classes):
pred_segs = []
truth_segs = []
prev_pred = False
prev_truth = False
tseg_start = 0
tseg_stop = 0
pseg_start = 0
pseg_stop = 0
for i in range(truth.shape[0]):
cur_truth = (int(truth[i]) == j)
cur_pred = (int(prediction[i]) == j)
# Truth segments
if cur_truth != prev_truth:
if cur_truth:
tseg_start = i
elif tseg_stop != 0:
truth_segs.append((tseg_start, tseg_stop))
tseg_stop = i
# Prediction segments
if cur_pred != prev_pred:
if cur_pred:
pseg_start = i
elif pseg_stop != 0:
pred_segs.append((pseg_start, pseg_stop))
pseg_stop = i
prev_truth = cur_truth
prev_pred = cur_pred
# Add compensated segments to predictions egments
for ts, (tseg_start, tseg_stop) in enumerate(truth_segs):
ps = _find_overlap_seg(pred_segs, tseg_start)
if ps == -1:
# potential underfill or deletion
ps = _find_seg_start_within(pred_segs, tseg_start, tseg_stop)
if ps != -1:
pseg_start = pred_segs[ps][0]
offset = (time_list[tseg_start] - time_list[pseg_start]).total_seconds()
if tseg_start != pseg_start and abs(offset) < 18000:
start_mismatch[j].append(offset)
else:
pseg_start = pred_segs[ps][0]
# Check the end of previous truth
if ts > 1 and truth_segs[ts-1][1] >= pseg_start:
continue
else:
offset = (time_list[tseg_start] - time_list[pseg_start]).total_seconds()
if tseg_start != pseg_start and abs(offset) < 18000:
# Calculate overfill
start_mismatch[j].append((time_list[tseg_start] - time_list[pseg_start]).total_seconds())
for ts, (tseg_start, tseg_stop) in enumerate(truth_segs):
ps = _find_overlap_seg(pred_segs, tseg_stop)
if ps == -1:
# potential underfill or deletion
ps = _find_seg_end_within(pred_segs, tseg_start, tseg_stop)
if ps != -1:
pseg_stop = pred_segs[ps][1]
offset = (time_list[tseg_stop] - time_list[pseg_stop]).total_seconds()
if tseg_stop != pseg_stop and abs(offset) < 18000:
stop_mismatch[j].append(offset)
else:
pseg_stop = pred_segs[ps][1]
# Check the end of previous truth
if ts < len(truth_segs) - 1 and truth_segs[ts-1][0] <= pseg_stop:
continue
else:
offset = (time_list[tseg_stop] - time_list[pseg_stop]).total_seconds()
if tseg_stop != pseg_stop and abs(offset) < 18000:
# Calculate overfill
stop_mismatch[j].append(offset)
# print("class: %d" % j)
# print("pred_segs: %d %s" % (len(pred_segs), str(pred_segs)))
# print("truth_segs: %d %s" % (len(truth_segs), str(truth_segs)))
# print("start_mismatch: %s" % start_mismatch)
# print("stop_mismatch: %s" % stop_mismatch)
return start_mismatch, stop_mismatch
def _get_timeliness_measures_depricated(classes, truth, prediction, truth_scoring, prediction_scoring, time_list):
num_classes = len(classes)
start_mismatch = [list([]) for i in range(num_classes)]
stop_mismatch = [list([]) for i in range(num_classes)]
# For each Underfill, Overfill
prev_truth = -1
for i in range(truth.shape[0]):
cur_truth = int(truth[i])
# Overfill/Underfill only occur at the boundary of any activity event, so look for the boundary first
if cur_truth != prev_truth:
truth_time = time_list[i]
# Check the start boundary
if truth[i] == prediction[i]:
# If current prediction is correct, then it can only be overfill of current truth label.
j = i - 1
while j >= 0 and prediction_scoring[j] == 'O':
j -= 1
# If there is no overfill for cur_truth, and the current truth and prediction are the same,
# then there is no start_boundary mismatch.
start_mismatch[cur_truth].append((time_list[j + 1] - truth_time).total_seconds())
else:
# If current prediction is incorrect, then it can only be underfill of current truth label at start
# boundary.
j = i
while j < truth.shape[0] and truth_scoring[j] == 'U':
j += 1
if j != i and j < truth.shape[0]:
start_mismatch[cur_truth].append((time_list[j-1] - truth_time).total_seconds())
# Check the stop boundary
if i > 0:
if prediction[i-1] == truth[i-1]:
# Previous prediction is correct, then it can only be overfill of previous truth.
# If there is no overfill, the stop boundary is accurate
j = i
while prediction_scoring[j] == 'o':
j += 1
stop_mismatch[prev_truth].append((time_list[j-1] - truth_time).total_seconds())
else:
# Check Underfill for prev_truth (at the stop boundary)
j = i - 1
while j >= 0 and truth_scoring[j] == 'u':
j -= 1
if j != i - 1:
stop_mismatch[prev_truth].append((time_list[j + 1] - truth_time).total_seconds())
if prev_truth != -1:
if len(stop_mismatch[prev_truth]) > 0 and abs(stop_mismatch[prev_truth][-1]) > 1800:
logger.warning('Stop mismatch is over half an hour: %s at %d (%s) - %f' %
(classes[prev_truth], i, time_list[i],
stop_mismatch[prev_truth][-1]))
if len(start_mismatch[cur_truth]) > 0 and abs(start_mismatch[cur_truth][-1]) > 1800:
logger.warning('Start mismatch is over half an hour: %s at %d (%s) - %f' %
(classes[cur_truth], i, time_list[i],
start_mismatch[cur_truth][-1]))
# Update prev truth
prev_truth = cur_truth
# Sort all arrays
for i in range(num_classes):
start_mismatch[i].sort()
stop_mismatch[i].sort()
# Return
return start_mismatch, stop_mismatch
def generate_latex_table(methods, classes, recall_metrics, precision_matrics,
background_class=None, filename=None,
as_percent=True, metric_name='recall'):
bg_class_id = _get_bg_class_id(classes, background_class)
metric_labels, metric_indices = _get_metric_label_dict(metric_name='recall')
rmp = _gether_per_class_metrics(methods, classes, recall_metrics, True,
metric_labels, metric_indices)
rmr = _gether_per_class_metrics(methods, classes, recall_metrics, False,
metric_labels, metric_indices)
metric_labels, metric_indices = _get_metric_label_dict(metric_name='precision')
pmp = _gether_per_class_metrics(methods, classes, precision_matrics, True,
metric_labels, metric_indices)
pmr = _gether_per_class_metrics(methods, classes, precision_matrics, False,
metric_labels, metric_indices)
if filename is None:
f = sys.stdout
else:
f = open(filename, 'w')
f.write('\\multirow{2}{*}{Models} & \\multirow{2}{*}{Activities} & '
'\\multirow{2}{*}{Total Truth} & \\multicolumn{2}{|c|}{Recall} & '
'\\multirow{2}{*}{Total Prediction} & \\multicolumn{2}{|c|}{Precision} \\\\ \\hline\n')
f.write('& & & C only & U included & & C only & O included \\\\ \\hline \n')
for i, method in enumerate(methods):
f.write('\\multirow{%d}{*}{%s} & ' % (len(classes), method.replace('_', '\_')))
for j, target in enumerate(classes):
if j != 0:
f.write('& ')
f.write('%s & '
'%d & %d (%.2f) & %d (%.2f) & '
'%d & %d (%.2f) & %d (%.2f) \\\\ \n' %
(target.replace('_', '\_'),
rmr[i][j,:].sum(), rmr[i][j,0], rmp[i][j,0],
rmr[i][j,0]+rmr[i][j,1]+rmr[i][j,2], rmp[i][j,0]+rmp[i][j,1]+rmp[i][j,2],
pmr[i][j,:].sum(), pmr[i][j,0], pmp[i][j,0],
pmr[i][j,0]+pmr[i][j,1]+pmr[i][j,2], pmp[i][j,0]+pmp[i][j,1]+pmp[i][j,2],
)
)
f.write('\\hline\n')
f.close()
def generate_seg_latex_table(methods, classes, recall_metrics, precision_matrics,
background_class=None, filename=None):
bg_class_id = _get_bg_class_id(classes, background_class)
metric_labels, metric_indices = _get_metric_label_dict(metric_name='recall')
rmp = _gether_per_class_metrics(methods, classes, recall_metrics, True,
metric_labels, metric_indices)
rmr = _gether_per_class_metrics(methods, classes, recall_metrics, False,
metric_labels, metric_indices)
metric_labels, metric_indices = _get_metric_label_dict(metric_name='precision')
pmp = _gether_per_class_metrics(methods, classes, precision_matrics, True,
metric_labels, metric_indices)
pmr = _gether_per_class_metrics(methods, classes, precision_matrics, False,
metric_labels, metric_indices)
if filename is None:
f = sys.stdout
else:
f = open(filename, 'w')
f.write('Metric & Activities')
for method in methods:
f.write('& %s' % method.replace('_', '\_'))
f.write('\\\\ \\hline \n')
for i, activity in enumerate(classes):
if i != bg_class_id:
if i == 0:
f.write('\multirow{%d}{*}{Recall} & ' % (len(classes) - 1))
else:
f.write(' & ')
f.write('%s ' % activity.replace('_', '\_'))
# Find maximum and store index
temp_array = np.array([rmp[j][i,0] for j in range(len(methods))])
max_index = temp_array.argpartition(-2)[-2:]
for j, method in enumerate(methods):
if j in max_index:
f.write('& \\textbf{%d/%.2f\\%%} ' % (rmr[j][i,0], rmp[j][i,0]* 100))
else:
f.write('& %d/%.2f\\%% ' % (rmr[j][i,0], rmp[j][i,0]* 100))
f.write('\\\\ \n')
f.write('\\hline \n')
for i, activity in enumerate(classes):
if i != bg_class_id:
if i == 0:
f.write('\multirow{%d}{*}{Precision} & ' % (len(classes) - 1))
else:
f.write(' & ')
f.write('%s ' % activity.replace('_', '\_'))
# Find maximum and store index
temp_array = np.array([pmp[j][i,0] for j in range(len(methods))])
max_index = temp_array.argpartition(-2)[-2:]
for j, method in enumerate(methods):
if j in max_index:
f.write('& \\textbf{%d/%.2f\\%%} ' % (pmr[j][i,0], pmp[j][i,0]* 100))
else:
f.write('& %d/%.2f\\%% ' % (pmr[j][i,0], pmp[j][i,0]* 100))
f.write('\\\\ \n')
f.write('\\hline \n')
def generate_event_recall_table(methods, classes, recall_metrics,
background_class=None, filename=None):
bg_class_id = _get_bg_class_id(classes, background_class)
metric_labels, metric_indices = _get_metric_label_dict(metric_name='recall')
rmp = _gether_per_class_metrics(methods, classes, recall_metrics, True,
metric_labels, metric_indices)
rmr = _gether_per_class_metrics(methods, classes, recall_metrics, False,
metric_labels, metric_indices)
if filename is None:
f = sys.stdout
else:
f = open(filename, 'w')
f.write('Activities')
for method in methods:
f.write('& %s' % method.replace('_', '\_'))
f.write('\\\\ \\hline \n')
for i, activity in enumerate(classes):
if i != bg_class_id:
f.write(' & ')
f.write('%s ' % activity.replace('_', '\_'))
# Find maximum and store index
temp_array = np.array([rmp[j][i, 0] for j in range(len(methods))])
max_index = temp_array.argpartition(-2)[-2:]
for j, method in enumerate(methods):
if j in max_index:
f.write('& \\textbf{%.2f\\%%} ' % (rmp[j][i,0]* 100))
else:
f.write('& %.2f\\%% ' % (rmp[j][i,0]* 100))
f.write('\\\\ | |
cur.execute('SELECT COUNT(*) AS count, XImage.id, path FROM XImage, XBelonging WHERE XImage.id=XBelonging.ximage_id GROUP BY XImage.id ORDER BY count DESC LIMIT 1;').fetchone()
print('Items per image:\n Minimum: %d (%s)\n Maximum: %d (%s)\n Average: %.1f' % (min_items_per_image, min_items_per_image_path, max_items_per_image, max_items_per_image_path, round(avg_items_per_image, 1)))
except ValueError:
print('No items found')
try:
(avg_blobs_per_item,) = cur.execute('SELECT AVG(count) FROM (SELECT COUNT(*) AS count, XBelonging.xitem_id FROM XBlob, XBelonging, XImage WHERE XImage.id=XBelonging.ximage_id AND XBelonging.id=XBlob.xbelonging_id GROUP BY XBelonging.xitem_id);').fetchone()
(min_blobs_per_item, min_blobs_per_item_uuid) = cur.execute('SELECT COUNT(*) AS count, XBelonging.xitem_id FROM XBlob, XBelonging, XImage WHERE XImage.id=XBelonging.ximage_id AND XBelonging.id=XBlob.xbelonging_id GROUP BY XBelonging.xitem_id ORDER BY count ASC LIMIT 1;').fetchone()
(max_blobs_per_item, max_blobs_per_item_uuid) = cur.execute('SELECT COUNT(*) AS count, XBelonging.xitem_id FROM XBlob, XBelonging, XImage WHERE XImage.id=XBelonging.ximage_id AND XBelonging.id=XBlob.xbelonging_id GROUP BY XBelonging.xitem_id ORDER BY count DESC LIMIT 1;').fetchone()
(avg_blobs_per_image,) = cur.execute('SELECT AVG(count) FROM (SELECT COUNT(*) AS count, XImage.id FROM XBlob, XBelonging, XImage WHERE XImage.id=XBelonging.ximage_id AND XBelonging.id=XBlob.xbelonging_id GROUP BY XImage.id);').fetchone()
(min_blobs_per_image, _, min_blobs_per_image_path) = cur.execute('SELECT COUNT(*) AS count, XImage.id, path FROM XBlob, XBelonging, XImage WHERE XImage.id=XBelonging.ximage_id AND XBelonging.id=XBlob.xbelonging_id GROUP BY XImage.id ORDER BY count ASC LIMIT 1;').fetchone()
(max_blobs_per_image, _, max_blobs_per_image_path) = cur.execute('SELECT COUNT(*) AS count, XImage.id, path FROM XBlob, XBelonging, XImage WHERE XImage.id=XBelonging.ximage_id AND XBelonging.id=XBlob.xbelonging_id GROUP BY XImage.id ORDER BY count DESC LIMIT 1;').fetchone()
(xblob_minarea, xblob_minarea_path) = cur.execute('SELECT area, path FROM XBlob, XBelonging, XImage WHERE XImage.id=XBelonging.ximage_id AND XBelonging.id=XBlob.xbelonging_id ORDER BY area ASC LIMIT 1;').fetchone()
(xblob_maxarea, xblob_maxarea_path) = cur.execute('SELECT area, path FROM XBlob, XBelonging, XImage WHERE XImage.id=XBelonging.ximage_id AND XBelonging.id=XBlob.xbelonging_id ORDER BY area DESC LIMIT 1;').fetchone()
(xblob_avgarea,) = cur.execute('SELECT AVG(area) FROM XBlob, XBelonging, XImage WHERE XImage.id=XBelonging.ximage_id AND XBelonging.id=XBlob.xbelonging_id;').fetchone()
print('Blobs per item:\n Minimum: %d (%s)\n Maximum: %d (%s)\n Average: %.1f' % (min_blobs_per_item, str(min_blobs_per_item_uuid), max_blobs_per_item, str(max_blobs_per_item_uuid), round(avg_blobs_per_item, 1)))
print('Blobs per image:\n Minimum: %d (%s)\n Maximum: %d (%s)\n Average: %.1f' % (min_blobs_per_image, min_blobs_per_image_path, max_blobs_per_image, max_blobs_per_image_path, round(avg_blobs_per_image, 1)))
print('Blobs areas:\n Minimum: %dpx (%s)\n Maximum: %dpx (%s)\n Average: %dpx' % (xblob_minarea, xblob_minarea_path, xblob_maxarea, xblob_maxarea_path, xblob_avgarea))
except ValueError:
print('No blobs found')
def ximage_query(args):
class XEvalContext(object):
def __init__(self, cur):
self.cur = cur
self.cur.execute('SELECT path FROM XImage;')
self.all_paths = self._fetch_all()
self.reset()
def push_param(self, p):
n = 'x%d' % (len(self.params),)
self.params[n] = p
return ':%s' % (n,)
def execute_query(self):
from_clause = ', '.join(self.from_tables)
where_clause = ' AND '.join(self.where_conjs)
groupby_clause = '' if len(self.having_conjs) == 0 else ' GROUP BY path HAVING %s' % (' AND '.join(self.having_conjs),)
query = 'SELECT path FROM %s WHERE %s%s;' % (from_clause, where_clause, groupby_clause)
#print query, self.params
self.cur.execute(query, self.params)
return self._fetch_all()
def reset(self):
self.params = {}
self.where_conjs = set()
self.from_tables = set()
self.having_conjs = set()
def _fetch_all(self):
return set([ r[0] for r in self.cur.fetchall() ])
def xeval_num(node):
return node.n
def xeval_str(node):
return node.s
def xeval_attribute(node, ctx):
assert type(node.value) == ast.Name
t = node.value.id.capitalize()
if t in [ 'Acquisition', 'Setup' ]:
ctx.from_tables.update([ 'XImage', 'XImageParam AS Acquisition', 'XImageParam AS Setup' ])
ctx.where_conjs.update([ 'Acquisition.param_type=0', 'Acquisition.ximage_id=XImage.id', 'Setup.param_type=1', 'Setup.ximage_id=XImage.id' ])
ctx.where_conjs.add('%s.name=%s' % (t, ctx.push_param(node.attr)))
return 'xvalue_parse(%s.val)' % (t,)
elif t == 'Item':
ctx.from_tables.update([ 'XImage', 'XBelonging', 'XBlob', 'XClass' ])
ctx.where_conjs.update([ 'XImage.id=XBelonging.ximage_id', 'XBlob.xbelonging_id=XBelonging.id', 'XBlob.xclass_id=XClass.id' ])
ctx.where_conjs.add('XClass.name=%s' % (ctx.push_param(node.attr),))
return '*'
else:
pass # raise
def xeval_call(node, ctx):
fn = node.func.id.lower()
if fn == 'count':
assert len(node.args) == 1 and type(node.args[0]) == ast.Attribute
return True, 'COUNT(%s)' % (xeval_attribute(node.args[0], ctx),)
elif fn == 'area':
assert len(node.args) == 1 and type(node.args[0]) == ast.Attribute
xeval_attribute(node.args[0], ctx)
return True, 'XBlob.area'
elif fn == 'areas':
assert len(node.args) == 1 and type(node.args[0]) == ast.Attribute
xeval_attribute(node.args[0], ctx)
return True, 'SUM(XBlob.area)'
else:
pass # Raise
def xeval_unaryop(node, ctx):
if type(node.op) == ast.Not:
return ctx.all_paths - xeval(node.operand, cur)
else:
pass # Raise
def xeval_boolop(node, ctx):
values = [ xeval(v, ctx) for v in node.values ]
if type(node.op) == ast.And:
return reduce(set.intersection, values, ctx.all_paths)
elif type(node.op) == ast.Or:
return reduce(set.union, values, set())
else:
pass # Raise
def xeval_compare(node, ctx):
comparators = [ node.left ] + node.comparators
paths = ctx.all_paths
for op, x, y in zip(map(type, node.ops), comparators[:-1], comparators[1:]):
if op == ast.Lt:
op_str = '<'
elif op == ast.LtE:
op_str = '<='
elif op == ast.Gt:
op_str = '>'
elif op == ast.GtE:
op_str = '>='
elif op == ast.Eq:
op_str = '='
elif op == ast.NotEq:
op_str = '<>'
else:
pass # raise
comps = [ '', '' ]
conjs = ctx.where_conjs
for i, z in enumerate([ x, y ]):
if type(z) == ast.Call:
h, comps[i] = xeval_call(z, ctx)
if h:
conjs = ctx.having_conjs
elif type(z) == ast.Attribute:
comps[i] = xeval_attribute(z, ctx)
elif type(z) == ast.Str:
comps[i] = ctx.push_param(xeval_str(z))
elif type(z) == ast.Num:
comps[i] = ctx.push_param(xeval_num(z))
else:
pass # raise
conjs.add('%s%s%s' % (comps[0], op_str, comps[1]))
#
paths = paths.intersection(ctx.execute_query())
ctx.reset()
if len(paths) == 0:
break
return paths
def xeval(node, ctx):
if type(node) == ast.UnaryOp:
return xeval_unaryop(node, ctx)
elif type(node) == ast.BoolOp:
return xeval_boolop(node, ctx)
elif type(node) == ast.Compare:
return xeval_compare(node, ctx)
else:
pass # raise
try:
conn = _ximage_index_connect(args)
except IOError as e:
sys.stderr.write('Error: cannot open index: %s\n' % (str(e),))
return 1
except ImportError:
sys.stderr.write('Error: cannot import sqlite3 module\n')
return -1
query = ' '.join(args.query)
if query is None or len(query.strip()) == 0:
paths = XEvalContext(conn.cursor()).all_paths
else:
root = ast.parse(query, '<query>', 'eval')
paths = xeval(root.body, XEvalContext(conn.cursor()))
print('\n'.join(sorted(paths)))
return 0
def ximage_main(prog_name='ximage'):
parser = argparse.ArgumentParser(prog=prog_name, description='Manipulate images along with its metadata')
subparsers = parser.add_subparsers(help='sub-commands help')
parser_import = subparsers.add_parser('import', help='Add blobs and metadata to an image, importing index mask')
parser_import.add_argument('-K', '--classes', type=str, required=False, nargs='+', default=[], help='List of classes, 0-indexed')
parser_import.add_argument('-U', '--uuids', type=str, required=False, nargs='+', default=[], help='List of UUIDs (0 to generate)')
parser_import.add_argument('-C', '--colors', type=str, required=False, nargs='+', default=[], help='List of classes\' colors')
parser_import.add_argument('mask', type=str, help='Index mask path')
parser_import.add_argument('path', type=str, help='Image path')
parser_import.set_defaults(func=ximage_import)
parser_export = subparsers.add_parser('export', help='Export index mask from an image')
parser_export.add_argument('path', type=str, help='Image path')
parser_export.add_argument('mask', type=str, help='Index mask path')
parser_export.set_defaults(func=ximage_export)
parser_inject = subparsers.add_parser('inject', help='Add blobs and metadata to an image')
parser_inject.add_argument('metadata', type=str, help='XML')
parser_inject.add_argument('path', type=str, help='Image path')
parser_inject.set_defaults(func=ximage_inject)
parser_extract = subparsers.add_parser('extract', help='Extract blobs and metadata from an image')
parser_extract.add_argument('path', type=str, help='Image path')
parser_extract.set_defaults(func=ximage_extract)
parser_update = subparsers.add_parser('update', help='Update image metadata with XML')
parser_update.add_argument('-f', '--overwrite', action='store_true', required=False, default=False, help='Overwrite present values (default: no)')
parser_update.add_argument('-K', '--replace-classes', action='store_true', required=False, default=False, help='Overwrite all defined classes (default: no)')
parser_update.add_argument('metadata', type=str, help='Metadata to update with')
parser_update.add_argument('path', type=str, help='Image path')
parser_update.add_argument('mapping', nargs=argparse.REMAINDER)
parser_update.set_defaults(func=ximage_update)
parser_uuid = subparsers.add_parser('uuid', help='Get/set items UUIDs (left to right, top to bottom)')
parser_uuid.add_argument('-U', '--uuids', type=str, required=False, nargs='+', default=[], help='List of new UUIDs (0 to skip)')
parser_uuid.add_argument('path', type=str, help='Image path')
parser_uuid.set_defaults(func=ximage_uuid)
parser_view = subparsers.add_parser('view', help='View images, blobs and other metadata')
parser_view.add_argument('-m', '--metadata', type=str, required=False, default=None, help='Use this XML instead of image\'s XMP')
parser_view.add_argument('-o', '--output_path', type=str, required=False, default=None, help='Output image path')
parser_view.add_argument('path', type=str, help='Image path')
parser_view.set_defaults(func=ximage_view)
parser_index = subparsers.add_parser('index', help='Index a directory (recursively) of XImages')
parser_index.add_argument('root', type=str, help='Root directory path')
parser_index.set_defaults(func=ximage_index)
parser_query = subparsers.add_parser('query', help='Query on indexed directory of XImages')
parser_query.add_argument('-D', '--root', type=str, required=False, default=os.getcwd(), help='Root directory path (default: cwd)')
parser_query.add_argument('query', nargs=argparse.REMAINDER)
parser_query.set_defaults(func=ximage_query)
parser_stats = subparsers.add_parser('stats', help='Show some indexed directory statistics')
parser_stats.add_argument('-D', '--root', type=str, required=False, default=os.getcwd(), help='Root directory path (default: cwd)')
parser_stats.set_defaults(func=ximage_stats)
args = parser.parse_args()
sys.exit(args.func(args))
_COLORS = dict(
maroon=(0x00, 0x00, 0x80),
darkred=(0x00, 0x00, 0x8b),
red=(0x00, 0x00, 0xff),
lightpink=(0xc1, 0xb6, 0xff),
crimson=(0x3c, 0x14, 0xdc),
palevioletred=(0x93, 0x70, 0xdb),
hotpink=(0xb4, 0x69, 0xff),
deeppink=(0x93, 0x14, 0xff),
mediumvioletred=(0x85, 0x15, 0xc7),
purple=(0x80, 0x00, 0x80),
darkmagenta=(0x8b, 0x00, 0x8b),
orchid=(0xd6, 0x70, 0xda),
thistle=(0xd8, 0xbf, 0xd8),
plum=(0xdd, 0xa0, 0xdd),
violet=(0xee, 0x82, 0xee),
fuchsia=(0xff, 0x00, 0xff),
magenta=(0xff, 0x00, 0xff),
mediumorchid=(0xd3, 0x55, 0xba),
darkviolet=(0xd3, 0x00, 0x94),
darkorchid=(0xcc, 0x32, 0x99),
blueviolet=(0xe2, 0x2b, 0x8a),
indigo=(0x82, 0x00, 0x4b),
mediumpurple=(0xdb, 0x70, 0x93),
slateblue=(0xcd, 0x5a, 0x6a),
mediumslateblue=(0xee, 0x68, 0x7b),
darkblue=(0x8b, 0x00, 0x00),
mediumblue=(0xcd, 0x00, 0x00),
blue=(0xff, 0x00, 0x00),
navy=(0x80, 0x00, 0x00),
midnightblue=(0x70, 0x19, 0x19),
darkslateblue=(0x8b, 0x3d, 0x48),
royalblue=(0xe1, 0x69, 0x41),
cornflowerblue=(0xed, 0x95, 0x64),
lightsteelblue=(0xde, 0xc4, 0xb0),
aliceblue=(0xff, 0xf8, 0xf0),
ghostwhite=(0xff, 0xf8, 0xf8),
lavender=(0xfa, 0xe6, 0xe6),
dodgerblue=(0xff, 0x90, 0x1e),
steelblue=(0xb4, 0x82, 0x46),
deepskyblue=(0xff, 0xbf, 0x00),
slategray=(0x90, 0x80, 0x70),
lightslategray=(0x99, 0x88, 0x77),
lightskyblue=(0xfa, 0xce, 0x87),
skyblue=(0xeb, 0xce, 0x87),
lightblue=(0xe6, 0xd8, 0xad),
teal=(0x80, 0x80, 0x00),
darkcyan=(0x8b, 0x8b, 0x00),
darkturquoise=(0xd1, 0xce, 0x00),
cyan=(0xff, 0xff, 0x00),
mediumturquoise=(0xcc, 0xd1, 0x48),
cadetblue=(0xa0, 0x9e, 0x5f),
paleturquoise=(0xee, 0xee, 0xaf),
lightcyan=(0xff, 0xff, 0xe0),
azure=(0xff, 0xff, 0xf0),
lightseagreen=(0xaa, 0xb2, 0x20),
turquoise=(0xd0, 0xe0, 0x40),
powderblue=(0xe6, 0xe0, 0xb0),
darkslategray=(0x4f, 0x4f, 0x2f),
aquamarine=(0xd4, 0xff, 0x7f),
mediumspringgreen=(0x9a, 0xfa, 0x00),
mediumaquamarine=(0xaa, | |
<filename>QUANTAXIS/QAFetch/QAQuery.py<gh_stars>1-10
# coding: utf-8
#
# The MIT License (MIT)
#
# Copyright (c) 2016-2018 yutiansut/QUANTAXIS
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
import datetime
import numpy
import pandas as pd
from pandas import DataFrame
from QUANTAXIS.QAUtil import (DATABASE, QA_Setting, QA_util_date_stamp,
QA_util_date_valid, QA_util_dict_remove_key,
QA_util_log_info, QA_util_code_tolist, QA_util_date_str2int, QA_util_date_int2str,
QA_util_sql_mongo_sort_DESCENDING,
QA_util_time_stamp, QA_util_to_json_from_pandas,
trade_date_sse)
from QUANTAXIS.QAData.financial_mean import financial_dict
"""
按要求从数据库取数据，并转换成numpy结构
2018-07-30 修改 增加batch_size 可以做到8MB/S-30mb/s的传输速度
"""
def QA_fetch_stock_day(code, start, end, format='numpy', frequence='day', collections=DATABASE.stock_day):
'获取股票日线'
start = str(start)[0:10]
end = str(end)[0:10]
#code= [code] if isinstance(code,str) else code
# code checking
code = QA_util_code_tolist(code)
if QA_util_date_valid(end):
__data = []
cursor = collections.find({
'code': {'$in': code}, "date_stamp": {
"$lte": QA_util_date_stamp(end),
"$gte": QA_util_date_stamp(start)}}, batch_size=10000)
#res=[QA_util_dict_remove_key(data, '_id') for data in cursor]
res = pd.DataFrame([item for item in cursor])
try:
res = res.drop('_id', axis=1).assign(volume=res.vol, date=pd.to_datetime(
res.date)).drop_duplicates((['date', 'code'])).query('volume>1').set_index('date', drop=False)
res = res.ix[:, ['code', 'open', 'high', 'low',
'close', 'volume', 'amount', 'date']]
except:
res = None
if format in ['P', 'p', 'pandas', 'pd']:
return res
elif format in ['json', 'dict']:
return QA_util_to_json_from_pandas(res)
# 多种数据格式
elif format in ['n', 'N', 'numpy']:
return numpy.asarray(res)
elif format in ['list', 'l', 'L']:
return numpy.asarray(res).tolist()
else:
print("QA Error QA_fetch_stock_day format parameter %s is none of \"P, p, pandas, pd , json, dict , n, N, numpy, list, l, L, !\" " % format)
return None
else:
QA_util_log_info(
'QA Error QA_fetch_stock_day data parameter start=%s end=%s is not right' % (start, end))
def QA_fetch_stock_min(code, start, end, format='numpy', frequence='1min', collections=DATABASE.stock_min):
'获取股票分钟线'
if frequence in ['1min', '1m']:
frequence = '1min'
elif frequence in ['5min', '5m']:
frequence = '5min'
elif frequence in ['15min', '15m']:
frequence = '15min'
elif frequence in ['30min', '30m']:
frequence = '30min'
elif frequence in ['60min', '60m']:
frequence = '60min'
else:
print("QA Error QA_fetch_stock_min parameter frequence=%s is none of 1min 1m 5min 5m 15min 15m 30min 30m 60min 60m" % frequence)
__data = []
# code checking
code = QA_util_code_tolist(code)
cursor = collections.find({
'code': {'$in': code}, "time_stamp": {
"$gte": QA_util_time_stamp(start),
"$lte": QA_util_time_stamp(end)
}, 'type': frequence
}, batch_size=10000)
res = pd.DataFrame([item for item in cursor])
try:
res = res.drop('_id', axis=1).assign(volume=res.vol, datetime=pd.to_datetime(
res.datetime)).query('volume>1').drop_duplicates(['datetime', 'code']).set_index('datetime', drop=False)
# return res
except:
res = None
if format in ['P', 'p', 'pandas', 'pd']:
return res
elif format in ['json', 'dict']:
return QA_util_to_json_from_pandas(res)
# 多种数据格式
elif format in ['n', 'N', 'numpy']:
return numpy.asarray(res)
elif format in ['list', 'l', 'L']:
return numpy.asarray(res).tolist()
else:
print("QA Error QA_fetch_stock_min format parameter %s is none of \"P, p, pandas, pd , json, dict , n, N, numpy, list, l, L, !\" " % format)
return None
def QA_fetch_trade_date():
'获取交易日期'
return trade_date_sse
def QA_fetch_stock_list(collections=DATABASE.stock_list):
'获取股票列表'
return [item for item in collections.find()]
def QA_fetch_index_list(collections=DATABASE.index_list):
'获取指数列表'
return [item for item in collections.find()]
def QA_fetch_stock_terminated(collections=DATABASE.stock_terminated):
'获取股票基本信息 , 已经退市的股票列表'
items = [item for item in collections.find()]
# 🛠todo 转变成 dataframe 类型数据
return items
def QA_fetch_stock_basic_info_tushare(collections=DATABASE.stock_info_tushare):
'''
purpose:
tushare 股票列表数据库
code,代码
name,名称
industry,所属行业
area,地区
pe,市盈率
outstanding,流通股本(亿)
totals,总股本(亿)
totalAssets,总资产(万)
liquidAssets,流动资产
fixedAssets,固定资产
reserved,公积金
reservedPerShare,每股公积金
esp,每股收益
bvps,每股净资
pb,市净率
timeToMarket,上市日期
undp,未分利润
perundp, 每股未分配
rev,收入同比(%)
profit,利润同比(%)
gpr,毛利率(%)
npr,净利润率(%)
holders,股东人数
add by tauruswang,
:param collections: stock_info_tushare 集合
:return:
'''
'获取股票基本信息'
items = [item for item in collections.find()]
# 🛠todo 转变成 dataframe 类型数据
return items
def QA_fetch_stock_to_market_date(stock_code):
'''
根据tushare 的数据库查找上市的日期
:param stock_code: '600001'
:return: string 上市日期 eg： '2018-05-15'
'''
items = QA_fetch_stock_basic_info_tushare()
for row in items:
if row['code'] == stock_code:
return row['timeToMarket']
def QA_fetch_stock_full(date, format='numpy', collections=DATABASE.stock_day):
'获取全市场的某一日的数据'
Date = str(date)[0:10]
if QA_util_date_valid(Date) is True:
__data = []
for item in collections.find({
"date_stamp": QA_util_date_stamp(Date)}, batch_size=10000):
__data.append([str(item['code']), float(item['open']), float(item['high']), float(
item['low']), float(item['close']), float(item['vol']), item['date']])
# 多种数据格式
if format in ['n', 'N', 'numpy']:
__data = numpy.asarray(__data)
elif format in ['list', 'l', 'L']:
__data = __data
elif format in ['P', 'p', 'pandas', 'pd']:
__data = DataFrame(__data, columns=[
'code', 'open', 'high', 'low', 'close', 'volume', 'date'])
__data['date'] = pd.to_datetime(__data['date'])
__data = __data.set_index('date', drop=False)
else:
print("QA Error QA_fetch_stock_full format parameter %s is none of \"P, p, pandas, pd , json, dict , n, N, numpy, list, l, L, !\" " % format)
return __data
else:
QA_util_log_info(
'QA Error QA_fetch_stock_full data parameter date=%s not right' % date)
def QA_fetch_index_day(code, start, end, format='numpy', collections=DATABASE.index_day):
'获取指数日线'
start = str(start)[0:10]
end = str(end)[0:10]
code = QA_util_code_tolist(code)
if QA_util_date_valid(end) == True:
__data = []
cursor = collections.find({
'code': {'$in': code}, "date_stamp": {
"$lte": QA_util_date_stamp(end),
"$gte": QA_util_date_stamp(start)}}, batch_size=10000)
if format in ['dict', 'json']:
return [data for data in cursor]
for item in cursor:
__data.append([str(item['code']), float(item['open']), float(item['high']), float(
item['low']), float(item['close']), int(item['up_count']), int(item['down_count']), float(item['vol']), float(item['amount']), item['date']])
# 多种数据格式
if format in ['n', 'N', 'numpy']:
__data = numpy.asarray(__data)
elif format in ['list', 'l', 'L']:
__data = __data
elif format in ['P', 'p', 'pandas', 'pd']:
__data = DataFrame(
__data, columns=['code', 'open', 'high', 'low', 'close', 'up_count', 'down_count', 'volume', 'amount', 'date'])
__data['date'] = pd.to_datetime(__data['date'])
__data = __data.set_index('date', drop=False)
else:
print("QA Error QA_fetch_index_day format parameter %s is none of \"P, p, pandas, pd , n, N, numpy !\" " % format)
return __data
else:
QA_util_log_info('QA something wrong with date')
def QA_fetch_index_min(
code,
start, end,
format='numpy',
frequence='1min',
collections=DATABASE.index_min):
'获取股票分钟线'
if frequence in ['1min', '1m']:
frequence = '1min'
elif frequence in ['5min', '5m']:
frequence = '5min'
elif frequence in ['15min', '15m']:
frequence = '15min'
elif frequence in ['30min', '30m']:
frequence = '30min'
elif frequence in ['60min', '60m']:
frequence = '60min'
__data = []
code = QA_util_code_tolist(code)
cursor = collections.find({
'code': {'$in': code}, "time_stamp": {
"$gte": QA_util_time_stamp(start),
"$lte": QA_util_time_stamp(end)
}, 'type': frequence
}, batch_size=10000)
if format in ['dict', 'json']:
return [data for data in cursor]
for item in cursor:
__data.append([str(item['code']), float(item['open']), float(item['high']), float(
item['low']), float(item['close']), int(item['up_count']), int(item['down_count']), float(item['vol']), float(item['amount']), item['datetime'], item['time_stamp'], item['date']])
__data = DataFrame(__data, columns=[
'code', 'open', 'high', 'low', 'close', 'up_count', 'down_count', 'volume', 'amount', 'datetime', 'time_stamp', 'date'])
__data['datetime'] = pd.to_datetime(__data['datetime'])
__data = __data.set_index('datetime', drop=False)
if format in ['numpy', 'np', 'n']:
return numpy.asarray(__data)
elif format in ['list', 'l', 'L']:
return numpy.asarray(__data).tolist()
elif format in ['P', 'p', 'pandas', 'pd']:
return __data
def QA_fetch_future_day(code, start, end, format='numpy', collections=DATABASE.future_day):
start = str(start)[0:10]
end = str(end)[0:10]
code = QA_util_code_tolist(code, auto_fill=False)
if QA_util_date_valid(end) == True:
__data = []
cursor = collections.find({
'code': {'$in': code}, "date_stamp": {
"$lte": QA_util_date_stamp(end),
"$gte": QA_util_date_stamp(start)}}, batch_size=10000)
if format in ['dict', 'json']:
return [data for data in cursor]
for item in cursor:
__data.append([str(item['code']), float(item['open']), float(item['high']), float(
item['low']), float(item['close']), float(item['position']), float(item['price']), float(item['trade']), item['date']])
# 多种数据格式
if format in ['n', 'N', 'numpy']:
__data = numpy.asarray(__data)
elif format in ['list', 'l', 'L']:
__data = __data
elif format in ['P', 'p', 'pandas', 'pd']:
__data = DataFrame(
__data, columns=['code', 'open', 'high', 'low', 'close', 'position', 'price', 'trade', 'date'])
__data['date'] = pd.to_datetime(__data['date'])
__data = __data.set_index('date', drop=False)
else:
print("QA Error QA_fetch_future_day format parameter %s is none of \"P, p, pandas, pd , n, N, numpy !\" " % format)
return __data
else:
QA_util_log_info('QA something wrong with date')
def QA_fetch_future_min(
code,
start, end,
format='numpy',
frequence='1min',
collections=DATABASE.future_min):
'获取股票分钟线'
if frequence in ['1min', '1m']:
frequence = '1min'
elif frequence in ['5min', '5m']:
frequence = '5min'
elif frequence in ['15min', '15m']:
frequence = '15min'
elif frequence in ['30min', '30m']:
frequence = '30min'
elif frequence in ['60min', '60m']:
frequence = '60min'
__data = []
code = QA_util_code_tolist(code,auto_fill=False)
cursor = collections.find({
'code': {'$in': code}, "time_stamp": {
"$gte": QA_util_time_stamp(start),
"$lte": QA_util_time_stamp(end)
}, 'type': frequence
}, batch_size=10000)
if format in ['dict', 'json']:
return [data for data in cursor]
| |
<gh_stars>1-10
# -*- coding: utf-8 -*-
"""EDA_Loan Approval System.ipynb
Automatically generated by Colaboratory.
Original file is located at
https://colab.research.google.com/drive/1Sv6QW4TJX0C9sCKhxevV5ocqAyY1sxbx
# Problem Statement
## Business Use-case
- Home loan company/bank gets application for loan from variour customers (loan applicants) where based on certain inputs company validates the customer eligibility for loan.
- We want to automate the loan eligibility process (real time) based on customer detail obtained during loan application. These details are Gender, Marital Status, Education, Number of Dependents, Income, Loan Amount, Credit History and others.
## Business goal
- If the loan approval process is automated, it can save a lot of man hours and improve the speed of service to the customers.
- The increase in customer satisfaction and savings in operational costs are significant.
- However, the benefits can only be reaped if the bank has a robust model to accurately predict which application it should approve and which to reject, in order to minimize the risk of loan default.
## Translating Problem into Data Science / Machine Learning use case
- This is a classification problem where we have to predict whether a loan will be approved or not.
- Specifically, it is a binary classification problem where we have to predict either one of the two classes given i.e. approved (Y) or not approved (N).
- Other way to frame the problem is to predict whether the loan will likely to default or not.
- The dependent variable is the Loan_Status, while the rest are independent variable or features.
- We need to develop a model using the features to predict the target variable.
"""
# Commented out IPython magic to ensure Python compatibility.
# import libraries
# %matplotlib inline
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
pd.set_option('display.max_rows', 500)
pd.set_option('display.max_columns', 500)
pd.set_option('display.width', 150)
import warnings
warnings.filterwarnings("ignore")
from google.colab import files
uploaded = files.upload()
"""## Exploratory Data Analysis (EDA)"""
# Import data
df = pd.read_csv("loan_train.csv")
print('Information on dataset:')
df.info()
print('Head:'); print(df.head()); print(); print('Tail:'); print(df.tail());
"""
## Hypotheses
Through this process, all the possible factors are listed here which can affect the outcome i.e. which of the features will have an impact on whether a loan will be approved or not.
Some of the hypothesis are:
- Education - Applicants with higher education level i.e. graduate level should have higher chances of loan approval
- Income: Applicants with higher income should have more chances of loan approval
- Loan amount: If the loan amount is less, the chances of loan approval should be high
- Loan term: Loans with shorter time period should have higher chances of approval
- Previous credit history: Applicants who have repayed their previous debts should have higher chances of loan approval
- Monthly installment amount: If the monthly installment amount is low, the chances of loan approval should be high And so on
Some of the hypothesis are intuitive while others may not. We will try to validate each of these hypothesis based on the dataset."""
df.describe()
"""# Exploratory data analysis
## Univariate analysis
###Target Variable (Categorical)
"""
plt.style.use('ggplot')
from pylab import rcParams
import matplotlib.ticker as mtick # For specifying the axes tick format
rcParams['figure.figsize']=10,6
# bar plot to visualize the frequency
ax = (df['Loan_Status'].value_counts()*100.0 /len(df)).plot(kind='bar', stacked = True, rot = 0)
ax.yaxis.set_major_formatter(mtick.PercentFormatter())
ax.set_ylabel('% Loan application')
ax.set_xlabel('Status')
ax.set_ylabel('% Customers')
ax.set_title('Application Distribution')
totals = [] # creating a list to collect the plt.patches data
# finding the values and append to list
for i in ax.patches:
totals.append(i.get_width())
total = sum(totals) # setting individual bar lables using above list
for i in ax.patches:
# getting_width pulls left or right; get_y pushes up or down
ax.text(i.get_x()+.15, i.get_height()-3.5, \
str(round((i.get_height()/total), 1))+'%', color='white', weight = 'bold')
"""The loan of around 68.7% was approved. There is no imbalanced classes issue in this dataset, thus accuracy as an evaluation metric should be appropriate.
### Independent Variable (Categorical)
There are 5 features that are categorical or binary (Gender, Married, Self_Employed, Credit_History, Education)
"""
# Visualizing categorical features
# plt.figure(1)
plt.subplot(231)
df['Gender'].value_counts(normalize=True).plot.bar(figsize=(20,10), title= 'Gender')
plt.subplot(232)
df['Married'].value_counts(normalize=True).plot.bar(title= 'Married')
plt.subplot(233)
df['Self_Employed'].value_counts(normalize=True).plot.bar(title= 'Self_Employed')
plt.subplot(234)
df['Credit_History'].value_counts(normalize=True).plot.bar(title= 'Credit_History')
plt.subplot(235)
df['Education'].value_counts(normalize=True).plot.bar(title= 'Education')
plt.show()
"""- 80% applicants in the dataset are male.
- 65% of the applicants in the dataset are married.
- 15% applicants in the dataset are self employed.
- 85% applicants have credit history (repaid their debts).
- 80% of the applicants are Graduate.
### Independent Variable (Ordinal)
There are 2 features that are Ordinal: Variables in categorical features having some order involved (Dependents, Property_Area)
"""
# Remaining categorical features
plt.subplot(121)
df['Dependents'].value_counts(normalize=True).plot.bar(figsize=(10,4), title= 'Dependents')
plt.subplot(122)
df['Property_Area'].value_counts(normalize=True).plot.bar(title= 'Property_Area')
plt.show()
"""- More than half of the applicants don’t have any dependents.
- Most of the applicants are from Semiurban area.
### Independent Variable
There are 4 features that are Numerical:
- ApplicantIncome,
- CoapplicantIncome,
- LoanAmount,
- Loan_Amount_Term
"""
numerical_columns = ['ApplicantIncome', 'CoapplicantIncome', 'LoanAmount']
print(numerical_columns)
fig,axes = plt.subplots(1,3,figsize=(17,5))
for idx,cat_col in enumerate(numerical_columns):
sns.boxplot(y=cat_col,data=df,x='Loan_Status',ax=axes[idx])
print(df[numerical_columns].describe())
plt.subplots_adjust(hspace=1)
plt.tight_layout()
"""### Applicant income distribution"""
plt.subplot(121)
sns.distplot(df['ApplicantIncome']);
plt.subplot(122)
df['ApplicantIncome'].plot.box(figsize=(10,5))
plt.show()
"""- Most of the data in the distribution of applicant income is towards left which means it is not normally distributed.
- Distribution is right-skewed.
- We need to make it normal.
The boxplot confirms the presence of a lot of outliers/extreme values.
"""
# Income vs Education
df.boxplot(column='ApplicantIncome', by = 'Education')
plt.suptitle(""); plt.show()
"""higher number of graduates with very high incomes, which are appearing to be the outliers."""
# co-applicant income distribution
plt.subplot(121)
sns.distplot(df['CoapplicantIncome']);
plt.subplot(122)
df['CoapplicantIncome'].plot.box(figsize=(10,5))
plt.show()
"""Majority of coapplicant’s income ranges from 0 to 5000. We also see a lot of outliers in the coapplicant income and it is not normally distributed."""
# distribution of LoanAmount
plt.subplot(121)
sns.distplot(df['LoanAmount']);
plt.subplot(122)
df['LoanAmount'].plot.box(figsize=(10,5))
plt.show()
"""normal distribution but still slightly right-skewed for LoanAmount but there are lot of outliers in this variable. """
# distribution of Loan_Amount_Term
df['Loan_Amount_Term'].value_counts(normalize=True).plot.bar(title= 'Loan_Amount_Term')
plt.show()
"""- 85% of the loans are 360 months term/30 years period
## Bivariate Analysis
### Categorical Independent Variable vs Target Variable
"""
print(pd.crosstab(df['Gender'],df['Loan_Status']))
Gender = pd.crosstab(df['Gender'],df['Loan_Status'])
Gender.div(Gender.sum(1).astype(float), axis = 0).plot(kind="bar", stacked=True, figsize=(6,4))
plt.xlabel('Gender')
p = plt.ylabel('Percentage')
plt.show()
print(pd.crosstab(df['Married'],df['Loan_Status']))
Married = pd.crosstab(df['Married'],df['Loan_Status'])
Married.div(Married.sum(1).astype(float), axis=0).plot(kind="bar", stacked=True, figsize=(6,4))
plt.xlabel('Married')
p = plt.ylabel('Percentage')
print(pd.crosstab(df['Dependents'],df['Loan_Status']))
Dependents=pd.crosstab(df['Dependents'],df['Loan_Status'])
Dependents.div(Dependents.sum(1).astype(float), axis=0).plot(kind="bar", stacked=True)
plt.xlabel('Dependents')
p = plt.ylabel('Percentage')
print(pd.crosstab(df['Education'],df['Loan_Status']))
Education=pd.crosstab(df['Education'],df['Loan_Status'])
Education.div(Education.sum(1).astype(float), axis=0).plot(kind="bar", stacked=True, figsize=(6,4))
plt.xlabel('Education')
p = plt.ylabel('Percentage')
print(pd.crosstab(df['Self_Employed'], df['Loan_Status']))
Self_Employed=pd.crosstab(df['Self_Employed'],df['Loan_Status'])
Self_Employed.div(Self_Employed.sum(1).astype(float), axis=0).plot(kind="bar", stacked=True, figsize=(6,4))
plt.xlabel('Self_Employed')
p = plt.ylabel('Percentage')
print(pd.crosstab(df['Credit_History'], df['Loan_Status']))
Credit_History=pd.crosstab(df['Credit_History'], df['Loan_Status'])
Credit_History.div(Credit_History.sum(1).astype(float), axis=0).plot(kind="bar", stacked=True, figsize=(6,4))
plt.xlabel('Credit_History')
p = plt.ylabel('Percentage')
print(pd.crosstab(df['Property_Area'],df['Loan_Status']))
Property_Area=pd.crosstab(df['Property_Area'],df['Loan_Status'])
Property_Area.div(Property_Area.sum(1).astype(float), axis=0).plot(kind="bar", stacked=True)
plt.xlabel('Property_Area')
P = plt.ylabel('Percentage')
"""- proportion of male and female applicants is more or less same for both approved and unapproved loans
- proportion of married applicants is higher for the approved loans
distribution of applicants with 1 or 3+ dependents is similar across both the categories of Loan_Status there is nothing significant we can infer from Self_Employed vs Loan_Status plot.
- proportion of loans getting approved for graduates is higher compared to non-graduates it seems people with credit history as 1 are more likely to get their loans approved
- proportion of loans getting approved in semiurban area is higher as compared to that in rural or urban areas.
### Numerical Independent Variable vs Target Variable
"""
df[df['ApplicantIncome'] > 20000].sort_values(by = 'ApplicantIncome')
"""All applicants with an income greater than 20,000 have higher level of education, it seems reasonable that these applicants would have higher income. However, since most of the dataset is comprised of applicants with higher education this alone would not explain the difference. However, for most of these points there is nothing indicating we should remove these points.
If we look at row 409, we see that this applicant's income is the largest in our dataset, and suspiciously ends in three 0's. Futhermore, the property area is rural, the credit history is marked 0, and the loan status is marked as having been declined. Given this information it is most likely that the applicant income was entered incorrectly.
**We should drop this point**
"""
df = df.drop(409)
df[df['LoanAmount'] > 400 ].sort_values(by = 'ApplicantIncome')
"""Only 4 out of 15 of the loans were denied, but since many of the incomes are fairly high this doesn't seem completely unreasonable.
While some of these points could be questioned, we lack significant evidence that any of these points should be removed.
"""
print(df.groupby('Loan_Status')['ApplicantIncome'].mean())
df.groupby('Loan_Status')['ApplicantIncome'].mean().plot.bar()
P = plt.ylabel('mean applicant income')
plt.show()
# making bins for applicant income variable
bins = [0,2500,4000,6000,81000]
group = ['Low','Average','High', 'Very high']
df['Income_bin'] = pd.cut(df['ApplicantIncome'],bins,labels=group)
df.head()
print(pd.crosstab(df['Income_bin'],df['Loan_Status']))
Income_bin = pd.crosstab(df['Income_bin'],df['Loan_Status'])
Income_bin.div(Income_bin.sum(1).astype(float), axis=0).plot(kind="bar", stacked=True)
plt.xlabel('ApplicantIncome')
P = plt.ylabel('Percentage')
plt.show()
"""Applicant income does not affect the chances of loan approval which contradicts our hypothesis in which we assumed that if the applicant income is high the chances of loan approval will also be high"""
# making bins for Coapplicant income variable
bins = [0,1000,3000,42000]
group = ['Low','Average','High']
df['Coapplicant_Income_bin'] = pd.cut(df['CoapplicantIncome'],bins,labels=group)
# plot the chart
Coapplicant_Income_bin = pd.crosstab(df['Coapplicant_Income_bin'],df['Loan_Status'])
Coapplicant_Income_bin.div(Coapplicant_Income_bin.sum(1).astype(float), axis=0).plot(kind="bar", stacked=True)
plt.xlabel('CoapplicantIncome')
P = plt.ylabel('Percentage')
plt.show()
print(len(df[df["CoapplicantIncome"] == 0]))
"Percentage of CoapplicantIncome = 0 is:", len(df[df["CoapplicantIncome"] == 0])/len(df["CoapplicantIncome"])
"""- Historically if coapplicant’s income is less the chances of loan approval are high.
- However, most | |
import h5py
import numpy as np
import pyxrf
from pyxrf.model.scan_metadata import *
from pyxrf.core.utils import *
from pyxrf.model.load_data_from_db import _get_fpath_not_existing, helper_encode_list
try:
from databroker.v0 import Broker
except ModuleNotFoundError:
from databroker import Broker
try:
from pyxrf.api_dev import db
except ImportError:
db = None
print("Error importing pyXRF. Continuing without import.")
if not db:
# Register the data broker
try:
db = Broker.named("srx")
except AttributeError:
db = Broker.named("temp")
print("Using temporary databroker.")
pyxrf_version = pyxrf.__version__
def _extract_metadata_from_header(hdr):
"""
Extract metadata from start and stop document. Metadata extracted from other document
in the scan are beamline specific and added to dictionary at later time.
"""
start_document = hdr.start
mdata = ScanMetadataXRF()
data_locations = {
"scan_id": ["scan_id"],
"scan_uid": ["uid"],
"scan_instrument_id": ["beamline_id"],
"scan_instrument_name": [],
"scan_time_start": ["time"],
"scan_time_start_utc": ["time"],
"instrument_mono_incident_energy": ["scan/energy"],
"instrument_beam_current": [],
"instrument_detectors": ["detectors"],
"sample_name": ["scan/sample_name"],
"experiment_plan_name": ["plan_name"],
"experiment_plan_type": ["plan_type"],
"experiment_fast_axis": ["scan/fast_axis/motor_name"],
"experiment_slow_axis": ["scan/slow_axis/motor_name"],
"proposal_num": ["proposal/proposal_num"],
"proposal_title": ["proposal/proposal_title"],
"proposal_PI_lastname": ["proposal/PI_lastname"],
"proposal_saf_num": ["proposal/saf_num"],
"proposal_cycle": ["proposal/cycle"]
}
for key, locations in data_locations.items():
# Go to the next key if no location is defined for the current key.
# No locations means that the data is not yet defined in start document on any beamline
# Multiple locations point to locations at different beamlines
if not locations:
continue
# For each metadata key there could be none, one or multiple locations in the start document
for loc in locations:
path = loc.split('/') #
ref = start_document
for n, p in enumerate(path):
if n >= len(path) - 1:
break
# 'ref' must always point to dictionary
if not isinstance(ref, dict):
ref = None
break
if p in ref:
ref = ref[p]
else:
ref = None
break
# At this point 'ref' must be a dictionary
value = None
if ref is not None and isinstance(ref, dict):
if path[-1] in ref:
value = ref[path[-1]]
# Now we finally arrived to the end of the path: the 'value' must be a scalar or a list
if value is not None and not isinstance(value, dict):
if path[-1] == 'time':
if key.endswith("_utc"):
value = convert_time_to_nexus_string(ttime.gmtime(value))
else:
value = convert_time_to_nexus_string(ttime.localtime(value))
mdata[key] = value
break
stop_document = hdr.stop
if stop_document:
if "time" in stop_document:
t = stop_document["time"]
mdata["scan_time_stop"] = convert_time_to_nexus_string(ttime.localtime(t))
mdata["scan_time_stop_utc"] = convert_time_to_nexus_string(ttime.gmtime(t))
if "exit_status" in stop_document:
mdata["scan_exit_status"] = stop_document["exit_status"]
else:
mdata["scan_exit_status"] = "incomplete"
# Add full beamline name (if available, otherwise don't create the entry).
# Also, don't overwrite the existing name if it was read from the start document
if "scan_instrument_id" in mdata and "scan_instrument_name" not in mdata:
instruments = {
"srx": "Submicron Resolution X-ray Spectroscopy",
"hxn": "Hard X-ray Nanoprobe",
"tes": "Tender Energy X-ray Absorption Spectroscopy",
"xfm": "X-ray Fluorescence Microprobe"
}
iname = instruments.get(mdata["scan_instrument_id"].lower(), "")
if iname:
mdata["scan_instrument_name"] = iname
return mdata
def new_makehdf(scanid=-1, create_each_det=False):
# Get scan header
h = db[int(scanid)]
scanid = int(h.start['scan_id'])
start_doc = h.start
scan_doc = h.start['scan']
stop_doc = h.stop
# Check if new type of metadata
if 'md_version' not in h.start:
print('Please use old make_hdf.')
return
# Check for detectors
dets = []
try:
if 'xs' in h.start['scan']['detectors']:
dets.append('xs')
elif 'xs2' in h.start['scan']['detectors']:
dets.append('xs2')
except KeyError:
# AMK forgot to add detectors to step scans
# This is fixed, but left in for those scans
if scan_doc['type'] == 'XRF_STEP':
dets.append('xs')
if dets == []:
print('No detectors found!')
return
# Get metadata
mdata = _extract_metadata_from_header(h)
# Get position data from scan
c, r = h.start['scan']['shape']
if scan_doc['type'] == 'XRF_FLY':
fast_motor = scan_doc['fast_axis']['motor_name']
if (fast_motor == 'nano_stage_sx'):
fast_key = 'enc1'
elif (fast_motor == 'nano_stage_x'):
fast_key = 'enc1'
elif (fast_motor == 'nano_stage_sy'):
fast_key = 'enc2'
elif (fast_motor == 'nano_stage_y'):
fast_key = 'enc2'
elif (fast_motor == 'nano_stage_sz'):
fast_key = 'enc3'
else:
print(f'{fast_motor} not found!')
return
slow_motor = scan_doc['slow_axis']['motor_name']
if (slow_motor == 'nano_stage_sx'):
slow_key = 'enc1'
elif (slow_motor == 'nano_stage_x'):
slow_key = 'enc1'
elif (slow_motor == 'nano_stage_sy'):
slow_key = 'enc2'
elif (slow_motor == 'nano_stage_y'):
slow_key = 'enc2'
elif (slow_motor == 'nano_stage_sz'):
slow_key = 'enc3'
else:
slow_key = slow_motor
fast_pos = h.data(fast_key, stream_name='stream0', fill=True)
fast_pos = np.array(list(fast_pos))
if 'enc' in slow_key:
slow_pos = h.data(slow_key, stream_name='stream0', fill=True)
slow_pos = np.array(list(slow_pos))
else:
slow_pos = h.data(slow_key, stream_name='primary', fill=True)
slow_pos = np.array(list(slow_pos))
slow_pos = np.array([slow_pos,]*c).T
num_events = stop_doc['num_events']['stream0']
# pos_pos = np.zeros((2, r, c))
pos_pos = np.zeros((2, num_events, c))
if 'x' in slow_key:
pos_pos[1, :, :] = fast_pos
pos_pos[0, :, :] = slow_pos
else:
pos_pos[0, :, :] = fast_pos
pos_pos[1, :, :] = slow_pos
pos_name = ['x_pos', 'y_pos']
# Get detector data
if 'xs' in dets:
d_xs = np.array(list(h.data('fluor', stream_name='stream0', fill=True)))
N_xs = d_xs.shape[2]
d_xs_sum = np.squeeze(np.sum(d_xs, axis=2))
if 'xs2' in dets:
d_xs2 = np.array(list(h.data('fluor_xs2', stream_name='stream0', fill=True)))
N_xs2 = d_xs2.shape[2]
d_xs2_sum = np.squeeze(np.sum(d_xs2, axis=2))
# Scaler list
sclr_list = ['i0', 'i0_time', 'time', 'im', 'it']
sclr = []
sclr_name = []
for s in sclr_list:
if s in h.table('stream0').keys():
tmp = np.array(list(h.data(s, stream_name='stream0', fill=True)))
sclr.append(tmp)
sclr_name.append(s)
sclr = np.array(sclr)
sclr = np.moveaxis(sclr, 0, -1)
if scan_doc['type'] == 'XRF_STEP':
# Define keys for motor data
fast_motor = scan_doc['fast_axis']['motor_name']
fast_key = fast_motor + '_user_setpoint'
slow_motor = scan_doc['slow_axis']['motor_name']
slow_key = slow_motor + '_user_setpoint'
# Collect motor positions
fast_pos = h.data(fast_key, stream_name='primary', fill=True)
fast_pos = np.array(list(fast_pos))
slow_pos = h.data(slow_key, stream_name='primary', fill=True)
slow_pos = np.array(list(slow_pos))
# Reshape motor positions
num_events = stop_doc['num_events']['primary']
r, c = scan_doc['shape']
if num_events != (r * c):
num_rows = num_events // c + 1 # number of rows
fast_pos = np.zeros((num_rows, c))
slow_pos = np.zeros((num_rows, c))
for i in range(num_rows):
for j in range(c):
fast_pos[i, j] = fast_pos[i*c + j]
slow_pos[i, j] = slow_pos[i*c + j]
else:
num_rows = r
fast_pos = np.reshape(fast_pos, (r, c))
slow_pos = np.reshape(slow_pos, (r, c))
# Put into one array for h5 file
pos_pos = np.zeros((2, num_rows, c))
if 'x' in slow_key:
pos_pos[1, :, :] = fast_pos
pos_pos[0, :, :] = slow_pos
else:
pos_pos[0, :, :] = fast_pos
pos_pos[1, :, :] = slow_pos
pos_name = ['x_pos', 'y_pos']
# Get detector data
keys = h.table().keys()
MAX_DET_ELEMENTS = 7
for i in np.arange(1, MAX_DET_ELEMENTS+1):
if f'xs_channel{i}' in keys:
N_xs = i
else:
break
N_pts = num_events
N_bins= 4096
if 'xs' in dets:
d_xs = np.empty((N_xs, N_pts, N_bins))
for i in np.arange(0, N_xs):
d = h.data(f'xs_channel{i+1}', fill=True)
d = np.array(list(d))
d_xs[i, :, :] = np.copy(d)
del d
# Reshape data
if num_events != (r * c):
tmp = np.zeros((N_xs, num_rows, c, N_bins))
for i in range(num_rows):
for j in range(c):
tmp[:, i, j, :] = fast_pos[:, i*c + j, :]
d_xs = np.copy(tmp)
del tmp
else:
d_xs = np.reshape(d_xs, (N_xs, r, c, N_bins))
# Sum data
d_xs_sum = np.squeeze(np.sum(d_xs, axis=0))
# Scaler list
sclr_list = ['sclr_i0', 'sclr_im', 'sclr_it']
sclr_name = []
for s in sclr_list:
if s in keys:
sclr_name.append(s)
sclr = np.array(h.table()[sclr_name].values)
# Reshape data
if num_events != (r * c):
tmp = np.zeros((num_rows, c))
for i in range(num_rows):
for j in range(c):
tmp[i, j] = fast_pos[i*c + j]
sclr = np.copy(tmp)
del tmp
else:
sclr = np.reshape(sclr, (r, c, len(sclr_name)))
# Consider snake
# pos_pos, d_xs, d_xs_sum, sclr
if scan_doc['snake'] == 1:
pos_pos[:, fc00:db20:35b:7399::5, :] = pos_pos[:, fc00:db20:35b:7399::5, ::-1]
d_xs[:, fc00:db20:35b:7399::5, :, :] = d_xs[:, fc00:db20:35b:7399::5, ::-1, :]
d_xs_sum[1::2, :, :] = d_xs_sum[1::2, ::-1, :]
sclr[1::2, :, :] = sclr[1::2, ::-1, :]
# Transpose map for y scans
if scan_doc['type'] == 'XRF_FLY':
if (fast_motor == 'nano_stage_sy' or
fast_motor == 'nano_stage_y'):
# Need to swapaxes on pos_pos, d_xs, d_xs_sum, sclr
pos_name = pos_name[::-1]
pos_pos = np.swapaxes(pos_pos, 1, 2)
d_xs = np.swapaxes(d_xs, 1, 2)
d_xs_sum = np.swapaxes(d_xs_sum, 0, 1)
sclr = np.swapaxes(sclr, 0, 1)
# Write file
interpath = 'xrfmap'
for d in dets:
if d == 'xs':
tmp_data = d_xs
tmp_data_sum = d_xs_sum
N = N_xs
elif d == 'xs2':
tmp_data = d_xs2
tmp_data_sum = d_xs2_sum
N = N_xs2
if (create_each_det):
fn = f'scan2D_{scanid}_{d}_{N}ch.h5'
else:
fn = f'scan2D_{scanid}_{d}_sum{N}ch.h5'
file_open_mode = 'a'
fname_add_version = True
file_overwrite_existing = False
if fname_add_version:
fpath = _get_fpath_not_existing(fn)
else:
if file_overwrite_existing:
file_open_mode = 'w'
else:
print('File already exists!')
return
with h5py.File(fn, file_open_mode) as f:
# Create metadata group
metadata_grp = f.create_group(f"{interpath}/scan_metadata")
| |
so change perms on the directory's contents
changed |= recursive_set_attributes(b_fsname, follow, file_args, mtime, atime)
# Change perms on the file pointed to by the link
tmp_file_args = file_args.copy()
tmp_file_args['path'] = to_native(b_fsname, errors='surrogate_or_strict')
changed |= module.set_fs_attributes_if_different(tmp_file_args, changed, expand=False)
changed |= update_timestamp_for_file(tmp_file_args['path'], mtime, atime)
return changed
def initial_diff(path, state, prev_state):
diff = {'before': {'path': path},
'after': {'path': path},
}
if prev_state != state:
diff['before']['state'] = prev_state
diff['after']['state'] = state
return diff
#
# States
#
def get_timestamp_for_time(formatted_time, time_format):
if formatted_time == 'preserve':
return None
elif formatted_time == 'now':
return Sentinel
else:
try:
struct = time.strptime(formatted_time, time_format)
struct_time = time.mktime(struct)
except (ValueError, OverflowError) as e:
raise AnsibleModuleError(results={'msg': 'Error while obtaining timestamp for time %s using format %s: %s'
% (formatted_time, time_format, to_native(e, nonstring='simplerepr'))})
return struct_time
def update_timestamp_for_file(path, mtime, atime, diff=None):
try:
# When mtime and atime are set to 'now', rely on utime(path, None) which does not require ownership of the file
# https://github.com/ansible/ansible/issues/50943
if mtime is Sentinel and atime is Sentinel:
# It's not exact but we can't rely on os.stat(path).st_mtime after setting os.utime(path, None) as it may
# not be updated. Just use the current time for the diff values
mtime = atime = time.time()
previous_mtime = os.stat(path).st_mtime
previous_atime = os.stat(path).st_atime
set_time = None
else:
# If both parameters are None 'preserve', nothing to do
if mtime is None and atime is None:
return False
previous_mtime = os.stat(path).st_mtime
previous_atime = os.stat(path).st_atime
if mtime is None:
mtime = previous_mtime
elif mtime is Sentinel:
mtime = time.time()
if atime is None:
atime = previous_atime
elif atime is Sentinel:
atime = time.time()
# If both timestamps are already ok, nothing to do
if mtime == previous_mtime and atime == previous_atime:
return False
set_time = (atime, mtime)
os.utime(path, set_time)
if diff is not None:
if 'before' not in diff:
diff['before'] = {}
if 'after' not in diff:
diff['after'] = {}
if mtime != previous_mtime:
diff['before']['mtime'] = previous_mtime
diff['after']['mtime'] = mtime
if atime != previous_atime:
diff['before']['atime'] = previous_atime
diff['after']['atime'] = atime
except OSError as e:
raise AnsibleModuleError(results={'msg': 'Error while updating modification or access time: %s'
% to_native(e, nonstring='simplerepr'), 'path': path})
return True
def keep_backward_compatibility_on_timestamps(parameter, state):
if state in ['file', 'hard', 'directory', 'link'] and parameter is None:
return 'preserve'
elif state == 'touch' and parameter is None:
return 'now'
else:
return parameter
def execute_diff_peek(path):
"""Take a guess as to whether a file is a binary file"""
b_path = to_bytes(path, errors='surrogate_or_strict')
appears_binary = False
try:
with open(b_path, 'rb') as f:
head = f.read(8192)
except Exception:
# If we can't read the file, we're okay assuming it's text
pass
else:
if b"\x00" in head:
appears_binary = True
return appears_binary
def ensure_absent(path):
b_path = to_bytes(path, errors='surrogate_or_strict')
prev_state = get_state(b_path)
result = {}
if prev_state != 'absent':
if not module.check_mode:
if prev_state == 'directory':
try:
shutil.rmtree(b_path, ignore_errors=False)
except Exception as e:
raise AnsibleModuleError(results={'msg': "rmtree failed: %s" % to_native(e)})
else:
try:
os.unlink(b_path)
except OSError as e:
if e.errno != errno.ENOENT: # It may already have been removed
raise AnsibleModuleError(results={'msg': "unlinking failed: %s " % to_native(e),
'path': path})
diff = initial_diff(path, 'absent', prev_state)
result.update({'path': path, 'changed': True, 'diff': diff})
else:
result.update({'path': path, 'changed': False})
return result
def execute_touch(path, follow, timestamps):
b_path = to_bytes(path, errors='surrogate_or_strict')
prev_state = get_state(b_path)
changed = False
result = {'dest': path}
mtime = get_timestamp_for_time(timestamps['modification_time'], timestamps['modification_time_format'])
atime = get_timestamp_for_time(timestamps['access_time'], timestamps['access_time_format'])
if not module.check_mode:
if prev_state == 'absent':
# Create an empty file if the filename did not already exist
try:
open(b_path, 'wb').close()
changed = True
except (OSError, IOError) as e:
raise AnsibleModuleError(results={'msg': 'Error, could not touch target: %s'
% to_native(e, nonstring='simplerepr'),
'path': path})
# Update the attributes on the file
diff = initial_diff(path, 'touch', prev_state)
file_args = module.load_file_common_arguments(module.params)
try:
changed = module.set_fs_attributes_if_different(file_args, changed, diff, expand=False)
changed |= update_timestamp_for_file(file_args['path'], mtime, atime, diff)
except SystemExit as e:
if e.code:
# We take this to mean that fail_json() was called from
# somewhere in basic.py
if prev_state == 'absent':
# If we just created the file we can safely remove it
os.remove(b_path)
raise
result['changed'] = changed
result['diff'] = diff
return result
def ensure_file_attributes(path, follow, timestamps):
b_path = to_bytes(path, errors='surrogate_or_strict')
prev_state = get_state(b_path)
file_args = module.load_file_common_arguments(module.params)
mtime = get_timestamp_for_time(timestamps['modification_time'], timestamps['modification_time_format'])
atime = get_timestamp_for_time(timestamps['access_time'], timestamps['access_time_format'])
if prev_state != 'file':
if follow and prev_state == 'link':
# follow symlink and operate on original
b_path = os.path.realpath(b_path)
path = to_native(b_path, errors='strict')
prev_state = get_state(b_path)
file_args['path'] = path
if prev_state not in ('file', 'hard'):
# file is not absent and any other state is a conflict
raise AnsibleModuleError(results={'msg': 'file (%s) is %s, cannot continue' % (path, prev_state),
'path': path})
diff = initial_diff(path, 'file', prev_state)
changed = module.set_fs_attributes_if_different(file_args, False, diff, expand=False)
changed |= update_timestamp_for_file(file_args['path'], mtime, atime, diff)
return {'path': path, 'changed': changed, 'diff': diff}
def ensure_directory(path, follow, recurse, timestamps):
b_path = to_bytes(path, errors='surrogate_or_strict')
prev_state = get_state(b_path)
file_args = module.load_file_common_arguments(module.params)
mtime = get_timestamp_for_time(timestamps['modification_time'], timestamps['modification_time_format'])
atime = get_timestamp_for_time(timestamps['access_time'], timestamps['access_time_format'])
# For followed symlinks, we need to operate on the target of the link
if follow and prev_state == 'link':
b_path = os.path.realpath(b_path)
path = to_native(b_path, errors='strict')
file_args['path'] = path
prev_state = get_state(b_path)
changed = False
diff = initial_diff(path, 'directory', prev_state)
if prev_state == 'absent':
# Create directory and assign permissions to it
if module.check_mode:
return {'changed': True, 'diff': diff}
curpath = ''
try:
# Split the path so we can apply filesystem attributes recursively
# from the root (/) directory for absolute paths or the base path
# of a relative path. We can then walk the appropriate directory
# path to apply attributes.
# Something like mkdir -p with mode applied to all of the newly created directories
for dirname in path.strip('/').split('/'):
curpath = '/'.join([curpath, dirname])
# Remove leading slash if we're creating a relative path
if not os.path.isabs(path):
curpath = curpath.lstrip('/')
b_curpath = to_bytes(curpath, errors='surrogate_or_strict')
if not os.path.exists(b_curpath):
try:
os.mkdir(b_curpath)
changed = True
except OSError as ex:
# Possibly something else created the dir since the os.path.exists
# check above. As long as it's a dir, we don't need to error out.
if not (ex.errno == errno.EEXIST and os.path.isdir(b_curpath)):
raise
tmp_file_args = file_args.copy()
tmp_file_args['path'] = curpath
changed = module.set_fs_attributes_if_different(tmp_file_args, changed, diff, expand=False)
changed |= update_timestamp_for_file(file_args['path'], mtime, atime, diff)
except Exception as e:
raise AnsibleModuleError(results={'msg': 'There was an issue creating %s as requested:'
' %s' % (curpath, to_native(e)),
'path': path})
return {'path': path, 'changed': changed, 'diff': diff}
elif prev_state != 'directory':
# We already know prev_state is not 'absent', therefore it exists in some form.
raise AnsibleModuleError(results={'msg': '%s already exists as a %s' % (path, prev_state),
'path': path})
#
# previous state == directory
#
changed = module.set_fs_attributes_if_different(file_args, changed, diff, expand=False)
changed |= update_timestamp_for_file(file_args['path'], mtime, atime, diff)
if recurse:
changed |= recursive_set_attributes(b_path, follow, file_args, mtime, atime)
return {'path': path, 'changed': changed, 'diff': diff}
def ensure_symlink(path, src, follow, force, timestamps):
b_path = to_bytes(path, errors='surrogate_or_strict')
b_src = to_bytes(src, errors='surrogate_or_strict')
prev_state = get_state(b_path)
file_args = module.load_file_common_arguments(module.params)
mtime = get_timestamp_for_time(timestamps['modification_time'], timestamps['modification_time_format'])
atime = get_timestamp_for_time(timestamps['access_time'], timestamps['access_time_format'])
# source is both the source of a symlink or an informational passing of the src for a template module
# or copy module, even if this module never uses it, it is needed to key off some things
if src is None:
if follow:
# use the current target of the link as the source
src = to_native(os.path.realpath(b_path), errors='strict')
b_src = to_bytes(src, errors='surrogate_or_strict')
if not os.path.islink(b_path) and os.path.isdir(b_path):
relpath = path
else:
b_relpath = os.path.dirname(b_path)
relpath = to_native(b_relpath, errors='strict')
absrc = os.path.join(relpath, src)
b_absrc = to_bytes(absrc, errors='surrogate_or_strict')
if not force and not os.path.exists(b_absrc):
raise AnsibleModuleError(results={'msg': 'src file does not exist, use "force=yes" if you'
' really want to create the link: %s' % absrc,
'path': path, 'src': src})
if prev_state == 'directory':
if not force:
raise AnsibleModuleError(results={'msg': 'refusing to convert from %s to symlink for %s'
% (prev_state, path),
'path': path})
elif os.listdir(b_path):
# refuse to replace a directory that has files in it
raise AnsibleModuleError(results={'msg': 'the directory %s is not empty, refusing to'
' convert it' % path,
'path': path})
elif | |
"""
The various classes that launch external programs to view files
"""
import plugins, os
from .. import guiplugins
from string import Template
from copy import copy
import subprocess
class FileViewAction(guiplugins.ActionGUI):
def __init__(self, *args, **kw):
self.performArgs = []
guiplugins.ActionGUI.__init__(self, *args, **kw)
def singleTestOnly(self):
return True
def isActiveOnCurrent(self, *args):
if not guiplugins.ActionGUI.isActiveOnCurrent(self):
return False
for fileName, obj in self.currFileSelection:
if self.isActiveForFile(fileName, obj):
return True
return False
def isActiveForFile(self, fileName, *args):
return fileName and not os.path.isdir(fileName)
def useFiltered(self):
return False
def getLargestFileSize(self, f, *args):
try:
return os.path.getsize(f)
except EnvironmentError:
return 0
def getConfirmationMessage(self):
self.performArgs = []
message = ""
for fileName, associatedObject in self.currFileSelection:
if self.isActiveForFile(fileName, associatedObject):
message, args = self.getConfMessageForFile(fileName, associatedObject)
self.performArgs.append(args)
return message
def performOnCurrent(self):
for args in self.performArgs:
self.performOnFile(*args)
def performOnFile(self, viewTool, *args):
try:
self._performOnFile(viewTool, *args)
except OSError:
self.showErrorDialog("Cannot find " + self.getToolDescription() + " '" + viewTool + \
"'.\nPlease install it somewhere on your PATH or\n"
"change the configuration entry '" + self.getToolConfigEntry() + "'.")
def getConfMessageForFile(self, fileName, associatedObject):
fileToView = self.getFileToView(fileName, associatedObject)
if os.path.isfile(fileToView) or os.path.islink(fileToView):
viewTool = self.getViewToolName(fileToView)
if viewTool:
args = (viewTool, fileToView, associatedObject)
maxFileSize = plugins.parseBytes(self.getConfigValue("max_file_size", viewTool))
if maxFileSize >= 0:
largestFileSize = self.getLargestFileSize(fileToView, associatedObject)
if largestFileSize > maxFileSize:
message = "You are trying to view a file of size " + str(largestFileSize) + " bytes, while a limit of " + \
str(maxFileSize) + " bytes is set for the tool '" + viewTool + "'. Are you sure you wish to continue?"
return message, args
return "", args
else:
raise plugins.TextTestError, "No " + self.getToolDescription() + " is defined for files of type '" + \
os.path.basename(fileToView).split(".")[0] + \
"'.\nPlease point the configuration entry '" + self.getToolConfigEntry() + \
"' at a valid program to view the file."
else:
raise plugins.TextTestError, "File '" + os.path.basename(fileName) + \
"' cannot be viewed as it has been removed in the file system." + self.noFileAdvice()
def isDefaultViewer(self, *args):
return False
def extraPostfix(self):
return ""
def notifyViewFile(self, fileName, comp, newFile):
if self.isDefaultViewer(comp, newFile):
allArgs = (fileName, comp)
self.currFileSelection = [ allArgs ]
self.runInteractive()
def getFileToView(self, fileName, associatedObject):
try:
# associatedObject might be a comparison object, but it might not
# Use the comparison if it's there
return associatedObject.existingFile(self.useFiltered(), self.extraPostfix())
except AttributeError:
return fileName
def noFileAdvice(self):
if len(self.currAppSelection) > 0:
return "\n" + self.currAppSelection[0].noFileAdvice()
else:
return ""
def testDescription(self):
if len(self.currTestSelection) > 0:
return " (from test " + self.currTestSelection[0].uniqueName + ")"
else:
return ""
def getRemoteHost(self):
if len(self.currTestSelection) > 0:
state = self.currTestSelection[0].stateInGui
if hasattr(state, "executionHosts") and len(state.executionHosts) > 0:
return plugins.interpretHostname(state.executionHosts[0])
return "localhost"
def getRemoteArgs(self, cmdArgs):
remoteHost = self.getRemoteHost()
return self.currTestSelection[0].app.getCommandArgsOn(remoteHost, cmdArgs, graphical=True)
def getSignalsSent(self):
return [ "ViewerStarted" ]
def startViewer(self, cmdArgs, description, checkOutput=False, **kwargs):
testDesc = self.testDescription()
fullDesc = description + testDesc
nullFile = open(os.devnull, "w")
stdout = subprocess.PIPE if checkOutput else nullFile
self.notify("Status", 'Started "' + description + '" in background' + testDesc + '.')
guiplugins.processMonitor.startProcess(cmdArgs, fullDesc, stdout=stdout, stderr=nullFile, **kwargs)
self.notifyThreaded("ViewerStarted") # Don't call application events directly in the GUI thread
def getStem(self, fileName):
return os.path.basename(fileName).split(".")[0]
def testRunning(self):
if len(self.currTestSelection) > 0:
return self.currTestSelection[0].stateInGui.hasStarted() and \
not self.currTestSelection[0].stateInGui.isComplete()
else:
return False
def getViewToolName(self, fileName):
stem = self.getStem(fileName)
return self.getConfigValue(self.getToolConfigEntry(), stem)
def getConfigValue(self, *args):
if len(self.currTestSelection) > 0:
return self.currTestSelection[0].getCompositeConfigValue(*args)
else:
return guiplugins.guiConfig.getCompositeValue(*args)
def differencesActive(self, comparison):
if not comparison or comparison.newResult() or comparison.missingResult():
return False
return comparison.hasDifferences()
def messageAfterPerform(self):
pass # provided by starting viewer, with message
class ViewInEditor(FileViewAction):
def __init__(self, allApps, dynamic, *args):
FileViewAction.__init__(self, allApps)
self.dynamic = dynamic
def _getStockId(self):
return "open"
def getToolConfigEntry(self):
return "view_program"
def getToolDescription(self):
return "file viewing program"
def viewFile(self, fileName, viewTool, exitHandler, exitHandlerArgs):
cmdArgs, descriptor, env = self.getViewCommand(fileName, viewTool)
description = descriptor + " " + os.path.basename(fileName)
checkOutput = cmdArgs[0] == "storytext_editor"
self.startViewer(cmdArgs, description=description, checkOutput=checkOutput, env=env,
exitHandler=exitHandler, exitHandlerArgs=exitHandlerArgs)
def getViewerEnvironment(self, cmdArgs):
# An absolute path to the viewer may indicate a custom tool, send the test environment along too
# Doing this is unlikely to cause harm in any case
if len(self.currTestSelection) > 0:
if cmdArgs[0] == "storytext_editor":
storytextHome = self.currTestSelection[0].getEnvironment("STORYTEXT_HOME")
return plugins.copyEnvironment({ "STORYTEXT_HOME" : storytextHome }, ignoreVars=[ "USECASE_RECORD_SCRIPT", "USECASE_REPLAY_SCRIPT" ])
elif os.path.isabs(cmdArgs[0]):
return self.currTestSelection[0].getRunEnvironment()
def getViewCommand(self, fileName, viewProgram):
# viewProgram might have arguments baked into it...
cmdArgs = plugins.splitcmd(viewProgram) + [ fileName ]
program = cmdArgs[0]
descriptor = " ".join([ os.path.basename(program) ] + cmdArgs[1:-1])
env = self.getViewerEnvironment(cmdArgs)
interpreter = plugins.getInterpreter(program)
if interpreter:
cmdArgs = [ interpreter ] + cmdArgs
if guiplugins.guiConfig.getCompositeValue("view_file_on_remote_machine", self.getStem(fileName)):
cmdArgs = self.getRemoteArgs(cmdArgs)
return cmdArgs, descriptor, env
def _performOnFile(self, viewTool, fileName, *args):
exitHandler, exitHandlerArgs = self.findExitHandlerInfo(fileName, *args)
return self.viewFile(fileName, viewTool, exitHandler, exitHandlerArgs)
def editingComplete(self):
self.applicationEvent("file editing operations to complete")
class ViewConfigFileInEditor(ViewInEditor):
def __init__(self, *args):
ViewInEditor.__init__(self, *args)
self.rootTestSuites = []
def _getTitle(self):
return "View In Editor"
def addSuites(self, suites):
self.rootTestSuites += suites
def isActiveOnCurrent(self, *args):
return len(self.currFileSelection) > 0
def notifyViewApplicationFile(self, fileName, apps, *args):
self.currFileSelection = [ (fileName, apps) ]
self.runInteractive()
def notifyViewReadonlyFile(self, fileName):
viewTool = self.getConfigValue("view_program", "default")
return self.viewFile(fileName, viewTool, self.applicationEvent, ("the readonly file viewer to be closed",))
def findExitHandlerInfo(self, dummy, apps):
return self.configFileChanged, (apps,)
def getSignalsSent(self):
return [ "ReloadConfig" ]
def configFileChanged(self, apps):
for app in apps:
app.setUpConfiguration()
suite = self.findSuite(app)
suite.refreshFilesRecursively()
# May have affected e.g. imported files, script references etc
self.notify("ReloadConfig")
self.editingComplete()
def findSuite(self, app):
for suite in self.rootTestSuites:
if suite.app is app:
return suite
class ViewTestFileInEditor(ViewInEditor):
def _getTitle(self):
return "View File"
def isDefaultViewer(self, comparison, isNewFile):
return not isNewFile and not self.differencesActive(comparison) and \
(not self.testRunning() or not guiplugins.guiConfig.getValue("follow_file_by_default"))
def findExitHandlerInfo(self, fileName, *args):
if self.dynamic:
return self.editingComplete, ()
# options file can change appearance of test (environment refs etc.)
baseName = os.path.basename(fileName)
for stem in [ "options", "testsuite", "config" ]:
if baseName.startswith(stem):
tests = self.getTestsForFile(stem, fileName)
if len(tests) > 0:
methodName = "handle" + stem.capitalize() + "Edit"
return getattr(self, methodName), (tests,)
return self.staticGUIEditingComplete, (copy(self.currTestSelection), fileName)
def getTestsForFile(self, stem, fileName):
tests = []
for test in self.currTestSelection:
defFile = test.getFileName(stem)
if defFile and plugins.samefile(fileName, defFile):
tests.append(test)
return tests
def handleTestsuiteEdit(self, suites):
for suite in suites:
suite.refresh(suite.app.getFilterList(suites))
self.editingComplete()
def handleOptionsEdit(self, tests):
for test in tests:
test.filesChanged()
self.editingComplete()
def handleConfigEdit(self, tests):
for test in tests:
test.reloadTestConfigurations()
self.editingComplete()
def getSignalsSent(self):
return [ "RefreshFilePreviews" ] + ViewInEditor.getSignalsSent(self)
def staticGUIEditingComplete(self, tests, fileName):
for test in tests:
self.notify("RefreshFilePreviews", test, fileName)
self.editingComplete()
class EditTestFileInEditor(ViewTestFileInEditor):
def _getTitle(self):
return "Edit File"
def getViewToolName(self, *args):
return self.getConfigValue(self.getToolConfigEntry(), "default")
def isDefaultViewer(self, comp, isNewFile):
return isNewFile
def _getStockId(self):
pass # don't use same stock for both
class ViewFilteredTestFileInEditor(ViewTestFileInEditor):
def _getStockId(self):
pass # don't use same stock for both
def useFiltered(self):
return True
def _getTitle(self):
return "View Filtered File"
def isActiveForFile(self, fileName, comparison):
return bool(comparison)
def isDefaultViewer(self, *args):
return False
class ContentFilterViewer:
def extraPostfix(self):
return ".normal"
def unorderedFiltersActive(self, comparison):
return len(self.currAppSelection[0].getCompositeConfigValue("unordered_text", comparison.stem)) > 0
class ViewContentFilteredTestFileInEditor(ContentFilterViewer, ViewFilteredTestFileInEditor):
def _getTitle(self):
return "View Content-Filtered File"
def isActiveForFile(self, fileName, comparison):
return ViewFilteredTestFileInEditor.isActiveForFile(self, fileName, comparison) and \
self.unorderedFiltersActive(comparison)
class ViewFilteredOrigFileInEditor(ViewFilteredTestFileInEditor):
def _getTitle(self):
return "View Filtered Original File"
def isActiveForFile(self, fileName, comparison):
return comparison and not comparison.newResult()
def getFileToView(self, fileName, comparison):
return comparison.getStdFile(self.useFiltered(), self.extraPostfix())
class ViewOrigFileInEditor(ViewFilteredOrigFileInEditor):
def _getTitle(self):
return "View Original File"
def useFiltered(self):
return False
class EditOrigFileInEditor(ViewOrigFileInEditor):
def _getTitle(self):
return "Edit Original File"
def getViewToolName(self, *args):
return self.getConfigValue(self.getToolConfigEntry(), "default")
class ViewContentFilteredOrigFileInEditor(ContentFilterViewer, ViewFilteredOrigFileInEditor):
def _getTitle(self):
return "View Content-Filtered Original File"
def isActiveForFile(self, fileName, comparison):
return ViewFilteredOrigFileInEditor.isActiveForFile(self, fileName, comparison) and \
self.unorderedFiltersActive(comparison)
class ViewFileDifferences(FileViewAction):
def _getTitle(self):
return "View Raw Differences"
def getToolConfigEntry(self):
return "diff_program"
def getToolDescription(self):
return "graphical difference program"
def isActiveForFile(self, fileName, comparison):
if bool(comparison):
if not (comparison.newResult() or comparison.missingResult()):
return True
return False
def getLargestFileSize(self, tmpFile, comparison):
stdFile = comparison.getStdFile(self.useFiltered(), self.extraPostfix())
return max(os.path.getsize(stdFile), os.path.getsize(tmpFile))
def _performOnFile(self, diffProgram, tmpFile, comparison):
stdFile = comparison.getStdFile(self.useFiltered(), self.extraPostfix())
self.runDiff(diffProgram, stdFile, tmpFile)
def runDiff(self, diffProgram, stdFile, tmpFile):
description = diffProgram + " " + os.path.basename(stdFile) + " " + os.path.basename(tmpFile)
cmdArgs = plugins.splitcmd(diffProgram) + [ stdFile, tmpFile ]
self.startViewer(cmdArgs, description=description, exitHandler=self.diffingComplete)
def diffingComplete(self, *args):
self.applicationEvent("the " + self.getToolDescription() + " to terminate")
class PairwiseFileViewer:
def singleTestOnly(self):
return False
def isActiveOnCurrent(self, *args):
return len(self.currTestSelection) == 2 and | |
False):
"""
Inits a row in current review optimization table
:param detector: User who created ReviewOptimization
:param argument: Argument.uid
:param statement: Statement.uid
:param is_executed: Boolean
:param is_revoked: Boolean
"""
self.detector: 'User' = detector
self.argument: Optional['Argument'] = argument
self.statement: Optional['Statement'] = statement
self.timestamp: ArrowType = get_now()
self.is_executed: bool = is_executed
self.is_revoked: bool = is_revoked
def set_executed(self, is_executed):
"""
Sets current review as executed
:param is_executed: Boolean
:return: None
"""
self.is_executed = is_executed
def set_revoked(self, is_revoked):
"""
Sets current review as revoked
:param is_revoked: Boolean
:return: None
"""
self.is_revoked = is_revoked
def update_timestamp(self):
"""
Update timestamp
:return: None
"""
self.timestamp = get_now()
def get_issues(self) -> [Issue]:
if self.argument:
return [self.argument.issue]
return self.statement.issues
def is_locked(self) -> bool:
lock = DBDiscussionSession.query(OptimizationReviewLocks).filter(
OptimizationReviewLocks.review_optimization_uid == self.uid).one_or_none()
return lock is not None
class ReviewDuplicate(AbstractReviewCase):
"""
ReviewDuplicate-table with several columns.
"""
__tablename__ = 'review_duplicates'
uid: int = Column(Integer, primary_key=True)
detector_uid: int = Column(Integer, ForeignKey('users.uid'))
duplicate_statement_uid: int = Column(Integer, ForeignKey('statements.uid'))
original_statement_uid: int = Column(Integer, ForeignKey('statements.uid'))
timestamp = Column(ArrowType, default=get_now())
is_executed: bool = Column(Boolean, nullable=False, default=False)
is_revoked: bool = Column(Boolean, nullable=False, default=False)
detector: User = relationship('User', foreign_keys=[detector_uid])
duplicate_statement: Statement = relationship('Statement', foreign_keys=[duplicate_statement_uid])
original_statement: Statement = relationship('Statement', foreign_keys=[original_statement_uid])
def __init__(self, detector: User, duplicate_statement: Statement = None, original_statement: Statement = None,
is_executed: bool = False, is_revoked: bool = False):
"""
Inits a row in current review duplicate table
:param detector: User.uid
:param duplicate_statement: Statement.uid
:param original_statement: Statement.uid
:param is_executed: Boolean
:param is_revoked: Boolean
"""
self.detector: User = detector
self.duplicate_statement: Statement = duplicate_statement
self.original_statement: Statement = original_statement
self.timestamp: ArrowType = get_now()
self.is_executed: bool = is_executed
self.is_revoked: bool = is_revoked
def set_executed(self, is_executed: bool):
"""
Sets current review as executed
:param is_executed: Boolean
:return: None
"""
self.is_executed = is_executed
def set_revoked(self, is_revoked: bool):
"""
Sets current review as revoked
:param is_revoked: Boolean
:return: None
"""
self.is_revoked = is_revoked
def update_timestamp(self):
"""
Update timestamp
:return: None
"""
self.timestamp = get_now()
def get_issues(self) -> [Issue]:
return self.duplicate_statement.issues
class ReviewMerge(AbstractReviewCase):
"""
Review-table with several columns.
"""
__tablename__ = 'review_merge'
uid: int = Column(Integer, primary_key=True)
detector_uid: int = Column(Integer, ForeignKey('users.uid'))
premisegroup_uid: int = Column(Integer, ForeignKey('premisegroups.uid'))
timestamp = Column(ArrowType, default=get_now())
is_executed: bool = Column(Boolean, nullable=False, default=False)
is_revoked: bool = Column(Boolean, nullable=False, default=False)
detector: User = relationship('User', foreign_keys=[detector_uid])
premisegroup: PremiseGroup = relationship('PremiseGroup', foreign_keys=[premisegroup_uid])
def __init__(self, detector: User, premisegroup: PremiseGroup, is_executed: bool = False, is_revoked: bool = False):
"""
Inits a row in current review merge table
:param detector: User
:param premisegroup: PremiseGroup
:param is_executed: Boolean
:param is_revoked: Boolean
"""
self.detector = detector
self.premisegroup = premisegroup
self.timestamp = get_now()
self.is_executed = is_executed
self.is_revoked = is_revoked
def set_executed(self, is_executed: bool):
"""
Sets current review as executed
:param is_executed: Boolean
:return: None
"""
self.is_executed = is_executed
def set_revoked(self, is_revoked: bool):
"""
Sets current review as revoked
:param is_revoked: Boolean
:return: None
"""
self.is_revoked = is_revoked
def update_timestamp(self):
"""
Update timestamp
:return: None
"""
self.timestamp = get_now()
def get_issues(self) -> [Issue]:
return [self.premisegroup.premises[0].issue]
class ReviewSplit(AbstractReviewCase):
"""
Review-table with several columns.
"""
__tablename__ = 'review_split'
uid: int = Column(Integer, primary_key=True)
detector_uid: int = Column(Integer, ForeignKey('users.uid'))
premisegroup_uid: int = Column(Integer, ForeignKey('premisegroups.uid'))
timestamp = Column(ArrowType, default=get_now())
is_executed: bool = Column(Boolean, nullable=False, default=False)
is_revoked: bool = Column(Boolean, nullable=False, default=False)
detector: User = relationship('User', foreign_keys=[detector_uid])
premisegroup: PremiseGroup = relationship('PremiseGroup', foreign_keys=[premisegroup_uid])
def __init__(self, detector: User, premisegroup: PremiseGroup, is_executed: bool = False, is_revoked: bool = False):
"""
Inits a row in current review split table
:param detector: User
:param premisegroup: PremiseGroup
:param is_executed: Boolean
:param is_revoked: Boolean
"""
self.detector = detector
self.premisegroup = premisegroup
self.timestamp = get_now()
self.is_executed = is_executed
self.is_revoked = is_revoked
def set_executed(self, is_executed: bool):
"""
Sets current review as executed
:param is_executed: Boolean
:return: None
"""
self.is_executed = is_executed
def set_revoked(self, is_revoked: bool):
"""
Sets current review as revoked
:param is_revoked: Boolean
:return: None
"""
self.is_revoked = is_revoked
def update_timestamp(self):
"""
Update timestamp
:return: None
"""
self.timestamp = get_now()
def get_issues(self) -> [Issue]:
return [self.premisegroup.premises[0].issue]
class ReviewSplitValues(DiscussionBase):
"""
Review-table with several columns.
"""
__tablename__ = 'review_split_values'
uid: int = Column(Integer, primary_key=True)
review_uid: int = Column(Integer, ForeignKey('review_split.uid'))
content: str = Column(Text, nullable=False)
review: ReviewSplit = relationship('ReviewSplit', foreign_keys=[review_uid])
def __init__(self, review: ReviewSplit, content: str):
"""
Inits a row in current review merge value table
:param review: ReviewSplit
:param content: String
"""
self.review = review
self.content = content
class ReviewMergeValues(DiscussionBase):
"""
Review-table with several columns.
"""
__tablename__ = 'review_merge_values'
uid: int = Column(Integer, primary_key=True)
review_uid: int = Column(Integer, ForeignKey('review_merge.uid'))
content: str = Column(Text, nullable=False)
review: ReviewMerge = relationship('ReviewMerge', foreign_keys=[review_uid])
def __init__(self, review: ReviewMerge, content: str):
"""
Inits a row in current review merge value table
:param review: ReviewMerge
:param content: String
"""
self.review = review
self.content = content
class ReviewDeleteReason(DiscussionBase):
"""
ReviewDeleteReason-table with several columns.
"""
__tablename__ = 'review_delete_reasons'
uid: int = Column(Integer, primary_key=True)
reason: str = Column(Text, nullable=False, unique=True)
def __init__(self, reason: str):
"""
Inits a row in current review delete reason table
:param reason: String
"""
self.reason = reason
class AbstractLastReviewerCase(DiscussionBase):
__abstract__ = True # Needed for SQLAlchemy
uid = NotImplemented
reviewer_uid = NotImplemented
review_uid = NotImplemented
timestamp = NotImplemented
@abstractmethod
def __eq__(self, other):
pass
def __init_subclass__(cls, **kwargs):
super().__init_subclass__(**kwargs)
if cls.uid is NotImplemented or \
cls.review_uid is NotImplemented or \
cls.reviewer_uid is NotImplemented or \
cls.timestamp is NotImplemented:
raise NotImplementedError("Your subclass of AbstractLastReviewerCase did not define all columns")
class LastReviewerDelete(AbstractLastReviewerCase):
"""
LastReviewerDelete-table with several columns.
"""
__tablename__ = 'last_reviewers_delete'
uid: int = Column(Integer, primary_key=True)
reviewer_uid: int = Column(Integer, ForeignKey('users.uid'))
review_uid: int = Column(Integer, ForeignKey('review_deletes.uid'))
is_okay: bool = Column(Boolean, nullable=False, default=False)
timestamp = Column(ArrowType, default=get_now())
reviewer: User = relationship('User', foreign_keys=[reviewer_uid])
review: ReviewDelete = relationship('ReviewDelete', foreign_keys=[review_uid])
def __init__(self, reviewer: User, review: ReviewDelete, is_okay: bool):
"""
Inits a row in current last reviewer delete table
:param reviewer: User
:param review: ReviewDelete
:param is_okay: Boolean
"""
self.reviewer = reviewer
self.review = review
self.is_okay = is_okay
self.timestamp = get_now()
def __eq__(self, other):
return self.uid == other.uid
class LastReviewerDuplicate(AbstractLastReviewerCase):
"""
LastReviewerDuplicate-table with several columns.
"""
__tablename__ = 'last_reviewers_duplicates'
uid: int = Column(Integer, primary_key=True)
reviewer_uid: int = Column(Integer, ForeignKey('users.uid'))
review_uid: int = Column(Integer, ForeignKey('review_duplicates.uid'))
is_okay: bool = Column(Boolean, nullable=False, default=False)
timestamp = Column(ArrowType, default=get_now())
reviewer: User = relationship('User', foreign_keys=[reviewer_uid])
review: ReviewDuplicate = relationship('ReviewDuplicate', foreign_keys=[review_uid])
def __init__(self, reviewer: User, review: ReviewDuplicate, is_okay: bool):
"""
Inits a row in current last reviewer duplicate table
:param reviewer: User
:param review: ReviewDuplicate
:param is_okay: Boolean
"""
self.reviewer = reviewer
self.review = review
self.is_okay = is_okay
self.timestamp = get_now()
def __eq__(self, other):
return self.uid == other.uid
class LastReviewerEdit(AbstractLastReviewerCase):
"""
LastReviewerEdit-table with several columns.
"""
__tablename__ = 'last_reviewers_edit'
uid: int = Column(Integer, primary_key=True)
reviewer_uid: int = Column(Integer, ForeignKey('users.uid'))
review_uid: int = Column(Integer, ForeignKey('review_edits.uid'))
is_okay: bool = Column(Boolean, nullable=False, default=False)
timestamp = Column(ArrowType, default=get_now())
reviewer: User = relationship('User', foreign_keys=[reviewer_uid])
review: ReviewEdit = relationship('ReviewEdit', foreign_keys=[review_uid])
def __init__(self, reviewer: User, review: ReviewEdit, is_okay: bool):
"""
:param reviewer: User
:param review: ReviewEdit
:param is_okay: Boolean
"""
self.reviewer = reviewer
self.review = review
self.is_okay = is_okay
self.timestamp = get_now()
def __eq__(self, other):
return self.uid == other.uid
class LastReviewerOptimization(AbstractLastReviewerCase):
"""
Inits a row in current last reviewer edit table
"""
__tablename__ = 'last_reviewers_optimization'
uid: int = Column(Integer, primary_key=True)
reviewer_uid: int = Column(Integer, ForeignKey('users.uid'))
review_uid: int = Column(Integer, ForeignKey('review_optimizations.uid'))
is_okay: bool = Column(Boolean, nullable=False, default=False)
timestamp = Column(ArrowType, default=get_now())
reviewer: User = relationship('User', foreign_keys=[reviewer_uid])
review: ReviewOptimization = relationship('ReviewOptimization', foreign_keys=[review_uid])
def __init__(self, reviewer: User, review: ReviewOptimization, is_okay: bool):
"""
Inits a row in current last reviewer optimization table
:param reviewer: User
:param review: ReviewOptimization
:param is_okay: boolean
"""
self.reviewer = reviewer
self.review = review
self.is_okay = is_okay
self.timestamp = get_now()
def __eq__(self, other):
return self.uid == other.uid
class LastReviewerSplit(AbstractLastReviewerCase):
"""
Inits a row in current last reviewer split table
"""
__tablename__ = 'last_reviewers_split'
uid: int = Column(Integer, primary_key=True)
reviewer_uid: int = Column(Integer, ForeignKey('users.uid'))
review_uid: int = Column(Integer, ForeignKey('review_split.uid'))
should_split: bool = Column(Boolean, nullable=False, default=False)
timestamp = Column(ArrowType, default=get_now())
reviewer: User = relationship('User', foreign_keys=[reviewer_uid])
review: ReviewSplit = relationship('ReviewSplit', foreign_keys=[review_uid])
def __init__(self, reviewer: User, review: ReviewSplit, should_split: bool):
"""
Inits a row in current last reviewer Split table
:param reviewer: User
:param review: ReviewSplit
| |
logger.info("Removing server access to NSD {0} from node "
"{1}".format(nsd_to_delete,
node_to_delete.get_admin_node_name()))
SpectrumScaleNSD.remove_server_access_to_nsd(nsd_to_delete,
node_to_delete.get_admin_node_name(),
nsd_attached_to_nodes)
# All "mmchnsd" calls are asynchronous. Therefore wait here till all
# modifications are committed before proceeding further. For now just
# sleep but we need to enhance this to ensure the async op has completed
time.sleep(10)
logger.debug("Function Exit: remove_multi_attach_nsd(). ")
#
# This function performs removal / termination of nodes from the IBM Spectrum
# Scale cluster. If the node is a server node that has access to NSD(s), then
# we attempt to remove access to this NSD (if the NSD is a shared NSD) or
# delete access to it (if its a dedicated NSD).
#
# Args:
# node_names_to_delete: Nodes to be deleted from the cluster
#
# Return:
# rc: Return code
# msg: Output message
def remove_nodes(logger, node_names_to_delete):
logger.debug("Function Entry: remove_nodes(). "
"Args: node_list={0}".format(node_names_to_delete))
rc = RC_SUCCESS
msg = result_json = ""
removed_node_list = []
logger.info("Attempting to remove node(s) {0} from the "
"cluster".format(' '.join(map(str, node_names_to_delete))))
# TODO: The cluster health check should only fail if we are attempting
# to remove NSD servers while other NSD servers are down. The
# removal of compute nodes should be permitted even if NSD
# servers are down. For now disable check until correct algorithm
# can be implemented
# Ensure all nodes in the cluster are healthy
#check_cluster_health(logger)
# Check that the list of nodes to delete already exist. If not,
# simply ignore
nodes_to_delete = check_nodes_exist(logger, node_names_to_delete)
if len(nodes_to_delete) == 0:
msg = str("All node(s) marked for removal ({0}) are already not part "
"of the cluster".format(' '.join(map(str,
node_names_to_delete))))
logger.info(msg)
return rc, msg, result_json
# Precheck nodes to make sure they do not have any roles that should
# not be deleted
check_roles_before_delete(logger, nodes_to_delete)
# For each Filesystem, Get the Filesystem to NSD (disk) mapping
fs_nsd_map = get_filesystem_to_nsd_mapping(logger)
# TODO: The disk health check should only fail if we are attempting
# to remove NSD servers when any disks are down. The removal
# of compute nodes should be permitted even if disks are down.
# For now disable check until correct algorithm can be implemented
#check_disk_health(logger, fs_nsd_map)
# An NSD node can have access to a multi attach NSD (shared NSD) or
# dedicated access to the NSD (FPO model) or a combination of both.
# First modify the Shared NSDs and remove access to all NSD Nodes
# that are to be deleted. Note: As long as these are Shared NSD's
# another NSD server will continue to have access to the NSD (and
# therefore Data)
remove_multi_attach_nsd(logger, nodes_to_delete)
# Finally delete any dedicated NSDs (this will force the data to be
# copied to another NSD in the same Filesystem). Finally delete the
# node from the cluster
logger.debug("Identified all filesystem to disk mapping: "
"{0}".format(fs_nsd_map))
for node_to_del_obj in nodes_to_delete:
node_to_del = node_to_del_obj.get_admin_node_name()
logger.debug("Operating on server: {0}".format(node_to_del))
# For each node to be deleted, retrieve the NSDs (disks) on the node
all_node_disks = get_all_nsds_of_node(logger, node_to_del)
logger.debug("Identified disks for server ({0}): "
"{1}".format(node_to_del, all_node_disks))
# The Node does not have any disks on it (compute node). Delete the
# node without any more processing
if len(all_node_disks) == 0:
logger.info("Unmounting filesystem(s) on {0}".format(node_to_del))
SpectrumScaleFS.unmount_filesystems(node_to_del, wait=True)
logger.info("Shutting down node {0}".format(node_to_del))
SpectrumScaleNode.shutdown_node(node_to_del, wait=True)
logger.info("Deleting compute node {0}".format(node_to_del))
SpectrumScaleCluster.delete_node(node_to_del)
removed_node_list.append(node_to_del)
continue
# Generate a list of NSD (disks) on the host to be deleted for
# each filesystem
#
# fs_disk_map{} contains the following:
# Filesystem Name -> NSDs on the host to be deleted
fs_disk_map = {}
for fs_name, disks in list(fs_nsd_map.items()):
node_specific_disks = []
for disk_instance in disks:
if disk_instance.get_nsd_name() in all_node_disks:
node_specific_disks.append(disk_instance.get_nsd_name())
fs_disk_map[fs_name] = node_specific_disks
logger.debug("Identified filesystem to disk map for server "
"({0}): {1}".format(node_to_del, fs_disk_map))
for fs in fs_disk_map:
disk_cap = gpfs_df_disk(logger, fs)
logger.debug("Identified disk capacity for filesystem "
"({0}): {1}".format(fs, disk_cap))
# Algorithm used for checking at-least 20% free space during
# mmdeldisk in progress;
# - Identify the size of data stored in disks going to be
# deleted.
# - Identify the free size of the filesystem
# (excluding the disk going to be deleted)
# - Allow for disk deletion, if total_free size is 20% greater
# even after moving used data stored in disk going to be deleted.
size_to_be_del = 0
for disk in fs_disk_map[fs]:
size_to_be_del += disk_cap[disk]['used_size']
logger.debug("Identified data size going to be deleted from "
"filesystem ({0}): {1}".format(fs, size_to_be_del))
other_disks = []
for disk_name in disk_cap:
if disk_name not in fs_disk_map[fs]:
other_disks.append(disk_name)
logger.debug("Identified other disks of the filesystem "
"({0}): {1}".format(fs, other_disks))
if not other_disks:
msg = str("No free disks available to restripe data "
"for the filesystem {0}".format(fs))
logger.error(msg)
raise SpectrumScaleException(msg=msg, mmcmd="", cmdargs=[],
rc=-1, stdout="", stderr="")
size_avail_after_migration, total_free = 0, 0
for disk in other_disks:
# Accumulate free size on all disks.
total_free += disk_cap[disk]['free_size']
logger.debug("Identified free size in other disks of the "
"filesystem ({0}): {1}".format(fs, total_free))
size_avail_after_migration = total_free - size_to_be_del
logger.debug("Expected size after restriping of the filesystem "
"({0}): {1}".format(fs, size_avail_after_migration))
percent = int(size_avail_after_migration*100/total_free)
logger.debug("Expected percentage of size left after restriping "
"of the filesystem ({0}): {1}".format(fs, percent))
if percent < 20:
msg = ("Not enough space left for restriping data for "
"filesystem {0}".format(fs))
logger.error(msg)
raise SpectrumScaleException(msg=msg, mmcmd="", cmdargs=[],
rc=-1, stdout="", stderr="")
if fs_disk_map[fs]:
# mmdeldisk will not be hit if there are no disks to delete.
logger.info("Deleting disk(s) {0} from node "
"{1}".format(' '.join(map(str, fs_disk_map[fs])),
node_to_del))
SpectrumScaleDisk.delete_disk(node_to_del, fs, fs_disk_map[fs])
if all_node_disks:
# mmdelnsd will not be hot if there are no disks to delete.
logger.info("Deleting all NSD(s) {0} attached to node "
"{1}".format(' '.join(map(str, all_node_disks)),
node_to_del))
SpectrumScaleNSD.delete_nsd(all_node_disks)
logger.info("Unmounting filesystem(s) on {0}".format(node_to_del))
SpectrumScaleFS.unmount_filesystems(node_to_del, wait=True)
logger.info("Shutting down node {0}".format(node_to_del))
SpectrumScaleNode.shutdown_node(node_to_del, wait=True)
logger.info("Deleting storage node {0}".format(node_to_del))
SpectrumScaleCluster.delete_node(node_to_del)
removed_node_list.append(node_to_del)
msg = str("Successfully removed node(s) {0} from the "
"cluster".format(' '.join(map(str, removed_node_list))))
logger.info(msg)
logger.debug("Function Exit: remove_nodes(). "
"Return Params: rc={0} msg={1}".format(rc, msg))
return rc, msg, result_json
###############################################################################
## ##
## Functions to retrieve Node information ##
## ##
###############################################################################
def get_node_info_as_json(logger, node_names=[]):
logger.debug("Function Entry: get_node_info_as_json(). "
"Args: node_names={0}".format(node_names))
rc = 0
msg = result_json = ""
node_info_dict = {}
node_info_list = []
cluster = SpectrumScaleCluster()
node_instance_list = cluster.get_nodes()
for node_instance in node_instance_list:
if len(node_names) == 0:
node_info_list.append(node_instance.get_node_dict())
else:
if (node_instance.get_ip_address() in node_names or
node_instance.get_admin_node_name() in node_names or
node_instance.get_daemon_node_name() in node_names):
node_info_list.append(node_instance.get_node_dict())
node_info_dict["clusterNodes"] = node_info_list
result_json = json.dumps(node_info_dict)
msg = "List cluster successfully executed"
logger.debug("Function Exit: get_node_info_as_json(). "
"Return Params: rc={0} msg={1} "
"result_json={2}".format(rc, msg, result_json))
return rc, msg, result_json
def get_node_status_as_json(logger, node_names=[]):
logger.debug("Function Entry: get_node_status_as_json(). "
"Args: node_names={0}".format(node_names))
rc = 0
msg = result_json = ""
node_status = {}
node_state = SpectrumScaleNode.get_state(node_names)
result_json = json.dumps(node_state)
msg = "Cluster status successfully executed"
logger.debug("Function Exit: get_node_status_as_json(). "
"Return Params: rc={0} msg={1} "
"result_json={2}".format(rc, msg, result_json))
return rc, msg, result_json
###############################################################################
## ##
## Functions to Stop/Start Node(s) in the Cluster ##
## ##
###############################################################################
def start_nodes(logger, node_names):
logger.debug("Function Entry: start_nodes(). "
"Args: node_names={0}".format(node_names))
rc = RC_SUCCESS
msg = stdout = result_json = ""
for node in node_names:
logger.info("Attempting to start node {0}".format(node))
rc, stdout = SpectrumScaleNode.start_node(node, wait=True)
msg = str("Successfully started node(s) "
"{0}".format(' '.join(map(str, node_names))))
logger.info(msg)
logger.debug("Function Exit: start_nodes(). "
"Return Params: rc={0} msg={1} "
"result_json={2}".format(rc, msg, result_json))
return rc, msg, result_json
def stop_nodes(logger, node_names):
logger.debug("Function Entry: stop_nodes(). "
"Args: node_names={0}".format(node_names))
rc = RC_SUCCESS
msg = stdout = result_json = ""
for node in node_names:
logger.info("Attempting to stop node {0}".format(node))
rc, stdout = SpectrumScaleNode.shutdown_node(node, wait=True)
msg = str("Successfully stopped node(s) "
"{0}".format(' '.join(map(str, node_names))))
logger.info(msg)
logger.debug("Function Exit: stop_nodes(). "
"Return Params: rc={0} msg={1} "
"result_json={2}".format(rc, msg, result_json))
return rc, msg, result_json
###############################################################################
## ##
## Functions to add Node(s) to the Cluster ##
## ##
###############################################################################
def add_nodes(logger, node_names, stanza, license):
logger.debug("Function Entry: add_nodes(). "
"Args: node_names={0}".format(node_names))
rc = RC_SUCCESS
msg = stdout = result_json = ""
logger.info("Attempting to add node(s) {0} to the "
"cluster".format(' '.join(map(str, node_names))))
rc, stdout, stderr = SpectrumScaleCluster.add_node(node_names, stanza)
logger.info("Attempting to | |
import tensorflow as tf
def build_VGG19_feature_extractor(input_shape):
x = tf.keras.Input(shape=input_shape)
base_model = VGG19(weights='imagenet',
include_top=False)
outputs = []
out = x
for layer in base_model.layers:
out = layer(out)
if layer.name in ['block1_conv1', 'block2_conv1', 'block3_conv1',
'block4_conv1', 'block5_conv1']:
outputs.append(out)
if layer.name == 'block5_conv1':
break
return base_model, tf.keras.Model(inputs=x,
outputs=outputs)
from tensorflow.python.keras.applications import imagenet_utils
WEIGHTS_PATH = ('https://storage.googleapis.com/tensorflow/keras-applications/'
'vgg19/vgg19_weights_tf_dim_ordering_tf_kernels.h5')
WEIGHTS_PATH_NO_TOP = ('https://storage.googleapis.com/tensorflow/'
'keras-applications/vgg19/'
'vgg19_weights_tf_dim_ordering_tf_kernels_notop.h5')
def preprocess_for_vgg(x):
return imagenet_utils.preprocess_input(x * 255., data_format=tf.keras.backend.image_data_format(), mode='caffe')
def VGG19(
include_top=True,
weights='imagenet',
input_tensor=None,
input_shape=None,
pooling=None,
classes=1000,
classifier_activation='softmax'):
"""Instantiates the VGG19 architecture.
Reference:
- [Very Deep Convolutional Networks for Large-Scale Image Recognition](
https://arxiv.org/abs/1409.1556) (ICLR 2015)
By default, it loads weights pre-trained on ImageNet. Check 'weights' for
other options.
This model can be built both with 'channels_first' data format
(channels, height, width) or 'channels_last' data format
(height, width, channels).
The default input size for this model is 224x224.
Note: each Keras Application expects a specific kind of input preprocessing.
For VGG19, call `tf.keras.applications.vgg19.preprocess_input` on your
inputs before passing them to the model.
Arguments:
include_top: whether to include the 3 fully-connected
layers at the top of the network.
weights: one of `None` (random initialization),
'imagenet' (pre-training on ImageNet),
or the path to the weights file to be loaded.
input_tensor: optional Keras tensor
(i.e. output of `layers.Input()`)
to use as image input for the model.
input_shape: optional shape tuple, only to be specified
if `include_top` is False (otherwise the input shape
has to be `(224, 224, 3)`
(with `channels_last` data format)
or `(3, 224, 224)` (with `channels_first` data format).
It should have exactly 3 inputs channels,
and width and height should be no smaller than 32.
E.g. `(200, 200, 3)` would be one valid value.
pooling: Optional pooling mode for feature extraction
when `include_top` is `False`.
- `None` means that the output of the model will be
the 4D tensor output of the
last convolutional block.
- `avg` means that global average pooling
will be applied to the output of the
last convolutional block, and thus
the output of the model will be a 2D tensor.
- `max` means that global max pooling will
be applied.
classes: optional number of classes to classify images
into, only to be specified if `include_top` is True, and
if no `weights` argument is specified.
classifier_activation: A `str` or callable. The activation function to use
on the "top" layer. Ignored unless `include_top=True`. Set
`classifier_activation=None` to return the logits of the "top" layer.
Returns:
A `keras.Model` instance.
Raises:
ValueError: in case of invalid argument for `weights`,
or invalid input shape.
ValueError: if `classifier_activation` is not `softmax` or `None` when
using a pretrained top layer.
"""
def relu(x):
return tf.where(x <= 0., 0., x)
# Determine proper input shape
input_shape = imagenet_utils.obtain_input_shape(
input_shape,
default_size=224,
min_size=32,
data_format=tf.keras.backend.image_data_format(),
require_flatten=include_top,
weights=weights)
if input_tensor is None:
img_input = tf.keras.layers.Input(shape=input_shape)
else:
if not tf.keras.backend.is_keras_tensor(input_tensor):
img_input = tf.keras.layers.Input(tensor=input_tensor, shape=input_shape)
else:
img_input = input_tensor
# Block 1
x = tf.keras.layers.Conv2D(
64, (3, 3), activation=relu, padding='same', name='block1_conv1')(
img_input)
x = tf.keras.layers.Conv2D(
64, (3, 3), activation=relu, padding='same', name='block1_conv2')(x)
x = tf.keras.layers.MaxPooling2D((2, 2), strides=(2, 2), name='block1_pool')(x)
# Block 2
x = tf.keras.layers.Conv2D(
128, (3, 3), activation=relu, padding='same', name='block2_conv1')(x)
x = tf.keras.layers.Conv2D(
128, (3, 3), activation=relu, padding='same', name='block2_conv2')(x)
x = tf.keras.layers.MaxPooling2D((2, 2), strides=(2, 2), name='block2_pool')(x)
# Block 3
x = tf.keras.layers.Conv2D(
256, (3, 3), activation=relu, padding='same', name='block3_conv1')(x)
x = tf.keras.layers.Conv2D(
256, (3, 3), activation=relu, padding='same', name='block3_conv2')(x)
x = tf.keras.layers.Conv2D(
256, (3, 3), activation=relu, padding='same', name='block3_conv3')(x)
x = tf.keras.layers.Conv2D(
256, (3, 3), activation=relu, padding='same', name='block3_conv4')(x)
x = tf.keras.layers.MaxPooling2D((2, 2), strides=(2, 2), name='block3_pool')(x)
# Block 4
x = tf.keras.layers.Conv2D(
512, (3, 3), activation=relu, padding='same', name='block4_conv1')(x)
x = tf.keras.layers.Conv2D(
512, (3, 3), activation=relu, padding='same', name='block4_conv2')(x)
x = tf.keras.layers.Conv2D(
512, (3, 3), activation=relu, padding='same', name='block4_conv3')(x)
x = tf.keras.layers.Conv2D(
512, (3, 3), activation=relu, padding='same', name='block4_conv4')(x)
x = tf.keras.layers.MaxPooling2D((2, 2), strides=(2, 2), name='block4_pool')(x)
# Block 5
x = tf.keras.layers.Conv2D(
512, (3, 3), activation=relu, padding='same', name='block5_conv1')(x)
x = tf.keras.layers.Conv2D(
512, (3, 3), activation=relu, padding='same', name='block5_conv2')(x)
x = tf.keras.layers.Conv2D(
512, (3, 3), activation=relu, padding='same', name='block5_conv3')(x)
x = tf.keras.layers.Conv2D(
512, (3, 3), activation=relu, padding='same', name='block5_conv4')(x)
x = tf.keras.layers.MaxPooling2D((2, 2), strides=(2, 2), name='block5_pool')(x)
if include_top:
# Classification block
x = tf.keras.layers.Flatten(name='flatten')(x)
x = tf.keras.layers.Dense(4096, activation=relu, name='fc1')(x)
x = tf.keras.layers.Dense(4096, activation=relu, name='fc2')(x)
imagenet_utils.validate_activation(classifier_activation, weights)
x = tf.keras.layers.Dense(classes, activation=classifier_activation,
name='predictions')(x)
else:
if pooling == 'avg':
x = tf.keras.layers.GlobalAveragePooling2D()(x)
elif pooling == 'max':
x = tf.keras.layers.GlobalMaxPooling2D()(x)
# Ensure that the model takes into account
# any potential predecessors of `input_tensor`.
if input_tensor is not None:
inputs = tf.keras.utils.layer_utils.get_source_inputs(input_tensor)
else:
inputs = img_input
# Create model.
model = tf.keras.Model(inputs, x, name='vgg19')
# Load weights.
if weights == 'imagenet':
if include_top:
weights_path = tf.keras.utils.get_file(
'vgg19_weights_tf_dim_ordering_tf_kernels.h5',
WEIGHTS_PATH,
cache_subdir='models',
file_hash='cbe5617147190e668d6c5d5026f83318')
else:
weights_path = tf.keras.utils.get_file(
'vgg19_weights_tf_dim_ordering_tf_kernels_notop.h5',
WEIGHTS_PATH_NO_TOP,
cache_subdir='models',
file_hash='253f8cb515780f3b799900260a226db6')
model.load_weights(weights_path)
elif weights is not None:
model.load_weights(weights)
return model
BASE_WEIGHTS_PATH = (
'https://storage.googleapis.com/tensorflow/keras-applications/resnet/')
WEIGHTS_HASHES = {
'resnet50': ('2cb95161c43110f7111970584f804107',
'4d473c1dd8becc155b73f8504c6f6626'),
'resnet101': ('f1aeb4b969a6efcfb50fad2f0c20cfc5',
'88cf7a10940856eca736dc7b7e228a21'),
'resnet152': ('100835be76be38e30d865e96f2aaae62',
'ee4c566cf9a93f14d82f913c2dc6dd0c'),
'resnet50v2': ('3ef43a0b657b3be2300d5770ece849e0',
'fac2f116257151a9d068a22e544a4917'),
'resnet101v2': ('6343647c601c52e1368623803854d971',
'c0ed64b8031c3730f411d2eb4eea35b5'),
'resnet152v2': ('a49b44d1979771252814e80f8ec446f9',
'ed17cf2e0169df9d443503ef94b23b33'),
'resnext50': ('67a5b30d522ed92f75a1f16eef299d1a',
'62527c363bdd9ec598bed41947b379fc'),
'resnext101':
('34fb605428fcc7aa4d62f44404c11509', '0f678c91647380debd923963594981b3')
}
layers = None
def ResNet(stack_fn,
preact,
use_bias,
model_name='resnet',
include_top=True,
weights='imagenet',
input_tensor=None,
input_shape=None,
pooling=None,
classes=1000,
classifier_activation='softmax',
conv_fun=tf.keras.layers.Conv2D,
**kwargs):
if kwargs:
raise ValueError('Unknown argument(s): %s' % (kwargs,))
if not (weights in {'imagenet', None} or file_io.file_exists_v2(weights)):
raise ValueError('The `weights` argument should be either '
'`None` (random initialization), `imagenet` '
'(pre-training on ImageNet), '
'or the path to the weights file to be loaded.')
if weights == 'imagenet' and include_top and classes != 1000:
raise ValueError('If using `weights` as `"imagenet"` with `include_top`'
' as true, `classes` should be 1000')
# Determine proper input shape
input_shape = imagenet_utils.obtain_input_shape(
input_shape,
default_size=224,
min_size=32,
data_format=tf.keras.backend.image_data_format(),
require_flatten=include_top,
weights=weights)
if input_tensor is None:
img_input = tf.keras.layers.Input(shape=input_shape)
else:
if not tf.keras.backend.is_keras_tensor(input_tensor):
img_input = tf.keras.layers.Input(tensor=input_tensor, shape=input_shape)
else:
img_input = input_tensor
bn_axis = 3 if tf.keras.backend.image_data_format() == 'channels_last' else 1
x = tf.keras.layers.ZeroPadding2D(
padding=((3, 3), (3, 3)), name='conv1_pad')(img_input)
x = conv_fun(64, 7, strides=2, use_bias=use_bias, name='conv1_conv')(x)
if not preact:
x = tf.keras.layers.BatchNormalization(
axis=bn_axis, epsilon=1.001e-5, name='conv1_bn')(x)
x = tf.keras.layers.Activation('relu', name='conv1_relu')(x)
x = tf.keras.layers.ZeroPadding2D(padding=((1, 1), (1, 1)), name='pool1_pad')(x)
x = tf.keras.layers.MaxPooling2D(3, strides=2, name='pool1_pool')(x)
x = stack_fn(x)
if preact:
x = tf.keras.layers.BatchNormalization(
axis=bn_axis, epsilon=1.001e-5, name='post_bn')(x)
x = tf.keras.layers.Activation('relu', name='post_relu')(x)
if include_top:
x = tf.keras.layers.GlobalAveragePooling2D(name='avg_pool')(x)
imagenet_utils.validate_activation(classifier_activation, weights)
x = tf.keras.layers.Dense(classes, activation=classifier_activation,
name='predictions')(x)
else:
if pooling == 'avg':
x = tf.keras.layers.GlobalAveragePooling2D(name='avg_pool')(x)
elif pooling == 'max':
x = tf.keras.layers.GlobalMaxPooling2D(name='max_pool')(x)
# Ensure that the model takes into account
# any potential predecessors of `input_tensor`.
if input_tensor is not None:
inputs = layer_utils.get_source_inputs(input_tensor)
else:
inputs = img_input
# Create model.
model = tf.keras.Model(inputs, x, name=model_name)
# Load weights.
if (weights == 'imagenet') and (model_name in WEIGHTS_HASHES):
if include_top:
file_name = model_name + '_weights_tf_dim_ordering_tf_kernels.h5'
file_hash = WEIGHTS_HASHES[model_name][0]
else:
file_name = model_name + '_weights_tf_dim_ordering_tf_kernels_notop.h5'
file_hash = WEIGHTS_HASHES[model_name][1]
weights_path = tf.keras.utils.get_file(
file_name,
BASE_WEIGHTS_PATH + file_name,
cache_subdir='models',
file_hash=file_hash)
model.load_weights(weights_path)
elif weights is not None:
model.load_weights(weights)
return model
def block1(x, filters, kernel_size=3, stride=1, conv_shortcut=True, name=None, conv_fun=tf.keras.layers.Conv2D):
"""A residual block.
Args:
x: input tensor.
filters: integer, filters of the bottleneck layer.
kernel_size: default 3, kernel size of the bottleneck layer.
stride: default 1, stride of the first layer.
conv_shortcut: default True, use convolution shortcut if True,
otherwise identity shortcut.
name: string, block label.
Returns:
Output tensor for the residual block.
"""
bn_axis = 3 if tf.keras.backend.image_data_format() == 'channels_last' else 1
if conv_shortcut:
shortcut = conv_fun(
4 * filters, 1, strides=stride, name=name + '_0_conv')(x)
shortcut = tf.keras.layers.BatchNormalization(
axis=bn_axis, epsilon=1.001e-5, name=name + '_0_bn')(shortcut)
else:
shortcut = x
x = conv_fun(filters, 1, strides=stride, name=name + '_1_conv')(x)
x = tf.keras.layers.BatchNormalization(
axis=bn_axis, epsilon=1.001e-5, name=name + '_1_bn')(x)
x = tf.keras.layers.Activation('relu', name=name + '_1_relu')(x)
x = conv_fun(
filters, kernel_size, padding='SAME', name=name + '_2_conv')(x)
x = tf.keras.layers.BatchNormalization(
axis=bn_axis, epsilon=1.001e-5, name=name + '_2_bn')(x)
x = tf.keras.layers.Activation('relu', name=name + '_2_relu')(x)
x = conv_fun(4 * filters, 1, name=name + '_3_conv')(x)
x = tf.keras.layers.BatchNormalization(
axis=bn_axis, epsilon=1.001e-5, name=name + '_3_bn')(x)
x = tf.keras.layers.Add(name=name + '_add')([shortcut, x])
x = tf.keras.layers.Activation('relu', name=name + '_out')(x)
return x
def stack1(x, filters, blocks, stride1=2, conv_fun=tf.keras.layers.Conv2D, name=None):
"""A set of stacked residual blocks.
Args:
x: input tensor.
filters: integer, filters of the bottleneck layer in a block.
blocks: integer, blocks in the stacked | |
or a list of strings with the technology names to run.")
# Based on wealth index, minimum wage and a lower an upper range for cost of oportunity
print(f'[{self.specs["Country_name"]}] Getting value of time')
self.get_value_of_time()
# Loop through each technology and calculate all benefits and costs
for tech in techs:
print(f'Calculating health benefits for {tech.name}...')
tech.morbidity(self)
tech.mortality(self)
print(f'Calculating carbon emissions benefits for {tech.name}...')
tech.carbon_emissions(self)
print(f'Calculating time saved benefits for {tech.name}...')
tech.time_saved(self)
print(f'Calculating costs for {tech.name}...')
tech.required_energy(self)
tech.discounted_om(self)
tech.discounted_inv(self)
tech.discount_fuel_cost(self)
tech.salvage(self)
print(f'Calculating net benefit for {tech.name}...\n')
if 'w_costs' not in self.specs.keys():
w_health = 1
w_environment = 1
w_social = 1
w_costs = 1
else:
w_health = self.specs['w_health']
w_environment = self.specs['w_environment']
w_social = self.specs['w_social']
w_costs = self.specs['w_costs']
tech.net_benefit(self, w_health, w_environment, w_social, w_costs)
print('Getting maximum net benefit technologies...')
self.maximum_net_benefit(techs)
print('Extracting indicators...')
print(' - Lives saved')
self.extract_lives_saved()
print(' - Health costs')
self.extract_health_costs_saved()
print(' - Time saved')
self.extract_time_saved()
print(' - Opportunity cost')
self.extract_opportunity_cost()
print(' - Avoided emissions')
self.extract_reduced_emissions()
print(' - Avoided emissions costs')
self.extract_emissions_costs_saved()
print(' - Investment costs')
self.extract_investment_costs()
print(' - Fuel costs')
self.extract_fuel_costs()
print(' - OM costs')
self.extract_om_costs()
print(' - Salvage value')
self.extract_salvage()
print('Done')
def _get_column_functs(self):
columns_dict = {column: 'first' for column in self.gdf.columns}
for column in self.gdf.columns[self.gdf.columns.str.contains('cost|benefit|pop|Pop|Households')]:
columns_dict[column] = 'sum'
columns_dict['max_benefit_tech'] = 'first'
return columns_dict
def maximum_net_benefit(self, techs):
net_benefit_cols = [col for col in self.gdf if 'net_benefit_' in col]
benefits_cols = [col for col in self.gdf if 'benefits_' in col]
for benefit, net in zip(benefits_cols, net_benefit_cols):
self.gdf[net + '_temp'] = self.gdf[net]
self.gdf.loc[self.gdf[benefit] < 0, net + '_temp'] = np.nan
temps = [col for col in self.gdf if '_temp' in col]
self.gdf["max_benefit_tech"] = self.gdf[temps].idxmax(axis=1)
self.gdf['max_benefit_tech'] = self.gdf['max_benefit_tech'].str.replace("net_benefit_", "")
self.gdf['max_benefit_tech'] = self.gdf['max_benefit_tech'].str.replace("_temp", "")
self.gdf["maximum_net_benefit"] = self.gdf[temps].max(axis=1)
gdf = gpd.GeoDataFrame()
gdf_copy = self.gdf.copy()
for tech in techs:
current = (tech.households < gdf_copy['Households']) & \
(gdf_copy["max_benefit_tech"] == tech.name)
dff = gdf_copy.loc[current].copy()
if current.sum() > 0:
dff.loc[current, "maximum_net_benefit"] *= tech.factor.loc[current]
dff.loc[current, f'net_benefit_{tech.name}_temp'] = np.nan
second_benefit_cols = temps.copy()
second_benefit_cols.remove(f'net_benefit_{tech.name}_temp')
second_best = dff.loc[current, second_benefit_cols].idxmax(axis=1)
second_best.replace(np.nan, 'NaN', inplace=True)
second_best = second_best.str.replace("net_benefit_", "")
second_best = second_best.str.replace("_temp", "")
second_best.replace('NaN', np.nan, inplace=True)
second_tech_net_benefit = dff.loc[current, second_benefit_cols].max(axis=1) * (1 - tech.factor.loc[current])
dff['max_benefit_tech'] = second_best
dff['maximum_net_benefit'] = second_tech_net_benefit
dff['Calibrated_pop'] *= (1 - tech.factor.loc[current])
dff['Households'] *= (1 - tech.factor.loc[current])
if tech.name == 'Electricity':
dff['Elec_pop_calib'] *= 0
self.gdf.loc[current, 'Elec_pop_calib'] *= tech.factor.loc[current]
self.gdf.loc[current, 'Calibrated_pop'] *= tech.factor.loc[current]
self.gdf.loc[current, 'Households'] *= tech.factor.loc[current]
gdf = gdf.append(dff)
self.gdf = self.gdf.append(gdf)
for net in net_benefit_cols:
self.gdf[net + '_temp'] = self.gdf[net]
temps = [col for col in self.gdf if 'temp' in col]
for tech in self.gdf["max_benefit_tech"].unique():
index = self.gdf.loc[self.gdf['max_benefit_tech'] == tech].index
self.gdf.loc[index, f'net_benefit_{tech}_temp'] = np.nan
isna = self.gdf["max_benefit_tech"].isna()
self.gdf.loc[isna, 'max_benefit_tech'] = self.gdf.loc[isna, temps].idxmax(axis=1)
self.gdf['max_benefit_tech'] = self.gdf['max_benefit_tech'].str.replace("net_benefit_", "")
self.gdf['max_benefit_tech'] = self.gdf['max_benefit_tech'].str.replace("_temp", "")
self.gdf.loc[isna, "maximum_net_benefit"] = self.gdf.loc[isna, temps].max(axis=1)
def add_admin_names(self, admin, column_name):
if isinstance(admin, str):
admin = gpd.read_file(admin)
admin.to_crs(self.gdf.crs, inplace=True)
self.gdf = gpd.sjoin(self.gdf, admin[[column_name, 'geometry']], how="inner", op='intersects')
self.gdf.drop('index_right', axis=1, inplace=True)
self.gdf.sort_index(inplace=True)
def extract_lives_saved(self):
self.gdf["deaths_avoided"] = self.gdf.apply(
lambda row: self.techs[row['max_benefit_tech']].deaths_avoided[row.name], axis=1) * self.gdf["Households"]
def extract_health_costs_saved(self):
self.gdf["health_costs_avoided"] = self.gdf.apply(
lambda row: self.techs[row['max_benefit_tech']].distributed_morbidity[row.name] +
self.techs[row['max_benefit_tech']].distributed_mortality[row.name], axis=1) * self.gdf[
"Households"]
def extract_time_saved(self):
self.gdf["time_saved"] = self.gdf.apply(
lambda row: self.techs[row['max_benefit_tech']].total_time_saved[row.name], axis=1) * \
self.gdf["Households"]
def extract_opportunity_cost(self):
self.gdf["opportunity_cost_gained"] = self.gdf.apply(
lambda row: self.techs[row['max_benefit_tech']].time_value[row.name], axis=1) * \
self.gdf["Households"]
def extract_reduced_emissions(self):
# TODO: Fix this
self.gdf["reduced_emissions"] = self.gdf.apply(
lambda row: self.techs[row['max_benefit_tech']].decreased_carbon_emissions[row.name], axis=1) * self.gdf["Households"]
# except:
# self.gdf["reduced_emissions"] = self.gdf.apply(
# lambda row: self.techs[row['max_benefit_tech']].decreased_carbon_emissions, axis=1) * self.gdf["Households"]
def extract_investment_costs(self):
self.gdf["investment_costs"] = self.gdf.apply(
lambda row: self.techs[row['max_benefit_tech']].discounted_investments[row.name], axis=1) * self.gdf["Households"]
def extract_om_costs(self):
self.gdf["om_costs"] = self.gdf.apply(
lambda row: self.techs[row['max_benefit_tech']].discounted_om_costs, axis=1) * self.gdf["Households"]
def extract_fuel_costs(self):
self.gdf["fuel_costs"] = self.gdf.apply(
lambda row: self.techs[row['max_benefit_tech']].discounted_fuel_cost[row.name], axis=1) * self.gdf[
"Households"]
def extract_salvage(self):
self.gdf["salvage_value"] = self.gdf.apply(
lambda row: self.techs[row['max_benefit_tech']].discounted_salvage_cost[row.name], axis=1) * self.gdf["Households"]
def extract_emissions_costs_saved(self):
# TODO: Fix this
self.gdf["emissions_costs_saved"] = self.gdf.apply(
lambda row: self.techs[row['max_benefit_tech']].decreased_carbon_costs[row.name], axis=1) * self.gdf["Households"]
# except:
# self.gdf["emissions_costs_saved"] = self.gdf.apply(
# lambda row: self.techs[row['max_benefit_tech']].decreased_carbon_costs, axis=1) * self.gdf["Households"]
def gdf_to_csv(self, scenario_name):
name = os.path.join(self.output_directory, scenario_name)
pt = self.gdf.to_crs({'init': 'EPSG:3395'})
pt["X"] = pt["geometry"].x
pt["Y"] = pt["geometry"].y
df = pd.DataFrame(pt.drop(columns='geometry'))
df.to_csv(name)
def extract_wealth_index(self, wealth_index, file_type="csv", x_column="longitude", y_column="latitude",
wealth_column="rwi"):
if file_type == "csv":
df = pd.read_csv(wealth_index)
gdf = gpd.GeoDataFrame(df, geometry=gpd.points_from_xy(df[x_column], df[y_column]))
gdf.crs = 4326
gdf.to_crs(self.gdf.crs, inplace=True)
s1_arr = np.column_stack((self.gdf.centroid.x, self.gdf.centroid.y))
s2_arr = np.column_stack((gdf.centroid.x, gdf.centroid.y))
def do_kdtree(combined_x_y_arrays, points):
mytree = scipy.spatial.cKDTree(combined_x_y_arrays)
dist, indexes = mytree.query(points)
return dist, indexes
results1, results2 = do_kdtree(s2_arr, s1_arr)
self.gdf["relative_wealth"] = gdf.loc[results2][wealth_column].values
elif file_type == "point":
gdf = gpd.read_file(wealth_index)
gdf.to_crs(self.gdf.crs, inplace=True)
s1_arr = np.column_stack((self.gdf.centroid.x, self.gdf.centroid.y))
s2_arr = np.column_stack((gdf.centroid.x, gdf.centroid.y))
def do_kdtree(combined_x_y_arrays, points):
mytree = scipy.spatial.cKDTree(combined_x_y_arrays)
dist, indexes = mytree.query(points)
return dist, indexes
results1, results2 = do_kdtree(s2_arr, s1_arr)
self.gdf["relative_wealth"] = gdf.loc[results2].reset_index()[wealth_column]
elif file_type == "polygon":
gdf = gpd.read_file(wealth_index)
gdf.to_crs(self.gdf.crs, inplace=True)
gdf.rename(columns={wealth_column: "relative_wealth"}, inplace = True)
self.gdf = gpd.sjoin(self.gdf, gdf[["relative_wealth", "geometry"]], how="left")
elif file_type == "raster":
layer = RasterLayer('Demographics', 'Wealth', layer_path=wealth_index, resample='average')
layer.align(self.base_layer.path)
self.raster_to_dataframe(layer.layer, name="relative_wealth", method='read',
nodata=layer.meta['nodata'], fill_nodata='interpolate')
else:
raise ValueError("file_type needs to be either csv, raster, polygon or point.")
def _create_layer(self, variable, labels=None, cmap=None):
layer = np.empty(self.base_layer.layer.shape)
layer[:] = np.nan
codes = None
if isinstance(self.gdf[variable].iloc[0], str):
dff = self.gdf.copy().reset_index(drop=False)
if isinstance(labels, dict):
for value, label in labels.items():
dff.loc[dff[variable] == value.replace('_', ' '), variable] = label
dff[variable] += ' and '
dff = dff.groupby('index').agg({variable: 'sum'})
dff[variable] = [s[0:len(s) - 5].replace('_', ' ') for s in dff[variable]]
if isinstance(labels, dict):
for value, label in labels.items():
dff.loc[dff[variable] == value.replace('_', ' '), variable] = label
codes = {tech: i for i, tech in enumerate(dff[variable].unique())}
if isinstance(cmap, dict):
cmap = {i: cmap[tech] for i, tech in enumerate(dff[variable].unique())}
layer[self.rows, self.cols] = [codes[tech] for tech in dff[variable]]
else:
dff = self.gdf.copy().reset_index(drop=False)
dff = dff.groupby('index').agg({variable: 'sum'})
layer[self.rows, self.cols] = dff[variable]
raster = RasterLayer('Output', variable)
raster.layer = layer
raster.meta = self.base_layer.meta
raster.meta.update(nodata=np.nan, dtype='float32')
raster.bounds = self.base_layer.bounds
return raster, codes, cmap
def to_raster(self, variable, labels=None, cmap=None):
raster, codes, cmap = self._create_layer(variable, labels=labels, cmap=cmap)
raster.save(os.path.join(self.output_directory, 'Output'))
print(f'Layer saved in {os.path.join(self.output_directory, "Output", variable + ".tif")}\n')
if codes and cmap:
with open(os.path.join(self.output_directory, 'ColorMap.clr'), 'w') as f:
for label, code in codes.items():
r = int(to_rgb(cmap[code])[0] * 255)
g = int(to_rgb(cmap[code])[1] * 255)
b = int(to_rgb(cmap[code])[2] * 255)
f.write(f'{code} {r} {g} {b} 255 {label}\n')
def plot(self, variable, cmap='viridis', cumulative_count=None, legend_position=(1.05, 1), dpi=150,
admin_layer=None, title=None, labels=None, legend=True, legend_title='', legend_cols=1, rasterized=True,
stats=False, stats_position=(1.05, 0.5)):
raster, codes, cmap = self._create_layer(variable, labels=labels, cmap=cmap)
if isinstance(admin_layer, gpd.GeoDataFrame):
admin_layer = admin_layer
elif not admin_layer:
admin_layer = self.mask_layer.layer
if stats:
fig, ax = plt.subplots(1, 1, figsize=(16, 9), dpi=dpi)
self.add_statistics(ax, stats_position)
else:
ax = None
raster.plot(cmap=cmap, cumulative_count=cumulative_count,
categories=codes, legend_position=legend_position,
admin_layer=admin_layer, title=title, legend=legend,
legend_title=legend_title, legend_cols=legend_cols, rasterized=rasterized,
ax=ax)
def add_statistics(self, ax, stats_position):
summary = self.summary(total=True)
deaths = TextArea("Deaths avoided", textprops=dict(fontsize=12, color='black'))
health = TextArea("Health costs avoided", textprops=dict(fontsize=12, color='black'))
emissions = TextArea("Emissions avoided", textprops=dict(fontsize=12, color='black'))
time = TextArea("Time saved", textprops=dict(fontsize=12, color='black'))
texts_vbox = VPacker(children=[deaths, health, emissions, time], pad=0, sep=6)
deaths_avoided = summary.loc['total', 'deaths_avoided']
health_costs_avoided = summary.loc['total', 'health_costs_avoided']
reduced_emissions = summary.loc['total', 'reduced_emissions']
time_saved = summary.loc['total', 'time_saved']
deaths = TextArea(f"{deaths_avoided:.0f} pp/yr", textprops=dict(fontsize=12, color='black'))
health = TextArea(f"{health_costs_avoided:.2f} b.USD", textprops=dict(fontsize=12, color='black'))
emissions = TextArea(f"{reduced_emissions:.2f} Mton", textprops=dict(fontsize=12, color='black'))
time = TextArea(f"{time_saved:.2f} h/pp.day", textprops=dict(fontsize=12, color='black'))
values_vbox = VPacker(children=[deaths, health, emissions, time], pad=0, sep=6, align='right')
hvox = HPacker(children=[texts_vbox, values_vbox], pad=0, sep=6)
ab = AnnotationBbox(hvox, stats_position,
xycoords='axes fraction',
box_alignment=(0, 0),
pad=0.0,
bboxprops=dict(boxstyle='round',
facecolor='#f1f1f1ff',
edgecolor='lightgray'))
ax.add_artist(ab)
def to_image(self, variable, type='png', cmap='viridis', cumulative_count=None, legend_position=(1.05, 1),
admin_layer=None, title=None, dpi=300, labels=None, legend=True, legend_title='', legend_cols=1,
rasterized=True, stats=False, stats_position=(1.05, 0.5)):
raster, codes, cmap = self._create_layer(variable, labels=labels, cmap=cmap)
raster.bounds = self.base_layer.bounds
if isinstance(admin_layer, gpd.GeoDataFrame):
admin_layer = admin_layer
elif not admin_layer:
admin_layer = self.mask_layer.layer
if stats:
fig, ax = plt.subplots(1, 1, figsize=(16, 9), dpi=dpi)
self.add_statistics(ax, stats_position)
else:
ax = None
raster.save_image(self.output_directory, type=type, cmap=cmap, cumulative_count=cumulative_count,
categories=codes, legend_position=legend_position,
admin_layer=admin_layer, title=title, ax=ax, dpi=dpi,
legend=legend, legend_title=legend_title, legend_cols=legend_cols, rasterized=rasterized)
def to_json(self, name):
self.gdf.to_file(os.path.join(self.output_directory, name), driver='GeoJSON')
def read_data(self, path):
self.gdf = gpd.read_file(path)
def summary(self, total=False):
summary = self.gdf.groupby(['max_benefit_tech']).agg({'Calibrated_pop': lambda row: np.nansum(row) / 1000000,
'maximum_net_benefit': lambda row: np.nansum(
row) / 1000000,
'deaths_avoided': 'sum',
'health_costs_avoided': lambda row: np.nansum(
row) / 1000000,
'time_saved': 'sum',
'opportunity_cost_gained': lambda row: np.nansum(
row) / 1000000,
'reduced_emissions': lambda row: np.nansum(
row) / 1000000000,
'emissions_costs_saved': lambda row: np.nansum(
row) / 1000000,
'investment_costs': lambda row: np.nansum(row) / 1000000,
'fuel_costs': lambda row: np.nansum(row) / 1000000,
'om_costs': lambda row: np.nansum(row) / 1000000,
'salvage_value': lambda row: np.nansum(row) | |
import functools
import json
import typing as t
import warnings
from datetime import datetime
from io import BytesIO
from .._internal import _to_str
from .._internal import _wsgi_decoding_dance
from ..datastructures import Accept
from ..datastructures import Authorization
from ..datastructures import CharsetAccept
from ..datastructures import CombinedMultiDict
from ..datastructures import EnvironHeaders
from ..datastructures import ETags
from ..datastructures import FileStorage
from ..datastructures import HeaderSet
from ..datastructures import IfRange
from ..datastructures import ImmutableList
from ..datastructures import ImmutableMultiDict
from ..datastructures import iter_multi_items
from ..datastructures import LanguageAccept
from ..datastructures import MIMEAccept
from ..datastructures import MultiDict
from ..datastructures import Range
from ..datastructures import RequestCacheControl
from ..formparser import default_stream_factory
from ..formparser import FormDataParser
from ..http import parse_accept_header
from ..http import parse_authorization_header
from ..http import parse_cache_control_header
from ..http import parse_cookie
from ..http import parse_date
from ..http import parse_etags
from ..http import parse_if_range_header
from ..http import parse_list_header
from ..http import parse_options_header
from ..http import parse_range_header
from ..http import parse_set_header
from ..urls import url_decode
from ..useragents import UserAgent
from ..utils import cached_property
from ..utils import environ_property
from ..utils import header_property
from ..wsgi import get_content_length
from ..wsgi import get_current_url
from ..wsgi import get_host
from ..wsgi import get_input_stream
from werkzeug.exceptions import BadRequest
if t.TYPE_CHECKING:
from wsgiref.types import WSGIApplication
from wsgiref.types import WSGIEnvironment
class Request:
"""Represents an incoming HTTP request, with headers and body taken
from the WSGI environment. Has properties and methods for using the
functionality defined by various HTTP specs. The data in requests
object is read-only.
Text data is assumed to use UTF-8 encoding, which should be true for
the vast majority of modern clients. Using an encoding set by the
client is unsafe in Python due to extra encodings it provides, such
as ``zip``. To change the assumed encoding, subclass and replace
:attr:`charset`.
:param environ: The WSGI environ is generated by the WSGI server and
contains information about the server configuration and client
request.
:param populate_request: Add this request object to the WSGI environ
as ``environ['werkzeug.request']``. Can be useful when
debugging.
:param shallow: Makes reading from :attr:`stream` (and any method
that would read from it) raise a :exc:`RuntimeError`. Useful to
prevent consuming the form data in middleware, which would make
it unavailable to the final application.
.. versionchanged:: 2.0
Combine ``BaseRequest`` and mixins into a single ``Request``
class. Using the old classes is deprecated and will be removed
in version 2.1.
.. versionchanged:: 0.5
Read-only mode is enforced with immutable classes for all data.
"""
#: the charset for the request, defaults to utf-8
charset = "utf-8"
#: the error handling procedure for errors, defaults to 'replace'
encoding_errors = "replace"
#: the maximum content length. This is forwarded to the form data
#: parsing function (:func:`parse_form_data`). When set and the
#: :attr:`form` or :attr:`files` attribute is accessed and the
#: parsing fails because more than the specified value is transmitted
#: a :exc:`~werkzeug.exceptions.RequestEntityTooLarge` exception is raised.
#:
#: Have a look at :doc:`/request_data` for more details.
#:
#: .. versionadded:: 0.5
max_content_length: t.Optional[int] = None
#: the maximum form field size. This is forwarded to the form data
#: parsing function (:func:`parse_form_data`). When set and the
#: :attr:`form` or :attr:`files` attribute is accessed and the
#: data in memory for post data is longer than the specified value a
#: :exc:`~werkzeug.exceptions.RequestEntityTooLarge` exception is raised.
#:
#: Have a look at :doc:`/request_data` for more details.
#:
#: .. versionadded:: 0.5
max_form_memory_size: t.Optional[int] = None
#: the class to use for `args` and `form`. The default is an
#: :class:`~werkzeug.datastructures.ImmutableMultiDict` which supports
#: multiple values per key. alternatively it makes sense to use an
#: :class:`~werkzeug.datastructures.ImmutableOrderedMultiDict` which
#: preserves order or a :class:`~werkzeug.datastructures.ImmutableDict`
#: which is the fastest but only remembers the last key. It is also
#: possible to use mutable structures, but this is not recommended.
#:
#: .. versionadded:: 0.6
parameter_storage_class: t.Type[MultiDict] = ImmutableMultiDict
#: the type to be used for list values from the incoming WSGI environment.
#: By default an :class:`~werkzeug.datastructures.ImmutableList` is used
#: (for example for :attr:`access_list`).
#:
#: .. versionadded:: 0.6
list_storage_class: t.Type[t.List] = ImmutableList
#: The type to be used for dict values from the incoming WSGI
#: environment. (For example for :attr:`cookies`.) By default an
#: :class:`~werkzeug.datastructures.ImmutableMultiDict` is used.
#:
#: .. versionchanged:: 1.0.0
#: Changed to ``ImmutableMultiDict`` to support multiple values.
#:
#: .. versionadded:: 0.6
dict_storage_class: t.Type[MultiDict] = ImmutableMultiDict
#: The form data parser that shoud be used. Can be replaced to customize
#: the form date parsing.
form_data_parser_class: t.Type[FormDataParser] = FormDataParser
#: Optionally a list of hosts that is trusted by this request. By default
#: all hosts are trusted which means that whatever the client sends the
#: host is will be accepted.
#:
#: Because `Host` and `X-Forwarded-Host` headers can be set to any value by
#: a malicious client, it is recommended to either set this property or
#: implement similar validation in the proxy (if application is being run
#: behind one).
#:
#: .. versionadded:: 0.9
trusted_hosts: t.Optional[t.List[str]] = None
#: Indicates whether the data descriptor should be allowed to read and
#: buffer up the input stream. By default it's enabled.
#:
#: .. versionadded:: 0.9
disable_data_descriptor: bool = False
#: The WSGI environment containing HTTP headers and information from
#: the WSGI server.
environ: "WSGIEnvironment"
#: Set when creating the request object. If ``True``, reading from
#: the request body will cause a ``RuntimeException``. Useful to
#: prevent modifying the stream from middleware.
shallow: bool
def __init__(
self,
environ: "WSGIEnvironment",
populate_request: bool = True,
shallow: bool = False,
) -> None:
self.environ = environ
if populate_request and not shallow:
self.environ["werkzeug.request"] = self
self.shallow = shallow
def __repr__(self) -> str:
# make sure the __repr__ even works if the request was created
# from an invalid WSGI environment. If we display the request
# in a debug session we don't want the repr to blow up.
args = []
try:
args.append(f"'{self.url}'")
args.append(f"[{self.method}]")
except Exception:
args.append("(invalid WSGI environ)")
return f"<{type(self).__name__} {' '.join(args)}>"
@property
def url_charset(self) -> str:
"""The charset that is assumed for URLs. Defaults to the value
of :attr:`charset`.
.. versionadded:: 0.6
"""
return self.charset
@classmethod
def from_values(cls, *args, **kwargs) -> "Request":
"""Create a new request object based on the values provided. If
environ is given missing values are filled from there. This method is
useful for small scripts when you need to simulate a request from an URL.
Do not use this method for unittesting, there is a full featured client
object (:class:`Client`) that allows to create multipart requests,
support for cookies etc.
This accepts the same options as the
:class:`~werkzeug.test.EnvironBuilder`.
.. versionchanged:: 0.5
This method now accepts the same arguments as
:class:`~werkzeug.test.EnvironBuilder`. Because of this the
`environ` parameter is now called `environ_overrides`.
:return: request object
"""
from ..test import EnvironBuilder
charset = kwargs.pop("charset", cls.charset)
kwargs["charset"] = charset
builder = EnvironBuilder(*args, **kwargs)
try:
return builder.get_request(cls)
finally:
builder.close()
@classmethod
def application(
cls, f: t.Callable[["Request"], "WSGIApplication"]
) -> "WSGIApplication":
"""Decorate a function as responder that accepts the request as
the last argument. This works like the :func:`responder`
decorator but the function is passed the request object as the
last argument and the request object will be closed
automatically::
@Request.application
def my_wsgi_app(request):
return Response('Hello World!')
As of Werkzeug 0.14 HTTP exceptions are automatically caught and
converted to responses instead of failing.
:param f: the WSGI callable to decorate
:return: a new WSGI callable
"""
#: return a callable that wraps the -2nd argument with the request
#: and calls the function with all the arguments up to that one and
#: the request. The return value is then called with the latest
#: two arguments. This makes it possible to use this decorator for
#: both standalone WSGI functions as well as bound methods and
#: partially applied functions.
from ..exceptions import HTTPException
@functools.wraps(f)
def application(*args):
request = cls(args[-2])
with request:
try:
resp = f(*args[:-2] + (request,))
except HTTPException as e:
resp = e.get_response(args[-2])
return resp(*args[-2:])
return application
def _get_file_stream(
self,
total_content_length: int,
content_type: t.Optional[str],
filename: t.Optional[str] = None,
content_length: t.Optional[int] = None,
):
"""Called to get a stream for the file upload.
This must provide a file-like | |
x, y, w, h):
"""
Set the dimensions for this view.
:param int x: The horizontal position.
:param int y: The vertical position.
:param int w: The width.
:param int h: The height.
:returns: Self, to allow chaining.
:rtype: VitessceConfigView
"""
self.view["x"] = x
self.view["y"] = y
self.view["w"] = w
self.view["h"] = h
return self
def set_props(self, **kwargs):
"""
Set the props for this view.
:param \*\*kwargs: A variable number of named props.
:returns: Self, to allow chaining.
:rtype: VitessceConfigView
"""
if "props" in self.view:
self.view["props"].update(kwargs)
else:
self.view["props"] = kwargs
return self
def get_props(self):
"""
Get the props for this view.
:returns: The props.
:rtype: dict or None
"""
return self.view.get("props")
def to_dict(self):
return self.view
def __or__(self, other):
return hconcat(self, other)
def __truediv__(self, other):
return vconcat(self, other)
class VitessceConfigCoordinationScope:
"""
A class to represent a coordination scope in the Vitessce view config coordination space.
"""
def __init__(self, c_type, c_scope, c_value=None):
"""
Not meant to be instantiated directly, but instead created and returned by the ``VitessceConfig.add_coordination()`` method.
:param str c_type: The coordination type for this coordination scope.
:param str c_scope: The coordination scope name.
:param c_value: The value for the coordination scope. Optional.
"""
self.c_type = c_type
self.c_scope = c_scope
self.c_value = c_value
def _to_py_params(self):
return {
"c_type": self.c_type,
"c_scope": self.c_scope,
"c_value": self.c_value,
}
def set_value(self, c_value):
"""
Set the value of the coordination scope.
:param any c_value: The coordination value to be set. Can be any value that is valid for the coordination type. Must be serializable to JSON.
:returns: Self, to allow chaining.
:rtype: VitessceConfigCoordinationScope
.. code-block:: python
:emphasize-lines: 14-16
from vitessce import VitessceConfig, Component as cm, CoordinationType as ct
vc = VitessceConfig()
my_dataset = vc.add_dataset(name='My Dataset')
v1 = vc.add_view(cm.SPATIAL, dataset=my_dataset)
v2 = vc.add_view(cm.SPATIAL, dataset=my_dataset)
zoom_scope, x_scope, y_scope = vc.add_coordination(
ct.SPATIAL_ZOOM,
ct.SPATIAL_TARGET_X,
ct.SPATIAL_TARGET_Y,
)
v1.use_coordination(zoom_scope, x_scope, y_scope)
v2.use_coordination(zoom_scope, x_scope, y_scope)
zoom_scope.set_value(2)
x_scope.set_value(0)
y_scope.set_value(0)
"""
self.c_value = c_value
return self
class VitessceConfig:
"""
A class to represent a Vitessce view config.
"""
def __init__(self, name=None, description=None, schema_version="1.0.7"):
"""
Construct a Vitessce view config object.
:param str name: A name for the view config. Optional.
:param str description: A description for the view config. Optional.
:param str schema_version: The view config schema version.
.. code-block:: python
:emphasize-lines: 3
from vitessce import VitessceConfig
vc = VitessceConfig(name='My Config')
"""
self.config = {
"version": schema_version,
"name": name,
"description": description,
"datasets": [],
"coordinationSpace": {},
"layout": [],
"initStrategy": "auto"
}
if name is None:
self.config["name"] = ""
else:
self.config["name"] = name
if description is None:
self.config["description"] = ""
else:
self.config["description"] = description
def _to_py_params(self):
return {
"name": self.config["name"],
"description": self.config["description"],
"schema_version": self.config["version"],
}
def add_dataset(self, name="", uid=None, files=None, objs=None):
"""
Add a dataset to the config.
:param str name: A name for this dataset.
:param str uid: A unique identifier for this dataset. Optional. If None, one will be automatically generated.
:param files: A list of VitessceConfigDatasetFile instances. optional.
:type files: list or None
:param objs: A list of AbstractWrapper instances. Optional.
:type objs: list or None
:returns: The instance for the new dataset.
:rtype: VitessceConfigDataset
.. code-block:: python
:emphasize-lines: 5
from vitessce import VitessceConfig, DataType as dt, FileType as ft
vc = VitessceConfig(name='My Config')
my_dataset = (
vc.add_dataset(name='My Dataset')
.add_file(
url="http://example.com/cells.json",
data_type=dt.CELLS,
file_type=ft.CELLS_JSON,
)
)
"""
uid = uid if uid is not None else _get_next_scope(
[d.dataset['uid'] for d in self.config["datasets"]])
assert type(uid) == str
vcd = VitessceConfigDataset(uid, name)
self.config["datasets"].append(vcd)
[d_scope] = self.add_coordination(ct.DATASET)
d_scope.set_value(uid)
if isinstance(files, list):
for obj in files:
vcd._add_file(obj)
if isinstance(objs, list):
for obj in objs:
vcd.add_object(obj)
return vcd
def get_dataset_by_uid(self, uid):
"""
Get a dataset associated with this configuration based on its uid.
:param str uid: The unique identifier for the dataset of interest.
:returns: The dataset object.
:rtype: VitessceConfigDataset or None
"""
for dataset in self.config["datasets"]:
if dataset.get_uid() == uid:
return dataset
return None
def get_dataset_by_coordination_scope_name(self, query_scope_name):
"""
Get a dataset associated with this configuration based on a coordination scope.
:param str query_scope_name: The unique identifier for the dataset coordination scope of interest.
:returns: The dataset object.
:rtype: VitessceConfigDataset or None
"""
if ct.DATASET.value in self.config["coordinationSpace"]:
for scope_name, dataset_scope in self.config["coordinationSpace"][ct.DATASET.value].items():
if scope_name == query_scope_name:
return self.get_dataset_by_uid(dataset_scope.c_value)
return None
def get_datasets(self):
"""
Get the datasets associated with this configuration.
:returns: The list of dataset objects.
:rtype: list of VitessceConfigDataset
"""
return self.config["datasets"]
def add_view(self, component, dataset=None, dataset_uid=None, x=0, y=0, w=1, h=1, mapping=None, coordination_scopes=None, props=None):
"""
Add a view to the config.
:param component: A component name, either as a string or using the Component enum values.
:type component: str or vitessce.constants.Component
:param dataset: A dataset instance to be used for the data visualized in this view. Must provide dataset or dataset_uid, but not both.
:type dataset: VitessceConfigDataset or None
:param dataset_uid: A unique ID for a dataset to be used for the data visualized in this view. Must provide dataset or dataset_uid, but not both.
:type dataset_uid: str or None
:param str mapping: An optional convenience parameter for setting the EMBEDDING_TYPE coordination scope value. This parameter is only applicable to the SCATTERPLOT component.
:param int x: The horizontal position of the view. Must be an integer between 0 and 11. Optional. This will be ignored if you call the `layout` method of this class using `VitessceConfigViewHConcat` and `VitessceConfigViewVConcat` objects.
:param int y: The vertical position of the view. Must be an integer between 0 and 11. Optional. This will be ignored if you call the `layout` method of this class using `VitessceConfigViewHConcat` and `VitessceConfigViewVConcat` objects.
:param int w: The width of the view. Must be an integer between 1 and 12. Optional. This will be ignored if you call the `layout` method of this class using `VitessceConfigViewHConcat` and `VitessceConfigViewVConcat` objects.
:param int h: The height of the view. Must be an integer between 1 and 12. Optional. This will be ignored if you call the `layout` method of this class using `VitessceConfigViewHConcat` and `VitessceConfigViewVConcat` objects.
:param coordination_scopes: A mapping from coordination types to coordination scope names for this view.
:type coordination_scopes: dict or None
:param props: Props to set for the view using the VitessceConfigView.set_props method.
:type props: dict or None
:returns: The instance for the new view.
:rtype: VitessceConfigView
.. code-block:: python
:emphasize-lines: 5-6
from vitessce import VitessceConfig, Component as cm
vc = VitessceConfig()
my_dataset = vc.add_dataset(name='My Dataset')
v1 = vc.add_view(cm.SPATIAL, dataset=my_dataset)
v2 = vc.add_view(cm.SCATTERPLOT, dataset=my_dataset, mapping="X_umap")
"""
# User should only provide dataset or dataset_uid, but not both.
assert isinstance(dataset, VitessceConfigDataset) or isinstance(
dataset_uid, str)
assert dataset is None or dataset_uid is None
assert type(component) in [str, cm]
if dataset is None:
dataset = self.get_dataset_by_uid(dataset_uid)
if dataset is None:
raise ValueError(
"A dataset with the provided dataset_uid could not be found.")
if type(component) == str:
component_str = component
else:
component_str = component.value
# Find the coordination scope name associated with the dataset
dataset_matches = [
scope_name
for scope_name, dataset_scope in self.config["coordinationSpace"][ct.DATASET.value].items()
if dataset_scope.c_value == dataset.dataset["uid"]
] if ct.DATASET.value in self.config["coordinationSpace"].keys() else []
if len(dataset_matches) == 1:
dataset_scope = dataset_matches[0]
else:
raise ValueError(
"No coordination scope matching the dataset parameter could be found in the coordination space.")
# Set up the view's dataset coordination scope based on the dataset parameter.
internal_coordination_scopes = {
ct.DATASET.value: dataset_scope
}
if coordination_scopes is not None:
internal_coordination_scopes.update(coordination_scopes)
vcv = VitessceConfigView(
component_str, internal_coordination_scopes, x, y, w, h)
# Use the mapping parameter if component is scatterplot and the mapping is not None
if mapping is not None:
[et_scope] = self.add_coordination(ct.EMBEDDING_TYPE)
et_scope.set_value(mapping)
vcv.use_coordination(et_scope)
if isinstance(props, dict):
vcv.set_props(**props)
self.config["layout"].append(vcv)
return vcv
def add_coordination(self, *c_types):
"""
Add scope(s) for new coordination type(s) to the config.
:param \*c_types: A variable number of coordination types.
:type \*c_types: str or vitessce.constants.CoordinationType
:returns: The instances for the new scope objects corresponding to each coordination type. These can be linked to views via the ``VitessceConfigView.use_coordination()`` method.
:rtype: list[VitessceConfigCoordinationScope]
.. code-block:: python
:emphasize-lines: 7-11
from vitessce | |
# Copyright (c) 2020 The Khronos Group Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from __future__ import division, print_function, absolute_import
from collections import Sequence
from functools import reduce
import six
import typing
import numpy as np
# noinspection PyProtectedMember
class Tensor:
def __init__(self,
graph, # type: Graph,
name=None, # type: typing.Optional[str]
shape=None, # type: typing.Optional[typing.Tuple[int, ...]]
dtype=None, # type: typing.Optional[type]
data=None, # type: typing.Union[None, np.ndarray, typing.Any]
quant=None # type: typing.Optional[typing.Dict[str, typing.Any]]
):
# type: (...)->None
self._graph = graph
self._producers = []
self._consumers = []
self.name = name # type: typing.Optional[str]
self.shape = shape # type: typing.Optional[typing.Tuple[int, ...]]
self.dtype = dtype # type: typing.Optional[type]
self.data = data # type: typing.Union[None, np.ndarray, typing.Any]
self.quant = quant or {} # type: typing.Optional[typing.Dict[str, typing.Any]]
assert isinstance(graph, Graph)
graph._tensors.append(self)
def copy_with(self, graph=None, name=None, dtype=None, shape=None, data=None, quant=None):
return Tensor(graph=graph if graph is not None else self.graph,
name=name if name is not None else self.name,
dtype=dtype if dtype is not None else self.dtype,
shape=shape if shape is not None else self.shape,
data=data if data is not None else self.data,
quant=quant if quant is not None else self.quant)
@property
def graph(self):
# type: ()->typing.Optional[Graph]
return self._graph
@property
def has_producer(self):
return len(self._producers) != 0
@property
def producers(self):
# type: ()->typing.List[Operation]
return self._producers
@property
def producer(self):
# type: ()->typing.Optional[Operation]
assert len(self._producers) <= 1
return self._producers[0] if len(self._producers) == 1 else None
@property
def has_consumer(self):
return len(self._consumers) != 0
@property
def consumers(self):
# type: ()->typing.List[Operation]
return self._consumers
@property
def consumer(self):
# type: ()->typing.Optional[Operation]
return self._consumers[0] if len(self._consumers) == 1 else None
@property
def name(self):
return self._name
@name.setter
def name(self, name):
assert name is None or isinstance(name, str)
self._name = name
@property
def shape(self):
return self._shape
@shape.setter
def shape(self, shape):
assert shape is None or isinstance(shape, (list, tuple))
assert shape is None or all(s is None or isinstance(s, int) for s in shape)
self._shape = tuple(shape) if shape is not None else None
@property
def dtype(self):
return self._dtype
@dtype.setter
def dtype(self, dtype):
assert dtype is None or isinstance(dtype, type)
self._dtype = dtype
@property
def rank(self):
# type: ()->typing.Optional[int]
return len(self.shape) if self.shape is not None else None
@property
def volume(self):
# type: ()->typing.Optional[int]
return reduce((lambda x, y: x * y), self.shape) if self.shape is not None and \
all(s is not None for s in self.shape) else None
@property
def is_constant(self):
# type: ()->bool
return self.data is not None
def __repr__(self):
return self.name if self.name is not None else _hex_id(self)
def __str__(self):
return '{name}: {dtype}[{shape}]'.format(
name=self.name if self.name is not None else _hex_id(self),
dtype=self.dtype.__name__,
shape=', '.join(str(s) for s in self.shape))
_TensorListOrTupleT = typing.Union[typing.List[Tensor], typing.Tuple[Tensor, ...]]
# noinspection PyProtectedMember
class Operation:
def __init__(self,
graph, # type: Graph
type=None, # type: typing.Optional[str]
name=None, # type: typing.Optional[str]
attribs=None, # type: typing.Dict[str, typing.Any]
inputs=None, # type: typing.Union[None, Tensor, _TensorListOrTuple]
outputs=None, # type: typing.Union[None, Tensor, _TensorListOrTuple]
custom=False, # type: bool
):
# type:(...)->None
self._graph = graph
self._inputs = tuple()
self._outputs = tuple()
assert name is None or isinstance(name, str)
if attribs is not None:
assert isinstance(attribs, dict)
assert all(isinstance(key, str) for key in six.iterkeys(attribs))
assert all(not isinstance(value, Tensor) for value in six.itervalues(attribs))
self.type = type # type: typing.Optional[str]
self.name = name # type: typing.Optional[str]
self.attribs = attribs or {} # type: typing.Dict[str, typing.Any]
self.custom = custom # type: bool
assert isinstance(graph, Graph)
graph._operations.append(self)
if inputs is not None:
self.inputs = inputs
if outputs is not None:
self.outputs = outputs
def copy_with(self, graph=None, type=None, name=None, attribs=None, inputs=None, outputs=None, custom=None):
return Operation(graph=graph if graph is not None else self.graph,
type=type if type is not None else self.type,
name=name if name is not None else self.name,
attribs=attribs if attribs is not None else self.attribs,
inputs=inputs if inputs is not None else self.inputs,
outputs=outputs if outputs is not None else self.outputs,
custom=custom if custom is not None else self.custom)
@property
def graph(self):
# type: ()->typing.Optional[Graph]
return self._graph
@property
def inputs(self):
# type: ()->_TensorListOrTupleT
return self._inputs
@property
def input(self):
# type: ()->Tensor
assert len(self._inputs) == 1
return self._inputs[0]
@inputs.setter
def inputs(self, tensors):
# type: (typing.Union[Tensor, _TensorListOrTupleT])->None
if isinstance(tensors, Tensor):
tensors = (tensors,)
for tensor in self._inputs:
assert self in tensor._consumers
for tensor in self._inputs:
if self in tensor._consumers:
tensor._consumers.remove(self)
self._inputs = _ListView(tensors) if isinstance(tensors, list) else tensors
for tensor in tensors:
assert isinstance(tensor, Tensor), "got {}".format(type(tensor))
assert tensor.graph is self.graph
if self not in tensor._consumers:
tensor._consumers.append(self)
@property
def outputs(self):
# type: ()->_TensorListOrTupleT
return self._outputs
@property
def output(self):
# type: ()->Tensor
assert len(self._outputs) == 1
return self._outputs[0]
@outputs.setter
def outputs(self, tensors):
# type: (typing.Union[Tensor, _TensorListOrTupleT])->None
if isinstance(tensors, Tensor):
tensors = (tensors,)
for tensor in self._outputs:
assert self in tensor._producers
tensor._producers.remove(self)
self._outputs = _ListView(tensors) if isinstance(tensors, list) else tensors
for tensor in tensors:
assert isinstance(tensor, Tensor), "got {}".format(type(tensor))
assert tensor.graph is self.graph
assert self not in tensor._producers
tensor._producers.append(self)
@property
def type(self):
return self._type
@type.setter
def type(self, type):
assert type is None or isinstance(type, str), "got '{}'".format(type)
self._type = type
@property
def name(self):
return self._name
@name.setter
def name(self, name):
assert name is None or isinstance(name, str), "got '{}'".format(name)
self._name = name
def __repr__(self):
return self.type if self.type is not None else _hex_id(self)
def __str__(self):
return '{outputs} = {op}{{{attribs}}}({inputs})'.format(
op=self.type if self.type is not None else _hex_id(self),
inputs=', '.join(repr(tensor) for tensor in self._inputs),
outputs=', '.join(str(tensor) for tensor in self._outputs),
attribs=', '.join('{}={}'.format(key, value) for key, value in self.attribs.items()))
# noinspection PyProtectedMember
class Graph:
def __init__(self, name=None):
# type:(typing.Optional[str])->None
self._operations = []
self._tensors = []
self._inputs = []
self._outputs = []
self._name = name
@property
def name(self):
return self._name
@name.setter
def name(self, name):
assert name is None or isinstance(name, str)
self._name = name
@property
def operations(self):
# type: ()->typing.Sequence[Operation]
return _ListView(self._operations)
@property
def tensors(self):
# type: ()->typing.Sequence[Tensor]
return _ListView(self._tensors)
@property
def inputs(self):
# type: ()->typing.Sequence[Tensor]
return _ListView(self._inputs)
@inputs.setter
def inputs(self, tensors):
# type: (_TensorListOrTupleT)->None
assert isinstance(tensors, (list, tuple))
self._inputs = tensors
for tensor in self._inputs:
assert isinstance(tensor, Tensor)
assert tensor.graph is self
@property
def outputs(self):
# type: ()->typing.Sequence[Tensor]
return _ListView(self._outputs)
@outputs.setter
def outputs(self, tensors):
# type: (_TensorListOrTupleT)->None
assert isinstance(tensors, (list, tuple))
self._outputs = tensors
for tensor in self._outputs:
assert isinstance(tensor, Tensor)
assert tensor.graph is self
def remove_tensor(self, tensor):
# type: (Tensor)->None
assert len(tensor.producers) == 0
assert len(tensor.consumers) == 0
assert tensor not in self._inputs
assert tensor not in self._outputs
self._tensors.remove(tensor)
tensor._graph = None
def remove_tensors(self, tensors):
# type: (typing.Iterable[Tensor])->None
for tensor in tensors:
assert len(tensor.producers) == 0
assert len(tensor.consumers) == 0
assert tensor not in self._inputs
assert tensor not in self._outputs
self._tensors = [tensor for tensor in self._tensors if tensor not in tensors]
for tensor in tensors:
tensor._graph = None
def remove_operation(self, operation, unlink=False):
# type: (Operation, bool)->None
if unlink:
operation.inputs = []
operation.outputs = []
else:
assert len(operation.inputs) == 0
assert len(operation.outputs) == 0
self._operations.remove(operation)
operation._graph = None
def remove_operations(self, operations, unlink=False):
# type: (typing.Iterable[Operation], bool)->None
operations = operations if isinstance(operations, set) else set(operations)
for operation in operations:
if unlink:
operation.inputs = []
operation.outputs = []
else:
assert len(operation.inputs) == 0
assert len(operation.outputs) == 0
self._operations = [op for op in self._operations if op not in operations]
for operation in operations:
operation._graph = None
def is_unique(self):
return all(len(t.producers) <= 1 for t in self.tensors)
def is_sorted(self):
seen = set()
for op in self.operations:
for tensor in op.inputs:
for producer in tensor.producers:
if producer not in seen:
return False
seen.add(op)
return True
def sort(self, offset=0):
count = len(self._operations)
sorted = {op: False for op in self._operations[offset:]}
for idx in range(offset, count):
i = idx
while i < count and not all(sorted.get(tensor.producer, True) for tensor in self._operations[i].inputs):
i += | |
shapes, they're completely
# useless. the previous step may also have created
# an empty geometry if there weren't any items of
# the type we're looking for.
if shape.is_empty:
return
# add the shape as-is unless we're trying to keep
# the geometry type or the geometry dimension is
# identical.
self.new_features.append((shape, props, fid))
# intersects the shape with the cutting shape and
# handles attribute projection. anything "inside" is
# kept as it must have intersected the highest
# priority cutting shape already. the remainder is
# returned.
def _intersect(self, shape, props, fid, cutting_shape,
cutting_attr, original_geom_dim):
inside, outside = \
self.intersect_func(shape, cutting_shape)
# intersections are tricky, and it seems that the geos
# library (perhaps only certain versions of it) don't
# handle intersection of a polygon with its boundary
# very well. for example:
#
# >>> import shapely.geometry as g
# >>> p = g.Point(0,0).buffer(1.0, resolution=2)
# >>> b = p.boundary
# >>> b.intersection(p).wkt
# 'MULTILINESTRING ((1 0, 0.7071067811865481 -0.7071067811865469), (0.7071067811865481 -0.7071067811865469, 1.615544574432587e-15 -1), (1.615544574432587e-15 -1, -0.7071067811865459 -0.7071067811865491), (-0.7071067811865459 -0.7071067811865491, -1 -3.231089148865173e-15), (-1 -3.231089148865173e-15, -0.7071067811865505 0.7071067811865446), (-0.7071067811865505 0.7071067811865446, -4.624589118372729e-15 1), (-4.624589118372729e-15 1, 0.7071067811865436 0.7071067811865515), (0.7071067811865436 0.7071067811865515, 1 0))' # noqa
#
# the result multilinestring could be joined back into
# the original object. but because it has separate parts,
# each requires duplicating the start and end point, and
# each separate segment gets a different polygon buffer
# in Tangram - basically, it's a problem all round.
#
# two solutions to this: given that we're cutting, then
# the inside and outside should union back to the
# original shape - if either is empty then the whole
# object ought to be in the other.
#
# the second solution, for when there is actually some
# part cut, is that we can attempt to merge lines back
# together.
if outside.is_empty and not inside.is_empty:
inside = shape
elif inside.is_empty and not outside.is_empty:
outside = shape
elif original_geom_dim == _LINE_DIMENSION:
inside = _linemerge(inside)
outside = _linemerge(outside)
if cutting_attr is not None:
inside_props = props.copy()
inside_props[self.target_attribute] = cutting_attr
else:
inside_props = props
self._add(inside, inside_props, fid,
original_geom_dim)
return outside
def _intersect_cut(shape, cutting_shape):
"""
intersect by cutting, so that the cutting shape defines
a part of the shape which is inside and a part which is
outside as two separate shapes.
"""
inside = shape.intersection(cutting_shape)
outside = shape.difference(cutting_shape)
return inside, outside
# intersect by looking at the overlap size. we can define
# a cut-off fraction and if that fraction or more of the
# area of the shape is within the cutting shape, it's
# inside, else outside.
#
# this is done using a closure so that we can curry away
# the fraction parameter.
def _intersect_overlap(min_fraction):
# the inner function is what will actually get
# called, but closing over min_fraction means it
# will have access to that.
def _f(shape, cutting_shape):
overlap = shape.intersection(cutting_shape).area
area = shape.area
# need an empty shape of the same type as the
# original shape, which should be possible, as
# it seems shapely geometries all have a default
# constructor to empty.
empty = type(shape)()
if ((area > 0) and (overlap / area) >= min_fraction):
return shape, empty
else:
return empty, shape
return _f
# intersect by looking at the overlap length. if more than a minimum fraction
# of the shape's length is within the cutting area, then we will consider it
# totally "cut".
def _intersect_linear_overlap(min_fraction):
# the inner function is what will actually get
# called, but closing over min_fraction means it
# will have access to that.
def _f(shape, cutting_shape):
overlap = shape.intersection(cutting_shape).length
total = shape.length
empty = type(shape)()
if ((total > 0) and (overlap / total) >= min_fraction):
return shape, empty
else:
return empty, shape
return _f
# find a layer by iterating through all the layers. this
# would be easier if they layers were in a dict(), but
# that's a pretty invasive change.
#
# returns None if the layer can't be found.
def _find_layer(feature_layers, name):
for feature_layer in feature_layers:
layer_datum = feature_layer['layer_datum']
layer_name = layer_datum['name']
if layer_name == name:
return feature_layer
return None
# shared implementation of the intercut algorithm, used both when cutting
# shapes and using overlap to determine inside / outsideness.
#
# the filter_fn are used to filter which features from the base layer are cut
# with which features from the cutting layer. cutting layer features which do
# not match the filter are ignored, base layer features are left in the layer
# unchanged.
def _intercut_impl(intersect_func, feature_layers, base_layer, cutting_layer,
attribute, target_attribute, cutting_attrs, keep_geom_type,
cutting_filter_fn=None, base_filter_fn=None):
# the target attribute can default to the attribute if
# they are distinct. but often they aren't, and that's
# why target_attribute is a separate parameter.
if target_attribute is None:
target_attribute = attribute
# search through all the layers and extract the ones
# which have the names of the base and cutting layer.
# it would seem to be better to use a dict() for
# layers, and this will give odd results if names are
# allowed to be duplicated.
base = _find_layer(feature_layers, base_layer)
cutting = _find_layer(feature_layers, cutting_layer)
# base or cutting layer not available. this could happen
# because of a config problem, in which case you'd want
# it to be reported. but also can happen when the client
# selects a subset of layers which don't include either
# the base or the cutting layer. then it's not an error.
# the interesting case is when they select the base but
# not the cutting layer...
if base is None or cutting is None:
return None
base_features = base['features']
cutting_features = cutting['features']
# filter out any features that we don't want to cut with
if cutting_filter_fn is not None:
cutting_features = filter(cutting_filter_fn, cutting_features)
# short-cut return if there are no cutting features => there's nothing
# to do.
if not cutting_features:
return base
# make a cutter object to help out
cutter = _Cutter(cutting_features, cutting_attrs,
attribute, target_attribute,
keep_geom_type, intersect_func)
skipped_features = []
for base_feature in base_features:
if base_filter_fn is None or base_filter_fn(base_feature):
# we use shape to track the current remainder of the
# shape after subtracting bits which are inside cuts.
shape, props, fid = base_feature
cutter.cut(shape, props, fid)
else:
skipped_features.append(base_feature)
base['features'] = cutter.new_features + skipped_features
return base
class Where(object):
"""
A "where" clause for filtering features based on their properties.
This is commonly used in post-processing steps to configure which features
in the layer we want to operate on, allowing us to write simple Python
expressions in the YAML.
"""
def __init__(self, where):
self.fn = compile(where, 'queries.yaml', 'eval')
def __call__(self, feature):
shape, props, fid = feature
local = defaultdict(lambda: None)
local.update(props)
return eval(self.fn, {}, local)
# intercut takes features from a base layer and cuts each
# of them against a cutting layer, splitting any base
# feature which intersects into separate inside and outside
# parts.
#
# the parts of each base feature which are outside any
# cutting feature are left unchanged. the parts which are
# inside have their property with the key given by the
# 'target_attribute' parameter set to the same value as the
# property from the cutting feature with the key given by
# the 'attribute' parameter.
#
# the intended use of this is to project attributes from one
# layer to another so that they can be styled appropriately.
#
# - feature_layers: list of layers containing both the base
# and cutting layer.
# - base_layer: str name of the base layer.
# - cutting_layer: str name of the cutting layer.
# - attribute: optional str name of the property / attribute
# to take from the cutting layer.
# - target_attribute: optional str name of the property /
# attribute to assign on the base layer. defaults to the
# same as the 'attribute' parameter.
# - cutting_attrs: list of str, the priority of the values
# to be used in the cutting operation. this ensures that
# items | |
self.x_tree[self.act_node['ix']] # get X data of the node
self.y_node = self.y_tree[self.act_node['ix']] # get Y data of the node
self.p_val = self.act_node['state']['p']
self.n_reduce_sigma = self.act_node['state']['Cr']
self.n_fail = self.act_node['state']['Cf']
self.gamma = self.act_node['state']['gamma']
self.gSRS_pct = np.floor(10*self.p_val)/10. # pertentage of global SRS (= percentage of Type I candidates)
self.sigma = self._init_sigma*0.5**self.n_reduce_sigma
########### Build RBF surrogate model ##############
if verbose:
sys.stdout.write('Building RBF regression model '+'.'*self._verbose_dot_len)
t1 = default_timer()
self.rbf_mod, _, _, _ = RBF_reg(self.x_node, self.y_node, self._lambda_range,
normalize_data=self._normalize_data, wgt_expon=self.gamma,
n_fold=self._n_fold, kernel=self._rbf_kernel,
poly_deg=self._rbf_poly_deg, pool=self._pool_rbf)
t2 = default_timer()
self.t_build = t2-t1
if verbose:
sys.stdout.write(' Done (time took: %.2e sec).\n' % self.t_build)
########### Propose new points using SRS method ##############
if verbose:
sys.stdout.write('Proposing new points '+'.'*self._verbose_dot_len)
t1 = default_timer()
new_pt = self.SRS()
t2 = default_timer()
self.t_srs = t2-t1
if verbose:
sys.stdout.write(' Done (time took: %.2e sec).\n' % self.t_srs)
tt2 = default_timer()
self.t_prop = tt2-tt1
return new_pt
def SRS(self):
"""
Propose new points using SRS method.
Returns:
new_pt (2d array): Proposed points.
"""
# generate candidate points
if self.gSRS_pct == 1:
# generate candidate points uniformly (global SRS)
cand_pt = np.zeros((self._n_cand, self._dim))
for d, bd in enumerate(self.act_node['domain']):
cand_pt[:, d] = np.random.uniform(low=bd[0], high=bd[1], size=self._n_cand)
else:
n_cand_gSRS = int(np.round(self._n_cand*self.gSRS_pct)) # number of candidate points for global SRS
n_cand_lSRS = self._n_cand-n_cand_gSRS # number of candidate points for local SRS
assert(n_cand_lSRS > 0) # sanity check
# generate candidate points uniformly (global SRS)
cand_pt_gSRS = np.zeros((n_cand_gSRS, self._dim))
if n_cand_gSRS > 0:
for d, bd in enumerate(self.act_node['domain']):
cand_pt_gSRS[:, d] = np.random.uniform(low=bd[0], high=bd[1], size=n_cand_gSRS)
# find x_star
Y_fit = self.rbf_mod(self.x_node)
min_ix = np.argmin(Y_fit)
x_star = self.x_node[min_ix]
assert(np.all([bd[0] <= x_star[j] <= bd[1] for j,bd in enumerate(self.act_node['domain'])])) # sanity check
# find step size (i.e. std) for each coordinate of `x_star`
step_size_arr = np.array([self.sigma*(bd[1]-bd[0]) for bd in self.act_node['domain']])
assert(np.min(step_size_arr) > 0) # sanity check
# generate candidate points (Gaussian about x_star, local SRS)
cand_pt_lSRS = np.random.multivariate_normal(x_star, np.diag(step_size_arr**2), n_cand_lSRS)
# combine two types of candidate points
comb_cand_pt = np.vstack((cand_pt_gSRS, cand_pt_lSRS))
# put candidate points back to the domain, if there's any outside
uniq_cand_pt, raw_cand_pt = put_back_box(comb_cand_pt, self.act_node['domain'])
# get candidate points (``len(uniq_cand_pt) < n_worker`` is pathological case, almost never encountered in practice)
cand_pt = uniq_cand_pt if len(uniq_cand_pt) >= self._n_worker else raw_cand_pt
# select new points from candidate points
n_cand = len(cand_pt)
assert(n_cand >= self._n_worker)
resp_cand = self.rbf_mod(cand_pt)
resp_score = scale_zero_one(resp_cand) # response score
# initializations
new_pt = np.zeros((self._n_worker, self._dim))
refer_pt = self.x_node.copy() # reference points based on which we compute distance scores
# select points sequentially
for j in range(self._n_worker):
wt = self.srs_wgt_pat[j]
if len(refer_pt) > 0:
if j == 0:
# distance matrix for `refer_pt` and `cand_pt`
dist_mat = cdist(cand_pt, refer_pt)
dist_cand = np.amin(dist_mat, axis=1)
else:
# distance to the previously proposed point
dist_prop_pt = cdist(cand_pt, new_pt[j-1].reshape((1, -1))).flatten()
dist_cand = np.minimum(dist_cand, dist_prop_pt)
dist_score = scale_one_zero(dist_cand) # distance score
else:
# pathological case
dist_score = np.zeros(n_cand) # distance score
cand_score = resp_score*wt+(1-wt)*dist_score # candidate score
assert (np.amax(cand_score)<=1 and np.amin(cand_score)>=0) # sanity check
# select the best one based on the score
min_ix = np.argmin(cand_score)
new_pt[j] = cand_pt[min_ix]
# update variables
refer_pt = np.vstack((refer_pt, new_pt[j].reshape((1, -1))))
dist_cand = np.delete(dist_cand, min_ix)
resp_score = np.delete(resp_score, min_ix)
cand_pt = np.delete(cand_pt, min_ix, axis=0)
n_cand -= 1
return new_pt
def eval_pt(self, x, verbose=True):
"""
Evaluate proposed points.
Args:
x (2d array): Points to be evaluated. Each row is one point.
verbose (bool, optional): Whether to verbose about the evaluation.
Returns:
y (1d array): Evaluations of points in `x`.
"""
if verbose:
sys.stdout.write('Evaluating proposed points '+'.'*self._verbose_dot_len)
t1 = default_timer()
assert(callable(self._prob.f)), 'Error! Unable to perform evaluations. Please first define the (noisy) optimization function ``f`` in the ``Problem`` object.'
y = eval_func(self._prob.f, x, n_proc=self._n_worker, seeds=self.eval_seeds.tolist(),
seed_func=self._seed_func)
t2 = default_timer()
self.t_eval = t2-t1
if verbose:
sys.stdout.write(' Done (time took: %.2e sec).\n' % self.t_eval)
return y
def update(self, new_x, new_y, verbose=True):
"""
Update the state of the optimizer.
Args:
new_x (2d array): Proposed new points. Each row is one point.
new_y (1d array): (Noisy) values of the points in `new_x`.
verbose (bool, optional): Whether to verbose about updating the state of the optimizer.
"""
if verbose:
sys.stdout.write('Updating optimizer state '+'.'*self._verbose_dot_len)
specific_msg = '' # specific message indicating the action
t1 = default_timer()
self.i_iter += 1
self.eval_seeds = self._seed+1+np.arange(self.i_iter*self._n_worker, (self.i_iter+1)*self._n_worker, dtype=int)
self.x_tree = np.vstack((self.x_tree, new_x))
self.y_tree = np.append(self.y_tree, new_y)
self.x_all = np.vstack((self.x_all, new_x))
self.y_all = np.append(self.y_all, new_y)
self.seed_all = np.append(self.seed_all, self.eval_seeds)
min_ix = np.argmin(self.y_all)
self.best_x = self.x_all[min_ix]
self.best_y = self.y_all[min_ix]
self.t_build_arr = np.append(self.t_build_arr, self.t_build)
self.t_srs_arr = np.append(self.t_srs_arr, self.t_srs)
self.t_prop_arr = np.append(self.t_prop_arr, self.t_prop)
try:
self.t_eval_arr = np.append(self.t_eval_arr, self.t_eval)
except:
# i.e., self.t_eval is not defined. This could happen when one uses customized evaluation function.
self.t_eval_arr = np.append(self.t_eval_arr, np.nan)
self.gSRS_pct_arr = np.append(self.gSRS_pct_arr, self.gSRS_pct)
self.zoom_lv_arr = np.append(self.zoom_lv_arr, self.zoom_lv)
if self.i_iter_doe < self._n_iter_doe: # i.e., current iteration is in DOE phase
self.i_iter_doe += 1
else:
# update weight pattern in SRS method
if self._n_worker == 1:
self.srs_wgt_pat = np.array([self._wgt_pat_bd[0]]) if self.srs_wgt_pat[0] == self._wgt_pat_bd[1] \
else np.array([self._wgt_pat_bd[1]]) # alternating weights
# update tree node
npt = len(self.x_tree)
self.act_node['ix'] = np.append(self.act_node['ix'], np.arange(npt-self._n_worker, npt, dtype=int))
if self._n_worker > 1 or (self._n_worker == 1 and self.srs_wgt_pat[0] == self._wgt_pat_bd[0]):
if self.p_val >= 0.1:
# compute p_val
if self._use_eff_npt:
eff_n = eff_npt(self.x_tree[self.act_node['ix']], self.act_node['domain'])
else:
eff_n = len(self.x_tree[self.act_node['ix']])
self.p_val = self.p_val*eff_n**(-self._alpha/float(self._dim))
if self.gSRS_pct == 0: # i.e. pure local SRS
best_Y_prev = np.min(self.y_node)
best_Y_new = np.min(new_y) # minimum of Y values of newly proposed points
if best_Y_prev <= best_Y_new: # failure
self.n_fail += 1 # count failure
else:
self.n_fail = 0
if self.n_fail == self._max_C_fail:
self.n_fail = 0
self.gamma -= self._delta_gamma
self.n_reduce_sigma += 1 # update counter
self.act_node['state']['p'] = self.p_val
self.act_node['state']['Cr'] = self.n_reduce_sigma
self.act_node['state']['Cf'] = self.n_fail
self.act_node['state']['gamma'] = self.gamma
if self.n_reduce_sigma > self._max_n_reduce_sigma:
# then we either restart or zoom-in (i.e., critical state is reached)
Y_fit = self.rbf_mod(self.x_tree[self.act_node['ix']])
min_ix = np.argmin(Y_fit)
x_star = self.x_tree[self.act_node['ix']][min_ix]
# suppose we're going to zoom in
child_node_ix = self.get_child_node(x_star)
if child_node_ix is None:
# then we create a new child (if zoom in)
domain_lb, domain_ub = zip(*self.act_node['domain'])
blen = np.array(domain_ub)-np.array(domain_lb) # bound length for each dimension
assert(np.min(blen)>0)
domain_lb = np.maximum(x_star-self._rho/2.*blen, domain_lb)
domain_ub = np.minimum(x_star+self._rho/2.*blen, domain_ub)
domain = list(zip(domain_lb, domain_ub)) # the list function is used to ensure compatibility of python3
child_node = {'ix': np.nonzero(boxify(self.x_tree, domain)[0])[0],
'domain': domain,
'parent_ix': self.act_node_ix,
'beta': self._init_beta,
'state': self.init_node_state()}
else:
# then we activate an existing child node (if zoom in)
child_node = self.tree[self.zoom_lv+1][child_node_ix]
child_node['ix'] = np.nonzero(boxify(self.x_tree, child_node['domain'])[0])[0]
child_npt = len(child_node['ix'])
domain_lb, domain_ub = zip(*child_node['domain'])
blen = np.array(domain_ub)-np.array(domain_lb) # bound length for each dimension
assert(np.min(blen)>0)
if np.all(blen*child_npt**(-1./self._dim) < (self._prob.domain_ub-self._prob.domain_lb)*self._resol): # resolution condition
# then we restart
if verbose:
specific_msg += 'Restart for the next iteration!\n'
self.i_iter_doe = 0
self.doe_samp = self.doe()
self.i_cycle += 1
self.zoom_lv = 0
self.act_node_ix = 0
self.x_tree = np.zeros((0, self._dim))
self.y_tree = np.zeros(0)
self.tree = self.init_tree()
else:
# then we zoom in
self.act_node['state'] = self.init_node_state() # reset the state of the current node
self.zoom_lv += 1
if child_node_ix is None:
# then we create a new child
if self.zoom_lv not in self.tree.keys():
self.act_node_ix = 0
self.tree[self.zoom_lv] = [child_node]
else:
self.act_node_ix = len(self.tree[self.zoom_lv])
self.tree[self.zoom_lv].append(child_node)
if verbose:
specific_msg += 'Zoom in (created a new child node)!\n'
else:
# then activate existing child node
self.act_node_ix = child_node_ix
# reduce zoom-out probability
child_node['beta'] = max(self._min_beta, child_node['beta']/2.)
if verbose:
specific_msg += 'Zoom in (activated an existing child node)!\n'
if self._n_worker > 1 or (self._n_worker == 1 and self.srs_wgt_pat[0] == self._wgt_pat_bd[0]):
if np.random.uniform() < self.tree[self.zoom_lv][self.act_node_ix]['beta'] and self.zoom_lv > 0 and self.i_iter_doe >= self._n_iter_doe:
# then we zoom out
child_node = self.tree[self.zoom_lv][self.act_node_ix]
self.act_node_ix = child_node['parent_ix']
self.zoom_lv -= 1
assert(self.act_node_ix is not None)
# | |
self.translation.write(f)
self.rotation.write(f)
self.scale.write(f)
vec3D.write(f, self.pivot)
return self
def build_relations(self, bones):
if self.parent_bone >= 0:
parent = bones[self.parent_bone]
self.parent = parent
parent.children.append(self)
def load_bone_name(self, bone_type_dict):
self.name = M2KeyBones.get_bone_name(self.key_bone_id, self.index)
b_type = bone_type_dict.get(self.index)
if b_type and self.key_bone_id < 0:
prefix, i, item = b_type
if prefix in ('AT', 'ET'):
self.name = "{}_{}_{}".format(prefix, item, i)
elif prefix in ('LT', 'RB', 'PT'):
self.name = "{}_{}".format(prefix, i)
def get_depth(self):
if not self.children:
return 0
return sum(map(lambda x: x.get_depth(), self.children)) + len(self.children)
@staticmethod
def size():
return 86 if M2VersionsManager().m2_version >= M2Versions.WOTLK else 110
#############################################################
###### Geometry and rendering ######
#############################################################
###### Vertices ######
class M2Vertex:
__slots__ = ('pos', 'bone_weights', 'bone_indices',
'normal', 'tex_coords', 'tex_coords2')
def __init__(self):
self.pos = (0.0, 0.0, 0.0)
self.bone_weights = (0, 0, 0, 0)
self.bone_indices = (0, 0, 0, 0)
self.normal = (0.0, 0.0, 0.0)
self.tex_coords = (0.0, 0.0)
self.tex_coords2 = (0.0, 0.0)
def read(self, f):
self.pos = vec3D.read(f)
self.bone_weights = uint8.read(f, 4)
self.bone_indices = uint8.read(f, 4)
self.normal = vec3D.read(f)
self.tex_coords = vec2D.read(f)
self.tex_coords2 = vec2D.read(f)
return self
def write(self, f):
vec3D.write(f, self.pos)
uint8.write(f, self.bone_weights, 4)
uint8.write(f, self.bone_indices, 4)
vec3D.write(f, self.normal)
vec2D.write(f, self.tex_coords)
vec2D.write(f, self.tex_coords2)
return self
###### Render flags ######
class M2Material:
def __init__(self):
self.flags = 0
self.blending_mode = 0 # apparently a bitfield
def read(self, f):
self.flags = uint16.read(f)
self.blending_mode = uint16.read(f)
return self
def write(self, f):
uint16.write(f, self.flags)
uint16.write(f, self.blending_mode)
return self
###### Colors and transparency ######
class M2Color:
def __init__(self):
self.color = M2Track(vec3D, M2Color)
self.alpha = M2Track(fixed16, M2Color)
def read(self, f):
self.color.read(f)
self.alpha.read(f)
return self
def write(self, f):
self.color.write(f)
self.alpha.write(f)
return self
@staticmethod
def size():
return 40 if M2VersionsManager().m2_version >= M2Versions.WOTLK else 56
class M2Texture:
def __init__(self):
self.type = 0
self.flags = 0
self.filename = M2String()
# BFA+ (internal use only)
self.fdid = 0
def read(self, f):
self.type = uint32.read(f)
self.flags = uint32.read(f)
self.filename.read(f)
return self
def write(self, f):
uint32.write(f, self.type)
uint32.write(f, self.flags)
self.filename.write(f)
return self
@staticmethod
def size():
return 16
#############################################################
###### Effects ######
#############################################################
class M2TextureTransform:
def __init__(self):
self.translation = M2Track(vec3D, M2TextureTransform)
self.rotation = M2Track(quat, M2TextureTransform) # rotation center is texture center (0.5, 0.5, 0.5)
self.scaling = M2Track(vec3D, M2TextureTransform)
def read(self, f):
self.translation.read(f)
self.rotation.read(f)
self.scaling.read(f)
return self
def write(self, f):
self.translation.write(f)
self.rotation.write(f)
self.scaling.write(f)
return self
@staticmethod
def size():
return 60 if M2VersionsManager().m2_version >= M2Versions.WOTLK else 84
class M2Ribbon:
def __init__(self):
self.m2_version = M2VersionsManager().m2_version
self.ribbon_id = -1 # Always (as I have seen): -1.
self.bone_index = 0 # A bone to attach to.
self.position = (0.0, 0.0, 0.0) # And a position, relative to that bone.
self.texture_indices = M2Array(uint16) # into textures
self.material_indices = M2Array(uint16) # into materials
self.color_track = M2Track(vec3D, M2Ribbon)
self.alpha_track = M2Track(fixed16, M2Ribbon) # And an alpha value in a short, where: 0 - transparent, 0x7FFF - opaque.
self.height_above_track = M2Track(float32, M2Ribbon)
self.height_below_track = M2Track(float32, M2Ribbon) # do not set to same!
self.edges_per_second = 0.0 # this defines how smooth the ribbon is. A low value may produce a lot of edges.
self.edge_lifetime = 0.0 # the length aka Lifespan. in seconds
self.gravity = 0.0 # use arcsin(val) to get the emission angle in degree
self.texture_rows = 0 # tiles in texture
self.texture_cols = 0
self.tex_slot_track = M2Track(uint16, M2Ribbon)
self.visibility_track = M2Track(uint8, M2Ribbon)
if self.m2_version >= M2Versions.WOTLK: # TODO: verify version
self.priority_plane = 0
self.padding = 0
def read(self, f):
self.ribbon_id = int32.read(f)
self.bone_index = uint32.read(f)
self.position = vec3D.read(f)
self.texture_indices.read(f)
self.material_indices.read(f)
self.color_track.read(f)
self.alpha_track.read(f)
self.height_above_track.read(f)
self.height_below_track.read(f)
self.edges_per_second = float32.read(f)
self.edge_lifetime = float32.read(f)
self.gravity = float32.read(f)
self.texture_rows = uint16.read(f)
self.texture_cols = uint16.read(f)
self.tex_slot_track.read(f)
self.visibility_track.read(f)
if self.m2_version >= M2Versions.WOTLK:
self.priority_plane = int16.read(f)
self.padding = uint16.read(f)
return self
def write(self, f):
int32.write(f, self.ribbon_id)
uint32.write(f, self.bone_index)
vec3D.write(f, self.position)
self.texture_indices.write(f)
self.material_indices.write(f)
self.color_track.write(f)
self.alpha_track.write(f)
self.height_above_track.write(f)
self.height_below_track.write(f)
float32.write(f, self.edges_per_second)
float32.write(f, self.edge_lifetime)
float32.write(f, self.gravity)
uint16.write(f, self.texture_rows)
uint16.write(f, self.texture_cols)
self.tex_slot_track.write(f)
self.visibility_track.write(f)
if self.m2_version >= M2Versions.WOTLK:
int16.write(f, self.priority_plane)
uint16.write(f, self.padding)
return self
@staticmethod
def size():
return 176 if M2VersionsManager().m2_version >= M2Versions.WOTLK else 220
class M2Particle:
def __init__(self):
self.m2_version = M2VersionsManager().m2_version
self.particle_id = 0 # Always (as I have seen): -1.
self.flags = 0 # See Below
self.position = (0.0, 0.0, 0.0) # The position. Relative to the following bone.
self.bone = 0 # The bone its attached to.
self.texture = 0 # And the textures that are used. For multi-textured particles actually three ids
self.geometry_model_filename = M2Array(int8) # if given, this emitter spawns models
self.recursion_model_filename = M2Array(int8) # if given, this emitter is an alias for the (maximum 4) emitters of the given model
if self.m2_version >= M2Versions.TBC:
self.blending_type = 0 # A blending type for the particle. See Below
self.emitter_type = 0 # 1 - Plane (rectangle), 2 - Sphere, 3 - Spline, 4 - Bone
self.particle_color_index = 0 # This one is used for ParticleColor.dbc. See below.
else:
self.blending_type = 0 # A blending type for the particle. See Below
self.emitter_type = 0 # 1 - Plane (rectangle), 2 - Sphere, 3 - Spline, 4 - Bone
if self.m2_version >= M2Versions.CATA:
self.multi_tex_param_x = fixed_point(uint8, 2, 5)
self.multi_tex_param_y = fixed_point(uint8, 2, 5)
else:
self.particle_type = 0 # Found below.
self.head_or_tail = 0 # 0 - Head, 1 - Tail, 2 - Both
self.texture_tile_rotation = 0 # Rotation for the texture tile. (Values: -1,0,1) -- priorityPlane
self.texture_dimensions_rows = 0 # for tiled textures
self.texture_dimension_columns = 0
self.emission_speed = M2Track(float32, M2Particle) # Base velocity at which particles are emitted.
self.speed_variation = M2Track(float32, M2Particle) # Random variation in particle emission speed. (range: 0 to 1)
self.vertical_range = M2Track(float32, M2Particle) # Drifting away vertically. (range: 0 to pi) For plane generators, this is the maximum polar angle of the initial velocity;
self.horizontal_range = M2Track(float32, M2Particle) # They can do it horizontally too! (range: 0 to 2*pi) For plane generators, this is the maximum azimuth angle of the initial velocity;
# 0 makes the velocity have no sideways (y-axis) component. For sphere generators, this is the maximum azimuth angle of the initial position.
self.gravity = M2Track(float32, M2Particle) # Not necessarily a float; see below.
self.lifespan = M2Track(float32, M2Particle) # 0 makes the velocity have no sideways (y-axis) component. For sphere generators, this is the maximum azimuth angle of the initial position.
if self.m2_version >= M2Versions.WOTLK:
self.life_span_vary = 0.0 # An individual particle's lifespan is added to by lifespanVary * random(-1, 1)
self.emission_rate_vary = 0.0 # This adds to the base emissionRate value the same way as lifespanVary. The random value is different every update.
self.emission_rate = M2Track(float32, M2Particle)
self.emission_area_length = M2Track(float32, M2Particle) # For plane generators, this is the width of the plane in the x-axis. For sphere generators, this is the minimum radius.
self.emission_area_width = M2Track(float32, M2Particle) # For plane generators, this is the width of the plane in the y-axis. For sphere generators, this is the maximum radius.
self.z_source = M2Track(float32, M2Particle) # When greater than 0, the initial velocity of the particle is (particle.position - C3Vector(0, 0, zSource)).Normalize()
if self.m2_version >= M2Versions.WOTLK:
self.color_track = FBlock(vec3D) # Most likely they all have 3 timestamps for {start, middle, end}.
self.alpha_track = FBlock(fixed16)
self.scale_track = FBlock(vec2D)
self.scale_vary = (0.0, 0.0) # A percentage amount to randomly vary the scale of each particle
self.head_cell_track = FBlock(uint16) # Some kind of intensity values seen: 0,16,17,32 (if set to different it will have high intensity)
self.tail_cell_track = FBlock(uint16)
else:
self.mid_point = 0.0 # Middle point in lifespan (0 to 1).
self.color_values = Array((Array << uint8, 4), 3)
self.scale_values = Array(float32, 4)
self.head_cell_begin = Array(uint16, 2)
self.head_cell_end = Array(uint16, 2)
self.tiles = Array(int16, 4) # Indices into the tiles on the texture? Or tailCell maybe?
self.tail_length = 0.0 # TailCellTime?
self.twinkle_speed = 0.0 # has something to do with the spread
self.twinkle_percent = 0.0 # has something to do with the spread
self.twinkle_scale = CRange()
self.burst_multiplier = 0.0 # ivelScale
self.drag = 0.0 # For a non-zero values, instead of travelling linearly the particles seem to slow down sooner. Speed is multiplied by exp( -drag * t ).
if self.m2_version >= M2Versions.WOTLK:
self.basespin = 0.0 # Initial rotation of | |
"""
Copyright 2019 Google LLC
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Parse the regression testlist in YAML format
"""
import os
import random
import sys
import re
import subprocess
import time
import yaml
import logging
from datetime import date
RET_SUCCESS = 0
RET_FAIL = 1
RET_FATAL = -1
def setup_logging(verbose):
"""Setup the root logger.
Args:
verbose: Verbose logging
"""
if verbose:
logging.basicConfig(format="%(asctime)s %(filename)s:%(lineno)-5s %(levelname)-8s %(message)s",
datefmt='%a, %d %b %Y %H:%M:%S',
level=logging.DEBUG)
else:
logging.basicConfig(format="%(asctime)s %(levelname)-8s %(message)s",
datefmt='%a, %d %b %Y %H:%M:%S',
level=logging.INFO)
def read_yaml(yaml_file):
""" Read YAML file to a dictionary
Args:
yaml_file : YAML file
Returns:
yaml_data : data read from YAML in dictionary format
"""
with open(yaml_file, "r") as f:
try:
yaml_data = yaml.safe_load(f)
except yaml.YAMLError as exc:
logging.error(exc)
sys.exit(RET_FAIL)
return yaml_data
def get_env_var(var, debug_cmd = None):
"""Get the value of environment variable
Args:
var : Name of the environment variable
Returns:
val : Value of the environment variable
"""
try:
val = os.environ[var]
except KeyError:
if debug_cmd:
return var
else:
logging.warning("Please set the environment variable %0s" % var)
sys.exit(RET_FAIL)
return val
def get_seed(seed):
"""Get the seed to run the generator
Args:
seed : input seed
Returns:
seed to run instruction generator
"""
if seed >= 0:
return seed
return random.getrandbits(32)
def run_cmd(cmd, timeout_s = 999, exit_on_error = 1, check_return_code = True, debug_cmd = None):
"""Run a command and return output
Args:
cmd : shell command to run
Returns:
command output
"""
logging.debug(cmd)
if debug_cmd:
debug_cmd.write(cmd)
debug_cmd.write("\n\n")
return
try:
ps = subprocess.Popen("exec " + cmd,
shell=True,
executable='/bin/bash',
universal_newlines=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
except subprocess.CalledProcessError:
logging.error(ps.communicate()[0])
sys.exit(RET_FAIL)
except KeyboardInterrupt:
logging.info("\nExited Ctrl-C from user request.")
sys.exit(130)
try:
output = ps.communicate(timeout = timeout_s)[0]
except subprocess.TimeoutExpired:
logging.error("Timeout[%ds]: %s" % (timeout_s, cmd))
output = ""
ps.kill()
rc = ps.returncode
if rc and check_return_code and rc > 0:
logging.info(output)
logging.error("ERROR return code: %d/%d, cmd:%s" % (check_return_code, rc, cmd))
if exit_on_error:
sys.exit(RET_FAIL)
logging.debug(output)
return output
def run_parallel_cmd(cmd_list, timeout_s = 999, exit_on_error = 0,
check_return_code = True, debug_cmd = None):
"""Run a list of commands in parallel
Args:
cmd_list: command list
Returns:
command output
"""
if debug_cmd:
for cmd in cmd_list:
debug_cmd.write(cmd)
debug_cmd.write("\n\n")
return
children = []
for cmd in cmd_list:
ps = subprocess.Popen("exec " + cmd,
shell=True,
executable='/bin/bash',
universal_newlines=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
children.append(ps)
for i in range(len(children)):
logging.info("Command progress: %d/%d" % (i, len(children)))
logging.debug("Waiting for command: %s" % cmd_list[i])
try:
output = children[i].communicate(timeout = timeout_s)[0]
except KeyboardInterrupt:
logging.info("\nExited Ctrl-C from user request.")
sys.exit(130)
except subprocess.TimeoutExpired:
logging.error("Timeout[%ds]: %s" % (timeout_s, cmd))
children[i].kill()
rc = children[i].returncode
if rc and check_return_code and rc > 0:
logging.info(output)
logging.error("ERROR return code: %d, cmd:%s" % (rc, cmd))
if exit_on_error:
sys.exit(RET_FAIL)
# Restore stty setting otherwise the terminal may go crazy
os.system("stty sane")
logging.debug(output)
def run_cmd_output(cmd, debug_cmd = None):
"""Run a command and return output
Args:
cmd : Command line to execute
"""
logging.debug(" ".join(cmd))
if debug_cmd:
debug_cmd.write(" ".join(cmd))
debug_cmd.write("\n\n")
return
try:
output = subprocess.check_output(cmd)
except subprocess.CalledProcessError as exc:
logging.debug(exc.output)
raise exc
sys.exit(RET_FAIL)
if output:
logging.debug(output)
def process_regression_list(testlist, test, iterations, matched_list, riscv_dv_root):
""" Get the matched tests from the regression test list
Args:
testlist : Regression test list
test : Test to run, "all" means all tests in the list
iterations : Number of iterations for each test
riscv_dv_root : Root directory of RISCV-DV
Returns:
matched_list : A list of matched tests
"""
logging.info("Processing regression test list : %s, test: %s" % (testlist, test))
yaml_data = read_yaml(testlist)
mult_test = test.split(',')
for entry in yaml_data:
if 'import' in entry:
sub_list = re.sub('<riscv_dv_root>', riscv_dv_root, entry['import'])
process_regression_list(sub_list, test, iterations, matched_list, riscv_dv_root)
else:
if (entry['test'] in mult_test) or (test == "all"):
if (iterations > 0 and entry['iterations'] > 0):
entry['iterations'] = iterations
if entry['iterations'] > 0:
logging.info("Found matched tests: %s, iterations:%0d" %
(entry['test'], entry['iterations']))
matched_list.append(entry)
def create_output(output, noclean, prefix = "out_"):
""" Create output directory
Args:
output : Name of specified output directory
noclean: Do not clean the output of the previous runs
Returns:
Output directory
"""
# Create output directory
if output is None:
output = prefix + str(date.today())
if noclean is False:
os.system("rm -rf %s" % output)
logging.info("Creating output directory: %s" % output)
subprocess.run(["mkdir", "-p", output])
return output
def gpr_to_abi(gpr):
"""Convert a general purpose register to its corresponding abi name"""
switcher = {
"x0" : "zero",
"x1" : "ra",
"x2" : "sp",
"x3" : "gp",
"x4" : "tp",
"x5" : "t0",
"x6" : "t1",
"x7" : "t2",
"x8" : "s0",
"x9" : "s1",
"x10" : "a0",
"x11" : "a1",
"x12" : "a2",
"x13" : "a3",
"x14" : "a4",
"x15" : "a5",
"x16" : "a6",
"x17" : "a7",
"x18" : "s2",
"x19" : "s3",
"x20" : "s4",
"x21" : "s5",
"x22" : "s6",
"x23" : "s7",
"x24" : "s8",
"x25" : "s9",
"x26" : "s10",
"x27" : "s11",
"x28" : "t3",
"x29" : "t4",
"x30" : "t5",
"x31" : "t6",
"f0" : "ft0",
"f1" : "ft1",
"f2" : "ft2",
"f3" : "ft3",
"f4" : "ft4",
"f5" : "ft5",
"f6" : "ft6",
"f7" : "ft7",
"f8" : "fs0",
"f9" : "fs1",
"f10" : "fa0",
"f11" : "fa1",
"f12" : "fa2",
"f13" : "fa3",
"f14" : "fa4",
"f15" : "fa5",
"f16" : "fa6",
"f17" : "fa7",
"f18" : "fs2",
"f19" : "fs3",
"f20" : "fs4",
"f21" : "fs5",
"f22" : "fs6",
"f23" : "fs7",
"f24" : "fs8",
"f25" : "fs9",
"f26" : "fs10",
"f27" : "fs11",
"f28" : "ft8",
"f29" : "ft9",
"f30" : "ft10",
"f31" : "ft11",
}
return switcher.get(gpr, "na")
def sint_to_hex(val):
"""Signed integer to hex conversion"""
return str(hex((val + (1 << 32)) % (1 << 32)))
BASE_RE = re.compile(r"(?P<rd>[a-z0-9]+?),(?P<imm>[\-0-9]*?)\((?P<rs1>[a-z0-9]+?)\)")
def convert_pseudo_instr(instr_name, operands, binary):
"""Convert pseudo instruction to regular instruction"""
if instr_name == "nop":
instr_name = "addi"
operands = "zero,zero,0"
elif instr_name == "mv":
instr_name = "addi"
operands = operands + ",0"
elif instr_name == "not":
instr_name = "xori"
operands = operands + ",-1"
elif instr_name == "neg":
instr_name = "sub"
o = operands.split(",")
operands = o[0] + ",zero," + o[1]
elif instr_name == "negw":
instr_name = "subw"
o = operands.split(",")
operands = o[0] + ",zero," + o[1]
elif instr_name == "sext.w":
instr_name = "addiw"
operands = operands + ",0"
elif instr_name == "seqz":
instr_name = "sltiu"
operands = operands + ",1"
elif instr_name == "snez":
instr_name = "sltu"
o = operands.split(",")
operands = o[0] + ",zero," + o[1]
elif instr_name == "sltz":
instr_name = "slt"
operands = operands + ",zero"
elif instr_name == "sgtz":
instr_name = "slt"
o = operands.split(",")
operands = o[0] + ",zero," + o[1]
elif instr_name in ["beqz", "bnez", "bgez", "bltz"]:
instr_name = instr_name[0:3]
o = operands.split(",")
operands = o[0] + ",zero," + o[1]
elif instr_name == "blez":
instr_name = "bge";
operands = "zero," + operands
elif instr_name == "bgtz":
instr_name = "blt";
operands = "zero," + operands
elif instr_name == "bgt":
instr_name = "blt";
o = operands.split(",")
operands = o[1] + "," + o[0] + "," + o[2]
elif instr_name == "ble":
instr_name = "bge";
o = operands.split(",")
operands = o[1] + "," + o[0] + "," + o[2]
elif instr_name == "bgtu":
instr_name = "bltu";
o = operands.split(",")
operands = o[1] + "," + o[0] + "," + o[2]
elif instr_name == "bleu":
instr_name = "bgeu";
o = operands.split(",")
operands = o[1] + "," + o[0] + "," + o[2]
elif instr_name == "csrr":
instr_name = "csrrw"
operands = operands + ",zero"
elif instr_name in ["csrw", "csrs", "csrc"]:
instr_name = "csrr" + instr_name[3:]
operands = "zero," + operands
elif instr_name in ["csrwi", "csrsi", "csrci"]:
instr_name = "csrr" + instr_name[3:]
operands = "zero," + operands
elif instr_name == "jr":
instr_name = "jalr"
operands = "zero,%s,0" % operands
elif instr_name == "j":
instr_name = "jal"
operands = "zero,%s" % | |
import time
from datetime import datetime
import os
import logging
import platform
import csv
import statistics
from polyglotdb import CorpusContext
from polyglotdb.config import CorpusConfig
from polyglotdb.io import (inspect_buckeye, inspect_textgrid, inspect_timit,
inspect_labbcat, inspect_mfa, inspect_fave,
guess_textgrid_format)
graph_db = {'graph_host':'localhost', 'graph_port': 7474,
'user': 'neo4j', 'password': '<PASSWORD>'}
amountofcorpus = 'full'
#amountofcorpus = 'partial'
globalphonebenchmark = 'globalphone_vn'
#globalphonebenchmark = 'timitbenchmark'
#globalphonesyllabic = ['a', 'aa', 'aw', 'e', 'ee', 'ew', 'i', 'ii', 'o', 'oo', 'ow', 'u', 'uu']#cz
#globalphonesyllabic = ['ab', 'e', 'i', 'i2', 'o', 'oe', 'u', 'ue']#tu
#globalphonesyllabic = ['a', 'e', 'i', 'o', 'u']#sa
#globalphonesyllabic = ['i', 'y', 'u', 'e', 'EU', 'o', 'E', 'OE', 'AX', 'O', 'a', 'AE', 'A~', 'E~', 'o~', 'OE~']#fr
#globalphonesyllabic = ['a', 'ae', 'ale', 'e', 'etu', 'i', 'o', 'oc', 'oe', 'ole', 'ox', 'u', 'ue', 'abl', 'ael', 'al',
# 'alel', 'el', 'il', 'oel', 'ole', 'olel', 'uel', 'ul', 'uxl']#sw
#globalphonesyllabic = ['a', 'ae', 'atu', 'e', 'etu', 'i', 'o', 'oe', 'u', 'ue', 'aI', 'aU', 'eU', 'al', 'el', 'il',
# 'oel', 'ol', 'uel', 'ul']#ge
#globalphonesyllabic = ['a', 'y', 'e', 'i', 'o', 'u', 'ja', 'ju']#bg
#globalphonesyllabic = ['a', 'e', 'i', 'o', 'u', 'a_L', 'e_L', 'i_L', 'o_L', 'u_L', 'a_T1', 'e_T1', 'i_T1', 'o_T1', 'u_T1',
# 'a_T2', 'e_T2', 'i_T2', 'o_T2', 'u_T2', 'a_T3', 'e_T3', 'i_T3', 'o_T3', 'u_T3', 'aI', 'aU']#ha
#globalphonesyllabic = ['a', 'e', 'i', 'i2', 'o', 'u', 'jA', 'jE', 'jO', 'jU']#ru
#globalphonesyllabic = ['a', 'e', 'eo5', 'i', 'i2', 'o', 'oc5', 'u']#pl
#globalphonesyllabic = ['A', 'AX', 'A~', 'E', 'E~', 'I', 'IX', 'I~', 'O', 'O~', 'U', 'UX', 'U~', 'A+', 'A~+',
# 'E+', 'E~+', 'O+', 'O~+', 'U+', 'U~+', 'I+', 'I~+']#po
#globalphonesyllabic = ['a', 'e', 'i', 'o', 'u', 'y']#ua
#globalphonesyllabic = ['A', 'EO', 'O', 'U', 'I', 'EU', 'AE', 'E', 'OE', 'UE', 'iA', 'iEO', 'iO', 'iU', 'iE', 'oA', 'uEO', 'eul']#ko
globalphonesyllabic = ['a1', 'a2', 'a3', 'e1', 'e2', 'i', 'o1', 'o2', 'o3', 'u1', 'u2', 'ai', 'ao', 'au', 'au3',
'ay', 'ay3', 'eo', 'eu', 'ie2', 'iu', 'oa', 'oe', 'oi', 'oi2', 'oi3', 'ua', 'ua2', 'ui', 'ui2', 'uu2', 'uy', 'ieu',
'uoi2', 'uoi3', 'uou']#vn
#globalphonesyllabic = ['a1', 'a2', 'a3', 'a4', 'a5', 'ai1', 'ai2', 'ai3', 'ai4', 'ai5', 'ao1', 'ao2', 'ao3', 'ao4', 'ao5',
# 'e1', 'e2', 'e3', 'e4', 'e5', 'ei1', 'ei2', 'ei3', 'ei4', 'ei5', 'i1', 'i2', 'i3', 'i4', 'i5',
# 'ia1', 'ia2', 'ia3', 'ia4', 'ia5', 'ie1', 'ie2', 'ie3', 'ie4', 'ie5', 'ii1', 'ii2', 'ii3', 'ii4', 'ii5',
# 'io1', 'io2', 'io3', 'io4', 'io5', 'iu1', 'iu2', 'iu3', 'iu4', 'iu5', 'o1', 'o2', 'o3', 'o4', 'o5',
# 'ou1', 'ou2', 'ou3', 'ou4', 'ou5', 'u1', 'u2', 'u3', 'u4', 'u5', 'ua1', 'ua2', 'ua3', 'ua4', 'ua5',
# 'ue1', 'ue2', 'ue3', 'ue4', 'ue5', 'uo1', 'uo2', 'uo3', 'uo4', 'uo5',
# 'v1', 'v2', 'v3', 'v4', 'v5', 'va1', 'va2', 'va3', 'va4', 've1', 've2', 've3', 've4',
# 'iao1', 'iao2', 'iao3', 'iao4', 'iao5', 'iou1', 'iou2', 'iou3', 'iou4', 'uai1', 'uai2', 'uai3', 'uai4', 'uai5',
# 'uei1', 'uei2', 'uei3', 'uei4', 'uei5',]#ch
#globalphonesyllabic = ['AA0', 'AE0', 'AH0', 'AO0', 'AW0', 'AY0', 'EH0', 'ER0', 'EY0', 'IH0', 'IY0', 'OW0', 'OY0', 'UH0', 'UW0',
# 'AA1', 'AE1', 'AH1', 'AO1', 'AW1', 'AY1', 'EH1', 'ER1', 'EY1', 'IH1', 'IY1', 'OW1', 'OY1', 'UH1', 'UW1',
# 'AA2', 'AE2', 'AH2', 'AO2', 'AW2', 'AY2', 'EH2', 'ER2', 'EY2', 'IH2', 'IY2', 'OW2', 'OY2', 'UH2', 'UW2']#librispeech
#globalphonesyllabic = ['aa', 'ae', 'ah', 'ao', 'aw', 'ax', 'ax-h', 'axr', 'ay',
# 'eh', 'el', 'em', 'en', 'eng', 'er', 'ey', 'ih', 'ix', 'iy', 'ow',' oy', 'uh', 'uw', 'ux']#timit
globalphone = os.path.expanduser('/media/share/corpora/GP_aligned/VN')
#globalphone = os.path.expanduser('/media/share/datasets/sct_benchmarks/LibriSpeech')
#globalphone = os.path.expanduser('/media/share/datasets/sct_benchmarks/automated/timit')
lang = 'vn'
outpath = 'export_vn.csv'
lasttime = time.time()
times = []
def call_back(*args):
global lasttime
print(*args)
if len(args) > 1:
return
if isinstance(args[0], int):
logtime = time.time() - lasttime
print(logtime)
times.append(logtime)
lasttime = time.time()
def import_corpus_run_query(data, path):
with CorpusContext(data, **graph_db) as c:
c.reset()
beg = time.time()
if data == 'buckeyebenchmark':
parser = inspect_buckeye(path)
elif data == 'timitbenchmark':
parser = inspect_timit(path)
else:
parser = inspect_mfa(path)
parser.call_back = call_back
c.load(parser, path)
end = time.time()
avgtime = sum(times)/(len(times))
sd = statistics.stdev(times)
return [(end - beg), avgtime, sd]
def pause_encoding_run_query(data):
beg = time.time()
with CorpusContext(data, **graph_db) as c:
#pattern = '^[<{].*$'
#if 'timit' in data:
# pattern = '^<?(sil|SIL)>?$'
c.encode_pauses('^[<{].*$', call_back=call_back)
end = time.time()
if len(times) >1:
avgtime = sum(times)/len(times)
sd = statistics.stdev(times)
else:
avgtime = times[0]
sd = None
return [(end - beg), avgtime, sd]
def utterance_encoding_run_query(data):
beg = time.time()
with CorpusContext(data, **graph_db) as c:
c.encode_utterances(0.5, 0, call_back=call_back)
end = time.time()
avgtime = sum(times)/len(times)
#sd = statistics.stdev(times)
sd = None
return [(end - beg), avgtime, sd]
def syllabic_encoding_run_query(data, syllabic):
beg = time.time()
with CorpusContext(data, **graph_db) as c:
c.reset_class('syllabic')
c.encode_class(syllabic, 'syllabic')
end = time.time()
#avgtime = sum(times)/len(times)
return [(end - beg), None]
def syllable_encoding_run_query(data):
beg = time.time()
algorithm = 'maxonset'
with CorpusContext(data, **graph_db) as c:
c.encode_syllables(algorithm = algorithm, call_back=call_back)
end = time.time()
return [(end - beg), None]
def speech_rate_phones(data):
beg = time.time()
with CorpusContext(data, **graph_db) as c:
c.encode_rate('utterance', 'phone', 'speech_rate_phones')
end = time.time()
return [(end-beg), None]
def speech_rate_syllables(data):
beg = time.time()
with CorpusContext(data, **graph_db) as c:
c.encode_rate('utterance', 'syllable', 'speech_rate_syllables')
end = time.time()
return [(end-beg), None]
def number_of_syllables(data):
beg = time.time()
with CorpusContext(data, **graph_db) as c:
c.encode_count('word', 'syllable', 'number_of_syllables')
end = time.time()
return [(end-beg), None]
def number_of_phones(data):
beg = time.time()
with CorpusContext(data, **graph_db) as c:
c.encode_count('syllable', 'phone', 'number_of_phones')
end = time.time()
return [(end-beg), None]
def number_of_words(data):
beg = time.time()
with CorpusContext(data, **graph_db) as c:
c.encode_count('utterance', 'word', 'number_of_words')
end = time.time()
return [(end-beg), None]
def position_in_utterance(data):
beg = time.time()
with CorpusContext(data, **graph_db) as c:
c.encode_position('utterance', 'word', 'position_in_utterance')
end = time.time()
return [(end-beg), None]
def position_in_word(data):
beg = time.time()
with CorpusContext(data, **graph_db) as c:
c.encode_position('word', 'syllable', 'position_in_word')
end = time.time()
return [(end-beg), None]
def export_query_pss(data, export_path):
beg = time.time()
with CorpusContext(data, **graph_db) as c:
#print (c.hierarchy.token_properties)
#print (c.hierarchy.type_properties)
c.refresh_hierarchy()
query = c.query_graph(c.syllable)
filters = (c.syllable.word.end == c.syllable.word.utterance.end)
query = query.filter(filters)
columns = (c.syllable.word.id.column_name('word_id'), c.syllable.word.label.column_name('orthography'), c.syllable.word.duration.column_name('word_duration'), c.syllable.word.begin.column_name('word_begin'), c.syllable.word.end.column_name('word_end'),
c.syllable.word.number_of_syllables.column_name('num_syllables_in_word'), c.syllable.word.position_in_utterance.column_name('position_in_utterance'),
c.pause.following.duration.column_name('following_pause_duration'), c.pause.following.label.column_name('following_pause_label'),
c.syllable.utterance.speech_rate_phones.column_name('speech_rate_phones'), c.syllable.utterance.speech_rate_syllables.column_name('speech_rate_syllables'), c.syllable.utterance.begin.column_name('utterance_begin'),
c.syllable.utterance.end.column_name('utterance_end'), c.syllable.utterance.number_of_words.column_name('num_words'),
c.syllable.discourse.name.column_name('discourse_name'), c.syllable.speaker.name.column_name('speaker_name'),
c.syllable.duration.column_name('syllable_duration'), c.syllable.label.column_name('syllable_label'), c.syllable.position_in_word.column_name('syllable_position'), c.syllable.number_of_phones.column_name('num_phones_in_syllable'))
query = query.columns(*columns)
print (query.cypher())
results = query.to_csv(export_path)
end = time.time()
return [(end-beg)]
#globalphone_import = import_corpus_run_query(globalphonebenchmark, globalphone)
#globalphone_import = import_corpus_run_query(globalphonebenchmark, globalphone)
#globalphone_pauses = pause_encoding_run_query(globalphonebenchmark)
#globalphone_utts = utterance_encoding_run_query(globalphonebenchmark)
#globalphone_syllabic = syllabic_encoding_run_query(globalphonebenchmark, globalphonesyllabic)
globalphone_syllables = syllable_encoding_run_query(globalphonebenchmark)
globalphone_speechrate_phones = speech_rate_phones(globalphonebenchmark)
globalphone_speechrate_syllables = speech_rate_syllables(globalphonebenchmark)
globalphone_num_syllables = number_of_syllables(globalphonebenchmark)
globalphone_num_phones = number_of_phones(globalphonebenchmark)
globalphone_num_words = number_of_words(globalphonebenchmark)
globalphone_word_position = position_in_utterance(globalphonebenchmark)
globalphone_syllable_position = position_in_word(globalphonebenchmark)
globalphone_export_pss = export_query_pss(globalphonebenchmark, outpath)
def WriteDictToCSV(csv_file,csv_columns,dict_data):
with open(csv_file, 'w') as csvfile:
writer = csv.DictWriter(csvfile, fieldnames=csv_columns)
writer.writeheader()
for data in dict_data:
writer.writerow(data)
return
csv_columns = ['Computer','Date','Corpus', 'Type of benchmark', 'Total time', 'Mean time per call back', 'sd time between call backs']
dict_data = [
#{'Computer': platform.node(), 'Date': str(datetime.now()), 'Corpus': amountofcorpus + globalphonebenchmark, 'Type of benchmark': 'Import', 'Total time': globalphone_import[0], 'Mean time per call back': globalphone_import[1], 'sd time between call backs': globalphone_import[2]},
#{'Computer': platform.node(), 'Date': str(datetime.now()), 'Corpus': globalphonebenchmark, 'Type of benchmark': 'Pause encoding', 'Total time': globalphone_pauses[0], 'Mean time per call back': globalphone_pauses[1], 'sd time between call backs': globalphone_pauses[2]},
#{'Computer': platform.node(), 'Date': str(datetime.now()), 'Corpus': globalphonebenchmark, 'Type of benchmark': 'Utterance encoding', 'Total time': globalphone_utts[0], 'Mean time per call back': globalphone_utts[1], 'sd time between call backs': globalphone_utts[2]},
#{'Computer': platform.node(), 'Date': str(datetime.now()), 'Corpus': globalphonebenchmark, 'Type of benchmark': 'Syllabic encoding', 'Total time': globalphone_syllabic[0], 'Mean time per call back': None, 'sd time between call backs': None},
{'Computer': platform.node(), 'Date': str(datetime.now()), 'Corpus': globalphonebenchmark, 'Type of benchmark': 'Syllable encoding', 'Total time': globalphone_syllables[0], 'Mean time per call back': None, 'sd time between call backs': None},
{'Computer': platform.node(), 'Date': str(datetime.now()), 'Corpus': globalphonebenchmark, 'Type of benchmark': 'Speech rate encoding (phones)', 'Total time': globalphone_speechrate_phones[0], 'Mean time per call back': None, 'sd time between call backs': None},
{'Computer': platform.node(), 'Date': str(datetime.now()), 'Corpus': globalphonebenchmark, 'Type of benchmark': 'Speech rate encoding (syllables)', 'Total time': globalphone_speechrate_syllables[0], 'Mean time per call back': None, 'sd time between call backs': None},
{'Computer': platform.node(), 'Date': str(datetime.now()), 'Corpus': globalphonebenchmark, 'Type of benchmark': 'Num syllables encoding', 'Total time': globalphone_num_syllables[0], 'Mean time per call back': None, 'sd time between call backs': None},
{'Computer': platform.node(), 'Date': str(datetime.now()), 'Corpus': globalphonebenchmark, 'Type of benchmark': 'Num phones encoding', 'Total time': globalphone_num_phones[0], 'Mean time per call back': None, 'sd time between call backs': None},
{'Computer': platform.node(), 'Date': str(datetime.now()), 'Corpus': globalphonebenchmark, 'Type of benchmark': 'Num words encoding', 'Total time': globalphone_num_words[0], 'Mean time per call back': None, 'sd time between call backs': None},
{'Computer': platform.node(), 'Date': str(datetime.now()), 'Corpus': globalphonebenchmark, 'Type of benchmark': 'Word position encoding', 'Total time': globalphone_word_position[0], 'Mean time per call back': None, 'sd time between call backs': None},
{'Computer': platform.node(), 'Date': str(datetime.now()), 'Corpus': globalphonebenchmark, 'Type of benchmark': 'Syllable position encoding', 'Total time': globalphone_syllable_position[0], 'Mean time per call back': None, 'sd time between call backs': None},
{'Computer': platform.node(), 'Date': str(datetime.now()), 'Corpus': globalphonebenchmark, 'Type | |
= 'ATP Hydrolysis'
reaction.lower_bound = 0. # This is the default
reaction.upper_bound = 1000. # This is the default
reaction.add_metabolites({atp_HAOc: -1.0,
h2o_HAOc: -1.0,
adp_HAOc: 1.0,
pi_HAOc: 1.0,
h_HAOc: 1.0,
ATP_SLP_HAO: -1.0})
model.add_reactions([reaction])
print(reaction.name + ": " + str(reaction.check_mass_balance()))
##Gluconeogenesis
# atp_HAOc + h2o_HAOc + pyr_HAOc <-> amp_HAOc + 2.0 h_HAOc + pep_HAOc + pi_HAOc
amp_HAOc = Metabolite('amp_HAOc', formula='C10H12N5O7P', name='AMP', compartment='HAOc', charge=-2)
reaction = Reaction('HAO_PPS')
reaction.name = 'Phosphoenolpyruvate synthase'
reaction.subsystem = 'Gluconeogenesis'
reaction.lower_bound = -1000. # This is the default
reaction.upper_bound = 1000. # This is the default
reaction.add_metabolites({atp_HAOc: -1.0,
h2o_HAOc: -1.0,
pyr_HAOc: -1.0,
amp_HAOc: 1.0,
h_HAOc: 2.0,
pep_HAOc: 1.0,
pi_HAOc: 1.0,
ATP_SLP_HAO: -1.0})
model.add_reactions([reaction])
print(reaction.name + ": " + str(reaction.check_mass_balance()))
# fdp_HAOc + h2o_HAOc <-> f6p_HAOc + pi_HAOc
reaction = Reaction('HAO_FBP')
reaction.name = 'Fructose-bisphosphatase'
reaction.subsystem = 'Gluconeogenesis'
reaction.lower_bound = 0. # This is the default
reaction.upper_bound = 1000. # This is the default
reaction.add_metabolites({fdp_HAOc: -1.0,
h2o_HAOc: -1.0,
f6p_HAOc: 1.0,
pi_HAOc: 1.0})
model.add_reactions([reaction])
print(reaction.name + ": " + str(reaction.check_mass_balance()))
# TCA Cycle
# malate dehydrogenase
mal__L_HAOc = Metabolite('mal__L_HAOc', formula='C4H4O5', name='L-Malate', compartment='HAOc', charge=-2)
oaa_HAOc = Metabolite('oaa_HAOc', formula='C4H2O5', name='Oxaloacetate', compartment='HAOc', charge=-2)
reaction = Reaction('HAO_MDH')
reaction.name = 'Malate dehydrogenase'
reaction.subsystem = 'Propionate Production'
reaction.lower_bound = -1000. # This is the default
reaction.upper_bound = 1000. # This is the default
reaction.add_metabolites({oaa_HAOc: -1.0,
nadh_HAOc: -1.0,
h_HAOc: -1.0,
nad_HAOc: 1.0,
mal__L_HAOc: 1.0})
model.add_reactions([reaction])
print(reaction.name + ": " + str(reaction.check_mass_balance()))
# fumarate reductase NADH
succ_HAOc = Metabolite('succ_HAOc', formula='C4H4O4', name='Succinate', compartment='c', charge=-2)
fum_HAOc = Metabolite('fum_HAOc', formula='C4H2O4', name='Fumarate', compartment='c', charge=-2)
reaction = Reaction('HAO_FRDx')
reaction.name = 'Fumarate Reductase NADH'
reaction.subsystem = 'Propionate Production'
reaction.lower_bound = -1000. # This is the default
reaction.upper_bound = 1000. # This is the default
reaction.add_metabolites({fum_HAOc: -1.0,
nadh_HAOc: -1.0,
h_HAOc: -1.0,
nad_HAOc: 1.0,
succ_HAOc: 1.0})
model.add_reactions([reaction])
print(reaction.name + ": " + str(reaction.check_mass_balance()))
# Bifurcated TCA Cycle
# OAA to PEP
# atp_HAOc + oaa_HAOc -> adp_HAOc + co2_HAOc + pep_HAOc
reaction = Reaction('HAO_PPCK')
reaction.name = 'Phosphoenolpyruvate carboxykinase'
reaction.subsystem = 'TCA Cycle'
reaction.lower_bound = 0. # This is the default
reaction.upper_bound = 1000. # This is the default
reaction.add_metabolites({atp_HAOc: -1.0,
oaa_HAOc: -1.0,
pep_HAOc: 1.0,
adp_HAOc: 1.0,
co2_HAOc: 1.0,
ATP_SLP_HAO: -1.0})
model.add_reactions([reaction])
print(reaction.name + ": " + str(reaction.check_mass_balance()))
# Acetyl-CoA to OAA and Fumarate
# co2_HAOc + h2o_HAOc + pep_HAOc <-> h_HAOc + oaa_HAOc + pi_HAOc
reaction = Reaction('HAO_PPC')
reaction.name = 'Phosphoenolpyruvate carboxylase'
reaction.subsystem = 'TCA Cycle'
reaction.lower_bound = 0. # This is the default
reaction.upper_bound = 1000. # This is the default
reaction.add_metabolites({co2_HAOc: -1.0,
h2o_HAOc: -1.0,
pep_HAOc: -1.0,
h_HAOc: 1.0,
oaa_HAOc: 1.0,
pi_HAOc: 1.0})
model.add_reactions([reaction])
print(reaction.name + ": " + str(reaction.check_mass_balance()))
# accoa_HAOc + h2o_HAOc + oaa_HAOc -> cit_HAOc + coa_HAOc + h_HAOc
cit_HAOc = Metabolite('cit_HAOc', formula='C6H5O7', name='Citrate', compartment='c', charge=-3)
reaction = Reaction('HAO_CS')
reaction.name = 'Citrate synthase'
reaction.subsystem = 'TCA Cycle'
reaction.lower_bound = -1000. # This is the default
reaction.upper_bound = 1000. # This is the default
reaction.add_metabolites({accoa_HAOc: -1.0,
h2o_HAOc: -1.0,
oaa_HAOc: -1.0,
cit_HAOc: 1.0,
coa_HAOc: 1.0,
h_HAOc: 1.0})
model.add_reactions([reaction])
print(reaction.name + ": " + str(reaction.check_mass_balance()))
# accoa_HAOc + h2o_HAOc + oaa_HAOc -> cit_HAOc + coa_HAOc + h_HAOc
icit_HAOc = Metabolite('icit_HAOc', formula='C6H5O7', name='Isocitrate', compartment='c', charge=-3)
reaction = Reaction('HAO_ACONT')
reaction.name = 'Aconitate hydratase'
reaction.subsystem = 'TCA Cycle'
reaction.lower_bound = -1000. # This is the default
reaction.upper_bound = 1000. # This is the default
reaction.add_metabolites({cit_HAOc: -1.0,
icit_HAOc: 1.0})
model.add_reactions([reaction])
print(reaction.name + ": " + str(reaction.check_mass_balance()))
# icit_c <-> glx_c + succ_c
glx_HAOc = Metabolite('glx_HAOc', formula='C2HO3', name='Glyxoxylate', compartment='HAOc', charge=-1)
reaction = Reaction('HAO_ICL')
reaction.name = 'Isocitrate lyase'
reaction.subsystem = 'TCA Cycle'
reaction.lower_bound = -1000. # This is the default
reaction.upper_bound = 1000. # This is the default
reaction.add_metabolites({icit_HAOc: -1.0,
glx_HAOc: 1.0,
succ_HAOc: 1.0})
model.add_reactions([reaction])
print(reaction.name + ": " + str(reaction.check_mass_balance()))
# accoa_c + glx_c + h2o_c <->g coa_c + h_c + mal__L_c
reaction = Reaction('HAO_MALS')
reaction.name = 'Malate synthase'
reaction.subsystem = 'TCA Cycle'
reaction.lower_bound = 0. # This is the default
reaction.upper_bound = 1000. # This is the default
reaction.add_metabolites({accoa_HAOc: -1.0,
glx_HAOc: -1.0,
h2o_HAOc: -1.0,
coa_HAOc: 1.0,
h_HAOc: 1.0,
mal__L_HAOc: 1.0})
model.add_reactions([reaction])
print(reaction.name + ": " + str(reaction.check_mass_balance()))
# icit_HAOc + nad_HAOc <-> akg_HAOc + co2_HAOc + nadh_HAOc
akg_HAOc = Metabolite('akg_HAOc', formula='C5H4O5', name='2-Oxoglutarate', compartment='HAOc', charge=-2)
reaction = Reaction('HAO_ICDHx')
reaction.name = 'Isocitrate dehydrogenase (NAD)'
reaction.subsystem = 'TCA Cycle'
reaction.lower_bound = -1000. # This is the default
reaction.upper_bound = 1000. # This is the default
reaction.add_metabolites({icit_HAOc: -1.0,
nad_HAOc: -1.0,
akg_HAOc: 1.0,
co2_HAOc: 1.0,
nadh_HAOc: 1.0})
model.add_reactions([reaction])
print(reaction.name + ": " + str(reaction.check_mass_balance()))
# mal__L_HAOc + nad_HAOc <-> h_HAOc + nadh_HAOc + oaa_HAOc
reaction = Reaction('HAO_MDH')
reaction.name = 'Malate dehydrogenase'
reaction.subsystem = 'TCA Cycle'
reaction.lower_bound = -1000. # This is the default
reaction.upper_bound = 1000. # This is the default
reaction.add_metabolites({mal__L_HAOc: -1.0,
nad_HAOc: -1.0,
h_HAOc: 1.0,
nadh_HAOc: 1.0,
oaa_HAOc: 1.0})
model.add_reactions([reaction])
print(reaction.name + ": " + str(reaction.check_mass_balance()))
# fum_HAOc + h2o_HAOc <-> mal__L_HAOc
reaction = Reaction('HAO_FUM')
reaction.name = 'Fumarase'
reaction.subsystem = 'TCA Cycle'
reaction.lower_bound = -1000. # This is the default
reaction.upper_bound = 1000. # This is the default
reaction.add_metabolites({fum_HAOc: -1.0,
h2o_HAOc: -1.0,
mal__L_HAOc: 1.0})
model.add_reactions([reaction])
print(reaction.name + ": " + str(reaction.check_mass_balance()))
# atp_c + cit_c + coa_c -> accoa_c + adp_c + oaa_c + pi_c
reaction = Reaction('HAO_ACITL')
reaction.name = '<NAME>'
reaction.subsystem = 'TCA Cycle'
reaction.lower_bound = 0. # This is the default
reaction.upper_bound = 1000. # This is the default
reaction.add_metabolites({coa_HAOc: -1.0,
atp_HAOc: -1.0,
cit_HAOc: -1.0,
accoa_HAOc: 1.0,
oaa_HAOc: 1.0,
adp_HAOc: 1.0,
pi_HAOc: 1.0,
ATP_SLP_HAO: -1.0})
model.add_reactions([reaction])
print(reaction.name + ": " + str(reaction.check_mass_balance()))
# mal__L_c + nad_c -> co2_c + nadh_c + pyr_c
reaction = Reaction('HAO_ME1')
reaction.name = 'Malic Enzyme (NAD)'
reaction.subsystem = 'TCA Cycle'
reaction.lower_bound = 0. # This is the default
reaction.upper_bound = 1000. # This is the default
reaction.add_metabolites({mal__L_HAOc: -1.0,
nad_HAOc: -1.0,
pyr_HAOc: 1.0,
nadh_HAOc: 1.0,
co2_HAOc: 1.0})
model.add_reactions([reaction])
print(reaction.name + ": " + str(reaction.check_mass_balance()))
# ac_HAOc + atp_HAOc + coa_HAOc -> accoa_HAOc + amp_HAOc + ppi_HAOc
ppi_HAOc = Metabolite('ppi_HAOc', formula='HO7P2', name='Diphosphate', compartment='c', charge=-3)
reaction = Reaction('HAO_ACS')
reaction.name = 'Acetyl-CoA synthetase'
reaction.subsystem = 'Acetate metabolism'
reaction.lower_bound = 0. # This is the default
reaction.upper_bound = 1000. # This is the default
reaction.add_metabolites({ac_HAOc: -1.0,
atp_HAOc: -1.0,
coa_HAOc: -1.0,
accoa_HAOc: 1.0,
amp_HAOc: 1.0,
ppi_HAOc: 1.0,
ATP_SLP_HAO: -1.0})
model.add_reactions([reaction])
print(reaction.name + ": " + str(reaction.check_mass_balance()))
# NADH/ NADPH Conversions
# atp_HAOc + nad_HAOc <-> adp_HAOc + h_HAOc + nadp_HAOc
nadp_HAOc = Metabolite('nadp_HAOc', formula='C21H25N7O17P3', name='Nicotinamide adenine dinucHAOtide phosphate',
compartment='c', charge=-3)
reaction = Reaction('HAO_NADK')
reaction.name = 'NAD kinase'
reaction.subsystem = 'NADH/ NADPH Conversions'
reaction.lower_bound = -1000. # This is the default
reaction.upper_bound = 1000. # This is the default
reaction.add_metabolites({atp_HAOc: -1.0,
nad_HAOc: -1.0,
adp_HAOc: 1.0,
h_HAOc: 1.0,
nadp_HAOc: 1.0,
ATP_SLP_HAO: -1.0})
model.add_reactions([reaction])
print(reaction.name + ": " + str(reaction.check_mass_balance()))
# nadh_HAOc + nadp_HAOc + 2.0 h_HAOi -> 2.0 h_HAOc + nad_HAOc + nadph_HAOc
nadph_HAOc = Metabolite('nadph_HAOc', formula='C21H26N7O17P3',
name='Nicotinamide adenine dinucHAOtide phosphate - reduced', compartment='c', charge=-4)
reaction = Reaction('HAO_THD2')
reaction.name = 'NAD(P) transhydrogenase'
reaction.subsystem = 'NADH/ NADPH Conversions'
reaction.lower_bound = -1000. # This is the default
reaction.upper_bound = 1000. # This is the default
reaction.add_metabolites({nadh_HAOc: -1.0,
nadp_HAOc: -1.0,
h_HAOi: -2.0,
h_HAOc: 2.0,
nad_HAOc: 1.0,
nadph_HAOc: 1.0})
model.add_reactions([reaction])
print(reaction.name + ": " + str(reaction.check_mass_balance()))
##Nitrogen and Sulfur Import
# nh4_e ->
nh4_HAOe = Metabolite('nh4_HAOe', formula='H4N', name='H2O', compartment='HAOe', charge=1)
reaction = Reaction('HAO_EX_nh4')
reaction.name = 'Ammonium Transport'
reaction.subsystem = 'Transport'
reaction.lower_bound = -1000. # This is the default
reaction.upper_bound = 1000. # This is the default
reaction.add_metabolites({nh4_e: HAO_Abnd,
nh4_HAOe: 1.0})
model.add_reactions([reaction])
print(reaction.name + ": " + str(reaction.check_mass_balance()))
nh4_HAOc = Metabolite('nh4_HAOc', formula='H4N', name='H2O', compartment='c', charge=1)
reaction = Reaction('HAO_nh4t')
reaction.name = 'Ammonium Transport'
reaction.subsystem = 'Transport'
reaction.lower_bound = -1000. # This is the default
reaction.upper_bound = 1000. # This is the default
reaction.add_metabolites({nh4_HAOe: -1.0,
nh4_HAOc: 1.0})
model.add_reactions([reaction])
print(reaction.name + ": " + str(reaction.check_mass_balance()))
# so4_e ->
so4_HAOe = Metabolite('so4_HAOe', formula='O4S', name='Sulfate', compartment='HAOe', charge=-2)
reaction = Reaction('EX_HAO_so4')
reaction.name = 'Sulfate Transport'
reaction.subsystem = 'Transport'
reaction.lower_bound = -1000. # This is the default
reaction.upper_bound = 1000. # This is the default
reaction.add_metabolites({so4_e: HAO_Abnd,
so4_HAOe: -1.0})
model.add_reactions([reaction])
print(reaction.name + ": " + str(reaction.check_mass_balance()))
so4_HAOc = | |
= coefs
self.offset = offset
self.symmetric_bonds = symmetric_bonds
kwargs = {**desc.index_dict, **kwargs}
Expr.__init__(self, **kwargs)
# === PROPERTY EVALUATION METHODS
def _pyomo_expr(self, index=None):
"""Interface for generating Pyomo expressions.
Args:
index (list): Optional, index to to create an instance of a Pyomo
expression. In the case of a scalar, the valid index is None.
Returns:
An instance of a Pyomo expression.
"""
i, *index = index
if index == (None,):
index = ()
result = self.offset
for n, j in enumerate(self.desc.canv.NeighborhoodIndexes[i]):
if j is not None:
if self.symmetric_bonds:
i, j = min(i, j), max(i, j)
result += (
self.coefs
if (
type(self.coefs) is float
or type(self.coefs) is int
or type(self.coefs) is SimpleParam
)
else self.coefs[n]
) * self.desc._pyomo_expr(index=(i, j, *index))
return result
class SumSites(Expr):
"""A class for expressions formed by summation over canvas sites.
Attributes:
desc (Descriptor/Expr): descriptors or expressions to sum over
coefs (float/list<float>): coefficients to multiply contributions
from each site
offset (float): coefficient to add to the expression
sites_to_sum (list<int>): sites to consider in the summation
(index information inherited from IndexedElem)
"""
# === STANDARD CONSTRUCTOR
def __init__(self, desc, coefs=1.0, offset=0.0, sites_to_sum=None, **kwargs):
"""Standard constructor for summation of site contributions.
Args:
desc (Descriptor): descriptors or expressions to sum across all sites
coefs (float/list<float>): Optional, coefficients to multiple each
site term by. Default=1.0
offset (float): Optional, coefficient to add to the expression.
Default=0.0
sites_to_sum (list<int>): Optional, subset of canvas sites to sum.
Default=None, meaning all sites in the desc object are considered.
**kwargs: Optional, index information passed to IndexedElem if
interested in a subset of indices
Possible choices: sites, bonds, site_types, bond_types, confs.
"""
self.desc = desc
self.coefs = coefs
self.offset = offset
self.sites_to_sum = sites_to_sum if sites_to_sum is not None else desc.sites
kwargs = {**desc.index_dict, **kwargs}
kwargs.pop("sites")
Expr.__init__(self, **kwargs)
# === PROPERTY EVALUATION METHODS
def _pyomo_expr(self, index=None):
"""Interface for generating Pyomo expressions.
Args:
index (list): Optional, index to to create an instance of a Pyomo
expression. In the case of a scalar, the valid index is None.
Returns:
An instance of a Pyomo expression.
"""
if index == (None,):
index = ()
result = self.offset
for i in self.sites_to_sum:
result += (
self.coefs
if (
type(self.coefs) is float
or type(self.coefs) is int
or type(self.coefs) is SimpleParam
)
else self.coefs[(i, *index)]
) * self.desc._pyomo_var[(i, *index)]
return result
class SumBonds(Expr):
"""A class for expressions formed by summation over canvas bonds.
Attributes:
desc (Descriptor/Expr): descriptors or expressions to sum over
coefs (float/list<float>): coefficients to multiply contributions
from each bond
offset (float): coefficient to add to the expression
bonds_to_sum (list<int>): bonds to consider in the summation
(index information inherited from IndexedElem)
"""
# === STANDARD CONSTRUCTOR
def __init__(self, desc, coefs=1.0, offset=0.0, bonds_to_sum=None, **kwargs):
"""Standard constructor for summation of bond contributions.
Args:
desc (Descriptor): descriptors or expressions to sum across all bonds
coefs (float/list<float>): Optional, coefficients to multiple each
bond term by. Default=1.0
offset (float): Optional, coefficient to add to the expression.
Default=0.0
bonds_to_sum (list<int>): Optional, subset of canvas bonds
(i.e., neighbor connections) to sum.
Default=None, meaning all bonds in the desc object are considered.
**kwargs: Optional, index information passed to IndexedElem if
interested in a subset of indices
Possible choices: sites, bonds, site_types, bond_types, confs.
"""
self.desc = desc
self.coefs = coefs
self.offset = offset
self.bonds_to_sum = bonds_to_sum if bonds_to_sum is not None else desc.bonds
kwargs = {**desc.index_dict, **kwargs}
kwargs.pop("bonds")
Expr.__init__(self, **kwargs)
# === PROPERTY EVALUATION METHODS
def _pyomo_expr(self, index=None):
"""Interface for generating Pyomo expressions.
Args:
index (list): Optional, index to to create an instance of a Pyomo
expression. In the case of a scalar, the valid index is None.
Returns:
An instance of a Pyomo expression.
"""
if index == (None,):
index = ()
result = self.offset
for i, j in self.bonds_to_sum:
result += (
self.coefs
if (
type(self.coefs) is float
or type(self.coefs) is int
or type(self.coefs) is SimpleParam
)
else self.coefs[(i, j, *index)]
) * self.desc._pyomo_var[(i, j, *index)]
return result
class SumSiteTypes(Expr):
"""A class for expressions formed by summation over building block types.
Attributes:
desc (Descriptor/Expr): descriptors or expressions to sum over
coefs (float/list<float>): coefficients to multiply contributions
from each building block type
offset (float): coefficient to add to the expression
site_types_to_sum (list<BBlock>): building block types to consider in
the summation (index information inherited from IndexedElem)
"""
# === STANDARD CONSTRUCTOR
def __init__(self, desc, coefs=1.0, offset=0.0, site_types_to_sum=None, **kwargs):
"""Standard constructor for summation of contributions by site-type.
Args:
desc (Descriptor): descriptors or expressions to sum across site types
coefs (float/list<float>): Optional, coefficients to multiple each
site-type term by. Default=1.0
offset (float): Optional, coefficient to add to the expression.
Default=0.0
bonds_types_to_sum (list<int>): Optional, subset of site types
to sum. Default=None, meaning all site-types in the desc object are
considered.
**kwargs: Optional, index information passed to IndexedElem if
interested in a subset of indices
Possible choices: sites, bonds, site_types, bond_types, confs.
"""
self.desc = desc
self.coefs = coefs
self.offset = offset
self.site_types_to_sum = (
site_types_to_sum if site_types_to_sum is not None else desc.site_types
)
kwargs = {**desc.index_dict, **kwargs}
kwargs.pop("site_types")
Expr.__init__(self, **kwargs)
# === PROPERTY EVALUATION METHODS
def _pyomo_expr(self, index=None):
"""Interface for generating Pyomo expressions.
Args:
index (list): Optional, index to to create an instance of a Pyomo
expression. In the case of a scalar, the valid index is None.
Returns:
An instance of a Pyomo expression.
"""
assert index is not None
i, *index = index
if index == (None,):
index = ()
result = self.offset
for k in self.site_types_to_sum:
result += (
self.coefs
if (
type(self.coefs) is float
or type(self.coefs) is int
or type(self.coefs) is SimpleParam
)
else self.coefs[(i, k, *index)]
) * self.desc._pyomo_var[(i, k, *index)]
return result
class SumBondTypes(Expr):
"""A class for expressions formed by summation over building block types.
Attributes:
desc (Descriptor/Expr): descriptors or expressions to sum over
coefs (float/list<float>): coefficients to multiply contributions
from each pair of building block types
offset (float): coefficient to add to the expression
bond_types_to_sum (list<tuple<BBlock,BBlock>>): building block pairs
to consider in the summation
(index information inherited from IndexedElem)
"""
# === STANDARD CONSTRUCTOR
def __init__(self, desc, coefs=1.0, offset=0.0, bond_types_to_sum=None, **kwargs):
"""Standard constructor for summation of contributions by bond-type.
Args:
desc (Descriptor): descriptors or expressions to sum across bond types
coefs (float/list<float>): Optional, coefficients to multiple each
bond-type term by. Default=1.0
offset (float): Optional, coefficient to add to the expression.
Default=0.0
bonds_types_to_sum (list<tuple<BBlock,BBlock>>): Optional, subset
of bond types to sum.
Default=None, meaning all bond-types in the desc object are
considered.
**kwargs: Optional, index information passed to IndexedElem if
interested in a subset of indices
Possible choices: sites, bonds, site_types, bond_types, confs.
"""
self.desc = desc
self.coefs = coefs
self.offset = offset
self.bond_types_to_sum = (
bond_types_to_sum if bond_types_to_sum is not None else desc.bond_types
)
kwargs = {**desc.index_dict, **kwargs}
kwargs.pop("bond_types")
Expr.__init__(self, **kwargs)
# === PROPERTY EVALUATION METHODS
def _pyomo_expr(self, index=None):
"""Interface for generating Pyomo expressions.
Args:
index (list): Optional, index to to create an instance of a Pyomo
expression. In the case of a scalar, the valid index is None.
Returns:
An instance of a Pyomo expression.
"""
assert index is not None
i, j, *index = index
if index == (None,):
index = ()
result = self.offset
for k, l in self.bond_types_to_sum:
result += (
self.coefs
if (
type(self.coefs) is float
or type(self.coefs) is int
or type(self.coefs) is SimpleParam
)
else self.coefs[(i, j, k, l, *index)]
) * self.desc._pyomo_var[(i, j, k, l, *index)]
return result
class SumSitesAndTypes(Expr):
"""A class for expressions formed by summation over sites and building
block types.
Attributes:
desc (Descriptor/Expr): descriptors or expressions to sum over
coefs (float/list<float>): coefficients to multiply contributions
from each building block type
offset (float): coefficient to add to the expression
sites_to_sum (list<int>): sites to consider in the summation
site_types_to_sum (list<BBlock>): building block types to consider in
the summation (index information inherited from IndexedElem)
"""
# === STANDARD CONSTRUCTOR
def __init__(
self,
desc,
coefs=1.0,
offset=0.0,
sites_to_sum=None,
site_types_to_sum=None,
**kwargs
):
"""Standard constructor for summation of site contributions.
Args:
| |
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from unittest import TestCase
import pytest
import os
from cielo_webservice.models import (
Comercial, Cartao, Pedido, Pagamento, Autenticacao, Autorizacao, Token,
Transacao, Avs, Captura, Cancelamento, Erro, xml_to_object
)
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
class TestComercial(TestCase):
def test_validate(self):
with pytest.raises(TypeError) as excinfo:
Comercial(numero='1234', chave='1234')
assert 'numero precisa ser do tipo inteiro.' in str(excinfo.value)
with pytest.raises(TypeError) as excinfo:
Comercial(numero=1234, chave=1234)
assert 'chave precisa ser do tipo string.' in str(excinfo.value)
def test_repr(self):
comercial = Comercial(
numero=1006993069,
chave='<KEY>'
)
self.assertEqual(
repr(comercial),
'<Comercial(numero=1006993069, chave=<KEY>)>'
)
class TestCartao(TestCase):
def test_validate(self):
with pytest.raises(TypeError) as excinfo:
Cartao(
numero='1234', validade=201805, indicador=1,
codigo_seguranca=123, nome_portador='<NAME>'
)
assert 'numero precisa ser do tipo inteiro.' in str(excinfo.value)
with pytest.raises(TypeError) as excinfo:
Cartao(
numero=1234, validade='201805', indicador=1,
codigo_seguranca=123, nome_portador='<NAME>'
)
assert 'validade precisa ser do tipo inteiro.' in str(excinfo.value)
with pytest.raises(TypeError) as excinfo:
Cartao(
numero=1234, validade=201805, indicador='1',
codigo_seguranca=123, nome_portador='<NAME>'
)
assert 'indicador precisa ser do tipo inteiro.' in str(excinfo.value)
with pytest.raises(TypeError) as excinfo:
Cartao(
numero=1234, validade=201805, indicador=1,
codigo_seguranca='123', nome_portador='<NAME>'
)
assert 'codigo_seguranca precisa ser do tipo inteiro.' in str(excinfo.value)
with pytest.raises(TypeError) as excinfo:
Cartao(
numero=1234, validade=201805, indicador=1,
codigo_seguranca=123, nome_portador=123
)
assert 'nome_portador precisa ser do tipo string.' in str(excinfo.value)
with pytest.raises(TypeError) as excinfo:
Cartao(token=123)
assert 'token precisa ser do tipo string.' in str(excinfo.value)
def test_repr(self):
cartao = Cartao(
numero=4012001037141112, validade=201805, indicador=1,
codigo_seguranca=123, nome_portador='<NAME>'
)
self.assertEqual(
repr(cartao),
'<Cartao(numero=4012001037141112, validade=201805, indicador=1, codigo_seguranca=123, nome_portador=<NAME>, token=None)>'
)
class TestPedido(TestCase):
def test_validate(self):
with pytest.raises(TypeError) as excinfo:
Pedido(
numero=1234, valor=10000, moeda=986,
data_hora='2011-12-07T11:43:37',
)
assert 'numero precisa ser do tipo string.' in str(excinfo.value)
with pytest.raises(TypeError) as excinfo:
Pedido(
numero='1234', valor='10000', moeda=986,
data_hora='2011-12-07T11:43:37',
)
assert 'valor precisa ser do tipo inteiro.' in str(excinfo.value)
with pytest.raises(TypeError) as excinfo:
Pedido(
numero='1234', valor=10000, moeda='986',
data_hora='2011-12-07T11:43:37',
)
assert 'moeda precisa ser do tipo inteiro.' in str(excinfo.value)
with pytest.raises(TypeError) as excinfo:
Pedido(
numero='1234', valor=10000, moeda=986,
data_hora=20111207,
)
assert 'data_hora precisa ser do tipo string.' in str(excinfo.value)
with pytest.raises(TypeError) as excinfo:
Pedido(
numero='1234', valor=10000, moeda=986,
data_hora='2011-12-07T11:43:37', descricao=123
)
assert 'descricao precisa ser do tipo string.' in str(excinfo.value)
with pytest.raises(TypeError) as excinfo:
Pedido(
numero='1234', valor=10000, moeda=986,
data_hora='2011-12-07T11:43:37', idioma=123
)
assert 'idioma precisa ser do tipo string.' in str(excinfo.value)
with pytest.raises(TypeError) as excinfo:
Pedido(
numero='1234', valor=10000, moeda=986,
data_hora='2011-12-07T11:43:37', taxa_embarque='123'
)
assert 'taxa_embarque precisa ser do tipo inteiro.' in str(excinfo.value)
with pytest.raises(TypeError) as excinfo:
Pedido(
numero='1234', valor=10000, moeda=986,
data_hora='2011-12-07T11:43:37', soft_descriptor=123
)
assert 'soft_descriptor precisa ser do tipo string.' in str(excinfo.value)
def test_repr(self):
pedido = Pedido(
numero='1234', valor=10000, moeda=986,
data_hora='2016-03-05T03:30:43.982543'
)
self.assertEqual(
repr(pedido),
'<Pedido(numero=1234, valor=10000, moeda=986, data_hora=2016-03-05T03:30:43.982543, descricao=None, idioma=PT, taxa_embarque=None, soft_descriptor=None)>'
)
class TestPagamento(TestCase):
def test_validate(self):
with pytest.raises(TypeError) as excinfo:
Pagamento(bandeira=1, produto=1, parcelas=1)
assert 'bandeira precisa ser do tipo string.' in str(excinfo.value)
with pytest.raises(TypeError) as excinfo:
Pagamento(bandeira='visa', produto=1, parcelas=1)
assert 'produto precisa ser do tipo string.' in str(excinfo.value)
with pytest.raises(TypeError) as excinfo:
Pagamento(bandeira='visa', produto='1', parcelas='1')
assert 'parcelas precisa ser do tipo inteiro.' in str(excinfo.value)
def test_repr(self):
pagamento = Pagamento(bandeira='visa', produto='1', parcelas=1)
self.assertEqual(
repr(pagamento),
'<Pagamento(bandeira=visa, produto=1, parcelas=1)>'
)
class TestAutenticacao(TestCase):
def test_validate(self):
with pytest.raises(TypeError) as excinfo:
Autenticacao(
codigo='1', mensagem='msg', data_hora='2011-12-07T11:43:37',
valor=10000, eci=7
)
assert 'codigo precisa ser do tipo inteiro.' in str(excinfo.value)
with pytest.raises(TypeError) as excinfo:
Autenticacao(
codigo=1, mensagem=1, data_hora='2011-12-07T11:43:37',
valor=10000, eci=7
)
assert 'mensagem precisa ser do tipo string.' in str(excinfo.value)
with pytest.raises(TypeError) as excinfo:
Autenticacao(
codigo=1, mensagem='msg', data_hora=201112,
valor=10000, eci=7
)
assert 'data_hora precisa ser do tipo string.' in str(excinfo.value)
with pytest.raises(TypeError) as excinfo:
Autenticacao(
codigo=1, mensagem='msg', data_hora='2011-12-07T11:43:37',
valor='10000', eci=7
)
assert 'valor precisa ser do tipo inteiro.' in str(excinfo.value)
with pytest.raises(TypeError) as excinfo:
Autenticacao(
codigo=1, mensagem='msg', data_hora='2011-12-07T11:43:37',
valor=10000, eci='7'
)
assert 'eci precisa ser do tipo inteiro.' in str(excinfo.value)
def test_repr(self):
autenticacao = Autenticacao(
codigo=6, mensagem='Transacao sem autenticacao',
data_hora='2016-03-05T00:03:46.158-03:00', valor=10000, eci=7
)
self.assertEqual(
repr(autenticacao),
'<Autenticacao(codigo=6, mensagem=Transacao sem autenticacao, data_hora=2016-03-05T00:03:46.158-03:00, valor=10000, eci=7)>'
)
class TestAutorizacao(TestCase):
def test_validate(self):
with pytest.raises(TypeError) as excinfo:
Autorizacao(
codigo='1', mensagem='msg', data_hora='2011-12-07T11:43:37',
valor=10000, lr="01", arp=1, nsu=1
)
assert 'codigo precisa ser do tipo inteiro.' in str(excinfo.value)
with pytest.raises(TypeError) as excinfo:
Autorizacao(
codigo=1, mensagem=1, data_hora='2011-12-07T11:43:37',
valor=10000, lr="01", arp=1, nsu=1
)
assert 'mensagem precisa ser do tipo string.' in str(excinfo.value)
with pytest.raises(TypeError) as excinfo:
Autorizacao(
codigo=1, mensagem='msg', data_hora=201112,
valor=10000, lr="01", arp=1, nsu=1
)
assert 'data_hora precisa ser do tipo string.' in str(excinfo.value)
with pytest.raises(TypeError) as excinfo:
Autorizacao(
codigo=1, mensagem='msg', data_hora='2011-12-07T11:43:37',
valor='10000', lr="01", arp=1, nsu=1
)
assert 'valor precisa ser do tipo inteiro.' in str(excinfo.value)
with pytest.raises(TypeError) as excinfo:
Autorizacao(
codigo=1, mensagem='msg', data_hora='2011-12-07T11:43:37',
valor=10000, lr=1, arp=1, nsu=1
)
assert 'lr precisa ser do tipo string.' in str(excinfo.value)
with pytest.raises(TypeError) as excinfo:
Autorizacao(
codigo=1, mensagem='msg', data_hora='2011-12-07T11:43:37',
valor=10000, lr="01", arp='1', nsu=1
)
assert 'arp precisa ser do tipo inteiro.' in str(excinfo.value)
with pytest.raises(TypeError) as excinfo:
Autorizacao(
codigo=1, mensagem='msg', data_hora='2011-12-07T11:43:37',
valor=10000, lr="01", arp=1, nsu='1'
)
assert 'nsu precisa ser do tipo inteiro.' in str(excinfo.value)
def test_repr(self):
autorizacao = Autorizacao(
codigo=6, mensagem='Transacao autorizada',
data_hora='2016-03-05T00:03:46.161-03:00', valor=10000, lr="00",
arp=123456, nsu=36318
)
self.assertEqual(
repr(autorizacao),
'<Autorizacao(codigo=6, mensagem=Transacao autorizada, data_hora=2016-03-05T00:03:46.161-03:00, valor=10000, lr=00, arp=123456, nsu=36318)>'
)
class TestToken(TestCase):
def test_validate(self):
with pytest.raises(TypeError) as excinfo:
Token(codigo=1, status=1, numero='1234')
assert 'codigo precisa ser do tipo string.' in str(excinfo.value)
with pytest.raises(TypeError) as excinfo:
Token(codigo='code', status='1', numero='1234')
assert 'status precisa ser do tipo inteiro.' in str(excinfo.value)
with pytest.raises(TypeError) as excinfo:
Token(codigo='code', status=1, numero=1234)
assert 'numero precisa ser do tipo string.' in str(excinfo.value)
def test_repr(self):
token = Token(codigo='code', status=1, numero='1234')
self.assertEqual(
repr(token),
'<Token(codigo=code, status=1, numero=1234)>'
)
class TestAvs(TestCase):
def test_validate(self):
with pytest.raises(TypeError) as excinfo:
Avs(
endereco=1, complemento='', numero=1, bairro='Bairro',
cep='00000-000'
)
assert 'endereco precisa ser do tipo string.' in str(excinfo.value)
with pytest.raises(TypeError) as excinfo:
Avs(
endereco='Rua 1', complemento=1, numero=1, bairro='Bairro',
cep='00000-000'
)
assert 'complemento precisa ser do tipo string.' in str(excinfo.value)
with pytest.raises(TypeError) as excinfo:
Avs(
endereco='Rua 1', complemento='', numero='1', bairro='Bairro',
cep='00000-000'
)
assert 'numero precisa ser do tipo inteiro.' in str(excinfo.value)
with pytest.raises(TypeError) as excinfo:
Avs(
endereco='Rua 1', complemento='', numero=1, bairro=1,
cep='00000-000'
)
assert 'bairro precisa ser do tipo string.' in str(excinfo.value)
with pytest.raises(TypeError) as excinfo:
Avs(
endereco='Rua 1', complemento='', numero=1, bairro='Bairro',
cep=00000000
)
assert 'cep precisa ser do tipo string.' in str(excinfo.value)
def test_repr(self):
avs = Avs(
endereco='Rua 1', complemento='', numero=1, bairro='Bairro',
cep='00000000'
)
self.assertEqual(
repr(avs),
'<Avs(endereco=Rua 1, complemento=, numero=1, bairro=Bairro, cep=00000000)>'
)
class TestCaptura(TestCase):
def test_validate(self):
with pytest.raises(TypeError) as excinfo:
Captura(
codigo='1', mensagem='mensagem',
data_hora='2011-12-07T11:43:37', valor=10000, taxa_embarque=0
)
assert 'codigo precisa ser do tipo inteiro.' in str(excinfo.value)
with pytest.raises(TypeError) as excinfo:
Captura(
codigo=1, mensagem=1, data_hora='2011-12-07T11:43:37',
valor=10000, taxa_embarque=0
)
assert 'mensagem precisa ser do tipo string.' in str(excinfo.value)
with pytest.raises(TypeError) as excinfo:
Captura(
codigo=1, mensagem='mensagem', data_hora=1,
valor=10000, taxa_embarque=0
)
assert 'data_hora precisa ser do tipo string.' in str(excinfo.value)
with pytest.raises(TypeError) as excinfo:
Captura(
codigo=1, mensagem='mensagem', data_hora='2011-12-07T11:43:37',
valor='10000', taxa_embarque=0
)
assert 'valor precisa ser do tipo inteiro.' in str(excinfo.value)
with pytest.raises(TypeError) as excinfo:
Captura(
codigo=1, mensagem='mensagem', data_hora='2011-12-07T11:43:37',
valor=10000, taxa_embarque='0'
)
assert 'taxa_embarque precisa ser do tipo inteiro.' in str(excinfo.value)
def test_repr(self):
captura = Captura(
codigo=1, mensagem='mensagem', data_hora='2011-12-07T11:43:37',
valor=10000, taxa_embarque=0
)
self.assertEqual(
repr(captura),
'<Captura(codigo=1, mensagem=mensagem, data_hora=2011-12-07T11:43:37, valor=10000, taxa_embarque=0)>'
)
class TestCancelamento(TestCase):
def test_validate(self):
with pytest.raises(TypeError) as excinfo:
Cancelamento(
codigo='1', mensagem='mensagem',
data_hora='2011-12-07T11:43:37', valor=10000,
)
assert 'codigo precisa ser do tipo inteiro.' in str(excinfo.value)
with pytest.raises(TypeError) as excinfo:
Cancelamento(
codigo=1, mensagem=1, data_hora='2011-12-07T11:43:37',
valor=10000,
)
assert 'mensagem precisa ser do tipo string.' in str(excinfo.value)
with pytest.raises(TypeError) as excinfo:
Cancelamento(
codigo=1, mensagem='mensagem', data_hora=201112, valor=10000
)
assert 'data_hora precisa ser do tipo string.' in str(excinfo.value)
with pytest.raises(TypeError) as excinfo:
Cancelamento(
codigo=1, mensagem='mensagem',
data_hora='2011-12-07T11:43:37', valor='10000',
)
assert 'valor precisa ser do tipo inteiro.' in str(excinfo.value)
def test_repr(self):
cancelamento = Cancelamento(
codigo=1, mensagem='mensagem', data_hora='2011-12-07T11:43:37',
valor=10000
)
self.assertEqual(
repr(cancelamento),
'<Cancelamento(codigo=1, mensagem=mensagem, data_hora=2011-12-07T11:43:37, valor=10000)>'
)
class TestErro(TestCase):
def test_validate(self):
with pytest.raises(TypeError) as excinfo:
Erro(codigo=1, mensagem='mensagem')
assert 'codigo precisa ser do tipo string.' in str(excinfo.value)
with pytest.raises(TypeError) as excinfo:
Erro(codigo='001', mensagem=1)
assert 'mensagem precisa ser do tipo string.' in str(excinfo.value)
def test_repr(self):
erro = Erro(codigo='001', mensagem='erro')
self.assertEqual(
repr(erro),
'<Erro(codigo=001, mensagem=erro)>'
)
class TestTransacao(TestCase):
def test_validate(self):
comercial = Comercial(numero=1234, chave='1234')
cartao = Cartao(
numero=1234, validade=201805, indicador=1,
codigo_seguranca=123, nome_portador='<NAME>'
)
pedido = Pedido(
numero='1234', valor=10000, moeda=986,
data_hora='2011-12-07T11:43:37',
)
pagamento = Pagamento(bandeira='visa', produto='1', parcelas=1)
autenticacao = Autenticacao(
codigo=1, mensagem='msg', data_hora='2011-12-07T11:43:37',
valor=10000, eci=7
)
autorizacao = Autorizacao(
codigo=1, mensagem='msg', data_hora='2011-12-07T11:43:37',
valor=10000, lr="01", arp=1, nsu=1
)
token = Token(codigo='codigo', status=1, numero='1234')
avs = Avs(
endereco='Rua 1', complemento='', | |
a topic distribution for "<input_data>"
Then the topic distribution is "<topic_distribution>"
And I create a local topic distribution for "<input_data>"
Then the local topic distribution is "<topic_distribution>"
"""
headers = ["data", "source_wait", "dataset_wait", "model_wait",
"source_conf", "input_data", "topic_distribution"]
examples = [
['data/spam.csv', '30', '30', '80',
'{"fields": {"000001": {"optype": "text", "term_analysis": '
'{"case_sensitive": true, "stem_words": true, '
'"use_stopwords": false, "language": "en"}}}}',
'{"Type": "ham", "Message": "Mobile call"}',
'[0.51133, 0.00388, 0.00574, 0.00388, 0.00388, 0.00388, '
'0.00388, 0.00388, 0.00388, 0.00388, 0.00388, 0.44801]'],
['data/spam.csv', '30', '30', '30',
'{"fields": {"000001": {"optype": "text", "term_analysis": '
'{"case_sensitive": true, "stem_words": true, '
'"use_stopwords": false, "language": "en"}}}}',
'{"Type": "ham", "Message": "Go until jurong point, crazy.. '
'Available only in bugis n great world la e buffet... Cine '
'there got amore wat..."}',
'[0.39188, 0.00643, 0.00264, 0.00643, 0.08112, 0.00264, '
'0.37352, 0.0115, 0.00707, 0.00327, 0.00264, 0.11086]']]
show_doc(self.test_scenario4)
for example in examples:
example = dict(zip(headers, example))
show_method(self, sys._getframe().f_code.co_name, example)
source_create.i_upload_a_file(self, example["data"])
source_create.the_source_is_finished(
self, example["source_wait"])
source_create.i_update_source_with(self, example["source_conf"])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(
self, example["dataset_wait"])
topic_create.i_create_a_topic_model(self)
topic_create.the_topic_model_is_finished_in_less_than(
self, example["model_wait"])
prediction_compare.i_create_a_local_topic_model(self)
topic_create.i_create_a_topic_distribution(
self, example["input_data"])
prediction_compare.the_topic_distribution_is(
self, example["topic_distribution"])
topic_create.i_create_a_local_topic_distribution(
self, example["input_data"])
prediction_compare.the_local_topic_distribution_is(
self, example["topic_distribution"])
def test_scenario5(self):
"""
Scenario: Successfully comparing association sets:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <source_wait> secs
And I update the source with params "<source_conf>"
And I create a dataset
And I wait until the dataset is ready less than <dataset_wait> secs
And I create a model
And I wait until the association is ready less than <model_wait> secs
And I create a local association
When I create an association set for "<input_data>"
Then the association set is like the contents of "<association_set_file>"
And I create a local association set for "<input_data>"
Then the local association set is like the contents of "<association_set_file>"
"""
headers = ["data", "source_wait", "dataset_wait", "model_wait",
"source_conf", "association_set_file", "input_data"]
examples = [
['data/groceries.csv', '20', '20', '50', '{"fields": {"00000": {"optype": "text", "term_analysis": {"token_mode": "all", "language": "en"}}}}', 'data/associations/association_set.json', '{"field1": "cat food"}']]
show_doc(self.test_scenario5)
for example in examples:
example = dict(zip(headers, example))
show_method(self, sys._getframe().f_code.co_name, example)
source_create.i_upload_a_file(self, example["data"])
source_create.the_source_is_finished(self, example["source_wait"])
source_create.i_update_source_with(self, example["source_conf"])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(
self, example["dataset_wait"])
association_create.i_create_an_association_from_dataset(self)
association_create.the_association_is_finished_in_less_than(
self, example["model_wait"])
prediction_compare.i_create_a_local_association(self)
prediction_create.i_create_an_association_set(
self, example["input_data"])
prediction_compare.the_association_set_is_like_file(
self, example["association_set_file"])
prediction_compare.i_create_a_local_association_set(
self, example["input_data"])
prediction_compare.the_local_association_set_is_like_file(
self, example["association_set_file"])
def test_scenario6(self):
"""
Scenario: Successfully comparing predictions for ensembles:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <source_wait> secs
And I create a dataset
And I wait until the dataset is ready less than <dataset_wait> secs
And I create an ensemble with "<model_conf>"
And I wait until the ensemble is ready less than <model_wait> secs
And I create a local ensemble
When I create a prediction for "<input_data>"
Then the prediction for "<objective_id>" is "<prediction>"
And I create a local prediction for "<input_data>"
Then the local prediction is "<prediction>"
"""
headers = ["data", "source_wait", "dataset_wait", "model_wait",
"input_data", "objective_id", "prediction", "model_conf"]
examples = [
['data/iris_unbalanced.csv', '30', '30', '120',
'{"petal width": 4}', '000004', 'Iris-virginica',
'{"boosting": {"iterations": 5}, "number_of_models": 5}'],
['data/grades.csv', '30', '30', '120', '{"Midterm": 20}',
'000005', 61.61036,
'{"boosting": {"iterations": 5}, "number_of_models": 5}']]
show_doc(self.test_scenario6)
for example in examples:
example = dict(zip(headers, example))
show_method(self, sys._getframe().f_code.co_name, example)
source_create.i_upload_a_file(
self, example["data"], shared=example["data"])
source_create.the_source_is_finished(
self, example["source_wait"], shared=example["data"])
dataset_create.i_create_a_dataset(self, shared=example["data"])
dataset_create.the_dataset_is_finished_in_less_than(
self, example["dataset_wait"], shared=example["data"])
ensemble_create.i_create_an_ensemble_with_params(
self, example["model_conf"])
ensemble_create.the_ensemble_is_finished_in_less_than(
self, example["model_wait"])
ensemble_create.create_local_ensemble(self)
prediction_create.i_create_an_ensemble_prediction(
self, example["input_data"])
prediction_create.the_prediction_is(
self, example["objective_id"], example["prediction"])
prediction_compare.i_create_a_local_ensemble_prediction(
self, example["input_data"])
prediction_compare.the_local_prediction_is(
self, example["prediction"])
def test_scenario7(self):
"""
Scenario: Successfully comparing predictions for ensembles with proportional missing strategy:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <source_wait> secs
And I create a dataset
And I wait until the dataset is ready less than <dataset_wait> secs
And I create an esemble with "<params>"
And I wait until the ensemble is ready less than <model_wait> secs
And I create a local ensemble
When I create a proportional missing strategy prediction for "<input_data>" with <"operating">
Then the prediction for "<objective_id>" is "<prediction>"
And the confidence for the prediction is "<confidence>"
And I create a proportional missing strategy local prediction for "<data_input>" with <"operating">
Then the local prediction is "<prediction>"
And the local prediction's confidence is "<confidence>"
"""
headers = ["data", "source_wait", "dataset_wait", "model_wait",
"input_data", "objective_id", "prediction", "confidence",
"model_conf", "operating"]
examples = [
['data/iris.csv', '30', '30', '80', '{}', '000004', 'Iris-virginica', '0.33784', '{"boosting": {"iterations": 5}}', {}],
['data/iris.csv', '30', '30', '80', '{}', '000004', 'Iris-versicolor', '0.27261', '{"number_of_models": 5"}', {"operating_kind": "confidence"}],
['data/grades.csv', '30', '30', '50', '{}', '000005', '70.505792', '30.7161', '{"number_of_models": 5}', {}]]
show_doc(self.test_scenario7)
for example in examples:
example = dict(zip(headers, example))
show_method(self, sys._getframe().f_code.co_name, example)
source_create.i_upload_a_file(
self, example["data"], shared=example["data"])
source_create.the_source_is_finished(
self, example["source_wait"], shared=example["data"])
dataset_create.i_create_a_dataset(self, shared=example["data"])
dataset_create.the_dataset_is_finished_in_less_than(
self, example["dataset_wait"], shared=example["data"])
ensemble_create.i_create_an_ensemble_with_params(
self, example["model_conf"])
ensemble_create.the_ensemble_is_finished_in_less_than(
self, example["model_wait"])
ensemble_create.create_local_ensemble(self)
prediction_create.i_create_an_ensemble_proportional_prediction(
self, example["input_data"])
prediction_create.the_prediction_is(
self, example["objective_id"], example["prediction"])
prediction_create.the_confidence_is(self, example["confidence"])
prediction_create.create_local_ensemble_proportional_prediction_with_confidence(
self, example["input_data"], example["operating"])
prediction_compare.the_local_ensemble_prediction_is(
self, example["prediction"])
prediction_compare.the_local_prediction_confidence_is(
self, example["confidence"])
def test_scenario7b(self):
"""
Scenario: Successfully comparing predictions for ensembles with proportional missing strategy:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <source_wait> secs
And I create a dataset
And I wait until the dataset is ready less than <dataset_wait> secs
And I create an esemble with "<model_conf>"
And I wait until the ensemble is ready less than <model_wait> secs
And I create a local ensemble
When I create a proportional missing strategy prediction for "<input_data>" with <"operating">
Then the prediction for "<objective_id>" is "<prediction>"
And the confidence for the prediction is "<confidence>"
And I create a proportional missing strategy local prediction for "<input_data>" with <"operating">
Then the local prediction is "<prediction>"
And the local prediction's confidence is "<confidence>"
"""
headers = ["data", "source_wait", "dataset_wait", "model_wait",
"input_data", "objective_id", "prediction", "confidence",
"model_conf", "operating"]
examples = [
['data/grades.csv', '30', '30', '80',
'{"Midterm": 20}', '000005', '54.82214', '25.89672',
'{"number_of_models": 5}', {"operating_kind": "confidence"}],
['data/grades.csv', '30', '30', '80', '{"Midterm": 20}',
'000005', '45.4573', '29.58403', '{"number_of_models": 5}', {}],
['data/grades.csv', '30', '30', '80',
'{"Midterm": 20, "Tutorial": 90, "TakeHome": 100}', '000005',
'42.814', '31.51804', '{"number_of_models": 5}', {}]]
show_doc(self.test_scenario7b)
for example in examples:
example = dict(zip(headers, example))
show_method(self, sys._getframe().f_code.co_name, example)
source_create.i_upload_a_file(
self, example["data"], shared=example["data"])
source_create.the_source_is_finished(
self, example["source_wait"], shared=example["data"])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(
self, example["dataset_wait"])
ensemble_create.i_create_an_ensemble_with_params(
self, example["model_conf"])
ensemble_create.the_ensemble_is_finished_in_less_than(
self, example["model_wait"])
ensemble_create.create_local_ensemble(self)
prediction_create.i_create_an_ensemble_proportional_prediction(
self, example["input_data"], example["operating"])
prediction_create.the_prediction_is(
self, example["objective_id"], example["prediction"])
prediction_create.the_confidence_is(self, example["confidence"])
prediction_create.create_local_ensemble_proportional_prediction_with_confidence(
self, example["input_data"], example["operating"])
prediction_compare.the_local_ensemble_prediction_is(
self, example["prediction"])
prediction_compare.the_local_prediction_confidence_is(
self, example["confidence"])
def test_scenario8(self):
"""
Scenario: Successfully comparing predictions for ensembles:
Given I create a local ensemble predictor from "<directory>"
And I create a local prediction for "<input_data>"
Then the local prediction is "<prediction>"
"""
headers = ["directory", "input_data", "prediction"]
examples = [
['bigml/tests/my_ensemble', '{"petal width": 4}', 68.1258030739]]
show_doc(self.test_scenario8)
for example in examples:
example = dict(zip(headers, example))
show_method(self, sys._getframe().f_code.co_name, example)
ensemble_create.create_local_ensemble_predictor(
self, example["directory"])
prediction_compare.i_create_a_local_ensemble_prediction(
self, example["input_data"])
prediction_compare.the_local_ensemble_prediction_is(
self, example["prediction"])
def test_scenario9(self):
"""
Scenario: Successfully comparing predictions for ensembles with proportional missing strategy in a supervised model:
Given I create a data source uploading a "<data>" file
And I wait until the source is ready less than <source_wait> secs
And I create a dataset
And I wait until the dataset is ready less than <dataset_wait> secs
And I create an esemble with "<model_conf>"
And I wait until the ensemble is ready less than <model_wait> secs
And I create a local ensemble
When I create a proportional missing strategy prediction for "<input_data>" with <"operating">
Then the prediction for "<objective_id>" is "<prediction>"
And the confidence for the prediction is "<confidence>"
And I create a proportional missing strategy local prediction for "<input_data>" with <"operating">
Then the local prediction is "<prediction>"
And the local prediction's confidence is "<confidence>"
"""
headers = ["data", "source_wait", "dataset_wait", "model_wait",
"input_data", "objective_id", "prediction", "confidence",
"model_conf", "operating"]
examples = [
['data/iris.csv', '10', '10', '80', '{}', '000004', 'Iris-virginica', '0.33784', '{"boosting": {"iterations": 5}}', {}],
['data/iris.csv', '10', '10', '80', '{}', '000004', 'Iris-versicolor', '0.27261', '{"number_of_models": 5"}', {"operating_kind": "confidence"}]]
show_doc(self.test_scenario9)
for example in examples:
example = dict(zip(headers, example))
show_method(self, sys._getframe().f_code.co_name, example)
source_create.i_upload_a_file(
self, example["data"], shared=example["data"])
source_create.the_source_is_finished(
self, example["source_wait"])
dataset_create.i_create_a_dataset(self)
dataset_create.the_dataset_is_finished_in_less_than(
| |
import logging, requests, json, smtplib, datetime, os, random, sys, subprocess, traceback
from django.utils import timezone
from django.contrib.auth.models import User
from django.core.exceptions import ObjectDoesNotExist
from homeauto.models import Trigger, Nugget, Action, HouseLight, Account, Person, CustomEvent
from hue.models import Sensor, Scene, Light, Group, Schedule
from wemo.models import Device as Wemo
from decora.models import Switch
from vivint.models import Device as VivintDevice
from vivint.models import Panel
import hue.actions as HueAction
import wemo.actions as WemoAction
import decora.actions as DecoraAction
from datetime import timedelta
from django.db.models.signals import pre_save, post_save
from django.dispatch import receiver
logger = logging.getLogger(__name__)
# this is for intercepting databse updates
@receiver(post_save, sender=Person)
def register_person_event(sender, instance, **kwargs):
logger.info("Person:{"+instance.user.username+"} is home {"+str(instance.is_home)+"}")
if instance.is_home:
triggers = Trigger.objects.filter(trigger=(Trigger.PEOPLE), people_has_arrived=True, people=instance)
for t in triggers:
results = []
logger.debug('Evaluating: ' + t.name + " ("+str(t.people.count())+" people)")
if t.enabled:
if t.people.count() > 1:
for person in t.people.all():
# person = Person.objects.get(id=person.id)
if person.is_home:
logger.debug(' TEST (arrive): '+person.user.username + ' is home, matching trigger: '+t.name)
results.append(True)
else:
logger.debug(' TEST (arrive): '+person.user.username + ' is not home, not matching trigger: '+t.name)
results.append(False)
else:
results.append(True)
else:
logger.debug('Trigger:{' + t.name + '}{' + str(t.id) + '}{disabled}')
results.append(False)
logger.debug(" Results: "+str(results))
if all(results):
logger.debug('Trigger:{' + t.name + '}{' + str(t.id) + '}{fired}')
evaluate_nuggets(t.id)
else:
triggers = Trigger.objects.filter(trigger=(Trigger.PEOPLE), people_has_left=True, people=instance)
for t in triggers:
results = []
logger.debug('Evaluating: ' + t.name + " ("+str(t.people.count())+" people)")
if t.enabled:
if t.people.count() > 1:
for person in t.people.all():
# person = Person.objects.get(id=person.id)
if not person.is_home:
logger.debug(' TEST (leave): '+person.user.username + ' is not home, matching trigger: '+t.name)
results.append(True)
else:
logger.debug(' TEST (leave): '+person.user.username + ' is home, NOT matching trigger: '+t.name)
results.append(False)
else:
results.append(True)
else:
logger.debug('Trigger:{' + t.name + '}{' + str(t.id) + '}{disabled}')
results.append(False)
logger.debug(" Results: "+str(results))
if all(results):
logger.debug('Trigger:{' + t.name + '}{' + str(t.id) + '}{fired}')
evaluate_nuggets(t.id)
def register_watcher_event(event):
logger.debug(event)
if event.event_type == 'created':
logger.info('Received created event - %s.' % event.src_path)
with open(event.src_path) as f:
logger.info(subprocess.run(['cat', event.src_path], stdout=subprocess.PIPE))
if not f.readline().rstrip():
logger.error('Input file is empty')
remove_file(event.src_path)
return
with open(event.src_path) as f:
s = f.readline().rstrip().split(':')
if len(s) == 1:
try:
e = CustomEvent.objects.get(name=(s[0].lower()))
except ObjectDoesNotExist as e:
logger.error(e)
logger.error('There are no watcher events defined for: ' + s[0])
except:
logger.error("Error:"+ str(traceback.format_exc()))
else:
try:
t = Trigger.objects.get(trigger=(Trigger.CUSTOM_EVENT), event__name=(e.name))
if t.enabled:
logger.debug('Trigger:{' + t.name + '}{' + str(t.id) + '}{fired}')
eval = True
else:
logger.debug('Trigger:{' + t.name + '}{' + str(t.id) + '}{disabled}')
eval = False
except Exception as e:
try:
logger.error(e)
eval = False
finally:
e = None
del e
if eval:
evaluate_nuggets(t.id)
elif len(s) == 2:
key = s[0].lower()
value = s[1]
logger.info('Found:{' + key + '}{' + value+"}")
if key == 'arrive':
try:
p = Person.objects.get(user__username=value)
logger.debug(p.user.first_name+" was found")
if p:
p.is_home = True
p.save()
else:
logger.error('No person was found with the username: ' + str(value))
except:
logger.error("Unexpected error:"+ str(traceback.format_exc()))
elif key == 'leave':
try:
p = Person.objects.get(user__username=value)
logger.debug(p.user.first_name+" was found")
if p:
p.is_home = False
try:
p.save()
except:
logger.error("Unexpected error:"+ str(traceback.format_exc()))
else:
logger.error('No person was found with the username: ' + str(value))
except:
logger.error("Unexpected error:"+ str(traceback.format_exc()))
else:
logger.error('No action defined for key: ' + str(key))
else:
logger.error(event.src_path + ' contains invalid content: ' + str(s))
remove_file(event.src_path)
else:
logger.info('New event - %s.' % event)
logger.debug("end of register watcher event - %s" % event)
def remove_file(path):
if os.path.isfile(path):
logger.debug('removeing ' + path)
try:
os.remove(path)
except:
logger.error("Unexpected error:"+ str(sys.exc_info()[0]))
def register_motion_event(source, device_id):
if 'Hue' in source:
m = Sensor.objects.get(id=device_id)
elif 'Vivint' in source:
m = VivintDevice.objects.get(id=device_id)
logger.info('Sensor{' + source + '}{' + m.name + '}{' + str(m.id) + '}{' + m.type + '}{Active}')
try:
t = Trigger.objects.get(trigger=(Trigger.MOTION), motion_detector__source_id=device_id)
if t.enabled:
logger.debug('Trigger:{' + t.name + '}{' + str(t.id) + '}{fired}')
eval = True
else:
logger.debug('Trigger:{' + t.name + '}{' + str(t.id) + '}{disabled}')
eval = False
except:
eval = False
if eval:
evaluate_nuggets(t.id)
def register_sensor_event(source, device_id, state):
if 'Hue' in source:
m = Sensor.objects.get(id=device_id)
elif 'Vivint' in source:
m = VivintDevice.objects.get(id=device_id)
logger.info('Sensor{' + source + '}{' + m.name + '}{' + str(m.id) + '}{' + m.type + '}{' + state+'}')
try:
if state == 'Opened':
t = Trigger.objects.get(trigger=(Trigger.SENSOR_OPENED), sensor__source_id=device_id)
elif state == 'Closed':
t = Trigger.objects.get(trigger=(Trigger.SENSOR_CLOSED), sensor__source_id=device_id)
elif state == 'Locked':
t = Trigger.objects.get(trigger=(Trigger.LOCK_LOCKED), lock__source_id=device_id)
elif state == 'Unlocked':
t = Trigger.objects.get(trigger=(Trigger.LOCK_UNLOCKED), lock__source_id=device_id)
else:
logger.error('Sensor has an unknown state of ' + state)
if t.enabled:
logger.debug('Trigger:{' + t.name + '}{' + str(t.id) + '}{fired}')
eval = True
else:
logger.debug('Trigger:{' + t.name + '}{' + str(t.id) + '}{disabled}')
eval = False
except:
eval = False
if eval:
evaluate_nuggets(t.id)
def check_security_trigger(t):
if t.enabled:
if t.security_armed_to:
logger.debug("Looking for triggers with security_armed_to flagged")
if trigger.people__user__first_name == who[0]:
logger.debug('Trigger:{' + t.name + '}{' + str(t.id) + '}{fired}')
evaluate_nuggets(t.id)
if t.security_changed_to:
logger.debug("Looking for triggers with security_changed_to flagged")
logger.debug('Trigger:{' + t.name + '}{' + str(t.id) + '}{fired}')
evaluate_nuggets(t.id)
else:
logger.debug('Trigger:{' + t.name + '}{' + str(t.id) + '}{disabled}')
def register_security_event(the_who, state):
try:
who = the_who.split()
username = User.objects.get(first_name=(who[0]), last_name=(who[1])).username
logger.info('Security{Vivint}{' + username + '} set house to {' + state+'}')
except:
logger.info('Security{Vivint}{' + the_who + '} set house to {' + state+']')
finally:
who = the_who.split()
try:
triggers = Trigger.objects.filter(trigger=(Trigger.SECURITY_ARMED_STATE), security_armed_state=state)
except:
logger.error(sys.exc_info()[0])
else:
logger.debug('found '+str(triggers.count())+' tiggers with '+state)
if triggers.count() > 1:
for trigger in triggers:
check_security_trigger(trigger)
else:
check_security_trigger(triggers.first())
def register_hvac_event(who, what, oldValue, newValue):
try:
v = float(oldValue)
logger.info('HvacValue:{' + who + '}{' + what + '}{' + str(oldValue) + '}{' + str(newValue)+"}")
except:
logger.info('HvacStatus:{' + who + '}{' + what + '}{' + str(oldValue) + '}{' + str(newValue)+"}")
def register_time_event(t):
if t.enabled:
logger.debug('Trigger:{' + t.name + '}{' + str(t.id) + '}{fired}')
evaluate_nuggets(t.id)
else:
logger.debug('Trigger:{' + t.name + '}{' + str(t.id) + '}{disabled}')
def is_anyone_home():
p = Person.objects.all()
for person in p:
if person.is_home:
return True
logger.debug('no one is home')
return False
def is_nugget_runable(nug):
if nug.enabled:
if not nug.only_execute_if_someone_is_home:
return True
if is_anyone_home():
return True
else:
logger.debug(nug.name + ' is disabled')
return False
def evaluate_nuggets(t_id):
nugs = Nugget.objects.filter(triggers=t_id)
for nug in nugs:
if is_nugget_runable(nug):
triggers = nug.triggers.all()
results = []
logger.debug('Evaluating: ' + nug.name + " ("+str(len(triggers))+" triggers)")
for t in triggers:
if t.id == t_id:
logger.debug(' TEST: ' + t.name + ' ' + str(t.id) + ' True')
results.append(True)
else:
if t.trigger == t.MOTION:
if t.motion_detector.source == 0:
try:
state = VivintDevice.objects.get(id=(t.motion_detector.source_id)).state
except ObjectDoesNotExist as e:
logger.error(e)
except:
logger.error("Error:"+ str(traceback.format_exc()))
else:
if state == 'Open':
state = True
elif state == 'Closed':
state = False
else:
state = False
results.append(state)
logger.debug(' TEST: ' + nug.name + ':Vivint:' + t.motion_detector.name + ' state ' + str(state))
elif t.motion_detector.source == 1:
try:
state = Sensor.objects.get(id=(t.motion_detector.source_id)).presence
except ObjectDoesNotExist as e:
logger.error(e)
except:
logger.error("Error:"+ str(traceback.format_exc()))
else:
logger.debug(' TEST: ' + nug.name + ':Hue:' + t.motion_detector.name + ' state ' + str(state))
results.append(state)
else:
logger.warning('There is no motion state lookup for source ' + str(t.motion_detector_id__source))
results.append(False)
elif t.trigger == t.WINDOW:
if t.window_start <= timezone.localtime().time() <= t.window_end:
logger.debug(" TEST: "+t.name + ' timeframe state True')
results.append(True)
else:
logger.debug(" TEST: "+t.name + ' timeframe state False')
results.append(False)
elif t.trigger == t.SCHEDULE:
logger.error('code has not been written for SCHEDULE trigger')
results.append(False)
elif t.trigger == t.SENSOR_OPENED:
logger.error('code has not been written for SENSOR_OPENED trigger')
results.append(False)
elif t.trigger == t.SENSOR_CLOSED:
logger.error('code has not been written for SENSOR_CLOSED trigger')
results.append(False)
elif t.trigger == t.LOCK_UNLOCKED:
logger.error('code has not been written for LOCK_UNLOCKED trigger')
results.append(False)
elif t.trigger == t.LOCK_LOCKED:
logger.error('code has not been written for LOCK_LOCKED trigger')
results.append(False)
elif t.trigger == t.HVAC_ACTIVITY:
logger.error('code has not been written for HVAC_ACTIVITY trigger')
results.append(False)
elif t.trigger == t.HVAC_FAN:
logger.error('code has not been written for HVAC_FAN trigger')
results.append(False)
elif t.trigger == t.HVAC_HITS_TEMP:
logger.error('code has not been written for HVAC_HITS_TEMP trigger')
results.append(False)
elif t.trigger == t.HVAC_HOLD:
logger.error('code has not been written for HVAC_HOLD trigger')
results.append(False)
elif t.trigger == t.HVAC_HEATMODE:
logger.error('code has not been written for HVAC_HEATMODE trigger')
results.append(False)
elif t.trigger == t.HVAC_FILTRLVL:
logger.error('code has not been written for HVAC_FILTRLVL trigger')
results.append(False)
elif t.trigger == t.HVAC_HUMLVL:
logger.error('code has not been written for HVAC_HUMLVL trigger')
results.append(False)
elif t.trigger == t.CUSTOM_EVENT:
logger.error('code has not been written for CUSTOM_EVENT trigger')
results.append(False)
elif t.trigger == t.SECURITY_ARMED_STATE:
try:
state = Panel.objects.get(id=(t.security_panel.id)).armed_state
except ObjectDoesNotExist as e:
logger.error(e)
except:
logger.error("Error:"+ | |
None:
stream_retval = RewriteRuleSubtreeStream(self._adaptor, "rule retval", retval.tree)
else:
stream_retval = RewriteRuleSubtreeStream(self._adaptor, "token retval", None)
root_0 = self._adaptor.nil()
# 218:36: -> set_func
self._adaptor.addChild(root_0, stream_set_func.nextTree())
retval.tree = root_0
retval.stop = self.input.LT(-1)
retval.tree = self._adaptor.rulePostProcessing(root_0)
self._adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop)
except RecognitionException as re:
self.reportError(re)
self.recover(self.input, re)
retval.tree = self._adaptor.errorNode(self.input, retval.start, self.input.LT(-1), re)
finally:
pass
return retval
# $ANTLR end "set_block"
class set_func_return(ParserRuleReturnScope):
def __init__(self):
super().__init__()
self.tree = None
# $ANTLR start "set_func"
# /home/tux/PycharmProjects/ProtoGen_public/Parser/ProtoCC.g:219:5: set_func : ID DOT set_function_types OBRACE ( set_nest )* CBRACE -> ^( SETFUNC_ ID DOT set_function_types OBRACE ( set_nest )* CBRACE ) ;
def set_func(self, ):
retval = self.set_func_return()
retval.start = self.input.LT(1)
root_0 = None
ID134 = None
DOT135 = None
OBRACE137 = None
CBRACE139 = None
set_function_types136 = None
set_nest138 = None
ID134_tree = None
DOT135_tree = None
OBRACE137_tree = None
CBRACE139_tree = None
stream_OBRACE = RewriteRuleTokenStream(self._adaptor, "token OBRACE")
stream_DOT = RewriteRuleTokenStream(self._adaptor, "token DOT")
stream_ID = RewriteRuleTokenStream(self._adaptor, "token ID")
stream_CBRACE = RewriteRuleTokenStream(self._adaptor, "token CBRACE")
stream_set_function_types = RewriteRuleSubtreeStream(self._adaptor, "rule set_function_types")
stream_set_nest = RewriteRuleSubtreeStream(self._adaptor, "rule set_nest")
try:
try:
# /home/tux/PycharmProjects/ProtoGen_public/Parser/ProtoCC.g:219:14: ( ID DOT set_function_types OBRACE ( set_nest )* CBRACE -> ^( SETFUNC_ ID DOT set_function_types OBRACE ( set_nest )* CBRACE ) )
# /home/tux/PycharmProjects/ProtoGen_public/Parser/ProtoCC.g:219:16: ID DOT set_function_types OBRACE ( set_nest )* CBRACE
pass
ID134 = self.match(self.input, ID, self.FOLLOW_ID_in_set_func1829)
stream_ID.add(ID134)
DOT135 = self.match(self.input, DOT, self.FOLLOW_DOT_in_set_func1831)
stream_DOT.add(DOT135)
self._state.following.append(self.FOLLOW_set_function_types_in_set_func1833)
set_function_types136 = self.set_function_types()
self._state.following.pop()
stream_set_function_types.add(set_function_types136.tree)
OBRACE137 = self.match(self.input, OBRACE, self.FOLLOW_OBRACE_in_set_func1835)
stream_OBRACE.add(OBRACE137)
# /home/tux/PycharmProjects/ProtoGen_public/Parser/ProtoCC.g:219:49: ( set_nest )*
while True: #loop21
alt21 = 2
LA21_0 = self.input.LA(1)
if (LA21_0 == ID) :
alt21 = 1
if alt21 == 1:
# /home/tux/PycharmProjects/ProtoGen_public/Parser/ProtoCC.g:219:49: set_nest
pass
self._state.following.append(self.FOLLOW_set_nest_in_set_func1837)
set_nest138 = self.set_nest()
self._state.following.pop()
stream_set_nest.add(set_nest138.tree)
else:
break #loop21
CBRACE139 = self.match(self.input, CBRACE, self.FOLLOW_CBRACE_in_set_func1840)
stream_CBRACE.add(CBRACE139)
# AST Rewrite
# elements: ID, DOT, set_function_types, OBRACE, set_nest, CBRACE
# token labels:
# rule labels: retval
# token list labels:
# rule list labels:
# wildcard labels:
retval.tree = root_0
if retval is not None:
stream_retval = RewriteRuleSubtreeStream(self._adaptor, "rule retval", retval.tree)
else:
stream_retval = RewriteRuleSubtreeStream(self._adaptor, "token retval", None)
root_0 = self._adaptor.nil()
# 219:66: -> ^( SETFUNC_ ID DOT set_function_types OBRACE ( set_nest )* CBRACE )
# /home/tux/PycharmProjects/ProtoGen_public/Parser/ProtoCC.g:220:9: ^( SETFUNC_ ID DOT set_function_types OBRACE ( set_nest )* CBRACE )
root_1 = self._adaptor.nil()
root_1 = self._adaptor.becomeRoot(
self._adaptor.createFromType(SETFUNC_, "SETFUNC_")
, root_1)
self._adaptor.addChild(root_1,
stream_ID.nextNode()
)
self._adaptor.addChild(root_1,
stream_DOT.nextNode()
)
self._adaptor.addChild(root_1, stream_set_function_types.nextTree())
self._adaptor.addChild(root_1,
stream_OBRACE.nextNode()
)
# /home/tux/PycharmProjects/ProtoGen_public/Parser/ProtoCC.g:220:53: ( set_nest )*
while stream_set_nest.hasNext():
self._adaptor.addChild(root_1, stream_set_nest.nextTree())
stream_set_nest.reset();
self._adaptor.addChild(root_1,
stream_CBRACE.nextNode()
)
self._adaptor.addChild(root_0, root_1)
retval.tree = root_0
retval.stop = self.input.LT(-1)
retval.tree = self._adaptor.rulePostProcessing(root_0)
self._adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop)
except RecognitionException as re:
self.reportError(re)
self.recover(self.input, re)
retval.tree = self._adaptor.errorNode(self.input, retval.start, self.input.LT(-1), re)
finally:
pass
return retval
# $ANTLR end "set_func"
class set_nest_return(ParserRuleReturnScope):
def __init__(self):
super().__init__()
self.tree = None
# $ANTLR start "set_nest"
# /home/tux/PycharmProjects/ProtoGen_public/Parser/ProtoCC.g:221:5: set_nest : ( set_func | object_expr );
def set_nest(self, ):
retval = self.set_nest_return()
retval.start = self.input.LT(1)
root_0 = None
set_func140 = None
object_expr141 = None
try:
try:
# /home/tux/PycharmProjects/ProtoGen_public/Parser/ProtoCC.g:221:14: ( set_func | object_expr )
alt22 = 2
LA22_0 = self.input.LA(1)
if (LA22_0 == ID) :
LA22_1 = self.input.LA(2)
if (LA22_1 == DOT) :
LA22_2 = self.input.LA(3)
if ((96 <= LA22_2 <= 100) or LA22_2 in {}) :
alt22 = 1
elif (LA22_2 in {ID, NID}) :
alt22 = 2
else:
nvae = NoViableAltException("", 22, 2, self.input)
raise nvae
elif (LA22_1 in {CBRACE, ID}) :
alt22 = 2
else:
nvae = NoViableAltException("", 22, 1, self.input)
raise nvae
else:
nvae = NoViableAltException("", 22, 0, self.input)
raise nvae
if alt22 == 1:
# /home/tux/PycharmProjects/ProtoGen_public/Parser/ProtoCC.g:221:16: set_func
pass
root_0 = self._adaptor.nil()
self._state.following.append(self.FOLLOW_set_func_in_set_nest1878)
set_func140 = self.set_func()
self._state.following.pop()
self._adaptor.addChild(root_0, set_func140.tree)
elif alt22 == 2:
# /home/tux/PycharmProjects/ProtoGen_public/Parser/ProtoCC.g:221:27: object_expr
pass
root_0 = self._adaptor.nil()
self._state.following.append(self.FOLLOW_object_expr_in_set_nest1882)
object_expr141 = self.object_expr()
self._state.following.pop()
self._adaptor.addChild(root_0, object_expr141.tree)
retval.stop = self.input.LT(-1)
retval.tree = self._adaptor.rulePostProcessing(root_0)
self._adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop)
except RecognitionException as re:
self.reportError(re)
self.recover(self.input, re)
retval.tree = self._adaptor.errorNode(self.input, retval.start, self.input.LT(-1), re)
finally:
pass
return retval
# $ANTLR end "set_nest"
class arch_block_return(ParserRuleReturnScope):
def __init__(self):
super().__init__()
self.tree = None
# $ANTLR start "arch_block"
# /home/tux/PycharmProjects/ProtoGen_public/Parser/ProtoCC.g:224:1: arch_block : ARCH ID OCBRACE arch_body CCBRACE -> ^( ARCH_ ^( MACHN_ ID ) arch_body ) ;
def arch_block(self, ):
retval = self.arch_block_return()
retval.start = self.input.LT(1)
root_0 = None
ARCH142 = None
ID143 = None
OCBRACE144 = None
CCBRACE146 = None
arch_body145 = None
ARCH142_tree = None
ID143_tree = None
OCBRACE144_tree = None
CCBRACE146_tree = None
stream_OCBRACE = RewriteRuleTokenStream(self._adaptor, "token OCBRACE")
stream_ARCH = RewriteRuleTokenStream(self._adaptor, "token ARCH")
stream_ID = RewriteRuleTokenStream(self._adaptor, "token ID")
stream_CCBRACE = RewriteRuleTokenStream(self._adaptor, "token CCBRACE")
stream_arch_body = RewriteRuleSubtreeStream(self._adaptor, "rule arch_body")
try:
try:
# /home/tux/PycharmProjects/ProtoGen_public/Parser/ProtoCC.g:224:12: ( ARCH ID OCBRACE arch_body CCBRACE -> ^( ARCH_ ^( MACHN_ ID ) arch_body ) )
# /home/tux/PycharmProjects/ProtoGen_public/Parser/ProtoCC.g:224:14: ARCH ID OCBRACE arch_body CCBRACE
pass
ARCH142 = self.match(self.input, ARCH, self.FOLLOW_ARCH_in_arch_block1892)
stream_ARCH.add(ARCH142)
ID143 = self.match(self.input, ID, self.FOLLOW_ID_in_arch_block1894)
stream_ID.add(ID143)
OCBRACE144 = self.match(self.input, OCBRACE, self.FOLLOW_OCBRACE_in_arch_block1896)
stream_OCBRACE.add(OCBRACE144)
self._state.following.append(self.FOLLOW_arch_body_in_arch_block1898)
arch_body145 = self.arch_body()
self._state.following.pop()
stream_arch_body.add(arch_body145.tree)
CCBRACE146 = self.match(self.input, CCBRACE, self.FOLLOW_CCBRACE_in_arch_block1900)
stream_CCBRACE.add(CCBRACE146)
# AST Rewrite
# elements: ID, arch_body
# token labels:
# rule labels: retval
# token list labels:
# rule list labels:
# wildcard labels:
retval.tree = root_0
if retval is not None:
stream_retval = RewriteRuleSubtreeStream(self._adaptor, "rule retval", retval.tree)
else:
stream_retval = RewriteRuleSubtreeStream(self._adaptor, "token retval", None)
root_0 = self._adaptor.nil()
# 224:48: -> ^( ARCH_ ^( MACHN_ ID ) arch_body )
# /home/tux/PycharmProjects/ProtoGen_public/Parser/ProtoCC.g:224:51: ^( ARCH_ ^( MACHN_ ID ) arch_body )
root_1 = self._adaptor.nil()
root_1 = self._adaptor.becomeRoot(
self._adaptor.createFromType(ARCH_, "ARCH_")
, root_1)
# /home/tux/PycharmProjects/ProtoGen_public/Parser/ProtoCC.g:224:59: ^( MACHN_ ID )
root_2 = self._adaptor.nil()
root_2 = self._adaptor.becomeRoot(
self._adaptor.createFromType(MACHN_, "MACHN_")
, root_2)
self._adaptor.addChild(root_2,
stream_ID.nextNode()
)
self._adaptor.addChild(root_1, root_2)
self._adaptor.addChild(root_1, stream_arch_body.nextTree())
self._adaptor.addChild(root_0, root_1)
retval.tree = root_0
retval.stop = self.input.LT(-1)
retval.tree = self._adaptor.rulePostProcessing(root_0)
self._adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop)
except RecognitionException as re:
self.reportError(re)
self.recover(self.input, re)
retval.tree = self._adaptor.errorNode(self.input, retval.start, self.input.LT(-1), re)
finally:
pass
return retval
# $ANTLR end "arch_block"
class arch_body_return(ParserRuleReturnScope):
def __init__(self):
super().__init__()
self.tree = None
# $ANTLR start "arch_body"
# /home/tux/PycharmProjects/ProtoGen_public/Parser/ProtoCC.g:226:1: arch_body : ( stable_def | process_block )* ;
def arch_body(self, ):
retval = self.arch_body_return()
retval.start = self.input.LT(1)
root_0 = None
stable_def147 = None
process_block148 = None
try:
try:
# /home/tux/PycharmProjects/ProtoGen_public/Parser/ProtoCC.g:226:10: ( ( stable_def | process_block )* )
# /home/tux/PycharmProjects/ProtoGen_public/Parser/ProtoCC.g:226:12: ( stable_def | process_block )*
pass
root_0 = self._adaptor.nil()
# /home/tux/PycharmProjects/ProtoGen_public/Parser/ProtoCC.g:226:12: ( stable_def | process_block )*
while True: #loop23
alt23 = 3
LA23_0 = self.input.LA(1)
if (LA23_0 == STABLE) :
alt23 = 1
elif (LA23_0 == PROC) :
alt23 = 2
if alt23 == 1:
# /home/tux/PycharmProjects/ProtoGen_public/Parser/ProtoCC.g:226:13: stable_def
pass
self._state.following.append(self.FOLLOW_stable_def_in_arch_body1922)
stable_def147 = self.stable_def()
self._state.following.pop()
self._adaptor.addChild(root_0, stable_def147.tree)
elif alt23 == 2:
# /home/tux/PycharmProjects/ProtoGen_public/Parser/ProtoCC.g:226:26: process_block
pass
self._state.following.append(self.FOLLOW_process_block_in_arch_body1926)
process_block148 = self.process_block()
self._state.following.pop()
self._adaptor.addChild(root_0, process_block148.tree)
else:
break #loop23
retval.stop = self.input.LT(-1)
retval.tree = self._adaptor.rulePostProcessing(root_0)
self._adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop)
except RecognitionException as re:
self.reportError(re)
self.recover(self.input, re)
retval.tree = self._adaptor.errorNode(self.input, retval.start, self.input.LT(-1), re)
finally:
pass
return retval
# $ANTLR end "arch_body"
class stable_def_return(ParserRuleReturnScope):
def __init__(self):
super().__init__()
self.tree = None
# $ANTLR start "stable_def"
# /home/tux/PycharmProjects/ProtoGen_public/Parser/ProtoCC.g:228:1: stable_def : STABLE OCBRACE ID ( COMMA ID )* CCBRACE -> ^( STABLE_ ID ( ID )* ) ;
def stable_def(self, ):
retval = self.stable_def_return()
retval.start = self.input.LT(1)
root_0 = None
STABLE149 = None
OCBRACE150 = None
ID151 = None
COMMA152 = None
ID153 = None
CCBRACE154 = None
STABLE149_tree = None
OCBRACE150_tree = None
ID151_tree = None
COMMA152_tree = None
ID153_tree = None
CCBRACE154_tree = None
stream_COMMA = RewriteRuleTokenStream(self._adaptor, "token COMMA")
stream_OCBRACE = RewriteRuleTokenStream(self._adaptor, "token OCBRACE")
stream_STABLE = RewriteRuleTokenStream(self._adaptor, "token STABLE")
stream_ID = RewriteRuleTokenStream(self._adaptor, "token ID")
stream_CCBRACE = RewriteRuleTokenStream(self._adaptor, "token CCBRACE")
try:
try:
# /home/tux/PycharmProjects/ProtoGen_public/Parser/ProtoCC.g:228:12: ( STABLE OCBRACE ID ( COMMA ID )* CCBRACE -> ^( STABLE_ ID ( ID )* ) )
# /home/tux/PycharmProjects/ProtoGen_public/Parser/ProtoCC.g:228:14: STABLE OCBRACE ID ( COMMA ID )* CCBRACE
pass
STABLE149 = self.match(self.input, STABLE, self.FOLLOW_STABLE_in_stable_def1936)
stream_STABLE.add(STABLE149)
OCBRACE150 = self.match(self.input, OCBRACE, self.FOLLOW_OCBRACE_in_stable_def1938)
stream_OCBRACE.add(OCBRACE150)
ID151 = self.match(self.input, ID, self.FOLLOW_ID_in_stable_def1940)
stream_ID.add(ID151)
# /home/tux/PycharmProjects/ProtoGen_public/Parser/ProtoCC.g:228:32: ( COMMA ID )*
while True: #loop24
alt24 = 2
LA24_0 = self.input.LA(1)
if (LA24_0 == COMMA) :
alt24 = 1
if alt24 == 1:
| |
'Renaming Unit/Int Front End RAT/Subthreshold Leakage with power gating': 0.00248228,
'Renaming Unit/Peak Dynamic': 3.58947,
'Renaming Unit/Runtime Dynamic': 0.337767,
'Renaming Unit/Subthreshold Leakage': 0.0552466,
'Renaming Unit/Subthreshold Leakage with power gating': 0.0276461,
'Runtime Dynamic': 2.80515,
'Subthreshold Leakage': 6.16288,
'Subthreshold Leakage with power gating': 2.55328},
{'Area': 32.0201,
'Execution Unit/Area': 7.68434,
'Execution Unit/Complex ALUs/Area': 0.235435,
'Execution Unit/Complex ALUs/Gate Leakage': 0.0132646,
'Execution Unit/Complex ALUs/Peak Dynamic': 5.19579e-05,
'Execution Unit/Complex ALUs/Runtime Dynamic': 0.20273,
'Execution Unit/Complex ALUs/Subthreshold Leakage': 0.20111,
'Execution Unit/Complex ALUs/Subthreshold Leakage with power gating': 0.0754163,
'Execution Unit/Floating Point Units/Area': 4.6585,
'Execution Unit/Floating Point Units/Gate Leakage': 0.0656156,
'Execution Unit/Floating Point Units/Peak Dynamic': 0.00072612,
'Execution Unit/Floating Point Units/Runtime Dynamic': 0.304033,
'Execution Unit/Floating Point Units/Subthreshold Leakage': 0.994829,
'Execution Unit/Floating Point Units/Subthreshold Leakage with power gating': 0.373061,
'Execution Unit/Gate Leakage': 0.120359,
'Execution Unit/Instruction Scheduler/Area': 1.66526,
'Execution Unit/Instruction Scheduler/FP Instruction Window/Area': 0.275653,
'Execution Unit/Instruction Scheduler/FP Instruction Window/Gate Leakage': 0.000977433,
'Execution Unit/Instruction Scheduler/FP Instruction Window/Peak Dynamic': 1.04181,
'Execution Unit/Instruction Scheduler/FP Instruction Window/Runtime Dynamic': 0.0580421,
'Execution Unit/Instruction Scheduler/FP Instruction Window/Subthreshold Leakage': 0.0143453,
'Execution Unit/Instruction Scheduler/FP Instruction Window/Subthreshold Leakage with power gating': 0.00810519,
'Execution Unit/Instruction Scheduler/Gate Leakage': 0.00568913,
'Execution Unit/Instruction Scheduler/Instruction Window/Area': 0.805223,
'Execution Unit/Instruction Scheduler/Instruction Window/Gate Leakage': 0.00414562,
'Execution Unit/Instruction Scheduler/Instruction Window/Peak Dynamic': 1.6763,
'Execution Unit/Instruction Scheduler/Instruction Window/Runtime Dynamic': 0.0936197,
'Execution Unit/Instruction Scheduler/Instruction Window/Subthreshold Leakage': 0.0625755,
'Execution Unit/Instruction Scheduler/Instruction Window/Subthreshold Leakage with power gating': 0.0355964,
'Execution Unit/Instruction Scheduler/Peak Dynamic': 3.82262,
'Execution Unit/Instruction Scheduler/ROB/Area': 0.584388,
'Execution Unit/Instruction Scheduler/ROB/Gate Leakage': 0.00056608,
'Execution Unit/Instruction Scheduler/ROB/Peak Dynamic': 1.10451,
'Execution Unit/Instruction Scheduler/ROB/Runtime Dynamic': 0.0472561,
'Execution Unit/Instruction Scheduler/ROB/Subthreshold Leakage': 0.00906853,
'Execution Unit/Instruction Scheduler/ROB/Subthreshold Leakage with power gating': 0.00364446,
'Execution Unit/Instruction Scheduler/Runtime Dynamic': 0.198918,
'Execution Unit/Instruction Scheduler/Subthreshold Leakage': 0.0859892,
'Execution Unit/Instruction Scheduler/Subthreshold Leakage with power gating': 0.047346,
'Execution Unit/Integer ALUs/Area': 0.47087,
'Execution Unit/Integer ALUs/Gate Leakage': 0.0265291,
'Execution Unit/Integer ALUs/Peak Dynamic': 0.0662712,
'Execution Unit/Integer ALUs/Runtime Dynamic': 0.101344,
'Execution Unit/Integer ALUs/Subthreshold Leakage': 0.40222,
'Execution Unit/Integer ALUs/Subthreshold Leakage with power gating': 0.150833,
'Execution Unit/Peak Dynamic': 3.95341,
'Execution Unit/Register Files/Area': 0.570804,
'Execution Unit/Register Files/Floating Point RF/Area': 0.208131,
'Execution Unit/Register Files/Floating Point RF/Gate Leakage': 0.000232788,
'Execution Unit/Register Files/Floating Point RF/Peak Dynamic': 0.00013718,
'Execution Unit/Register Files/Floating Point RF/Runtime Dynamic': 0.00243454,
'Execution Unit/Register Files/Floating Point RF/Subthreshold Leakage': 0.00399698,
'Execution Unit/Register Files/Floating Point RF/Subthreshold Leakage with power gating': 0.00176968,
'Execution Unit/Register Files/Gate Leakage': 0.000622708,
'Execution Unit/Register Files/Integer RF/Area': 0.362673,
'Execution Unit/Register Files/Integer RF/Gate Leakage': 0.00038992,
'Execution Unit/Register Files/Integer RF/Peak Dynamic': 0.017606,
'Execution Unit/Register Files/Integer RF/Runtime Dynamic': 0.0180049,
'Execution Unit/Register Files/Integer RF/Subthreshold Leakage': 0.00614175,
'Execution Unit/Register Files/Integer RF/Subthreshold Leakage with power gating': 0.00246675,
'Execution Unit/Register Files/Peak Dynamic': 0.0177432,
'Execution Unit/Register Files/Runtime Dynamic': 0.0204395,
'Execution Unit/Register Files/Subthreshold Leakage': 0.0101387,
'Execution Unit/Register Files/Subthreshold Leakage with power gating': 0.00423643,
'Execution Unit/Results Broadcast Bus/Area Overhead': 0.0390912,
'Execution Unit/Results Broadcast Bus/Gate Leakage': 0.00537402,
'Execution Unit/Results Broadcast Bus/Peak Dynamic': 0.0371038,
'Execution Unit/Results Broadcast Bus/Runtime Dynamic': 0.0973803,
'Execution Unit/Results Broadcast Bus/Subthreshold Leakage': 0.081478,
'Execution Unit/Results Broadcast Bus/Subthreshold Leakage with power gating': 0.0305543,
'Execution Unit/Runtime Dynamic': 0.924844,
'Execution Unit/Subthreshold Leakage': 1.79543,
'Execution Unit/Subthreshold Leakage with power gating': 0.688821,
'Gate Leakage': 0.368936,
'Instruction Fetch Unit/Area': 5.85939,
'Instruction Fetch Unit/Branch Predictor/Area': 0.138516,
'Instruction Fetch Unit/Branch Predictor/Chooser/Area': 0.0435221,
'Instruction Fetch Unit/Branch Predictor/Chooser/Gate Leakage': 0.000278362,
'Instruction Fetch Unit/Branch Predictor/Chooser/Peak Dynamic': 0.0168831,
'Instruction Fetch Unit/Branch Predictor/Chooser/Runtime Dynamic': 0.000845929,
'Instruction Fetch Unit/Branch Predictor/Chooser/Subthreshold Leakage': 0.00759719,
'Instruction Fetch Unit/Branch Predictor/Chooser/Subthreshold Leakage with power gating': 0.0039236,
'Instruction Fetch Unit/Branch Predictor/Gate Leakage': 0.000757657,
'Instruction Fetch Unit/Branch Predictor/Global Predictor/Area': 0.0435221,
'Instruction Fetch Unit/Branch Predictor/Global Predictor/Gate Leakage': 0.000278362,
'Instruction Fetch Unit/Branch Predictor/Global Predictor/Peak Dynamic': 0.0168831,
'Instruction Fetch Unit/Branch Predictor/Global Predictor/Runtime Dynamic': 0.000845929,
'Instruction Fetch Unit/Branch Predictor/Global Predictor/Subthreshold Leakage': 0.00759719,
'Instruction Fetch Unit/Branch Predictor/Global Predictor/Subthreshold Leakage with power gating': 0.0039236,
'Instruction Fetch Unit/Branch Predictor/L1_Local Predictor/Area': 0.0257064,
'Instruction Fetch Unit/Branch Predictor/L1_Local Predictor/Gate Leakage': 0.000154548,
'Instruction Fetch Unit/Branch Predictor/L1_Local Predictor/Peak Dynamic': 0.0142575,
'Instruction Fetch Unit/Branch Predictor/L1_Local Predictor/Runtime Dynamic': 0.0007604,
'Instruction Fetch Unit/Branch Predictor/L1_Local Predictor/Subthreshold Leakage': 0.00384344,
'Instruction Fetch Unit/Branch Predictor/L1_Local Predictor/Subthreshold Leakage with power gating': 0.00198631,
'Instruction Fetch Unit/Branch Predictor/L2_Local Predictor/Area': 0.0151917,
'Instruction Fetch Unit/Branch Predictor/L2_Local Predictor/Gate Leakage': 8.00196e-05,
'Instruction Fetch Unit/Branch Predictor/L2_Local Predictor/Peak Dynamic': 0.00527447,
'Instruction Fetch Unit/Branch Predictor/L2_Local Predictor/Runtime Dynamic': 0.000307269,
'Instruction Fetch Unit/Branch Predictor/L2_Local Predictor/Subthreshold Leakage': 0.00181347,
'Instruction Fetch Unit/Branch Predictor/L2_Local Predictor/Subthreshold Leakage with power gating': 0.000957045,
'Instruction Fetch Unit/Branch Predictor/Peak Dynamic': 0.0597838,
'Instruction Fetch Unit/Branch Predictor/RAS/Area': 0.0105732,
'Instruction Fetch Unit/Branch Predictor/RAS/Gate Leakage': 4.63858e-05,
'Instruction Fetch Unit/Branch Predictor/RAS/Peak Dynamic': 0.0117602,
'Instruction Fetch Unit/Branch Predictor/RAS/Runtime Dynamic': 0.000258642,
'Instruction Fetch Unit/Branch Predictor/RAS/Subthreshold Leakage': 0.000932505,
'Instruction Fetch Unit/Branch Predictor/RAS/Subthreshold Leakage with power gating': 0.000494733,
'Instruction Fetch Unit/Branch Predictor/Runtime Dynamic': 0.0027109,
'Instruction Fetch Unit/Branch Predictor/Subthreshold Leakage': 0.0199703,
'Instruction Fetch Unit/Branch Predictor/Subthreshold Leakage with power gating': 0.0103282,
'Instruction Fetch Unit/Branch Target Buffer/Area': 0.64954,
'Instruction Fetch Unit/Branch Target Buffer/Gate Leakage': 0.00272758,
'Instruction Fetch Unit/Branch Target Buffer/Peak Dynamic': 0.177867,
'Instruction Fetch Unit/Branch Target Buffer/Runtime Dynamic': 0.0072676,
'Instruction Fetch Unit/Branch Target Buffer/Subthreshold Leakage': 0.0811682,
'Instruction Fetch Unit/Branch Target Buffer/Subthreshold Leakage with power gating': 0.0435357,
'Instruction Fetch Unit/Gate Leakage': 0.0589979,
'Instruction Fetch Unit/Instruction Buffer/Area': 0.0226323,
'Instruction Fetch Unit/Instruction Buffer/Gate Leakage': 6.83558e-05,
'Instruction Fetch Unit/Instruction Buffer/Peak Dynamic': 0.606827,
'Instruction Fetch Unit/Instruction Buffer/Runtime Dynamic': 0.0173086,
'Instruction Fetch Unit/Instruction Buffer/Subthreshold Leakage': 0.00151885,
'Instruction Fetch Unit/Instruction Buffer/Subthreshold Leakage with power gating': 0.000701682,
'Instruction Fetch Unit/Instruction Cache/Area': 3.14635,
'Instruction Fetch Unit/Instruction Cache/Gate Leakage': 0.029931,
'Instruction Fetch Unit/Instruction Cache/Peak Dynamic': 1.10098,
'Instruction Fetch Unit/Instruction Cache/Runtime Dynamic': 0.0680732,
'Instruction Fetch Unit/Instruction Cache/Subthreshold Leakage': 0.367022,
'Instruction Fetch Unit/Instruction Cache/Subthreshold Leakage with power gating': 0.180386,
'Instruction Fetch Unit/Instruction Decoder/Area': 1.85799,
'Instruction Fetch Unit/Instruction Decoder/Gate Leakage': 0.0222493,
'Instruction Fetch Unit/Instruction Decoder/Peak Dynamic': 1.37404,
'Instruction Fetch Unit/Instruction Decoder/Runtime Dynamic': 0.0587878,
'Instruction Fetch Unit/Instruction Decoder/Subthreshold Leakage': 0.442943,
'Instruction Fetch Unit/Instruction Decoder/Subthreshold Leakage with power gating': 0.166104,
'Instruction Fetch Unit/Peak Dynamic': 3.37292,
'Instruction Fetch Unit/Runtime Dynamic': 0.154148,
'Instruction Fetch Unit/Subthreshold Leakage': 0.932286,
'Instruction Fetch Unit/Subthreshold Leakage with power gating': 0.40843,
'L2/Area': 4.53318,
'L2/Gate Leakage': 0.015464,
'L2/Peak Dynamic': 0.0280726,
'L2/Runtime Dynamic': 0.00871061,
'L2/Subthreshold Leakage': 0.834142,
'L2/Subthreshold Leakage with power gating': 0.401066,
'Load Store Unit/Area': 8.80901,
'Load Store Unit/Data Cache/Area': 6.84535,
'Load Store Unit/Data Cache/Gate Leakage': 0.0279261,
'Load Store Unit/Data Cache/Peak Dynamic': 1.85339,
'Load Store Unit/Data Cache/Runtime Dynamic': 0.30892,
'Load Store Unit/Data Cache/Subthreshold Leakage': 0.527675,
'Load Store Unit/Data Cache/Subthreshold Leakage with power gating': 0.25085,
'Load Store Unit/Gate Leakage': 0.0350888,
'Load Store Unit/LoadQ/Area': 0.0836782,
'Load Store Unit/LoadQ/Gate Leakage': 0.00059896,
'Load Store Unit/LoadQ/Peak Dynamic': 0.0199378,
'Load Store Unit/LoadQ/Runtime Dynamic': 0.0199379,
'Load Store Unit/LoadQ/Subthreshold Leakage': 0.00941961,
'Load Store Unit/LoadQ/Subthreshold Leakage with power gating': 0.00536918,
'Load Store Unit/Peak Dynamic': 1.94754,
'Load Store Unit/Runtime Dynamic': 0.427185,
'Load Store Unit/StoreQ/Area': 0.322079,
'Load Store Unit/StoreQ/Gate Leakage': 0.00329971,
'Load Store Unit/StoreQ/Peak Dynamic': 0.0491633,
'Load Store Unit/StoreQ/Runtime Dynamic': 0.0983271,
'Load Store Unit/StoreQ/Subthreshold Leakage': 0.0345621,
'Load Store Unit/StoreQ/Subthreshold Leakage with power gating': 0.0197004,
'Load Store Unit/Subthreshold Leakage': 0.591321,
'Load Store Unit/Subthreshold Leakage with power gating': 0.283293,
'Memory Management Unit/Area': 0.4339,
'Memory Management Unit/Dtlb/Area': 0.0879726,
'Memory Management Unit/Dtlb/Gate Leakage': 0.00088729,
'Memory Management Unit/Dtlb/Peak Dynamic': 0.0174482,
'Memory Management Unit/Dtlb/Runtime Dynamic': 0.0178557,
'Memory Management Unit/Dtlb/Subthreshold Leakage': 0.0155699,
'Memory Management Unit/Dtlb/Subthreshold Leakage with power gating': 0.00887485,
'Memory Management Unit/Gate Leakage': 0.00808595,
'Memory Management Unit/Itlb/Area': 0.301552,
'Memory Management Unit/Itlb/Gate Leakage': 0.00393464,
'Memory Management Unit/Itlb/Peak Dynamic': 0.0684547,
'Memory Management Unit/Itlb/Runtime Dynamic': 0.0112016,
'Memory Management Unit/Itlb/Subthreshold Leakage': 0.0413758,
'Memory Management Unit/Itlb/Subthreshold Leakage with power gating': 0.0235842,
'Memory Management Unit/Peak Dynamic': 0.254536,
'Memory Management Unit/Runtime Dynamic': 0.0290573,
'Memory Management Unit/Subthreshold Leakage': 0.0766103,
'Memory Management Unit/Subthreshold Leakage with power gating': 0.0398333,
'Peak Dynamic': 13.146,
'Renaming Unit/Area': 0.303608,
'Renaming Unit/FP Front End RAT/Area': 0.131045,
'Renaming Unit/FP Front End RAT/Gate Leakage': 0.00351123,
'Renaming Unit/FP Front End RAT/Peak Dynamic': 2.51468,
'Renaming Unit/FP Front End RAT/Runtime Dynamic': 0.000360828,
'Renaming Unit/FP Front End RAT/Subthreshold Leakage': 0.0308571,
'Renaming Unit/FP Front End RAT/Subthreshold Leakage with power gating': 0.0175885,
'Renaming Unit/Free List/Area': 0.0340654,
'Renaming Unit/Free List/Gate Leakage': 2.5481e-05,
'Renaming Unit/Free List/Peak Dynamic': 0.0306032,
'Renaming Unit/Free List/Runtime Dynamic': 0.00262309,
'Renaming Unit/Free List/Subthreshold Leakage': 0.000370144,
'Renaming Unit/Free List/Subthreshold Leakage with power gating': 0.000201064,
'Renaming Unit/Gate Leakage': 0.00708398,
'Renaming Unit/Int Front End RAT/Area': 0.0941223,
'Renaming Unit/Int Front End RAT/Gate Leakage': 0.000283242,
'Renaming Unit/Int Front End RAT/Peak Dynamic': 0.731965,
'Renaming Unit/Int Front End RAT/Runtime Dynamic': 0.0294031,
'Renaming Unit/Int Front End RAT/Subthreshold Leakage': 0.00435488,
'Renaming | |
#!/usr/local/bin/python3
import sys
import re
import os
import copy
import pickle
if len(sys.argv) < 2:
sys.exit('./callMom.py <reference> <fasta>')
### CLASS DEFINITIONS
# Site variables: id, pos, end, ref, alt, len, out, vtype, maxlen
# create site class
class Site():
def __init__(self, a, b, c, d):
self.id = a
self.pos = int(b)
self.end = int(b)
self.ref = c
self.alt = d
self.len = 1
self.out = 0
self.vtype = ''
self.maxlen = 1
def printsite(self):
self.updatesite()
out = self.id + '\t' + str(self.pos) + '\t' + str(self.end) + '\t' + self.ref + '\t' + self.alt + '\t' + str(
self.len) + '\t' + str(self.maxlen) + '\t' + self.vtype + '\t' + str(self.out)
return out
def updatesite(self):
self.len = len(self.alt)
self.end = self.pos + self.len -1
# create object for storing all variant alleles at a position in refseq
class Var():
def __init__(self, a):
self.pos = int(a)
self.len = []
self.ref = []
self.alt = []
self.altcode = []
self.ac = []
self.vtype = []
self.maxlen = 0
self.hasvar = {}
# extend ref/alt by 1 bp upstream
def addbp(self, r):
for i in range(len(self.ref)):
self.ref[i] = r[self.pos - 1] + self.ref[i]
for i in range(len(self.alt)):
self.alt[i] = r[self.pos - 1] + self.alt[i]
self.len[i] = len(self.alt[i])
if self.len[i] > self.maxlen:
self.maxlen = self.len[i]
self.vtype = 'M'
# function for outputting a string of the object contents
# varfrqout1.write("pos\tref\talt\tlen\tac\tvtype\thas\n")
def printvar(self):
out = str(self.pos)
tref = []
for a1 in self.ref:
tref.append(a1)
out = out + '\t' + ','.join(tref)
talt = []
for a2 in self.alt:
talt.append(a2)
out = out + '\t' + ','.join(talt)
tlen = []
for a3 in self.len:
tlen.append(str(a3))
out = out + '\t' + ','.join(tlen)
tac = []
for a4 in self.ac:
tac.append(str(a4))
out = out + '\t' + ','.join(tac)
tvtype = []
for a5 in self.vtype:
tvtype.append(str(a5))
out = out + '\t' + ','.join(tvtype)
thasvar = []
done = []
for a6 in range(len(self.ref)):
for a7 in range(len(self.alt)):
k = self.ref[a6] + ':' + self.alt[a7]
if k in self.hasvar.keys() and k not in done:
thasvar.append(self.ref[a6] + ':' + self.alt[a7] + ':' + ','.join(
self.hasvar[self.ref[a6] + ':' + self.alt[a7]]))
done.append(k)
out = out + '\t' + '\t'.join(thasvar)
return out
def vcf(v, ids):
# combine genotypes into a string
gtar = []
# loop through ids
for i in ids:
hasalt = 0
# loop through alts
for a in range(len(v.alt)):
k = v.ref[0] + ':' + v.alt[a]
if i in v.hasvar[k]:
# individual has this alt allele
# add genotype code
gtcode = a + 1
gtar.append(str(gtcode))
hasalt = 1
if hasalt == 0:
gtar.append('0')
gtstr = '\t'.join(gtar)
# put together string of ac
acar = []
for a in v.ac:
acar.append(str(a))
acstr = ','.join(acar)
# compile final output string
out = '\t'.join(['MT', str(v.pos), '.', v.ref[0], ','.join(v.alt), '100', 'fa',
'VT=' + ','.join(v.vtype) + ';' + 'AC=' + acstr, 'GT', gtstr])
return out
# check for errors
def err(v1):
if len(set(v1.alt)) != len(v1.alt) or len(set(v1.ref)) != len(v1.ref):
return 1
if len(set(v1.alt)) == len(v1.alt) and len(set(v1.ref)) == len(v1.ref):
return 0
# check if two variants 1 bp away are the same indel
def samevar(v1, v2):
for vt1 in range(len(v1.vtype)):
for vt2 in range(len(v2.vtype)):
if v1.vtype[vt1] == 'I' and v2.vtype[vt2] == 'I':
return 1
if v1.vtype[vt1] == 'M' and v2.vtype[vt2] == 'M':
return 1
# lengthen snp alt when overlapping indel
def updatealt(self):
if len(self.alt) > 1:
# multiple alternate alleles
if 'I' not in set(self.vtype) and 'M' not in set(self.vtype):
# multiple SNP alleles
self.ref = list(set(self.ref))
if 'I' in set(self.vtype) or 'M' in set(self.vtype):
# contains complex variants
# get longest ref
maxlen = 0
maxref = ''
for r in self.ref:
if len(r) > maxlen:
maxref = r
maxlen = len(r)
self.maxlen = maxlen
# store the original variant
ogv = copy.deepcopy(self)
# set the new ref
self.ref = []
self.ref.append(maxref)
# loop through alts
for i in range(len(self.alt)):
# add bases to the alt for snps
if 'S' in self.vtype[i]:
j = len(self.alt[i])
while len(self.alt[i]) < len(self.ref[0]):
self.alt[i] = self.alt[i] + list(self.ref[0])[j]
j = j + 1
# add bases to the alt for mnps
if 'M' in self.vtype[i]:
j = len(self.alt[i])
while len(self.alt[i]) < len(self.ref[0]):
self.alt[i] = self.alt[i] + list(self.ref[0])[j]
j = j + 1
# add bases to the alt for indels
if 'I' in self.vtype[i]:
# no need to edit when ref len is same
if len(self.ref[0]) != len(ogv.ref[i]):
# add bases to alt
j = len(ogv.ref[i])
while j < len(self.ref[0]):
self.alt[i] = self.alt[i] + list(self.ref[0])[j]
j = j + 1
# update all the hasvar keys
temp = {}
for i in range(len(ogv.alt)):
k0 = ogv.ref[i] + ':' + ogv.alt[i]
k1 = self.ref[0] + ':' + self.alt[i]
if k1 not in temp.keys():
temp[k1] = self.hasvar[k0]
self.hasvar = temp
# sort alt alleles in order of frequency
# assign numbers to the alleles
# self.pos=int(a)
# self.len=[]
# self.ref=[]
# self.alt=[]
# self.altcode=[]
# self.ac=[]
# self.vtype=[]
# self.maxlen=0
# self.hasvar={}
def sortalt(self):
# create a duplicate variant
ogv = copy.deepcopy(self)
# only needed if n>1
if len(self.ac) > 1:
# store the unsorted list
usoac = copy.deepcopy(self.ac)
# sort the list
soac = copy.deepcopy(self.ac)
soac = sorted(soac, reverse=True)
# update the sorted list in self
self.ac.sort(reverse=True)
# reset the other items to be sorted
self.alt = []
self.len = []
self.vtype = []
# loop through new ac order
for i in range(len(soac)):
# pop the first item
ac = soac.pop(0)
# get first index of item with ac
ui = usoac.index(ac)
# clear the value
usoac[ui] = ''
# update other lists
self.alt.append(ogv.alt[ui])
self.len.append(ogv.len[ui])
self.vtype.append(ogv.vtype[ui])
### OPERATION CODE
# STEP 1
# read in reference sequence to list
refseq = ['>']
f1 = open(sys.argv[1], 'r')
for l in f1:
l = l.rstrip()
if '>' not in l:
for b in l:
refseq.append(b.upper())
f1.close()
bases = ['A', 'C', 'G', 'T']
# STEP 2
# identify all variant bases
# store in database indexed by id then position
initvar = open('cmo.0.initvar.txt', 'w')
ids = []
vars = {}
curid = ''
f2 = open(sys.argv[2], 'r')
acgtn = ['A', 'C', 'G', 'T', 'N']
indel = ['-']
fastas = {}
for l in f2:
l = l.rstrip()
# read the sequence
if '>' not in l:
seq = '>' + l
fastas[curid]=seq
# loop through fasta file
# check if variant in individual
p = 0
while p < len(seq):
# matches reference, continue
if refseq[p] == seq[p].upper():
p = p + 1
continue
# does not match reference, variant
if refseq[p] != seq[p].upper():
# record variant site
initvar.write(curid + '\t' + str(p) + '\n')
# is it a SNP or MNP?
if seq[p].upper() in acgtn:
# initalize variant record for id at position
vars[curid][p] = ''
q = p
# check all consecutive positions that differ
done = 0
while refseq[q] != seq[q].upper() and done == 0:
if seq[q].upper() in acgtn:
# store the variant position and base
vars[curid][p] = vars[curid][p] + seq[q].upper()
# go to the next base
q = q + 1
if seq[q].upper() not in acgtn:
done = 1
p = q
# found a deletion
if seq[p] in indel:
vars[curid][p] = ''
q = p
# check all consecutive positions that differ
done = 0
while refseq[q] != seq[q].upper() and done == 0:
if seq[q].upper() in indel:
# store the variant position and base
vars[curid][p] = vars[curid][p] + seq[q].upper()
q = q + 1
if seq[q].upper() not in indel:
done = 1
p = q
if seq[p] not in indel and seq[p].upper() not in acgtn:
# skip these sites
p = p + 1
# read the id
if '>' in l:
l = l.replace('>', '')
ids.append(l)
# initialize database of variants
vars[l] = {}
curid = l
f2.close()
initvar.close()
# DATA
# vars[id][position] contains list of variants for each individual
# STEP 3
# populate list of all individual variant alleles
sites = []
# loop through ids
for i in ids:
# loop through variant sites in this individual
| |
waveform_size, n_spikes = wf.shape
# upsample using cubic interpolation
x = np.linspace(0, waveform_size - 1, num=waveform_size, endpoint=True)
shifts = np.linspace(0, 1, upsample_factor, endpoint=False)
xnew = np.sort(np.reshape(x[:, np.newaxis] + shifts, -1))
wfs_upsampled = np.zeros((waveform_size * upsample_factor, n_spikes))
# compute template and interpolate it
template = np.mean(wf,axis=1)
ff = interp1d(x, template, kind='cubic')
idx_good = np.logical_and(xnew >= 0, xnew <= waveform_size - 1)
template_upsampled = ff(xnew[idx_good])
return template_upsampled
def shift_template(template_upsampled, n_shifts, window):
''' Select n_shifts version of the tempalte shifting from
-n_shifts/2 to + n_shifts/2 in the original waveform
Cat TODO: this should be done pythonically
'''
temp_array = []
for s in range(-n_shifts//2, n_shifts//2, 1):
temp_array.append(template_upsampled[template_upsampled.shape[0]//2-window+s:
template_upsampled.shape[0]//2+window+s])
return np.array(temp_array)
def return_shifts(wfs_upsampled, template_shifted, window):
shift_array = []
out_array = []
waveform_len = wfs_upsampled.shape[0]
for k in range(wfs_upsampled.shape[1]):
temp = np.matmul(wfs_upsampled[waveform_len//2-window:waveform_len//2+window,k],
template_shifted.T)
shift_array.append(np.argmax(temp))
return np.array(shift_array) #, out_array
# PCA function return PCA and reconstructed data
def PCA(X, n_components):
from sklearn import decomposition
pca = decomposition.PCA(n_components)
pca.fit(X)
X = pca.transform(X)
Y = pca.inverse_transform(X)
return X, Y, pca
def align_channelwise3(wf, upsample_factor = 20, nshifts = 7):
wf_up = upsample_resample(wf.T, upsample_factor)
wlen = wf_up.shape[1]
wf_start = int(.2 * (wlen-1))
wf_end = -int(.3 * (wlen-1))
wf_trunc = wf_up[:,wf_start:wf_end]
wlen_trunc = wf_trunc.shape[1]
#if type(ref) == 'ndarray':
# ref_upsampled = upsample_resample(ref,20)
#else:
ref_upsampled = wf_up.mean(0)
ref_shifted = np.zeros([wf_trunc.shape[1], nshifts])
for i,s in enumerate(range(-int((nshifts-1)/2), int((nshifts-1)/2+1))):
ref_shifted[:,i] = ref_upsampled[s+ wf_start: s+ wf_end]
bs_indices = np.matmul(wf_trunc[:,np.newaxis,:], ref_shifted).squeeze(1).argmax(1)
best_shifts = (np.arange(-int((nshifts-1)/2), int((nshifts-1)/2+1)))[bs_indices]
wf_final = np.zeros([wf.shape[0], (wlen-1)//2 +1])
for i,s in enumerate(best_shifts):
wf_final[i] = wf_up[i,-s+ wf_start: -s+ wf_end]
return wf_final[:,::upsample_factor]
def align_mc_templates(wf, mc, spike_padding, upsample_factor = 5,
nshifts = 15):
''' Align all waveforms to the master channel
wf = selected waveform matrix (# spikes, # samples, # featchans)
mc = maximum channel from featchans; usually first channle, i.e. 0
'''
# convert nshifts from timesamples to #of times in upsample_factor
nshifts = (nshifts*upsample_factor)
if nshifts%2==0:
nshifts+=1
# or loop over every channel and parallelize each channel:
wf_up = []
for k in range(wf.shape[2]):
#print ("aligning : ", k)
wf_up.append(upsample_resample_parallel_channel(wf[:,:,k], upsample_factor))
wf_up = np.array(wf_up).swapaxes(1,2).swapaxes(0,2)
wlen = wf_up.shape[1]
wf_start = spike_padding*upsample_factor
wf_end = -spike_padding*upsample_factor
wf_trunc = wf_up[:,wf_start:wf_end]
wlen_trunc = wf_trunc.shape[1]
ref_upsampled = wf_up[:,:,mc].mean(0)
ref_shifted = np.zeros([wf_trunc.shape[1], nshifts])
for i,s in enumerate(range(-int((nshifts-1)/2), int((nshifts-1)/2+1))):
ref_shifted[:,i] = ref_upsampled[s+ wf_start: s+ wf_end]
bs_indices = np.matmul(wf_trunc[:,np.newaxis,:, mc], ref_shifted).squeeze(1).argmax(1)
best_shifts = (np.arange(-int((nshifts-1)/2), int((nshifts-1)/2+1)))[bs_indices]
wf_final = np.zeros([wf.shape[0],wlen_trunc, wf.shape[2]])
for i,s in enumerate(best_shifts):
wf_final[i] = wf_up[i,-s+ wf_start: -s+ wf_end][:, np.arange(wf.shape[2])]
# plot original waveforms
#print ("Plotting align_mc")
#ax = plt.subplot(131)
#plt.plot(wf[:1000,:,mc].T,alpha=0.1)
## plot aligned waveforms
#ax = plt.subplot(132)
#plt.plot(wf_final[:1000,::upsample_factor,mc].T, alpha=0.1)
#plt.savefig('/media/cat/1TB/liam/49channels/data1_allset/tmp/cluster/chunk_000000/channel_31_aligning.png')
#quit()
return wf_final[:,::upsample_factor]
def align_mc_cumulative(wf, mc, CONFIG, upsample_factor = 20, nshifts = 7,
ref = None):
''' Align all waveforms to the master channel
wf = selected waveform matrix (# spikes, # samples, # featchans)
mc = maximum channel from featchans; usually first channle, i.e. 0
'''
# convert nshifts from timesamples to #of times in upsample_factor
nshifts = (nshifts*upsample_factor)
if nshifts%2==0:
nshifts+=1
# or loop over every channel and parallelize each channel:
wf_up = []
for k in range(wf.shape[2]):
#print (" upsampling chan (parallel): ", k)
wf_up.append(upsample_resample_parallel_channel(wf[:,:,k], upsample_factor))
wf_up = np.array(wf_up).swapaxes(1,2).swapaxes(0,2)
#print ('wf_upsampled: ', wf_up.shape)
wlen = wf_up.shape[1]
wf_start = int(.2 * (wlen-1))
wf_end = -int(.3 * (wlen-1))
wf_trunc = wf_up[:,wf_start:wf_end]
wlen_trunc = wf_trunc.shape[1]
if ref is not None:
ref_upsampled = upsample_resample(ref[:,np.newaxis],upsample_factor)[0]
else:
ref_upsampled = wf_up[:,:,mc].mean(0)
ref_shifted = np.zeros([wf_trunc.shape[1], nshifts])
#print (ref_shifted.shape)
for i,s in enumerate(range(-int((nshifts-1)/2), int((nshifts-1)/2+1))):
ref_shifted[:,i] = ref_upsampled[s+ wf_start: s+ wf_end]
bs_indices = np.matmul(wf_trunc[:,np.newaxis,:, mc], ref_shifted).squeeze(1).argmax(1)
best_shifts = (np.arange(-int((nshifts-1)/2), int((nshifts-1)/2+1)))[bs_indices]
wf_final = np.zeros([wf.shape[0],wlen_trunc, wf.shape[2]])
for i,s in enumerate(best_shifts):
wf_final[i] = wf_up[i,-s+ wf_start: -s+ wf_end][:, np.arange(wf.shape[2])]
return wf_final[:,::upsample_factor]
def upsample_resample(wf, upsample_factor):
waveform_len, n_spikes = wf.shape
traces = np.zeros((n_spikes, (waveform_len-1)*upsample_factor+1),'float32')
for j in range(n_spikes):
traces[j] = signal.resample(wf[:,j],(waveform_len-1)*upsample_factor+1)
return traces
def upsample_resample_parallel(wf, upsample_factor):
waveform_len, n_spikes = wf.shape
traces = np.zeros((n_spikes, (waveform_len-1)*upsample_factor+1),'float32')
for j in range(n_spikes):
traces[j] = signal.resample(wf[:,j],(waveform_len-1)*upsample_factor+1)
return traces
def upsample_resample_parallel_channel(wf, upsample_factor):
n_spikes, _ = wf.shape
# dont' parallize alignment - unless seems ok otherwise
# Cat: TODO: can we parallize recursively and to this?
wf_up = upsample_parallel(wf, upsample_factor)
return wf_up
def shift_chans(wf, best_shifts, CONFIG):
# use template feat_channel shifts to interpolate shift of all spikes on all other chans
# Cat: TODO read this from CNOFIG
upsample_factor = 5.
wf_shifted = []
all_shifts = best_shifts/upsample_factor
wfs_final=[]
for k, shift_ in enumerate(all_shifts):
if int(shift_)==shift_:
ceil = int(shift_)
temp = np.roll(wf[k],ceil,axis=0)
else:
ceil = int(math.ceil(shift_))
floor = int(math.floor(shift_))
temp = np.roll(wf[k],ceil,axis=0)*(shift_-floor)+np.roll(wf[k],floor, axis=0)*(ceil-shift_)
wfs_final.append(temp)
wf_shifted = np.array(wfs_final)
return wf_shifted
def align_get_shifts(wf, CONFIG, upsample_factor = 5, nshifts = 15):
''' Align all waveforms on a single channel
wf = selected waveform matrix (# spikes, # samples)
max_channel: is the last channel provided in wf
Returns: superresolution shifts required to align all waveforms
- used downstream for linear interpolation alignment
'''
# convert nshifts from timesamples to #of times in upsample_factor
nshifts = (nshifts*upsample_factor)
if nshifts%2==0:
nshifts+=1
# or loop over every channel and parallelize each channel:
#wf_up = []
wf_up = upsample_resample_parallel_channel(wf, upsample_factor)
wlen = wf_up.shape[1]
wf_start = int(.2 * (wlen-1))
wf_end = -int(.3 * (wlen-1))
wf_trunc = wf_up[:,wf_start:wf_end]
wlen_trunc = wf_trunc.shape[1]
# align to last chanenl which is largest amplitude channel appended
ref_upsampled = wf_up.mean(0)
ref_shifted = np.zeros([wf_trunc.shape[1], nshifts])
for i,s in enumerate(range(-int((nshifts-1)/2), int((nshifts-1)/2+1))):
ref_shifted[:,i] = ref_upsampled[s+ wf_start: s+ wf_end]
bs_indices = np.matmul(wf_trunc[:,np.newaxis], ref_shifted).squeeze(1).argmax(1)
best_shifts = (np.arange(-int((nshifts-1)/2), int((nshifts-1)/2+1)))[bs_indices]
return best_shifts
def upsample_parallel(wf, upsample_factor):
wf = wf.T
waveform_len, n_spikes = wf.shape
traces = np.zeros((n_spikes, (waveform_len-1)*upsample_factor+1),'float32')
for j in range(wf.shape[1]):
traces[j] = signal.resample(wf[:,j],(waveform_len-1)*upsample_factor+1)
return traces
def RRR3_noregress_recovery_dynamic_features(channel, current_indexes, gen, fig,
grid, x, ax_t, triageflag, alignflag, plotting, n_feat_chans,
n_dim_pca, wf_start, wf_end, mfm_threshold, CONFIG,
upsample_factor, nshifts, assignment_global, spike_index,
scale, knn_triage_threshold, deconv_flag, templates,
min_spikes_local, active_chans=None):
''' Recursive clusteringn function
channel: current channel being clusterd
wf = wf_PCA: denoised waveforms (# spikes, # time points, # chans)
sic = spike_indexes of spikes on current channel
gen = generation of cluster; increases with each clustering step
'''
# Cat: TODO read from CONFIG File
verbose=True
# load correct waveforms from disk
#wf = np.load(wf_fname)[current_indexes]
wf = wf_global[current_indexes]
# ************* CHECK SMALL CLUSTERS *************
# Exit clusters that are too small
if wf.shape[0] < CONFIG.cluster.min_spikes:
return
if verbose:
print("chan/unit "+str(channel)+' gen: '+str(gen)+' # spikes: '+
str(wf.shape[0]))
''' *************************************************
** ALIGN ALL CHANS TO MAX CHAN - LINEAR INTERP **
*************************************************
'''
# align, note: aligning all channels to max chan which is appended to the end
# note: max chan is first from feat_chans above, ensure order is preserved
if alignflag:
if verbose:
print ("chan "+str(channel)+' gen: '+str(gen)+" - aligning")
mc = wf.mean(0).ptp(0).argmax(0)
best_shifts = align_get_shifts(wf[:,:,mc], CONFIG)
wf_align = shift_chans(wf, best_shifts, CONFIG)
else:
wf_align = wf
''' *************************************************
************** ACTIVE CHAN SELECTION ************
*************************************************
'''
active_chans_flag = False
if active_chans_flag and gen == 0:
stds = np.median(np.abs(wf - np.median(wf_align, axis=0, keepdims=True)), axis=0)*1.4826
active_chans = np.where(stds.max(0) > 1.05)[0]
neighbors = n_steps_neigh_channels(CONFIG.neigh_channels, 1)
active_chans = np.hstack((active_chans, np.where(neighbors[channel])[0]))
active_chans = np.where(connected_channels(active_chans, channel, neighbors))[0]
#def plot_with_geom(data, geom, time_scale=0.5, scale=10, color='k', mark_channels=None):
# t, c = data.shape
# plt.plot(geom[:,0]+np.arange(-data.shape[0],0)[:,np.newaxis]/time_scale,
# geom[:,1] + data*scale, color=color, alpha=.8)
# if mark_channels is not None:
# plt.scatter(geom[mark_channels,0], geom[mark_channels,1], s=scale*10, color='green')
# for j in range(c):
# plt.text(geom[j,0], geom[j,1], str(j))
#chunk_dir = CONFIG.data.root_folder+"/tmp/cluster/chunk_000000"
#plt.figure(figsize=(30,20))
#plot_with_geom(stds, CONFIG.geom, time_scale=2, scale=10, color='k', mark_channels=active_chans)
#plt.savefig(chunk_dir+"/channel_{}_active_chans.png".format(channel))
else:
active_chans = np.arange(wf_align.shape[2])
# Cat: TODO: so we force all subsequent generations to use gen0 alignment
#wf=wf_align
''' ************************************************
****** FIND FEATURE CHANNELS & FEATURIZE *******
************************************************
'''
if verbose:
print("chan/unit "+str(channel)+' gen: '+str(gen)+' getting feat chans')
# Cat: TODO: is 10k spikes enough?
# Cat: TODO: what do these metrics look like for 100 spikes!?; should we simplify for | |
from __future__ import (absolute_import, division, print_function,
unicode_literals)
import copy
import six
import warnings
import logging
import numpy as np
from ..utils import (apply_to_dict_recursively, sanitize_np,
format_time as _format_time, transpose as _transpose)
from event_model import MismatchedDataKeys
logger = logging.getLogger(__name__)
# singletons defined as they are defined in pymongo
ASCENDING = 1
DESCENDING = -1
def _format_regex(d):
for k, v in six.iteritems(d):
if k == '$regex':
# format regex for monoquery
d[k] = '/{0}/'.format(v)
else:
# recurse if v is a dict
if hasattr(v, 'items'):
_format_regex(v)
class NoRunStop(Exception):
pass
class NoRunStart(Exception):
pass
class NoEventDescriptors(Exception):
pass
def doc_or_uid_to_uid(doc_or_uid):
"""Given Document or uid return the uid
Parameters
----------
doc_or_uid : dict or str
If str, then assume uid and pass through, if not, return
the 'uid' field
Returns
-------
uid : str
A string version of the uid of the given document
"""
if not isinstance(doc_or_uid, six.string_types):
doc_or_uid = doc_or_uid['uid']
return doc_or_uid
def _cache_run_start(run_start, run_start_cache):
"""Cache a RunStart document
Parameters
----------
run_start : dict
raw pymongo dictionary. This is expected to have
an entry `_id` with the ObjectId used by mongo.
run_start_cache : dict
Dict[str, Document]
Returns
-------
run_start : dict
Document instance for this RunStart document.
The ObjectId has been stripped.
"""
run_start = dict(run_start)
# TODO actually do this de-reference for documents that have it
# There is no known actually usage of this document and it is not being
# created going forward
run_start.pop('beamline_config_id', None)
# get the mongo ObjectID
oid = run_start.pop('_id', None)
run_start_cache[run_start['uid']] = run_start
run_start_cache[oid] = run_start
return run_start
def _cache_run_stop(run_stop, run_stop_cache):
"""Cache a RunStop document
Parameters
----------
run_stop : dict
raw pymongo dictionary. This is expected to have
an entry `_id` with the ObjectId used by mongo.
run_stop_cache : dict
Dict[str, Document]
Returns
-------
run_stop : dict
Document instance for this RunStop document.
The ObjectId (if it exists) has been stripped.
"""
run_stop = dict(run_stop)
# pop off the ObjectId of this document
oid = run_stop.pop('_id', None)
try:
run_stop['run_start']
except KeyError:
run_stop['run_start'] = run_stop.pop('run_start_id')
run_stop_cache[run_stop['uid']] = run_stop
# this is
if oid is not None:
run_stop_cache[oid] = run_stop
return run_stop
def _cache_descriptor(descriptor, descritor_cache):
"""De-reference and cache a RunStop document
The de-referenced Document is cached against the
ObjectId and the uid -> ObjectID mapping is stored.
Parameters
----------
descriptor : dict
raw pymongo dictionary. This is expected to have
an entry `_id` with the ObjectId used by mongo.
Returns
-------
descriptor : dict
Document instance for this EventDescriptor document.
The ObjectId has been stripped.
"""
descriptor = dict(descriptor)
# pop the ObjectID
oid = descriptor.pop('_id', None)
try:
descriptor['run_start']
except KeyError:
descriptor['run_start'] = descriptor.pop('run_start_id')
descritor_cache[descriptor['uid']] = descriptor
if oid is not None:
descritor_cache[oid] = descriptor
return descriptor
def run_start_given_uid(uid, run_start_col, run_start_cache):
"""Given a uid, return the RunStart document
Parameters
----------
uid : str
The uid
run_start_col : pymongo.Collection
The collection to search for documents
run_start_cache : MutableMapping
Mutable mapping to serve as a local cache
Returns
-------
run_start : dict
The RunStart document.
"""
try:
return run_start_cache[uid]
except KeyError:
pass
run_start = run_start_col.find_one({'uid': uid})
if run_start is None:
raise NoRunStart("No runstart with uid {!r}".format(uid))
return _cache_run_start(run_start, run_start_cache)
def run_stop_given_uid(uid, run_stop_col, run_stop_cache):
"""Given a uid, return the RunStop document
Parameters
----------
uid : str
The uid
run_stop_col : pymongo.Collection
The collection to search for documents
run_stop_cache : MutableMapping
Mutable mapping to serve as a local cache
Returns
-------
run_stop : dict
The RunStop document fully de-referenced
"""
try:
return run_stop_cache[uid]
except KeyError:
pass
# get the raw run_stop
run_stop = run_stop_col.find_one({'uid': uid})
return _cache_run_stop(run_stop, run_stop_cache)
def descriptor_given_uid(uid, descriptor_col, descriptor_cache):
"""Given a uid, return the EventDescriptor document
Parameters
----------
uid : str
The uid
descriptor_col : pymongo.Collection
The collection to search for documents
descriptor_cache : MutableMapping
Mutable mapping to serve as a local cache
Returns
-------
descriptor : dict
The EventDescriptor document fully de-referenced
"""
try:
return descriptor_cache[uid]
except KeyError:
pass
descriptor = descriptor_col.find_one({'uid': uid})
return _cache_descriptor(descriptor, descriptor_cache)
def stop_by_start(run_start, run_stop_col, run_stop_cache):
"""Given a RunStart return it's RunStop
Raises if no RunStop exists.
Parameters
----------
run_start : dict or str
The RunStart to get the RunStop for. Can be either
a Document/dict with a 'uid' key or a uid string
Returns
-------
run_stop : dict
The RunStop document
Raises
------
NoRunStop
If no RunStop document exists for the given RunStart
"""
run_start_uid = doc_or_uid_to_uid(run_start)
run_stop = run_stop_col.find_one({'run_start': run_start_uid})
if run_stop is None:
raise NoRunStop("No run stop exists for {!r}".format(run_start))
return _cache_run_stop(run_stop, run_stop_cache)
def descriptors_by_start(run_start, descriptor_col, descriptor_cache):
"""Given a RunStart return a list of it's descriptors
Raises if no EventDescriptors exist.
Parameters
----------
run_start : dict or str
The RunStart to get the EventDescriptors for. Can be either
a Document/dict with a 'uid' key or a uid string
descriptor_col
A collection we can search against
descriptor_cache : dict
Dict[str, Document]
Returns
-------
event_descriptors : list
A list of EventDescriptor documents
Raises
------
NoEventDescriptors
If no EventDescriptor documents exist for the given RunStart
"""
# normalize the input and get the run_start oid
run_start_uid = doc_or_uid_to_uid(run_start)
# query the database for any event descriptors which
# refer to the given run_start
descriptors = descriptor_col.find({'run_start': run_start_uid})
# loop over the found documents, cache, and dereference
rets = [_cache_descriptor(descriptor, descriptor_cache)
for descriptor in descriptors]
# if nothing found, raise
if not rets:
raise NoEventDescriptors("No EventDescriptors exists "
"for {!r}".format(run_start))
# return the list of event descriptors
return rets
def get_events_generator(descriptor, event_col, descriptor_col,
descriptor_cache, run_start_col,
run_start_cache, convert_arrays=True):
"""A generator which yields all events from the event stream
Parameters
----------
descriptor : dict or str
The EventDescriptor to get the Events for. Can be either
a Document/dict with a 'uid' key or a uid string
event_col
Collection we can search for events given descriptor in.
descriptor_col
Collection we can search for descriptors given a uid
descriptor_cache : dict
Dict[str, Document]
convert_arrays: boolean, optional
convert 'array' type to numpy.ndarray; True by default
Yields
------
event : dict
All events for the given EventDescriptor from oldest to
newest
"""
descriptor_uid = doc_or_uid_to_uid(descriptor)
descriptor = descriptor_given_uid(descriptor_uid, descriptor_col,
descriptor_cache)
col = event_col
ev_cur = col.find({'descriptor': descriptor_uid},
sort=[('time', ASCENDING)])
data_keys = descriptor['data_keys']
external_keys = [k for k in data_keys if 'external' in data_keys[k]]
for ev in ev_cur:
# ditch the ObjectID
ev.pop('_id', None)
ev['descriptor'] = descriptor_uid
for k, v in ev['data'].items():
try:
_dk = data_keys[k]
except KeyError as err:
raise MismatchedDataKeys(
"The documents are not valid. Either because they "
"were recorded incorrectly in the first place, "
"corrupted since, or exercising a yet-undiscovered "
"bug in a reader. event['data'].keys() "
"must equal descriptor['data_keys'].keys(). "
f"event['data'].keys(): {ev['data'].keys()}, "
"descriptor['data_keys'].keys(): "
f"{descriptor['data_keys'].keys()}") from err
# convert any arrays stored directly in mds into ndarray
if convert_arrays:
if _dk['dtype'] == 'array' and not _dk.get('external', False):
ev['data'][k] = np.asarray(ev['data'][k])
# note which keys refer to dereferences (external) data
ev['filled'] = {k: False for k in external_keys}
yield ev
def get_events_table(descriptor, event_col, descriptor_col,
descriptor_cache, run_start_col, run_start_cache):
"""All event data as tables
Parameters
----------
descriptor : dict or str
The EventDescriptor to get the Events for. Can be either
a Document/dict with a 'uid' key or a uid string
event_col
Collection we can search for events given descriptor in.
descriptor_col
Collection we can search for descriptors given a uid
descriptor_cache : dict
Dict[str, Document]
convert_arrays: boolean, optional
convert 'array' type to numpy.ndarray; True by default
Returns
-------
descriptor : dict
EventDescriptor document
data_table : dict
dict of lists of the transposed data
seq_nums : list
The sequence number of each event.
times : list
The time of each event.
uids : list
The uid of each event.
timestamps_table : dict
The timestamps of each of the measurements as dict of lists. Same
keys as `data_table`.
"""
desc_uid = doc_or_uid_to_uid(descriptor)
descriptor = descriptor_given_uid(desc_uid, descriptor_col,
descriptor_cache)
# this will get more complicated once transpose caching layer is in place
all_events = list(get_events_generator(desc_uid, event_col,
descriptor_col,
descriptor_cache,
run_start_col,
run_start_cache))
# get event sequence numbers
seq_nums = [ev['seq_num'] for ev in all_events]
# get event times
times = [ev['time'] for ev in all_events]
# get uids
uids = [ev['uid'] | |
'HLT_BTagMu_DiJet40_Mu5_v3',
'HLT_BTagMu_DiJet70_Mu5_v3',
'HLT_BTagMu_Jet300_Mu5_v3'),
Charmonium = cms.vstring('HLT_Dimuon0_Jpsi_Muon_v3',
'HLT_Dimuon0er16_Jpsi_NoOS_NoVertexing_v3',
'HLT_Dimuon0er16_Jpsi_NoVertexing_v3',
'HLT_Dimuon10_Jpsi_Barrel_v4',
'HLT_Dimuon13_PsiPrime_v3',
'HLT_Dimuon16_Jpsi_v3',
'HLT_Dimuon20_Jpsi_v3',
'HLT_Dimuon6_Jpsi_NoVertexing_v3',
'HLT_Dimuon8_PsiPrime_Barrel_v4',
'HLT_DoubleMu4_3_Bs_v4',
'HLT_DoubleMu4_3_Jpsi_Displaced_v4',
'HLT_DoubleMu4_JpsiTrk_Displaced_v4',
'HLT_DoubleMu4_PsiPrimeTrk_Displaced_v4',
'HLT_Mu7p5_L2Mu2_Jpsi_v3',
'HLT_Mu7p5_Track2_Jpsi_v3',
'HLT_Mu7p5_Track3p5_Jpsi_v3',
'HLT_Mu7p5_Track7_Jpsi_v3',
'HLT_QuadMuon0_Dimuon0_Jpsi_v3'),
Commissioning = cms.vstring('HLT_DiSC30_18_EIso_AND_HE_Mass70_v4',
'HLT_IsoTrackHB_v2',
'HLT_IsoTrackHE_v2',
'HLT_L1BeamGasMinus_v2',
'HLT_L1BeamGasPlus_v2',
'HLT_L1BptxXOR_v2',
'HLT_L1SingleMuOpen_DT_v3'),
DisplacedJet = cms.vstring('HLT_HT200_DisplacedDijet40_DisplacedTrack_v3',
'HLT_HT200_v3',
'HLT_HT250_DisplacedDijet40_DisplacedTrack_v4',
'HLT_HT275_v3',
'HLT_HT325_v3',
'HLT_HT350_DisplacedDijet40_DisplacedTrack_v4',
'HLT_HT350_DisplacedDijet40_Inclusive_v3',
'HLT_HT350_DisplacedDijet80_DisplacedTrack_v4',
'HLT_HT350_DisplacedDijet80_Tight_DisplacedTrack_v4',
'HLT_HT400_DisplacedDijet40_Inclusive_v4',
'HLT_HT425_v3',
'HLT_HT500_DisplacedDijet40_Inclusive_v4',
'HLT_HT550_DisplacedDijet40_Inclusive_v4',
'HLT_HT575_v3',
'HLT_HT650_DisplacedDijet80_Inclusive_v4',
'HLT_HT750_DisplacedDijet80_Inclusive_v4',
'HLT_VBF_DisplacedJet40_DisplacedTrack_2TrackIP2DSig5_v3',
'HLT_VBF_DisplacedJet40_DisplacedTrack_v3',
'HLT_VBF_DisplacedJet40_Hadronic_2PromptTrack_v3',
'HLT_VBF_DisplacedJet40_Hadronic_v3',
'HLT_VBF_DisplacedJet40_TightID_DisplacedTrack_v3',
'HLT_VBF_DisplacedJet40_TightID_Hadronic_v3',
'HLT_VBF_DisplacedJet40_VTightID_DisplacedTrack_v3',
'HLT_VBF_DisplacedJet40_VTightID_Hadronic_v3',
'HLT_VBF_DisplacedJet40_VVTightID_DisplacedTrack_v3',
'HLT_VBF_DisplacedJet40_VVTightID_Hadronic_v3'),
DoubleEG = cms.vstring('HLT_Diphoton30EB_18EB_R9Id_OR_IsoCaloId_AND_HE_R9Id_DoublePixelVeto_Mass55_v4',
'HLT_Diphoton30PV_18PV_R9Id_AND_IsoCaloId_AND_HE_R9Id_DoublePixelVeto_Mass55_v4',
'HLT_Diphoton30_18_R9Id_OR_IsoCaloId_AND_HE_R9Id_DoublePixelSeedMatch_Mass70_v4',
'HLT_Diphoton30_18_R9Id_OR_IsoCaloId_AND_HE_R9Id_Mass90_v4',
'HLT_Diphoton30_18_Solid_R9Id_AND_IsoCaloId_AND_HE_R9Id_Mass55_v4',
'HLT_DoubleEle24_22_eta2p1_WPLoose_Gsf_v5',
'HLT_DoubleEle33_CaloIdL_GsfTrkIdVL_MW_v6',
'HLT_DoubleEle33_CaloIdL_GsfTrkIdVL_v6',
'HLT_DoubleEle33_CaloIdL_MW_v4',
'HLT_DoubleEle33_CaloIdL_v4',
'HLT_DoubleEle37_Ele27_CaloIdL_GsfTrkIdVL_v4',
'HLT_DoubleEle8_CaloIdM_TrackIdM_Mass8_PFHT250_v4',
'HLT_DoubleEle8_CaloIdM_TrackIdM_Mass8_PFHT300_v7',
'HLT_DoublePhoton60_v4',
'HLT_DoublePhoton85_v5',
'HLT_ECALHT800_v4',
'HLT_Ele10_CaloIdM_TrackIdM_CentralPFJet30_BTagCSV_p13_v4',
'HLT_Ele12_CaloIdL_TrackIdL_IsoVL_PFJet30_v6',
'HLT_Ele12_CaloIdL_TrackIdL_IsoVL_v6',
'HLT_Ele12_CaloIdM_TrackIdM_PFJet30_v6',
'HLT_Ele16_Ele12_Ele8_CaloIdL_TrackIdL_v6',
'HLT_Ele17_CaloIdL_GsfTrkIdVL_v4',
'HLT_Ele17_CaloIdL_TrackIdL_IsoVL_PFJet30_v4',
'HLT_Ele17_CaloIdL_TrackIdL_IsoVL_v5',
'HLT_Ele17_CaloIdM_TrackIdM_PFJet30_v4',
'HLT_Ele17_Ele12_CaloIdL_TrackIdL_IsoVL_DZ_v6',
'HLT_Ele17_Ele12_CaloIdL_TrackIdL_IsoVL_v6',
'HLT_Ele23_CaloIdL_TrackIdL_IsoVL_PFJet30_v6',
'HLT_Ele23_CaloIdL_TrackIdL_IsoVL_v6',
'HLT_Ele23_CaloIdM_TrackIdM_PFJet30_v6',
'HLT_Ele23_Ele12_CaloIdL_TrackIdL_IsoVL_DZ_L1JetTauSeeded_v1',
'HLT_Ele23_Ele12_CaloIdL_TrackIdL_IsoVL_DZ_v6',
'HLT_Ele23_Ele12_CaloIdL_TrackIdL_IsoVL_v6',
'HLT_Ele27_HighEta_Ele20_Mass55_v4',
'HLT_Ele30WP60_Ele8_Mass55_v5',
'HLT_Ele30WP60_SC4_Mass55_v6',
'HLT_Ele8_CaloIdL_TrackIdL_IsoVL_PFJet30_v4',
'HLT_Ele8_CaloIdM_TrackIdM_PFJet30_v6',
'HLT_Photon26_R9Id85_OR_CaloId24b40e_Iso50T80L_Photon16_AND_HE10_R9Id65_Eta2_Mass60_v5',
'HLT_Photon36_R9Id85_OR_CaloId24b40e_Iso50T80L_Photon22_AND_HE10_R9Id65_Eta2_Mass15_v5',
'HLT_Photon42_R9Id85_OR_CaloId24b40e_Iso50T80L_Photon25_AND_HE10_R9Id65_Eta2_Mass15_v5'),
DoubleMuon = cms.vstring('HLT_DoubleMu18NoFiltersNoVtx_v3',
'HLT_DoubleMu23NoFiltersNoVtxDisplaced_v3',
'HLT_DoubleMu28NoFiltersNoVtxDisplaced_v3',
'HLT_DoubleMu33NoFiltersNoVtx_v3',
'HLT_DoubleMu38NoFiltersNoVtx_v3',
'HLT_DoubleMu8_Mass8_PFHT250_v3',
'HLT_DoubleMu8_Mass8_PFHT300_v6',
'HLT_L2DoubleMu23_NoVertex_v4',
'HLT_L2DoubleMu28_NoVertex_2Cha_Angle2p5_Mass10_v4',
'HLT_L2DoubleMu38_NoVertex_2Cha_Angle2p5_Mass10_v4',
'HLT_Mu10_CentralPFJet30_BTagCSV_p13_v2',
'HLT_Mu17_Mu8_DZ_v4',
'HLT_Mu17_Mu8_SameSign_DZ_v3',
'HLT_Mu17_Mu8_SameSign_v3',
'HLT_Mu17_Mu8_v3',
'HLT_Mu17_TkMu8_DZ_v3',
'HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_v4',
'HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_v4',
'HLT_Mu17_TrkIsoVVL_TkMu8_TrkIsoVVL_DZ_v3',
'HLT_Mu17_TrkIsoVVL_TkMu8_TrkIsoVVL_v3',
'HLT_Mu17_TrkIsoVVL_v3',
'HLT_Mu17_v3',
'HLT_Mu20_Mu10_DZ_v3',
'HLT_Mu20_Mu10_SameSign_DZ_v3',
'HLT_Mu20_Mu10_SameSign_v2',
'HLT_Mu20_Mu10_v3',
'HLT_Mu27_TkMu8_v3',
'HLT_Mu30_TkMu11_v3',
'HLT_Mu3_PFJet40_v3',
'HLT_Mu40_TkMu11_v3',
'HLT_Mu8_TrkIsoVVL_v4',
'HLT_Mu8_v4',
'HLT_TripleMu_12_10_5_v3',
'HLT_TripleMu_5_3_3_v1',
'HLT_TrkMu15_DoubleTrkMu5NoFiltersNoVtx_v4',
'HLT_TrkMu17_DoubleTrkMu8NoFiltersNoVtx_v4'),
DoubleMuonLowMass = cms.vstring('HLT_DoubleMu3_Trk_Tau3mu_v2',
'HLT_DoubleMu4_LowMassNonResonantTrk_Displaced_v4'),
EcalLaser = cms.vstring('HLT_EcalCalibration_v3'),
EmptyBX = cms.vstring('HLT_L1BptxMinus_v2',
'HLT_L1BptxPlus_v2',
'HLT_L1NotBptxOR_v2'),
EventDisplay = cms.vstring('HLT_AK4PFJet100_v4',
'HLT_AK8PFJet360_TrimMass30_v4',
'HLT_HISinglePhoton60_v3',
'HLT_Photon175_v6'),
ExpressPhysics = cms.vstring('HLT_Ele17_Ele12_CaloIdL_TrackIdL_IsoVL_DZ_v6',
'HLT_Ele23_Ele12_CaloIdL_TrackIdL_IsoVL_DZ_v6',
'HLT_Ele250_CaloIdVT_GsfTrkIdT_v4',
'HLT_Ele300_CaloIdVT_GsfTrkIdT_v4',
'HLT_HT2000_v3',
'HLT_HT2500_v3',
'HLT_IsoMu20_v4',
'HLT_IsoMu24_v2',
'HLT_L1FatEvents_v1',
'HLT_MET600_v3',
'HLT_MET700_v3',
'HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_v4',
'HLT_Mu300_v2',
'HLT_Mu350_v2',
'HLT_PFMET500_v3',
'HLT_PFMET600_v3',
'HLT_Photon500_v4',
'HLT_Photon600_v4',
'HLT_Physics_v4',
'HLT_Random_v2',
'HLT_ZeroBias_FirstCollisionAfterAbortGap_TCDS_v1',
'HLT_ZeroBias_FirstCollisionAfterAbortGap_v2',
'HLT_ZeroBias_IsolatedBunches_v3',
'HLT_ZeroBias_v4'),
FSQJets = cms.vstring('HLT_DiPFJet15_FBEta3_NoCaloMatched_v3',
'HLT_DiPFJet15_NoCaloMatched_v2',
'HLT_DiPFJet25_FBEta3_NoCaloMatched_v3',
'HLT_DiPFJet25_NoCaloMatched_v2',
'HLT_DiPFJetAve15_HFJEC_v2',
'HLT_DiPFJetAve25_HFJEC_v2',
'HLT_DiPFJetAve35_HFJEC_v2',
'HLT_PFJet15_NoCaloMatched_v4',
'HLT_PFJet25_NoCaloMatched_v2'),
HINCaloJets = cms.vstring('HLT_AK4CaloJet100_v3',
'HLT_AK4CaloJet30_v4',
'HLT_AK4CaloJet40_v3',
'HLT_AK4CaloJet50_v3',
'HLT_AK4CaloJet80_v3'),
HINPFJets = cms.vstring('HLT_AK4PFJet100_v4',
'HLT_AK4PFJet30_v4',
'HLT_AK4PFJet50_v4',
'HLT_AK4PFJet80_v4'),
HINPhoton = cms.vstring('HLT_HISinglePhoton10_v3',
'HLT_HISinglePhoton15_v3',
'HLT_HISinglePhoton20_v3',
'HLT_HISinglePhoton40_v3',
'HLT_HISinglePhoton60_v3'),
HLTMonitor = cms.vstring('HLT_DiPFJetAve40_v4',
'HLT_PFHT350_v5',
'HLT_PFMET120_BTagCSV_p067_v3',
'HLT_PFMET120_Mu5_v3',
'HLT_PFMET120_PFMHT120_IDTight_v4',
'HLT_QuadPFJet_BTagCSV_p016_VBF_Mqq460_v2',
'HLT_QuadPFJet_BTagCSV_p016_VBF_Mqq500_v2',
'HLT_QuadPFJet_BTagCSV_p016_p11_VBF_Mqq200_v2',
'HLT_QuadPFJet_BTagCSV_p016_p11_VBF_Mqq240_v2',
'HLT_QuadPFJet_VBF_v5'),
HLTPhysics = cms.vstring('HLT_L1FatEvents_v1',
'HLT_Physics_v4'),
HLTPhysics0 = cms.vstring('HLT_L1FatEvents_part0_v1'),
HLTPhysics1 = cms.vstring('HLT_L1FatEvents_part1_v1'),
HLTPhysics2 = cms.vstring('HLT_L1FatEvents_part2_v1'),
HLTPhysics3 = cms.vstring('HLT_L1FatEvents_part3_v1'),
HTMHT = cms.vstring('HLT_DiPFJet40_DEta3p5_MJJ600_PFMETNoMu140_v2',
'HLT_DiPFJet40_DEta3p5_MJJ600_PFMETNoMu80_v2',
'HLT_PFHT200_DiPFJetAve90_PFAlphaT0p57_v4',
'HLT_PFHT200_DiPFJetAve90_PFAlphaT0p63_v4',
'HLT_PFHT200_PFAlphaT0p51_v4',
'HLT_PFHT250_DiPFJetAve90_PFAlphaT0p55_v4',
'HLT_PFHT250_DiPFJetAve90_PFAlphaT0p58_v4',
'HLT_PFHT300_DiPFJetAve90_PFAlphaT0p53_v4',
'HLT_PFHT300_DiPFJetAve90_PFAlphaT0p54_v4',
'HLT_PFHT300_PFMET100_v3',
'HLT_PFHT300_PFMET110_v3',
'HLT_PFHT350_DiPFJetAve90_PFAlphaT0p52_v4',
'HLT_PFHT350_DiPFJetAve90_PFAlphaT0p53_v4',
'HLT_PFHT400_DiPFJetAve90_PFAlphaT0p51_v4',
'HLT_PFHT400_DiPFJetAve90_PFAlphaT0p52_v4',
'HLT_Rsq0p25_v3',
'HLT_Rsq0p30_v3',
'HLT_RsqMR240_Rsq0p09_MR200_4jet_v3',
'HLT_RsqMR240_Rsq0p09_MR200_v3',
'HLT_RsqMR270_Rsq0p09_MR200_4jet_v3',
'HLT_RsqMR270_Rsq0p09_MR200_v3'),
HcalHPDNoise = cms.vstring('HLT_GlobalRunHPDNoise_v4'),
HcalNZS = cms.vstring('HLT_HcalNZS_v3',
'HLT_HcalPhiSym_v3'),
HighMultiplicity85EOF = cms.vstring('HLT_PixelTracks_Multiplicity85ForEndOfFill_v2'),
HighMultiplicityEOF = cms.vstring('HLT_FullTracks_Multiplicity100_v2',
'HLT_FullTracks_Multiplicity130_v2',
'HLT_FullTracks_Multiplicity150_v2',
'HLT_FullTracks_Multiplicity80_v2',
'HLT_PixelTracks_Multiplicity110ForEndOfFill_v3',
'HLT_PixelTracks_Multiplicity135ForEndOfFill_v3',
'HLT_PixelTracks_Multiplicity160ForEndOfFill_v3',
'HLT_PixelTracks_Multiplicity60ForEndOfFill_v2'),
JetHT = cms.vstring('HLT_AK8DiPFJet250_200_TrimMass30_BTagCSV_p20_v2',
'HLT_AK8DiPFJet250_200_TrimMass30_v2',
'HLT_AK8DiPFJet280_200_TrimMass30_BTagCSV_p20_v2',
'HLT_AK8DiPFJet280_200_TrimMass30_v2',
'HLT_AK8PFHT600_TrimR0p1PT0p03Mass50_BTagCSV_p20_v3',
'HLT_AK8PFHT650_TrimR0p1PT0p03Mass50_v4',
'HLT_AK8PFHT700_TrimR0p1PT0p03Mass50_v5',
'HLT_AK8PFJet140_v1',
'HLT_AK8PFJet200_v1',
'HLT_AK8PFJet260_v1',
'HLT_AK8PFJet320_v1',
'HLT_AK8PFJet360_TrimMass30_v4',
'HLT_AK8PFJet400_v1',
'HLT_AK8PFJet40_v2',
'HLT_AK8PFJet450_v1',
'HLT_AK8PFJet500_v1',
'HLT_AK8PFJet60_v1',
'HLT_AK8PFJet80_v1',
'HLT_CaloJet500_NoJetID_v4',
'HLT_DiCentralPFJet170_CFMax0p1_v2',
'HLT_DiCentralPFJet170_v2',
'HLT_DiCentralPFJet220_CFMax0p3_v2',
'HLT_DiCentralPFJet330_CFMax0p5_v2',
'HLT_DiCentralPFJet430_v2',
'HLT_DiPFJetAve100_HFJEC_v4',
'HLT_DiPFJetAve140_v3',
'HLT_DiPFJetAve160_HFJEC_v4',
'HLT_DiPFJetAve200_v3',
'HLT_DiPFJetAve220_HFJEC_v4',
'HLT_DiPFJetAve260_v3',
'HLT_DiPFJetAve300_HFJEC_v4',
'HLT_DiPFJetAve320_v3',
'HLT_DiPFJetAve400_v3',
'HLT_DiPFJetAve40_v4',
'HLT_DiPFJetAve500_v3',
'HLT_DiPFJetAve60_HFJEC_v4',
'HLT_DiPFJetAve60_v4',
'HLT_DiPFJetAve80_HFJEC_v4',
'HLT_DiPFJetAve80_v3',
'HLT_HT2000_v3',
'HLT_HT2500_v3',
'HLT_L1_TripleJet_VBF_v5',
'HLT_PFHT125_v2',
'HLT_PFHT200_v3',
'HLT_PFHT250_v3',
'HLT_PFHT300_v4',
'HLT_PFHT350_v5',
'HLT_PFHT400_SixJet30_DoubleBTagCSV_p056_v2',
'HLT_PFHT400_SixJet30_v4',
'HLT_PFHT400_v4',
'HLT_PFHT450_SixJet40_BTagCSV_p056_v2',
'HLT_PFHT450_SixJet40_v4',
'HLT_PFHT475_v4',
'HLT_PFHT550_4JetPt50_v3',
'HLT_PFHT600_v5',
'HLT_PFHT650_4JetPt50_v3',
'HLT_PFHT650_WideJetMJJ900DEtaJJ1p5_v5',
'HLT_PFHT650_WideJetMJJ950DEtaJJ1p5_v5',
'HLT_PFHT650_v5',
'HLT_PFHT750_4JetPt50_v5',
'HLT_PFHT800_v4',
'HLT_PFHT900_v3',
'HLT_PFJet140_v5',
'HLT_PFJet200_v5',
'HLT_PFJet260_v5',
'HLT_PFJet320_v5',
'HLT_PFJet400_v5',
'HLT_PFJet40_v6',
'HLT_PFJet450_v5',
'HLT_PFJet500_v5',
'HLT_PFJet60_v6',
'HLT_PFJet80_v5',
'HLT_QuadPFJet_VBF_v5',
'HLT_SingleCentralPFJet170_CFMax0p1_v2'),
L1Accept = cms.vstring('DST_Physics_v2'),
L1MinimumBias = cms.vstring('HLT_L1MinimumBiasHF_AND_v2',
'HLT_L1MinimumBiasHF_OR_v2'),
MET = cms.vstring('HLT_CaloMHTNoPU90_PFMET90_PFMHT90_IDTight_BTagCSV_p067_v3',
'HLT_CaloMHTNoPU90_PFMET90_PFMHT90_IDTight_v4',
'HLT_DiCentralPFJet55_PFMET110_v3',
'HLT_DoubleMu3_PFMET50_v2',
'HLT_MET200_v3',
'HLT_MET250_v3',
'HLT_MET300_v3',
'HLT_MET600_v3',
'HLT_MET60_IsoTrk35_Loose_v2',
'HLT_MET700_v3',
'HLT_MET75_IsoTrk50_v4',
'HLT_MET90_IsoTrk50_v4',
'HLT_MonoCentralPFJet80_PFMETNoMu100_PFMHTNoMu100_IDTight_v4',
'HLT_MonoCentralPFJet80_PFMETNoMu110_PFMHTNoMu110_IDTight_v4',
'HLT_MonoCentralPFJet80_PFMETNoMu120_PFMHTNoMu120_IDTight_v4',
'HLT_MonoCentralPFJet80_PFMETNoMu90_PFMHTNoMu90_IDTight_v4',
'HLT_Mu14er_PFMET100_v2',
'HLT_Mu3er_PFHT140_PFMET125_v3',
'HLT_Mu6_PFHT200_PFMET100_v2',
'HLT_Mu6_PFHT200_PFMET80_BTagCSV_p067_v2',
'HLT_PFMET100_PFMHT100_IDTight_v4',
'HLT_PFMET110_PFMHT110_IDTight_v4',
'HLT_PFMET120_BTagCSV_p067_v3',
'HLT_PFMET120_Mu5_v3',
'HLT_PFMET120_PFMHT120_IDTight_v4',
'HLT_PFMET170_BeamHaloCleaned_v2',
'HLT_PFMET170_HBHECleaned_v4',
'HLT_PFMET170_NotCleaned_v3',
'HLT_PFMET300_v3',
'HLT_PFMET400_v3',
'HLT_PFMET500_v3',
'HLT_PFMET600_v3',
'HLT_PFMET90_PFMHT90_IDTight_v4',
'HLT_PFMETNoMu100_PFMHTNoMu100_IDTight_v4',
'HLT_PFMETNoMu110_PFMHTNoMu110_IDTight_v4',
'HLT_PFMETNoMu120_PFMHTNoMu120_IDTight_v4',
'HLT_PFMETNoMu90_PFMHTNoMu90_IDTight_v4'),
MonteCarlo = cms.vstring('MC_AK4CaloJets_v2',
'MC_AK4PFJets_v3',
'MC_AK8CaloHT_v2',
'MC_AK8PFHT_v3',
'MC_AK8PFJets_v3',
'MC_AK8TrimPFJets_v3',
'MC_CaloHT_v2',
'MC_CaloMET_JetIdCleaned_v2',
'MC_CaloMET_v2',
'MC_CaloMHT_v2',
'MC_Diphoton10_10_R9Id_OR_IsoCaloId_AND_HE_R9Id_Mass10_v4',
'MC_DoubleEle5_CaloIdL_GsfTrkIdVL_MW_v5',
'MC_DoubleGlbTrkMu_TrkIsoVVL_DZ_v2',
'MC_DoubleL1Tau_MediumIsoPFTau32_Trk1_eta2p1_Reg_v1',
'MC_DoubleMuNoFiltersNoVtx_v2',
'MC_DoubleMu_TrkIsoVVL_DZ_v2',
'MC_Ele15_Ele10_CaloIdL_TrackIdL_IsoVL_DZ_v5',
'MC_Ele5_WPLoose_Gsf_v5',
'MC_IsoMu_v5',
'MC_IsoTkMu15_v5',
'MC_LooseIsoPFTau20_v2',
'MC_LooseIsoPFTau50_Trk30_eta2p1_v1',
'MC_PFHT_v3',
'MC_PFMET_v3',
'MC_PFMHT_v3',
'MC_ReducedIterativeTracking_v2'),
MuOnia = cms.vstring('HLT_Dimuon0_Phi_Barrel_v4',
'HLT_Dimuon0_Upsilon_Muon_v3',
'HLT_Dimuon13_Upsilon_v3',
'HLT_Dimuon8_Upsilon_Barrel_v4',
'HLT_Mu16_TkMu0_dEta18_Onia_v3',
'HLT_Mu16_TkMu0_dEta18_Phi_v3',
'HLT_Mu25_TkMu0_dEta18_Onia_v4',
'HLT_Mu7p5_L2Mu2_Upsilon_v3',
'HLT_Mu7p5_Track2_Upsilon_v3',
'HLT_Mu7p5_Track3p5_Upsilon_v3',
'HLT_Mu7p5_Track7_Upsilon_v3',
'HLT_QuadMuon0_Dimuon0_Upsilon_v3'),
MuonEG = cms.vstring('HLT_DiMu9_Ele9_CaloIdL_TrackIdL_v6',
'HLT_Mu12_Photon25_CaloIdL_L1ISO_v6',
'HLT_Mu12_Photon25_CaloIdL_L1OR_v6',
'HLT_Mu12_Photon25_CaloIdL_v6',
'HLT_Mu17_Photon22_CaloIdL_L1ISO_v4',
'HLT_Mu17_Photon30_CaloIdL_L1ISO_v6',
'HLT_Mu17_Photon35_CaloIdL_L1ISO_v6',
'HLT_Mu17_TrkIsoVVL_Ele12_CaloIdL_TrackIdL_IsoVL_v6',
'HLT_Mu23NoFiltersNoVtx_Photon23_CaloIdL_v5',
'HLT_Mu23_TrkIsoVVL_Ele12_CaloIdL_TrackIdL_IsoVL_v6',
'HLT_Mu23_TrkIsoVVL_Ele8_CaloIdL_TrackIdL_IsoVL_v4',
'HLT_Mu27_Ele37_CaloIdL_GsfTrkIdVL_v3',
'HLT_Mu28NoFiltersNoVtxDisplaced_Photon28_CaloIdL_v5',
'HLT_Mu30_Ele30_CaloIdL_GsfTrkIdVL_v5',
'HLT_Mu33NoFiltersNoVtxDisplaced_Photon33_CaloIdL_v5',
'HLT_Mu37_Ele27_CaloIdL_GsfTrkIdVL_v3',
'HLT_Mu38NoFiltersNoVtx_Photon38_CaloIdL_v5',
'HLT_Mu42NoFiltersNoVtx_Photon42_CaloIdL_v5',
'HLT_Mu8_DiEle12_CaloIdL_TrackIdL_v6',
'HLT_Mu8_Ele8_CaloIdM_TrackIdM_Mass8_PFHT250_v4',
'HLT_Mu8_Ele8_CaloIdM_TrackIdM_Mass8_PFHT300_v7',
'HLT_Mu8_TrkIsoVVL_Ele17_CaloIdL_TrackIdL_IsoVL_v6',
'HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_v6'),
NoBPTX = cms.vstring('HLT_JetE30_NoBPTX3BX_v3',
'HLT_JetE30_NoBPTX_v3',
'HLT_JetE50_NoBPTX3BX_v2',
'HLT_JetE70_NoBPTX3BX_v2',
'HLT_L2Mu10_NoVertex_NoBPTX3BX_v2',
'HLT_L2Mu10_NoVertex_NoBPTX_v3',
'HLT_L2Mu35_NoVertex_3Sta_NoBPTX3BX_v2',
'HLT_L2Mu40_NoVertex_3Sta_NoBPTX3BX_v2'),
OnlineMonitor = cms.vstring( ('DST_CaloJet40_BTagScouting_v4',
'DST_CaloJet40_CaloBTagScouting_v3',
'DST_CaloJet40_CaloScouting_PFScouting_v4',
'DST_DoubleMu3_Mass10_BTagScouting_v4',
'DST_DoubleMu3_Mass10_CaloScouting_PFScouting_v3',
'DST_HT250_CaloBTagScouting_v2',
'DST_HT250_CaloScouting_v4',
'DST_HT410_BTagScouting_v4',
'DST_HT410_PFScouting_v4',
'DST_HT450_BTagScouting_v4',
'DST_HT450_PFScouting_v4',
'DST_L1DoubleMu_BTagScouting_v4',
'DST_L1DoubleMu_CaloScouting_PFScouting_v3',
'DST_L1HTT_BTagScouting_v4',
'DST_L1HTT_CaloBTagScouting_v3',
'DST_L1HTT_CaloScouting_PFScouting_v4',
'DST_ZeroBias_BTagScouting_v4',
'DST_ZeroBias_CaloScouting_PFScouting_v3',
'HLT_AK4CaloJet100_v3',
'HLT_AK4CaloJet30_v4',
'HLT_AK4CaloJet40_v3',
'HLT_AK4CaloJet50_v3',
'HLT_AK4CaloJet80_v3',
'HLT_AK4PFJet100_v4',
'HLT_AK4PFJet30_v4',
'HLT_AK4PFJet50_v4',
'HLT_AK4PFJet80_v4',
'HLT_AK8DiPFJet250_200_TrimMass30_BTagCSV_p20_v2',
'HLT_AK8DiPFJet250_200_TrimMass30_v2',
'HLT_AK8DiPFJet280_200_TrimMass30_BTagCSV_p20_v2',
'HLT_AK8DiPFJet280_200_TrimMass30_v2',
'HLT_AK8PFHT600_TrimR0p1PT0p03Mass50_BTagCSV_p20_v3',
'HLT_AK8PFHT650_TrimR0p1PT0p03Mass50_v4',
'HLT_AK8PFHT700_TrimR0p1PT0p03Mass50_v5',
'HLT_AK8PFJet140_v1',
'HLT_AK8PFJet200_v1',
'HLT_AK8PFJet260_v1',
'HLT_AK8PFJet320_v1',
'HLT_AK8PFJet360_TrimMass30_v4',
'HLT_AK8PFJet400_v1',
'HLT_AK8PFJet40_v2',
'HLT_AK8PFJet450_v1',
'HLT_AK8PFJet500_v1',
'HLT_AK8PFJet60_v1',
'HLT_AK8PFJet80_v1',
'HLT_BTagMu_AK8Jet300_Mu5_v2',
'HLT_BTagMu_DiJet110_Mu5_v3',
'HLT_BTagMu_DiJet170_Mu5_v2',
'HLT_BTagMu_DiJet20_Mu5_v3',
'HLT_BTagMu_DiJet40_Mu5_v3',
'HLT_BTagMu_DiJet70_Mu5_v3',
'HLT_BTagMu_Jet300_Mu5_v3',
'HLT_CaloJet500_NoJetID_v4',
'HLT_CaloMHTNoPU90_PFMET90_PFMHT90_IDTight_BTagCSV_p067_v3',
'HLT_CaloMHTNoPU90_PFMET90_PFMHT90_IDTight_v4',
'HLT_DiCentralPFJet170_CFMax0p1_v2',
'HLT_DiCentralPFJet170_v2',
'HLT_DiCentralPFJet220_CFMax0p3_v2',
'HLT_DiCentralPFJet330_CFMax0p5_v2',
'HLT_DiCentralPFJet430_v2',
'HLT_DiCentralPFJet55_PFMET110_v3',
'HLT_DiMu9_Ele9_CaloIdL_TrackIdL_v6',
'HLT_DiPFJet15_FBEta3_NoCaloMatched_v3',
'HLT_DiPFJet15_NoCaloMatched_v2',
'HLT_DiPFJet25_FBEta3_NoCaloMatched_v3',
'HLT_DiPFJet25_NoCaloMatched_v2',
'HLT_DiPFJet40_DEta3p5_MJJ600_PFMETNoMu140_v2',
'HLT_DiPFJet40_DEta3p5_MJJ600_PFMETNoMu80_v2',
'HLT_DiPFJetAve100_HFJEC_v4',
'HLT_DiPFJetAve140_v3',
'HLT_DiPFJetAve15_HFJEC_v2',
'HLT_DiPFJetAve160_HFJEC_v4',
'HLT_DiPFJetAve200_v3',
'HLT_DiPFJetAve220_HFJEC_v4',
'HLT_DiPFJetAve25_HFJEC_v2',
'HLT_DiPFJetAve260_v3',
'HLT_DiPFJetAve300_HFJEC_v4',
'HLT_DiPFJetAve320_v3',
'HLT_DiPFJetAve35_HFJEC_v2',
'HLT_DiPFJetAve400_v3',
'HLT_DiPFJetAve40_v4',
'HLT_DiPFJetAve500_v3',
'HLT_DiPFJetAve60_HFJEC_v4',
'HLT_DiPFJetAve60_v4',
'HLT_DiPFJetAve80_HFJEC_v4',
'HLT_DiPFJetAve80_v3',
'HLT_DiSC30_18_EIso_AND_HE_Mass70_v4',
'HLT_Dimuon0_Jpsi_Muon_v3',
'HLT_Dimuon0_Phi_Barrel_v4',
'HLT_Dimuon0_Upsilon_Muon_v3',
'HLT_Dimuon0er16_Jpsi_NoOS_NoVertexing_v3',
'HLT_Dimuon0er16_Jpsi_NoVertexing_v3',
'HLT_Dimuon10_Jpsi_Barrel_v4',
'HLT_Dimuon13_PsiPrime_v3',
'HLT_Dimuon13_Upsilon_v3',
'HLT_Dimuon16_Jpsi_v3',
'HLT_Dimuon20_Jpsi_v3',
'HLT_Dimuon6_Jpsi_NoVertexing_v3',
'HLT_Dimuon8_PsiPrime_Barrel_v4',
'HLT_Dimuon8_Upsilon_Barrel_v4',
'HLT_Diphoton30EB_18EB_R9Id_OR_IsoCaloId_AND_HE_R9Id_DoublePixelVeto_Mass55_v4',
'HLT_Diphoton30PV_18PV_R9Id_AND_IsoCaloId_AND_HE_R9Id_DoublePixelVeto_Mass55_v4',
'HLT_Diphoton30_18_R9Id_OR_IsoCaloId_AND_HE_R9Id_DoublePixelSeedMatch_Mass70_v4',
'HLT_Diphoton30_18_R9Id_OR_IsoCaloId_AND_HE_R9Id_Mass90_v4',
'HLT_Diphoton30_18_Solid_R9Id_AND_IsoCaloId_AND_HE_R9Id_Mass55_v4',
'HLT_DoubleEle24_22_eta2p1_WPLoose_Gsf_v5',
'HLT_DoubleEle33_CaloIdL_GsfTrkIdVL_MW_v6',
'HLT_DoubleEle33_CaloIdL_GsfTrkIdVL_v6',
'HLT_DoubleEle33_CaloIdL_MW_v4',
'HLT_DoubleEle33_CaloIdL_v4',
'HLT_DoubleEle37_Ele27_CaloIdL_GsfTrkIdVL_v4',
'HLT_DoubleEle8_CaloIdM_TrackIdM_Mass8_PFHT250_v4',
'HLT_DoubleEle8_CaloIdM_TrackIdM_Mass8_PFHT300_v7',
'HLT_DoubleIsoMu17_eta2p1_noDzCut_v2',
'HLT_DoubleIsoMu17_eta2p1_v4',
'HLT_DoubleJet90_Double30_DoubleBTagCSV_p087_v2',
'HLT_DoubleJet90_Double30_TripleBTagCSV_p087_v2',
'HLT_DoubleJetsC100_DoubleBTagCSV_p014_DoublePFJetsC100MaxDeta1p6_v2',
'HLT_DoubleJetsC100_DoubleBTagCSV_p026_DoublePFJetsC160_v2',
'HLT_DoubleJetsC100_SingleBTagCSV_p014_SinglePFJetC350_v2',
'HLT_DoubleJetsC100_SingleBTagCSV_p014_v2',
'HLT_DoubleJetsC100_SingleBTagCSV_p026_SinglePFJetC350_v2',
'HLT_DoubleJetsC100_SingleBTagCSV_p026_v2',
'HLT_DoubleJetsC112_DoubleBTagCSV_p014_DoublePFJetsC112MaxDeta1p6_v2',
'HLT_DoubleJetsC112_DoubleBTagCSV_p026_DoublePFJetsC172_v2',
'HLT_DoubleMediumIsoPFTau32_Trk1_eta2p1_Reg_v2',
'HLT_DoubleMediumIsoPFTau35_Trk1_eta2p1_Reg_v3',
'HLT_DoubleMediumIsoPFTau40_Trk1_eta2p1_Reg_v5',
'HLT_DoubleMu18NoFiltersNoVtx_v3',
'HLT_DoubleMu23NoFiltersNoVtxDisplaced_v3',
'HLT_DoubleMu28NoFiltersNoVtxDisplaced_v3',
'HLT_DoubleMu33NoFiltersNoVtx_v3',
'HLT_DoubleMu38NoFiltersNoVtx_v3',
'HLT_DoubleMu3_PFMET50_v2',
'HLT_DoubleMu3_Trk_Tau3mu_v2',
'HLT_DoubleMu4_3_Bs_v4',
'HLT_DoubleMu4_3_Jpsi_Displaced_v4',
'HLT_DoubleMu4_JpsiTrk_Displaced_v4',
'HLT_DoubleMu4_LowMassNonResonantTrk_Displaced_v4',
'HLT_DoubleMu4_PsiPrimeTrk_Displaced_v4',
'HLT_DoubleMu8_Mass8_PFHT250_v3',
'HLT_DoubleMu8_Mass8_PFHT300_v6',
'HLT_DoublePhoton60_v4',
'HLT_DoublePhoton85_v5',
'HLT_ECALHT800_v4',
'HLT_Ele105_CaloIdVT_GsfTrkIdT_v6',
'HLT_Ele10_CaloIdM_TrackIdM_CentralPFJet30_BTagCSV_p13_v4',
'HLT_Ele115_CaloIdVT_GsfTrkIdT_v5',
'HLT_Ele12_CaloIdL_TrackIdL_IsoVL_PFJet30_v6',
'HLT_Ele12_CaloIdL_TrackIdL_IsoVL_v6',
'HLT_Ele12_CaloIdM_TrackIdM_PFJet30_v6',
'HLT_Ele15_IsoVVVL_BTagCSV_p067_PFHT400_v4',
'HLT_Ele15_IsoVVVL_PFHT350_PFMET50_v5',
'HLT_Ele15_IsoVVVL_PFHT350_v5',
'HLT_Ele15_IsoVVVL_PFHT400_PFMET50_v3',
'HLT_Ele15_IsoVVVL_PFHT400_v3',
'HLT_Ele15_IsoVVVL_PFHT600_v6',
'HLT_Ele16_Ele12_Ele8_CaloIdL_TrackIdL_v6',
'HLT_Ele17_CaloIdL_GsfTrkIdVL_v4',
'HLT_Ele17_CaloIdL_TrackIdL_IsoVL_PFJet30_v4',
'HLT_Ele17_CaloIdL_TrackIdL_IsoVL_v5',
'HLT_Ele17_CaloIdM_TrackIdM_PFJet30_v4',
'HLT_Ele17_Ele12_CaloIdL_TrackIdL_IsoVL_DZ_v6',
'HLT_Ele17_Ele12_CaloIdL_TrackIdL_IsoVL_v6',
'HLT_Ele22_eta2p1_WPLoose_Gsf_LooseIsoPFTau20_SingleL1_v5',
'HLT_Ele22_eta2p1_WPLoose_Gsf_v6',
'HLT_Ele23_CaloIdL_TrackIdL_IsoVL_PFJet30_v6',
'HLT_Ele23_CaloIdL_TrackIdL_IsoVL_v6',
'HLT_Ele23_CaloIdM_TrackIdM_PFJet30_v6',
'HLT_Ele23_Ele12_CaloIdL_TrackIdL_IsoVL_DZ_L1JetTauSeeded_v1',
'HLT_Ele23_Ele12_CaloIdL_TrackIdL_IsoVL_DZ_v6',
'HLT_Ele23_Ele12_CaloIdL_TrackIdL_IsoVL_v6',
'HLT_Ele23_WPLoose_Gsf_WHbbBoost_v5',
'HLT_Ele23_WPLoose_Gsf_v6',
'HLT_Ele24_eta2p1_WPLoose_Gsf_LooseIsoPFTau20_SingleL1_v4',
'HLT_Ele24_eta2p1_WPLoose_Gsf_LooseIsoPFTau20_v4',
'HLT_Ele24_eta2p1_WPLoose_Gsf_v4',
'HLT_Ele250_CaloIdVT_GsfTrkIdT_v4',
'HLT_Ele25_WPTight_Gsf_v4',
'HLT_Ele25_eta2p1_WPLoose_Gsf_v4',
'HLT_Ele25_eta2p1_WPTight_Gsf_v4',
'HLT_Ele27_HighEta_Ele20_Mass55_v4',
'HLT_Ele27_WPLoose_Gsf_WHbbBoost_v5',
'HLT_Ele27_WPLoose_Gsf_v4',
'HLT_Ele27_WPTight_Gsf_L1JetTauSeeded_v1',
'HLT_Ele27_WPTight_Gsf_v4',
'HLT_Ele27_eta2p1_WPLoose_Gsf_DoubleMediumIsoPFTau32_Trk1_eta2p1_Reg_v4',
'HLT_Ele27_eta2p1_WPLoose_Gsf_DoubleMediumIsoPFTau35_Trk1_eta2p1_Reg_v5',
'HLT_Ele27_eta2p1_WPLoose_Gsf_DoubleMediumIsoPFTau40_Trk1_eta2p1_Reg_v6',
'HLT_Ele27_eta2p1_WPLoose_Gsf_HT200_v5',
'HLT_Ele27_eta2p1_WPLoose_Gsf_LooseIsoPFTau20_SingleL1_v4',
'HLT_Ele27_eta2p1_WPLoose_Gsf_v5',
'HLT_Ele27_eta2p1_WPTight_Gsf_v5',
'HLT_Ele300_CaloIdVT_GsfTrkIdT_v4',
'HLT_Ele30WP60_Ele8_Mass55_v5',
'HLT_Ele30WP60_SC4_Mass55_v6',
'HLT_Ele32_eta2p1_WPLoose_Gsf_LooseIsoPFTau20_SingleL1_v4',
'HLT_Ele32_eta2p1_WPTight_Gsf_v5',
'HLT_Ele35_CaloIdVT_GsfTrkIdT_PFJet150_PFJet50_v4',
'HLT_Ele35_WPLoose_Gsf_v4',
'HLT_Ele45_CaloIdVT_GsfTrkIdT_PFJet200_PFJet50_v6',
'HLT_Ele45_WPLoose_Gsf_L1JetTauSeeded_v1',
| |
"""
# pylint: disable-msg=too-many-locals
def __init__(self,
name: str = '',
command: Optional[List[str]] = None,
environment: Optional[Dict[str, str]] = None,
artifacts: str = '',
report_artifacts: str = '',
artifact_prebuild_clean: bool = False,
directory: str = '',
critical: bool = False,
background: bool = False,
finish_background: bool = False,
code_report: bool = False,
pass_tag: str = '',
fail_tag: str = '',
if_env_set: str = '',
**kwargs) -> None:
self.name: str = name
self.directory: str = directory
self.code_report: bool = code_report
self.command: List[str] = command if command else []
self.environment: Dict[str, str] = environment if environment else {}
self.artifacts: str = artifacts
self.report_artifacts: str = report_artifacts
self.artifact_prebuild_clean: bool = artifact_prebuild_clean
self.critical: bool = critical
self.background: bool = background
self.finish_background: bool = finish_background
self.pass_tag: str = pass_tag
self.fail_tag: str = fail_tag
self.if_env_set: str = if_env_set
self.children: Optional['Configuration'] = None
self._extras: Dict[str, str] = {}
for key, value in kwargs.items():
self._extras[key] = value
def __repr__(self) -> str:
"""
This function simulates `dict`-like representation for string output. This is useful when printing contents of
:class:`Configuration` objects, as internally they wrap a list of :class:`Step` objects
:return: a `dict`-like string
>>> step = Step(name='foo', command=['bar'], my_var='baz')
>>> repr(step)
"{'name': 'foo', 'command': 'bar', 'my_var': 'baz'}"
"""
res = {k: v for k, v in self.__dict__.items() if v and k != '_extras'}
res.update(self._extras)
if len(self.command) == 1: # command should be printed as one string, instead of list
res['command'] = self.command[0]
return str(res)
def __eq__(self, other: Any) -> bool:
"""
This functions simulates `dict`-like check for match
:param other: `dict` to compare values, or :class:`Step` object to check equality
:return: `True` if `other` matches
>>> step1 = Step(name='foo', my_var='bar')
>>> step2 = Step(name='foo', my_var='bar')
>>> step3 = Step(name='foo', my_var='bar', critical=True)
>>> step1 == step1
True
>>> step1 == step2
True
>>> step1 == step3
False
>>> step1 == {'name': 'foo', 'my_var': 'bar'}
True
>>> step1 == {'name': 'foo', 'my_var': 'bar', 'critical': False}
True
>>> step1 == {'name': 'foo', 'my_var': 'bar', 'test': None}
True
>>> step1 == {'name': 'foo', 'my_var': 'bar', 'test': ''}
True
>>> step1 == {'name': 'foo', 'my_var': 'bar', 'test': ' '}
False
"""
if isinstance(other, Step):
return self == other.__dict__
if isinstance(other, dict):
for key, val in other.items():
if val and self[key] != val:
return False
return True
return super().__eq__(other)
def __getitem__(self, key: str) -> Any:
"""
This functions simulates `dict`-like legacy read access
.. note::
It is recommended to use field-like access to non user-defined attributes of Step.
This preserves data type information for mypy static analysis.
:param key: client-defined item
:return: client-defined value
>>> step = Step(name='foo', my_var='bar')
>>> step['name'] == step.name == 'foo'
True
Note that step['name'] has type 'Any', but step.name has type 'str'
>>> step['my_var']
'bar'
>>> step['test']
"""
# _extras are checked first - just in case _extras field is added manually
# do note that __setitem__ checks predefined fields first, however it's impossible to shadow them by
# modifying _extras
return self._extras.get(key, self.__dict__.get(key, None))
def __setitem__(self, key: str, value: Any) -> None:
"""
This functions simulates `dict`-like legacy write access
.. note::
It is recommended to use field-like access to non user-defined attributes of Step.
This allows static analysis to catch possible type mismatch.
:param key: client-defined key
:param value: client-defined value
>>> import warnings
>>> def do_and_get_warnings(f):
... with warnings.catch_warnings(record=True) as w:
... warnings.simplefilter("always")
... f()
... return w
>>> def assign_legacy(o, k, v):
... o[k] = v
>>> def assign_name_legacy(o, v):
... o['name'] = v
>>> def assign_name_new(o, v):
... o.name = v
>>> step = Step(name='foo', my_var='bar')
>>> do_and_get_warnings(lambda : assign_legacy(step, 'name', 'bar')) # doctest: +ELLIPSIS
[<warnings.WarningMessage object at ...>]
>>> step['name']
'bar'
>>> do_and_get_warnings(lambda : assign_name_new(step, 'baz')) # doctest: +ELLIPSIS
[]
>>> step['name']
'baz'
>>> do_and_get_warnings(lambda : assign_legacy(step, 'directory', 'foo')) # doctest: +ELLIPSIS
[<warnings.WarningMessage object at ...>]
>>> do_and_get_warnings(lambda : assign_legacy(step, 'test', 42))
[]
>>> do_and_get_warnings(lambda : assign_legacy(step, '_extras', {'name': 'baz'}))
[]
>>> step
{'name': 'baz', 'directory': 'foo', 'my_var': 'bar', 'test': 42, '_extras': {'name': 'baz'}}
"""
if key in self.__dict__ and key != '_extras':
warn("Re-defining the value of Step field. Please use var." + key + " to set it instead of "
"using var['" + key + "']")
self.__dict__[key] = value
else:
self._extras[key] = value
def get(self, key: str, default: Any = None) -> Any:
"""
This functions simulates `dict`-like legacy read access
.. note::
It is recommended to use field-like access to non user-defined attributes of Step.
This preserves data type information for mypy static analysis.
:param key: client-defined item
:param default: value to return if `key` is absent in `dict`
:return: client-defined value
>>> import warnings
>>> def do_and_get_warnings(f):
... with warnings.catch_warnings(record=True) as w:
... warnings.simplefilter("always")
... f()
... return w
>>> step = Step(name='foo', my_var='bar')
>>> do_and_get_warnings(lambda : step.get('name', 'test')) # doctest: +ELLIPSIS
[<warnings.WarningMessage object at ...>]
Note that step.get('name') has type 'Any', but step.name has type 'str'
>>> step.get('my_var', 'test')
'bar'
>>> step.get('my_var_2', 'test')
'test'
>>> step.get('command', 'test')
'test'
"""
result = self._extras.get(key)
if result:
return result
result = self.__dict__.get(key)
if result:
warn("Using legacy API to access configuration values. Please use var." + key + " instead.")
return result
return default
def __add__(self, other: 'Step') -> 'Step':
"""
This functions defines operator ``+`` for :class:`Step` class objects by
concatenating strings and contents of dictionaries. Note that `critical` attribute is not merged.
:param other: `Step` object
:return: new `Step` object, including all attributes from both `self` and `other` objects
>>> step1 = Step(name='foo', command=['foo'], critical=True, my_var1='foo')
>>> step2 = Step(name='bar', command=['bar'], background=True, my_var1='bar', my_var2='baz')
>>> step1 + step2
{'name': 'foobar', 'command': ['foo', 'bar'], 'background': True, 'my_var1': 'foobar', 'my_var2': 'baz'}
"""
return Step(
name=self.name + other.name,
command=self.command + other.command,
environment=combine(self.environment, other.environment),
artifacts=self.artifacts + other.artifacts,
report_artifacts=self.report_artifacts + other.report_artifacts,
artifact_prebuild_clean=self.artifact_prebuild_clean or other.artifact_prebuild_clean,
directory=self.directory + other.directory,
critical=False,
background=self.background or other.background,
finish_background=self.finish_background or other.finish_background,
code_report=self.code_report or other.code_report,
pass_tag=self.pass_tag + other.pass_tag,
fail_tag=self.fail_tag + other.fail_tag,
if_env_set=self.if_env_set + other.if_env_set,
**combine(self._extras, other._extras)
)
def replace_string(self, from_string: str, to_string: str) -> None:
"""
Replace instances of a string, used for pseudo-variables
:param from_string: string to replace, e.g. `${CODE_REPORT_FILE}`
:param to_string: value to put in place of `from_string`
>>> step = Step(name='foo test', command=['foo', 'baz', 'foobar'], myvar1='foo', myvar2='bar', myvar3=1)
>>> step.replace_string('foo', 'bar')
>>> step
{'name': 'foo test', 'command': ['bar', 'baz', 'barbar'], 'myvar1': 'bar', 'myvar2': 'bar', 'myvar3': 1}
>>> step = Step(artifacts='foo', report_artifacts='foo', directory='foo')
>>> step.replace_string('foo', 'bar')
>>> step
{'directory': 'bar', 'artifacts': 'bar', 'report_artifacts': 'bar'}
"""
self.command = [word.replace(from_string, to_string) for word in self.command]
self.artifacts = self.artifacts.replace(from_string, to_string)
self.report_artifacts = self.report_artifacts.replace(from_string, to_string)
self.directory = self.directory.replace(from_string, to_string)
for k, v in self._extras.items():
if isinstance(v, str):
self._extras[k] = v.replace(from_string, to_string)
def stringify_command(self) -> bool:
"""
Concatenates components of a command into one element
:return: `True`, if any of the command components have space inside
>>> step = Step(name='stringify test', command=['foo', 'bar', '--baz'])
>>> step.stringify_command()
False
>>> step
{'name': 'stringify test', 'command': 'foo bar --baz'}
>>> step.stringify_command()
True
"""
result = False
command_line = ""
for argument in self.command:
if " " in argument:
argument = "\"" + argument + "\""
result = True
command_line = command_line + " " + argument if command_line else argument
self.command = [command_line] if command_line else []
return result
DictType = TypeVar('DictType', bound=dict)
def combine(dictionary_a: DictType, dictionary_b: DictType) -> DictType:
# TODO: move to utils, as this is no longer specific to configurations
"""
Combine two dictionaries using plus operator for matching keys
:param dictionary_a: may have any keys and values
:param dictionary_b: may have any keys, but the values of keys, matching `dictionary_a`,
should be the compatible, so that `dictionary_a[key] + dictionary_b[key]` is a valid expression
:return: new dictionary containing all keys from both `dictionary_a` and `dictionary_b`;
for each matching key the value in resulting dictionary is a sum of two corresponding values
For example:
>>> combine(dict(attr_a = "a1", attr_b = ["b11", "b12"]), dict(attr_a = "a2", attr_b = ["b2"]))
{'attr_a': 'a1a2', 'attr_b': | |
"""
Magic Link.
pymdownx.magiclink
An extension for Python Markdown.
Find http|ftp links and email address and turn them to actual links
MIT license.
Copyright (c) 2014 - 2017 <NAME> <<EMAIL>>
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
documentation files (the "Software"), to deal in the Software without restriction, including without limitation
the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions
of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
"""
from __future__ import unicode_literals
from markdown import Extension
from markdown.inlinepatterns import LinkPattern, Pattern
from markdown.treeprocessors import Treeprocessor
from markdown import util as md_util
from . import util
from .util import PymdownxDeprecationWarning
import warnings
import re
import os
MAGIC_LINK = 1
MAGIC_AUTO_LINK = 2
RE_MAIL = r'''(?xi)
(
(?<![-/\+@a-z\d_])(?:[-+a-z\d_]([-a-z\d_+]|\.(?!\.))*) # Local part
(?<!\.)@(?:[-a-z\d_]+\.) # @domain part start
(?:(?:[-a-z\d_]|(?<!\.)\.(?!\.))*)[a-z]\b # @domain.end (allow multiple dot names)
(?![-@]) # Don't allow last char to be followed by these
)
'''
RE_LINK = r'''(?xi)
(
(?:(?<=\b)|(?<=_))(?:
(?:ht|f)tps?://(?:(?:[^_\W][-\w]*(?:\.[-\w.]+)+)|localhost)| # (http|ftp)://
(?P<www>w{3}\.)[^_\W][-\w]*(?:\.[-\w.]+)+ # www.
)
/?[-\w.?,!'(){}\[\]/+&@%$#=:"|~;]* # url path, fragments, and query stuff
(?:[^_\W]|[-/#@$+=]) # allowed end chars
)
'''
RE_SHORTHANDS = r'''(?x)
(?:
(?P<mention>(?<![a-zA-Z])@[a-zA-Z\d](?:[-a-zA-Z\d_]{0,37}[a-zA-Z\d])?)
(?:/(?P<mention_repo>[-._a-zA-Z\d]{0,99}[a-zA-Z\d]))? |
(?<![@/])(?:
(?:(?P<user>\b[a-zA-Z\d](?:[-a-zA-Z\d_]{0,37}[a-zA-Z\d])?)/)?
(?P<repo>\b[-._a-zA-Z\d]{0,99}[a-zA-Z\d])
)
(?:(?P<issue>(?:\#|!)[1-9][0-9]*)|(?P<commit>@[a-f\d]{40})) |
(?:(?<![a-zA-Z])(?P<issue2>(?:\#|!)[1-9][0-9]*)|(?P<commit2>(?<![@/])\b[a-f\d]{40}))
)\b
'''
RE_EXTERNAL_SHORTHANDS = r'''(?x)
(?:
(?P<mention>(?<![a-zA-Z])@(?P<provider>(?:github|gitlab|bitbucket):)[a-zA-Z\d](?:[-a-zA-Z\d_]{0,37}[a-zA-Z\d])?)
(?:/(?P<mention_repo>[-._a-zA-Z\d]{,99}[a-zA-Z\d]))? |
(?<![@/])(?:
(?P<provider2>\b(?:github|gitlab|bitbucket):)
(?P<user>[a-zA-Z\d](?:[-a-zA-Z\d_]{0,37}[a-zA-Z\d])?)/
(?P<repo>[-._a-zA-Z\d]{0,99}[a-zA-Z\d])
)
(?:(?P<issue>(?:\#|!)[1-9][0-9]*)|(?P<commit>@[a-f\d]{40}))
)\b
'''
RE_AUTOLINK = r'(?i)<((?:ht|f)tps?://[^>]*)>'
RE_REPO_LINK = re.compile(
r'''(?xi)
(?:
(?P<github>(?P<github_base>https://(?:w{3}\.)?github.com/(?P<github_user_repo>[^/]+/[^/]+))/
(?:issues/(?P<github_issue>\d+)/?|
pull/(?P<github_pull>\d+)/?|
commit/(?P<github_commit>[\da-f]{40})/?)) |
(?P<bitbucket>(?P<bitbucket_base>https://(?:w{3}\.)?bitbucket.org/(?P<bitbucket_user_repo>[^/]+/[^/]+))/
(?:issues/(?P<bitbucket_issue>\d+)(?:/[^/]+)?/?|
pull-requests/(?P<bitbucket_pull>\d+)(?:/[^/]+(?:/diff)?)?/?|
commits/commit/(?P<bitbucket_commit>[\da-f]{40})/?)) |
(?P<gitlab>(?P<gitlab_base>https://(?:w{3}\.)?gitlab.com/(?P<gitlab_user_repo>[^/]+/[^/]+))/
(?:issues/(?P<gitlab_issue>\d+)/?|
merge_requests/(?P<gitlab_pull>\d+)/?|
commit/(?P<gitlab_commit>[\da-f]{40})/?))
)
'''
)
PROVIDER_INFO = {
"gitlab": {
"provider": "GitLab",
"url": "https://gitlab.com",
"issue": "https://gitlab.com/%s/%s/issues/%s",
"pull": "https://gitlab.com/%s/%s/merge_requests/%s",
"commit": "https://gitlab.com/%s/%s/commit/%s",
"hash_size": 8
},
"bitbucket": {
"provider": "Bitbucket",
"url": "https://bitbucket.org",
"issue": "https://bitbucket.org/%s/%s/issues/%s",
"pull": "https://bitbucket.org/%s/%s/pull-requests/%s",
"commit": "https://bitbucket.org/%s/%s/commits/commit/%s",
"hash_size": 7
},
"github": {
"provider": "GitHub",
"url": "https://github.com",
"issue": "https://github.com/%s/%s/issues/%s",
"pull": "https://github.com/%s/%s/pull/%s",
"commit": "https://github.com/%s/%s/commit/%s",
"hash_size": 7
}
}
class MagicShortenerTreeprocessor(Treeprocessor):
"""Treeprocessor that finds repo issue and commit links and shortens them."""
# Repo link types
ISSUE = 0
PULL = 1
COMMIT = 2
def __init__(self, md, base_url, base_user_url, labels):
"""Initialize."""
self.base = base_url
self.base_user = base_user_url
self.repo_labels = labels
self.labels = {
"github": "GitHub",
"bitbucket": "Bitbucket",
"gitlab": "GitLab"
}
Treeprocessor.__init__(self, md)
def shorten(self, link, provider, my_repo, my_user, link_type, user_repo, value, url, hash_size):
"""Shorten url."""
label = PROVIDER_INFO[provider]['provider']
prov_class = 'magiclink-%s' % provider
class_attr = link.get('class', '')
class_name = class_attr.split(' ') if class_attr else []
if 'magiclink' not in class_name:
class_name.append('magiclink')
if prov_class not in class_name:
class_name.append(prov_class)
if link_type is self.COMMIT:
# user/repo@hash
repo_label = self.repo_labels.get('commit', 'Commit')
if my_repo:
text = value[0:hash_size]
elif my_user:
text = '%s@%s' % (user_repo.split('/')[1], value[0:hash_size])
else:
text = '%s@%s' % (user_repo, value[0:hash_size])
link.text = md_util.AtomicString(text)
if 'magiclink-commit' not in class_name:
class_name.append('magiclink-commit')
link.set(
'title',
'%s %s: %s@%s' % (label, repo_label, user_repo.rstrip('/'), value[0:hash_size])
)
else:
# user/repo#(issue|pull)
if link_type == self.ISSUE:
issue_type = self.repo_labels.get('issue', 'Issue')
separator = '#'
if 'magiclink-issue' not in class_name:
class_name.append('magiclink-issue')
else:
issue_type = self.repo_labels.get('pull', 'Pull Request')
separator = '!'
if 'magiclink-pull' not in class_name:
class_name.append('magiclink-pull')
if my_repo:
text = separator + value
elif my_user:
text = user_repo.split('/')[1] + separator + value
else:
text = user_repo + separator + value
link.text = md_util.AtomicString(text)
link.set('title', '%s %s: %s%s%s' % (label, issue_type, user_repo.rstrip('/'), separator, value))
link.set('class', ' '.join(class_name))
def get_provider(self, match):
"""Get the provider and hash size."""
# Set provider specific variables
if match.group('github'):
provider = 'github'
elif match.group('bitbucket'):
provider = 'bitbucket'
elif match.group('gitlab'):
provider = 'gitlab'
return provider
def get_type(self, provider, match):
"""Get the link type."""
# Gather info about link type
if match.group(provider + '_commit') is not None:
value = match.group(provider + '_commit')
link_type = self.COMMIT
elif match.group(provider + '_pull') is not None:
value = match.group(provider + '_pull')
link_type = self.PULL
else:
value = match.group(provider + '_issue')
link_type = self.ISSUE
return value, link_type
def is_my_repo(self, provider, match):
"""Check if link is from our specified user and repo."""
# See if these links are from the specified repo.
return self.base and match.group(provider + '_base') + '/' == self.base
def is_my_user(self, provider, match):
"""Check if link is from our specified user."""
return self.base_user and match.group(provider + '_base').startswith(self.base_user)
def run(self, root):
"""Shorten popular git repository links."""
self.hide_protocol = self.config['hide_protocol']
links = root.iter('a')
for link in links:
has_child = len(list(link))
is_magic = link.attrib.get('magiclink')
href = link.attrib.get('href', '')
text = link.text
if is_magic:
del link.attrib['magiclink']
# We want a normal link. No subelements embedded in it, just a normal string.
if has_child or not text: # pragma: no cover
continue
# Make sure the text matches the href. If needed, add back protocol to be sure.
# Not all links will pass through MagicLink, so we try both with and without protocol.
if (text == href or (is_magic and self.hide_protocol and ('https://' + text) == href)):
m = RE_REPO_LINK.match(href)
if m:
provider = self.get_provider(m)
my_repo = self.is_my_repo(provider, m)
my_user = my_repo or self.is_my_user(provider, m)
value, link_type = self.get_type(provider, m)
# All right, everything set, let's shorten.
self.shorten(
link,
provider,
my_repo,
my_user,
link_type,
m.group(provider + '_user_repo'),
value,
href,
PROVIDER_INFO[provider]['hash_size']
)
return root
class MagiclinkPattern(LinkPattern):
"""Convert html, ftp links to clickable links."""
def handleMatch(self, m):
"""Handle URL matches."""
el = md_util.etree.Element("a")
el.text = md_util.AtomicString(m.group(2))
if m.group("www"):
href = "http://%s" % m.group(2)
else:
href = m.group(2)
if self.config['hide_protocol']:
el.text = md_util.AtomicString(el.text[el.text.find("://") + 3:])
el.set("href", self.sanitize_url(self.unescape(href.strip())))
if self.config.get('repo_url_shortener', False):
el.set('magiclink', md_util.text_type(MAGIC_LINK))
return el
class MagiclinkAutoPattern(Pattern):
"""Return a link Element given an autolink `<http://example/com>`."""
def handleMatch(self, m):
"""Return link optionally without protocol."""
el = md_util.etree.Element("a")
el.set('href', self.unescape(m.group(2)))
el.text = md_util.AtomicString(m.group(2))
if self.config['hide_protocol']:
el.text = md_util.AtomicString(el.text[el.text.find("://") + 3:])
if self.config.get('repo_url_shortener', False):
el.set('magiclink', md_util.text_type(MAGIC_AUTO_LINK))
return el
class MagicMailPattern(LinkPattern):
"""Convert emails to clickable email links."""
def email_encode(self, code):
"""Return entity definition by code, or the code if not defined."""
return "%s#%d;" % (md_util.AMP_SUBSTITUTE, code)
def handleMatch(self, m):
"""Handle email link patterns."""
el = md_util.etree.Element("a")
email = self.unescape(m.group(2))
href = "mailto:%s" % email
el.text = md_util.AtomicString(''.join([self.email_encode(ord(c)) for c in email]))
el.set("href", ''.join([md_util.AMP_SUBSTITUTE + '#%d;' % ord(c) for c in href]))
return el
class MagiclinkShorthandPattern(Pattern):
"""Convert emails to clickable email links."""
def __init__(self, pattern, md, user, repo, provider, labels, external=False):
"""Initialize."""
self.user = user
self.repo = repo
self.labels = labels
self.provider = provider
self.external = external
Pattern.__init__(self, pattern, md)
def process_mention(self, el, provider, mention):
"""Process mention."""
prov = provider if provider else self.provider
el.set('href', '%s/%s' % (PROVIDER_INFO[prov]['url'], mention[1:]))
el.set(
'title',
"%s %s: %s" % (PROVIDER_INFO[prov]['provider'], self.labels.get('mention', "User"), mention[1:])
)
el.set('class', 'magiclink magiclink-%s magiclink-mention' % prov)
el.text = md_util.AtomicString(mention)
return el
def process_mention_repo(self, el, provider, mention, repo_name):
"""Process mentioned repository."""
prov = provider if provider else self.provider
el.set('href', '%s/%s/%s' % (PROVIDER_INFO[prov]['url'], mention[1:], repo_name))
el.set(
'title',
"%s %s: %s/%s" % (
PROVIDER_INFO[prov]['provider'], self.labels.get('repository', 'Repository'), mention[1:], repo_name
)
)
el.set('class', 'magiclink magiclink-%s magiclink-repository' % prov)
user = mention[1:]
# if user == self.user and prov == self.provider:
# el.text = md_util.AtomicString(repo_name)
# else:
el.text = md_util.AtomicString('%s/%s' % (user, repo_name))
return el
def process_issues(self, el, provider, user, repo, issue):
"""Process issues."""
my_repo = not repo
my_user = not user
if my_repo:
repo = self.repo
if my_user:
user = self.user
prov = provider if provider else self.provider
issue_value = issue[1:]
issue_type = issue[:1]
if issue_type == '#':
issue_link = PROVIDER_INFO[prov]['issue']
issue_label = self.labels.get('issue', 'Issue')
class_name = 'magiclink-issue'
else:
issue_link = PROVIDER_INFO[prov]['pull']
issue_label = self.labels.get('pull', 'Pull Request')
class_name = 'magiclink-pull'
if my_repo:
text = '%s%s' % (issue_type, issue_value)
elif my_user:
text = '%s%s%s' % (repo, issue_type, issue_value)
else:
text = '%s/%s%s%s' % (user, repo, issue_type, issue_value)
el.set('href', issue_link % (user, repo, issue_value))
el.text = md_util.AtomicString(text)
el.set('class', 'magiclink magiclink-%s %s' % (prov, class_name))
el.set(
'title',
'%s %s: %s/%s%s%s' % (
PROVIDER_INFO[prov]['provider'],
issue_label,
user,
repo,
issue_type,
issue_value
)
)
def | |
# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
# For details: https://github.com/nedbat/coveragepy/blob/master/NOTICE.txt
"""Determining whether files are being measured/reported or not."""
# For finding the stdlib
import atexit
import inspect
import itertools
import os
import platform
import re
import sys
import traceback
from coverage import env
from coverage.backward import code_object
from coverage.disposition import FileDisposition, disposition_init
from coverage.files import TreeMatcher, FnmatchMatcher, ModuleMatcher
from coverage.files import prep_patterns, find_python_files, canonical_filename
from coverage.misc import CoverageException
from coverage.python import source_for_file, source_for_morf
# Pypy has some unusual stuff in the "stdlib". Consider those locations
# when deciding where the stdlib is. These modules are not used for anything,
# they are modules importable from the pypy lib directories, so that we can
# find those directories.
_structseq = _pypy_irc_topic = None
if env.PYPY:
try:
import _structseq
except ImportError:
pass
try:
import _pypy_irc_topic
except ImportError:
pass
def canonical_path(morf, directory=False):
"""Return the canonical path of the module or file `morf`.
If the module is a package, then return its directory. If it is a
module, then return its file, unless `directory` is True, in which
case return its enclosing directory.
"""
morf_path = canonical_filename(source_for_morf(morf))
if morf_path.endswith("__init__.py") or directory:
morf_path = os.path.split(morf_path)[0]
return morf_path
def name_for_module(filename, frame):
"""Get the name of the module for a filename and frame.
For configurability's sake, we allow __main__ modules to be matched by
their importable name.
If loaded via runpy (aka -m), we can usually recover the "original"
full dotted module name, otherwise, we resort to interpreting the
file name to get the module's name. In the case that the module name
can't be determined, None is returned.
"""
module_globals = frame.f_globals if frame is not None else {}
if module_globals is None: # pragma: only ironpython
# IronPython doesn't provide globals: https://github.com/IronLanguages/main/issues/1296
module_globals = {}
dunder_name = module_globals.get('__name__', None)
if isinstance(dunder_name, str) and dunder_name != '__main__':
# This is the usual case: an imported module.
return dunder_name
loader = module_globals.get('__loader__', None)
for attrname in ('fullname', 'name'): # attribute renamed in py3.2
if hasattr(loader, attrname):
fullname = getattr(loader, attrname)
else:
continue
if isinstance(fullname, str) and fullname != '__main__':
# Module loaded via: runpy -m
return fullname
# Script as first argument to Python command line.
inspectedname = inspect.getmodulename(filename)
if inspectedname is not None:
return inspectedname
else:
return dunder_name
def module_is_namespace(mod):
"""Is the module object `mod` a PEP420 namespace module?"""
return hasattr(mod, '__path__') and getattr(mod, '__file__', None) is None
def module_has_file(mod):
"""Does the module object `mod` have an existing __file__ ?"""
mod__file__ = getattr(mod, '__file__', None)
if mod__file__ is None:
return False
return os.path.exists(mod__file__)
class InOrOut(object):
"""Machinery for determining what files to measure."""
def __init__(self, warn):
self.warn = warn
# The matchers for should_trace.
self.source_match = None
self.source_pkgs_match = None
self.pylib_paths = self.cover_paths = None
self.pylib_match = self.cover_match = None
self.include_match = self.omit_match = None
self.plugins = []
self.disp_class = FileDisposition
# The source argument can be directories or package names.
self.source = []
self.source_pkgs = []
self.source_pkgs_unmatched = []
self.omit = self.include = None
def configure(self, config):
"""Apply the configuration to get ready for decision-time."""
for src in config.source or []:
if os.path.isdir(src):
self.source.append(canonical_filename(src))
else:
self.source_pkgs.append(src)
self.source_pkgs_unmatched = self.source_pkgs[:]
self.omit = prep_patterns(config.run_omit)
self.include = prep_patterns(config.run_include)
# The directories for files considered "installed with the interpreter".
self.pylib_paths = set()
if not config.cover_pylib:
# Look at where some standard modules are located. That's the
# indication for "installed with the interpreter". In some
# environments (virtualenv, for example), these modules may be
# spread across a few locations. Look at all the candidate modules
# we've imported, and take all the different ones.
for m in (atexit, inspect, os, platform, _pypy_irc_topic, re, _structseq, traceback):
if m is not None and hasattr(m, "__file__"):
self.pylib_paths.add(canonical_path(m, directory=True))
if _structseq and not hasattr(_structseq, '__file__'):
# PyPy 2.4 has no __file__ in the builtin modules, but the code
# objects still have the file names. So dig into one to find
# the path to exclude. The "filename" might be synthetic,
# don't be fooled by those.
structseq_file = code_object(_structseq.structseq_new).co_filename
if not structseq_file.startswith("<"):
self.pylib_paths.add(canonical_path(structseq_file))
# To avoid tracing the coverage.py code itself, we skip anything
# located where we are.
self.cover_paths = [canonical_path(__file__, directory=True)]
if env.TESTING:
# Don't include our own test code.
self.cover_paths.append(os.path.join(self.cover_paths[0], "tests"))
# When testing, we use PyContracts, which should be considered
# part of coverage.py, and it uses six. Exclude those directories
# just as we exclude ourselves.
import contracts
import six
for mod in [contracts, six]:
self.cover_paths.append(canonical_path(mod))
# Create the matchers we need for should_trace
if self.source or self.source_pkgs:
self.source_match = TreeMatcher(self.source)
self.source_pkgs_match = ModuleMatcher(self.source_pkgs)
else:
if self.cover_paths:
self.cover_match = TreeMatcher(self.cover_paths)
if self.pylib_paths:
self.pylib_match = TreeMatcher(self.pylib_paths)
if self.include:
self.include_match = FnmatchMatcher(self.include)
if self.omit:
self.omit_match = FnmatchMatcher(self.omit)
def should_trace(self, filename, frame=None):
"""Decide whether to trace execution in `filename`, with a reason.
This function is called from the trace function. As each new file name
is encountered, this function determines whether it is traced or not.
Returns a FileDisposition object.
"""
original_filename = filename
disp = disposition_init(self.disp_class, filename)
def nope(disp, reason):
"""Simple helper to make it easy to return NO."""
disp.trace = False
disp.reason = reason
return disp
if frame is not None:
# Compiled Python files have two file names: frame.f_code.co_filename is
# the file name at the time the .pyc was compiled. The second name is
# __file__, which is where the .pyc was actually loaded from. Since
# .pyc files can be moved after compilation (for example, by being
# installed), we look for __file__ in the frame and prefer it to the
# co_filename value.
dunder_file = frame.f_globals and frame.f_globals.get('__file__')
if dunder_file:
filename = source_for_file(dunder_file)
if original_filename and not original_filename.startswith('<'):
orig = os.path.basename(original_filename)
if orig != os.path.basename(filename):
# Files shouldn't be renamed when moved. This happens when
# exec'ing code. If it seems like something is wrong with
# the frame's file name, then just use the original.
filename = original_filename
if not filename:
# Empty string is pretty useless.
return nope(disp, "empty string isn't a file name")
if filename.startswith('memory:'):
return nope(disp, "memory isn't traceable")
if filename.startswith('<'):
# Lots of non-file execution is represented with artificial
# file names like "<string>", "<doctest readme.txt[0]>", or
# "<exec_function>". Don't ever trace these executions, since we
# can't do anything with the data later anyway.
return nope(disp, "not a real file name")
# pyexpat does a dumb thing, calling the trace function explicitly from
# C code with a C file name.
if re.search(r"[/\\]Modules[/\\]pyexpat.c", filename):
return nope(disp, "pyexpat lies about itself")
# Jython reports the .class file to the tracer, use the source file.
if filename.endswith("$py.class"):
filename = filename[:-9] + ".py"
canonical = canonical_filename(filename)
disp.canonical_filename = canonical
# Try the plugins, see if they have an opinion about the file.
plugin = None
for plugin in self.plugins.file_tracers:
if not plugin._coverage_enabled:
continue
try:
file_tracer = plugin.file_tracer(canonical)
if file_tracer is not None:
file_tracer._coverage_plugin = plugin
disp.trace = True
disp.file_tracer = file_tracer
if file_tracer.has_dynamic_source_filename():
disp.has_dynamic_filename = True
else:
disp.source_filename = canonical_filename(
file_tracer.source_filename()
)
break
except Exception:
self.warn(
"Disabling plug-in %r due to an exception:" % (plugin._coverage_plugin_name)
)
traceback.print_exc()
plugin._coverage_enabled = False
continue
else:
# No plugin wanted it: it's Python.
disp.trace = True
disp.source_filename = canonical
if not disp.has_dynamic_filename:
if not disp.source_filename:
raise CoverageException(
"Plugin %r didn't set source_filename for %r" %
(plugin, disp.original_filename)
)
reason = self.check_include_omit_etc(disp.source_filename, frame)
if reason:
nope(disp, reason)
return disp
def check_include_omit_etc(self, filename, frame):
"""Check a file name against the include, omit, etc, rules.
Returns a string or None. String means, don't trace, and is the reason
why. None means no reason found to not trace.
"""
modulename = name_for_module(filename, frame)
# If the user specified source or include, then that's authoritative
# about the outer bound of what to measure and we don't have to apply
# any canned exclusions. If they didn't, then we have to exclude the
# stdlib and coverage.py directories.
if self.source_match:
if self.source_pkgs_match.match(modulename):
if modulename in self.source_pkgs_unmatched:
self.source_pkgs_unmatched.remove(modulename)
elif not self.source_match.match(filename):
return "falls outside the --source trees"
elif self.include_match:
| |
# Open the database to keep "done" records,
# and delete moldy, old in-progress records.
g.mdb = searchdatabasemongo.CSearchDatabase(g.sSearchDbMongoName,
g.sSearchDbProgressCollectionName,
g.sSearchDbDoneCollectionName)
g.mdb.fnvDeleteProgressCollection()
# Get the set of instructions for today from database.
NTRC.tracef(0,"MAIN","proc querydict2|%s|"
% (list(util.fngSortDictItemsByKeys(dQuery))))
itAllInstructions = searchspace.fndgGetSearchSpace(g.sInsDir, g.sInsTyp,
dQuery)
# Start the start-end threads.
# Define queues.
# Need a Multiprocessing Manager to own the output queue. (Do we?) (Yes.)
mpmgr = mp.Manager()
g.qJobs = mp.Queue()
g.qOutput = mpmgr.Queue()
# Start pool of worker processes.
g.cWorkersInst = cworkers.CWorkers(nservers=g.nCores
, qinputjobs=g.qJobs, qoutputdata=g.qOutput)
# If this wasn't just a listonly run, do all the cases.
if not g.sListOnly.startswith("Y"):
NTRC.ntracef(3, "MAIN", "proc all instr|%s|" % (g.lGiantInstr))
else:
NTRC.ntracef(0, "MAIN", "Listonly.")
nRuns = fnnProcessAllInstructions(itAllInstructions)
NTRC.ntracef(0, "MAIN", "End queued all runs ncases|%s|" % (g.nCases,))
#===========================================================
# f n n P r o c e s s A l l I n s t r u c t i o n s
@catchex
@ntracef("MAIN")
def fnnProcessAllInstructions(myitInstructionIterator):
'''
Get the set of instructions that match the user's criteria for this batch,
and run them one by one.
Each instruction (run) is executed once for each random seed value.
Count the number of runs, and don't exceed the user's limit, if any.
If the execution reports a serious error, stop the loop.
'''
nRunNumber = 0
maxcount = int(g.nTestLimit)
# Is this a completely fake test run? Replace templates.
if g.sTestFib.startswith("Y"):
g.lTemplates = g.lFibTemplates
# Process each instruction in turn.
for dRawInstruction in myitInstructionIterator:
NTRC.ntracef(3,"MAIN","proc main raw instruction\n|%s|"
% (dRawInstruction))
dInstruction = fndMaybeEnhanceInstruction(dRawInstruction)
NTRC.ntracef(3,"MAIN","proc main enhanced instruction\n|%s|"
% (dInstruction))
# Execute each instruction many times, once for each random seed value.
nRunNumber += 1
fnnProcessOneInstructionManyTimes(nRunNumber
, dInstruction)
# If user asked for a short test run today, maybe stop now.
maxcount -= 1
if int(g.nTestLimit) > 0 and maxcount <= 0: break
# That's all, folks. All instructions have been queued and will
# eventually be processed.
# Send the shutdown messages to worker processes.
g.cWorkersInst.Close()
return nRunNumber
#===========================================================
# f n s t P r o c e s s O n e I n s t r u c t i o n M a n y T i m e s
@catchex
@ntracef("MAIN")
def fnnProcessOneInstructionManyTimes(mynRunNumber, mydInstruction):
'''
Process a single instruction (set of params) once for each of a
predetermined number and sequence of random seeds.
Assign an id to each run that consists of the instruction hash (_id)
followed by _<seed number>.
'''
lManyInstr = []
lSeedsToUse = fnlGetRandomSeeds(util.fnIntPlease(g.nRandomSeeds),
g.sRandomSeedFile)
mydInstruction["sBaseId"] = str(mydInstruction["_id"])
for (nIdx, nMaybeSeed) in enumerate(lSeedsToUse):
# Adjust run number and mongo id because there are now
# multiple seeds and runs per instruction.
sRunId = str(mynRunNumber) + "." + str(nIdx+1)
sId = str(mydInstruction["sBaseId"])
mydInstruction["_id"] = sId + "_" + str(nIdx+1)
mydInstruction["_runid"] = sRunId
nStatus = 0
try:
nSeed = int(nMaybeSeed)
except ValueError:
raise ValueError("Random seed not integer |%s|" % (nMaybeSeed))
mydInstruction["nRandomseed"] = nSeed
tOneInstr = fntProcessOneInstruction(sRunId, mydInstruction, nSeed)
return g.nRandomSeeds
#===========================================================
# f n t P r o c e s s O n e I n s t r u c t i o n
@catchex
@ntracef("MAIN")
def fntProcessOneInstruction(mysRunNumber, mydInstruction, mynSeed):
'''
Process one single instruction for one run.
Slightly convoluted logic required here.
If just testing today, print instruction contents but do not run it.
If the instruction has already been processed, skip over it unless
the user requires it to be redone.
("Has been processed" = there is a MongoDB "done" record with the
same key. The key is the concatenation of all options and the
seed number.)
The instruction is actually executed by some worker process at
sometime in the future. We just queue the instruction for processing.
'''
sInstructionId = str(mydInstruction["_id"])
# If this instruction has already been processed, maybe skip it.
bIsItDone = g.mdb.fnbIsItDone(sInstructionId)
if bIsItDone and not g.sRedo.startswith("Y"):
# If the user has not insisted on redo, skip it.
NTRC.ntracef(0,"MAIN","proc skip item already done run|%s| "
"id|%s| copies|%s| lifem|%s|"
% (mysRunNumber, sInstructionId, mydInstruction["nCopies"],
mydInstruction["nLifem"]))
else:
# If the user specifies, redo this case even if was done before.
if g.sRedo.startswith("Y"):
NTRC.ntracef(0,"MAIN","proc force redo of run|%s| id|%s| "
% (mysRunNumber, sInstructionId))
# Well, maybe. Could be listonly.
if g.sListOnly.startswith("Y"):
NTRC.ntracef(0,"MAIN","proc ListOnly, item run|%s| "
"ncopies|%s| lifem|%s| id|%s| dict|%s|"
% (mysRunNumber, mydInstruction["nCopies"], mydInstruction["nLifem"],
sInstructionId, list(util.fngSortDictItemsByKeys(mydInstruction))))
else:
# Okay, not listonly, therefore really do this instruction.
mydInstruction["nRandomSeed"] = mynSeed
NTRC.ntracef(0,"MAIN","proc queue instr, item run|%s| "
"ncopies|%s| lifem|%s| id|%s|"
% (mysRunNumber, mydInstruction["nCopies"], mydInstruction["nLifem"],
sInstructionId))
# Format commands to be executed by somebody.
g.sShelfLogFileName = g.cFmt.msGentlyFormat(
g.sShelfLogFileTemplate, mydInstruction, g, CG)
g.lCommands = []
for sTemplate in g.lTemplates:
sCmd = g.cFmt.msGentlyFormat(sTemplate, mydInstruction, g, CG)
g.lCommands.append(sCmd)
# Where do files go, and what are they called.
g.sActorLogDir = g.cFmt.msGentlyFormat(
g.sActorLogDirTemplate, mydInstruction, g, CG)
# Record that this job will soon be running.
mydInstruction["starttime"] = util.fnsGetTimeStamp()
g.mdb.fndInsertProgressRecord(mydInstruction["_id"], mydInstruction)
# Return the full instruction to caller, too.
tThisInst = cworkers.tInstruction(cmdlist=g.lCommands
, logname=g.sShelfLogFileName + "_case.log"
, logdir=g.sActorLogDir
)
# Send the instruction out to be done. Just drop it in the
# queue (think of it as the outbox).
# g.qJobs.put(tThisInst)
fnSendOneJobSlowly(tThisInst, g.qJobs)
g.nCases += 1
return tThisInst
# f n S e n d O n e J o b S l o w l y
@ntracef("QTHR")
def fnSendOneJobSlowly(myInstruction, myqJobs):
''' Queue this instruction as a job.
If the queue size gets out of hand, wait for
some jobs to be removed from it.0
'''
# If qsize > hi threshold, wait for it to come down.
""" Boy, the walrus operator would really come in handy here.
But that would restrict us to Python versions >= 3.8.
if (nQSize := myqJobs.qsize()) > g.nQThreshHi:
NTRC.ntracef(3, "QTHR", "proc qsize over hi |%s|" % (nQSize))
while (nQSize := myqJobs.qsize()) > g.nQThreshLo:
time.sleep(g.nQThreshSleep)
NTRC.ntracef(3, "QTHR", "proc qsize under lo |%s|" % (nQSize))
"""
nQSize = myqJobs.qsize()
if nQSize > g.nQThreshHi:
NTRC.ntracef(3, "QTHR", "proc qsize over hi |%s|" % (nQSize))
while True:
time.sleep(g.nQThreshSleep)
nQSize = myqJobs.qsize()
if nQSize < g.nQThreshLo:
break
NTRC.ntracef(3, "QTHR", "proc qsize under lo |%s|" % (nQSize))
# Okay, now queue the job.
myqJobs.put(myInstruction)
return nQSize
#===========================================================
# Utility functions:
# - Get list of random seeds
# - Get environment vars that control timing
# - Keep text log of commands to broker
# - Check for valid dirs
#===========================================================
# f n l G e t R a n d o m S e e d s
@catchex
@ntracef("MAIN")
def fnlGetRandomSeeds(mynHowMany, mysFilename):
'''
Return a list of the first mynHowMany random seeds from the
file specified.
This is the primitive version that does not permit blank lines,
comments, or other detritus in the list of seed numbers.
'''
with open(mysFilename, "r") as fhSeeds:
lsSeeds = [(next(fhSeeds)) for _ in range(mynHowMany)]
lnSeeds = [util.fnIntPlease(_) for _ in lsSeeds]
return lnSeeds
#===========================================================
# f n v G e t E n v i r o n m e n t O v e r r i d e s
@catchex
@ntracef("MAIN")
def fnvGetEnvironmentOverrides():
'''
Get a few arguments from environment variables, which are
allowed to override built-in defaults.
'''
# Allow user to override number of cores to use today.
# Utility routine looks at HW and possible user envir override.
g.nCores = brokergetcores.fnnGetResolvedCores()
NTRC.ntracef(0, "MAIN", "proc ncores|%s|" % (g.nCores))
# If you want to overbook the available cores, do it here.
g.nParallel = g.nCores # Sorry for the name change.
# Allow user to override the polite interval to use today.
try:
g.nPoliteTimer = int(os.getenv("NPOLITE", CG.nPoliteTimer))
g.nCoreTimer = g.nPoliteTimer # Sorry for the name change.
NTRC.ntracef(0, "MAIN", "proc politetimer|%s|msec" % (g.nPoliteTimer))
except (ValueError, TypeError):
raise TypeError("Environment variable NPOLITE must be "
"an integer number of milliseconds.")
#===========================================================
# f n s R e c o n s t | |
"""Contains plot functions."""
from platform import system
import numpy as np
import matplotlib.pyplot as plt
from matplotlib import gridspec
from matplotlib.lines import Line2D
from matplotlib.patches import Polygon
from . import utils as ut
from . import salt_utils as salt_ut
from . import nb_fun as nbf
def plt_maximize():
"""Enable full screen.
Notes
-----
Come from
https://stackoverflow.com/questions/12439588/how-to-maximize-a-plt-show-window-using-python/22418354#22418354
"""
# See discussion on:
# https://stackoverflow.com/questions/12439588/how-to-maximize-a-plt-show-window-using-python
backend = plt.get_backend()
cfm = plt.get_current_fig_manager()
if backend == "wxAgg":
cfm.frame.Maximize(True)
elif backend == "TkAgg":
if system() == "win32":
cfm.window.state('zoomed') # This is windows only
else:
cfm.resize(*cfm.window.maxsize())
elif backend in ('QT4Agg', 'QT5Agg'):
cfm.window.showMaximized()
elif callable(getattr(cfm, "full_screen_toggle", None)):
if not getattr(cfm, "flag_is_max", None):
cfm.full_screen_toggle()
cfm.flag_is_max = True
else:
raise RuntimeError("plt_maximize() is not implemented for current backend:", backend)
def param_text_box(text_ax, model_name, sim_par=None, fit_par=None, pos=[0.01, 0.25]):
"""Add a text legend with model parameters to the plot.
Parameters
----------
text_ax : matplotlib.axes
Axes where place the text.
model_name : str
The name of the sn model that is used.
sim_par : list(float)
The parameters of the model.
fit_par : list(tuple(float,float))
The fitted parameters and errors.
"""
par_dic = {'salt': [('t0', '.2f'), ('x0', '.2e'), ('mb', '.2f'), ('x1', '.2f'), ('c', '.3f')],
'mw_': [('Rv', '.2f'), ('E(B-V)', '.3f')]}
par = par_dic[model_name]
str_list = [''] * (len(par) + 1)
if sim_par is not None:
str_list[0] += 'SIMULATED PARAMETERS :@'
if fit_par is not None:
str_list[0] += 'FITTED PARAMETERS :@'
for i, p in enumerate(par):
if sim_par is not None:
str_list[i + 1] += f"{p[0]} = {sim_par[i]:{p[1]}}@"
if fit_par is not None:
if isinstance(fit_par[i], (int, float)):
str_list[i + 1] += f"{p[0]} = {fit_par[i]:{p[1]}}"
else:
str_list[i + 1] += f"{p[0]} = {fit_par[i][0]:{p[1]}} $\pm$ {fit_par[i][1]:{p[1]}}@"
final_str = ""
if str_list[0].count('@') == 2:
len_str = []
for i, s in enumerate(str_list):
str_list[i] = s.split('@')
len_str.append(len(str_list[i][0]))
max_len = np.max(len_str)
for i in range(len(str_list)):
final_str += str_list[i][0] + " " * (max_len - len_str[i] + 2) + "| "
final_str += str_list[i][1] + "\n"
elif str_list[0].count('@') == 1:
for i, s in enumerate(str_list):
final_str += str_list[i][:-1] + '\n'
prop = dict(boxstyle='round,pad=1', facecolor='navajowhite', alpha=0.5)
text_ax.axis('off')
text_ax.text(pos[0], pos[1], final_str[:-1], transform=text_ax.transAxes, fontsize=9, bbox=prop)
def plot_lc(
flux_table,
meta,
zp=25.,
mag=False,
Jy=False,
snc_sim_model=None,
snc_fit_model=None,
fit_cov=None,
residuals=False,
full_screen=False,
figsize=(35 / 2.54, 20 / 2.54),
dpi=120):
"""Ploting a lightcurve flux table.
Parameters
----------
flux_table : astropy.Table
The lightcurve to plot.
zp : float, default = 25.
Zeropoint at which rescale the flux.
mag : bool
If True plot the magnitude.
snc_sim_model : sncosmo.Model
Model used to simulate the lightcurve.
snc_fit_model : sncosmo.Model
Model used to fit the lightcurve.
fit_cov : numpy.ndaray(float, size=(4, 4))
sncosmo t0, x0, x1, c covariance matrix from SALT fit.
residuals : bool
If True plot fit residuals.
full_screen : bool
Try to plot the figure in full screen.
Returns
-------
None
Just plot the lightcurve.
"""
plt.rcParams['font.family'] = 'monospace'
bands = np.unique(flux_table['band'])
flux_norm, fluxerr_norm = ut.norm_flux(flux_table, zp)
time = flux_table['time']
t0 = meta['sim_t0']
z = meta['zobs']
time_th = np.linspace(t0 - 19.8 * (1 + z), t0 + 49.8 * (1 + z), 200)
fig = plt.figure(figsize=figsize, dpi=dpi)
###################
# INIT THE FIGURE #
###################
if residuals:
gs = gridspec.GridSpec(3, 1, height_ratios=[0.5, 2, 1])
text_ax = fig.add_subplot(gs[0])
ax0 = fig.add_subplot(gs[1])
ax1 = fig.add_subplot(gs[2], sharex=ax0)
ax1_y_lim = []
elif snc_sim_model is None and (snc_fit_model is None or fit_cov is None):
gs = gridspec.GridSpec(1, 1, height_ratios=[1])
ax0 = fig.add_subplot(gs[0])
else:
gs = gridspec.GridSpec(2, 1, height_ratios=[0.5, 2])
text_ax = fig.add_subplot(gs[0])
ax0 = fig.add_subplot(gs[1])
fig.suptitle(f'SN at redshift z : {z:.5f} and peak at time t$_0$ : {t0:.2f} MJD',
fontsize='xx-large')
plt.xlabel('Time relative to peak', fontsize='x-large')
################
# PLOT SECTION #
################
for b in bands:
band_mask = flux_table['band'] == b
flux_b = flux_norm[band_mask]
fluxerr_b = fluxerr_norm[band_mask]
time_b = time[band_mask]
if mag:
ax0.invert_yaxis()
ax0.set_ylabel('Mag', fontsize='x-large')
# Delete < 0 pts
flux_mask = flux_b > 0
flux_b = flux_b[flux_mask]
fluxerr_b = fluxerr_b[flux_mask]
time_b = time_b[flux_mask]
plot = -2.5 * np.log10(flux_b) + zp
err = 2.5 / np.log(10) * 1 / flux_b * fluxerr_b
if snc_sim_model is not None:
plot_th = snc_sim_model.bandmag(b, 'ab', time_th)
if snc_fit_model is not None:
plot_fit = snc_fit_model.bandmag(b, 'ab', time_th)
if fit_cov is not None:
if snc_fit_model.source.name in ('salt2', 'salt3'):
err_th = salt_ut.compute_salt_fit_error(snc_fit_model,
fit_cov[1:, 1:],
b, time_th, zp)
err_th = 2.5 / \
(np.log(10) * 10**(-0.4 * (plot_fit - zp))) * err_th
if residuals:
fit_pts = snc_fit_model.bandmag(b, 'ab', time_b)
rsd = plot - fit_pts
else:
if Jy:
ax0.set_ylabel('Flux [$\mu$Jy]', fontsize='x-large')
norm = ut.flux_to_Jansky(zp, b)
else:
ax0.set_ylabel(f'Flux (ZP = {zp})', fontsize='x-large')
norm = 1.0
ax0.axhline(ls='dashdot', c='black', lw=1.5)
plot = flux_b * norm
err = fluxerr_b * norm
if snc_sim_model is not None:
plot_th = snc_sim_model.bandflux(b, time_th, zp=zp, zpsys='ab') * norm
if snc_fit_model is not None:
plot_fit = snc_fit_model.bandflux(
b, time_th, zp=zp, zpsys='ab') * norm
if fit_cov is not None:
if snc_fit_model.source.name in ('salt2', 'salt3'):
err_th = salt_ut.compute_salt_fit_error(snc_fit_model, fit_cov[1:, 1:],
b, time_th, zp) * norm
if residuals:
fit_pts = snc_fit_model.bandflux(b, time_b, zp=zp, zpsys='ab') * norm
rsd = plot - fit_pts
p = ax0.errorbar(time_b - t0, plot, yerr=err,
label=b, fmt='o', markersize=2.5)
handles, labels = ax0.get_legend_handles_labels()
if snc_sim_model is not None:
ax0.plot(time_th - t0, plot_th, color=p[0].get_color())
sim_line = Line2D([0], [0], color='k', linestyle='solid')
sim_label = 'Sim'
handles.append(sim_line)
labels.append(sim_label)
if snc_fit_model is not None:
fit_line = Line2D([0], [0], color='k', linestyle='--')
fit_label = 'Fit'
handles.append(fit_line)
labels.append(fit_label)
ax0.plot(time_th - t0, plot_fit, color=p[0].get_color(), ls='--')
if fit_cov is not None:
ax0.fill_between(
time_th - t0,
plot_fit - err_th,
plot_fit + err_th,
alpha=0.5)
if residuals:
ax1.set_ylabel('Data - Model', fontsize='x-large')
ax1.errorbar(time_b - t0, rsd, yerr=err, fmt='o')
ax1.axhline(0, ls='dashdot', c='black', lw=1.5)
ax1_y_lim.append(3 * np.std(rsd))
ax1.plot(time_th - t0, err_th, ls='--', color=p[0].get_color())
ax1.plot(time_th - t0, -err_th, ls='--', color=p[0].get_color())
ax0.legend(handles=handles, labels=labels, fontsize='x-large')
sim_par = None
sim_mwd_par = None
fit_par = None
fit_mwd_par = None
if snc_sim_model is not None:
plt.xlim(snc_sim_model.mintime() - t0, snc_sim_model.maxtime() - t0)
sim_par = [meta['sim_t0'],
meta['sim_x0'],
meta['sim_mb'],
meta['sim_x1'],
meta['sim_c']]
if 'mw_' in snc_sim_model.effect_names:
sim_mwd_par = []
if 'mw_r_v' in meta:
sim_mwd_par.append(meta['mw_r_v'])
else:
mod_index = np.where(np.array(snc_sim_model.effect_names) == 'mw_')[0][0]
sim_mwd_par.append(snc_sim_model.effects[mod_index]._r_v)
sim_mwd_par.append(meta['mw_ebv'])
elif snc_fit_model is not None:
plt.xlim(snc_fit_model.mintime() - t0, snc_fit_model.maxtime() - t0)
else:
plt.xlim(np.min(time) - 1 - t0, np.max(time) + 1 - t0)
if residuals:
ax1.set_ylim(-np.nanmax(ax1_y_lim), np.nanmax(ax1_y_lim))
if snc_fit_model is not None and fit_cov is not None:
mb_fit = snc_fit_model.source_peakmag('bessellb', 'ab')
mb_err = np.sqrt(salt_ut.cov_x0_to_mb(snc_fit_model.parameters[2], fit_cov[1:, 1:])[0, 0])
fit_par = [(snc_fit_model.parameters[1], np.sqrt(fit_cov[0, 0])),
(snc_fit_model.parameters[2], np.sqrt(fit_cov[1, 1])),
(mb_fit, mb_err),
(snc_fit_model.parameters[3], np.sqrt(fit_cov[2, 2])),
(snc_fit_model.parameters[4], np.sqrt(fit_cov[3, 3]))]
if 'mw_' in snc_fit_model.effect_names:
fit_mwd_par = []
if 'mw_r_v' not in snc_fit_model.param_names:
mod_index = np.where(np.array(snc_fit_model.effect_names) == 'mw_')[0][0]
fit_mwd_par.append(snc_fit_model.effects[mod_index]._r_v)
else:
par_idx = np.where(np.asarray(snc_fit_model.param_names) == 'mw_r_v')[0][0]
fit_mwd_par.append(snc_fit_model.parameters[par_idx])
par_idx = np.where(np.asarray(snc_fit_model.param_names) == 'mw_ebv')[0][0]
fit_mwd_par.append(snc_fit_model.parameters[par_idx])
if fit_par is not None or sim_par is not None:
param_text_box(text_ax, model_name='salt', sim_par=sim_par, fit_par=fit_par)
if fit_mwd_par is not None or sim_mwd_par is not None:
param_text_box(text_ax, model_name='mw_', sim_par=sim_mwd_par, fit_par=fit_mwd_par,
pos=[0.4, 0.25])
plt.subplots_adjust(hspace=.0)
if full_screen:
try:
plt_maximize()
except Exception:
pass
plt.show()
def plot_ra_dec(ra, dec, vpec=None, field_list=None, field_dic=None, field_size=None, **kwarg):
"""Plot a mollweide map of ra, dec.
Parameters
----------
ra : list(float)
Right Ascension.
dec : type
Declinaison.
vpec : type
Peculiar velocities.
Returns
-------
None
Just plot the map.
"""
plt.figure()
ax = plt.subplot(111, projection='mollweide')
ax.set_axisbelow(True)
plt.grid()
ra = ra - 2 * np.pi * (ra > np.pi)
if vpec is None:
plt.scatter(ra, dec, s=10, **kwarg)
else:
plot = plt.scatter(ra, dec, c=vpec, vmin=-1500, vmax=1500, s=10, **kwarg)
plt.colorbar(plot, label='$v_p$ [km/s]')
if field_list is not None and field_dic is not None and field_size is not None:
ra_edges = np.array([field_size[0] / 2,
field_size[0] / 2,
-field_size[0] / 2,
-field_size[0] / 2])
dec_edges = np.array([field_size[1] / 2,
-field_size[1] / 2,
-field_size[1] / 2,
field_size[1] / 2])
vec = np.array([np.cos(ra_edges) * np.cos(dec_edges),
np.sin(ra_edges) * np.cos(dec_edges),
np.sin(dec_edges)]).T
for ID in field_list:
# if ID < 880:
ra = field_dic[ID]['ra']
dec = field_dic[ID]['dec']
new_coord = [nbf.R_base(
ra, -dec, v, to_field_frame=False) for v in vec]
new_radec = [[np.arctan2(x[1], x[0]), np.arcsin(x[2])] for x in new_coord]
if new_radec[3][0] > new_radec[0][0]:
if new_radec[3][0] * new_radec[2][0] > 0:
x1 = [-np.pi, new_radec[0][0], new_radec[0][0], -np.pi]
y1 = [new_radec[0][1], new_radec[0][1],
new_radec[1][1], new_radec[1][1]]
x2 = [np.pi, new_radec[2][0], new_radec[2][0], np.pi]
y2 = [new_radec[2][1], new_radec[2][1],
new_radec[3][1], new_radec[3][1]]
ax.plot(x1, y1, ls='--', color='blue', lw=1, zorder=2)
ax.plot(x2, y2, | |
<reponame>woblob/Crystal_Symmetry
import podstawa as pod
# missing matrices
_matrix_inv_000_h00_miss = pod.matrices_dict["inv_000"] + pod._translation_h00 #0
_matrix_m_0yz_h00_miss = pod.matrices_dict["m_0yz"] + pod._translation_h00 #1
_matrix_m_x0z_h00_miss = pod.matrices_dict["m_x0z"] + pod._translation_h00 #2
_matrix_m_xy0_h00_miss = pod.matrices_dict["m_xy0"] + pod._translation_h00 #3
_matrix_m_xmxz_h00_miss = pod.matrices_dict["m_xmxz"] + pod._translation_h00 #4
_matrix_m_xymy_h00_miss = pod.matrices_dict["m_xymy"] + pod._translation_h00 #5
_matrix_m_xymx_h00_miss = pod.matrices_dict["m_xymx"] + pod._translation_h00 #6
_matrix_m_xyx_h00_miss = pod.matrices_dict["m_xyx"] + pod._translation_h00 #7
_matrix_m_xxz_h00_miss = pod.matrices_dict["m_xxz"] + pod._translation_h00 #8
_matrix_m_xyy_h00_miss = pod.matrices_dict["m_xyy"] + pod._translation_h00 #9
_matrix_2_x00_h00_miss = pod.matrices_dict["2_x00"] + pod._translation_h00 #10
_matrix_2_0y0_h00_miss = pod.matrices_dict["2_0y0"] + pod._translation_h00 #11
_matrix_2_00z_h00_miss = pod.matrices_dict["2_00z"] + pod._translation_h00 #12
_matrix_2_xx0_h00_miss = pod.matrices_dict["2_xx0"] + pod._translation_h00 #13
_matrix_2_x0x_h00_miss = pod.matrices_dict["2_x0x"] + pod._translation_h00 #14
_matrix_2_0yy_h00_miss = pod.matrices_dict["2_0yy"] + pod._translation_h00 #15
_matrix_2_xmx0_h00_miss = pod.matrices_dict["2_xmx0"] + pod._translation_h00 #16
_matrix_2_mx0x_h00_miss = pod.matrices_dict["2_mx0x"] + pod._translation_h00 #17
_matrix_2_0myy_h00_miss = pod.matrices_dict["2_0myy"] + pod._translation_h00 #18
_matrix_3_xxx_h00_miss = pod.matrices_dict["3_xxx"] + pod._translation_h00 #19
_matrix_3_xmxmx_h00_miss = pod.matrices_dict["3_xmxmx"] + pod._translation_h00 #20
_matrix_3_mxxmx_h00_miss = pod.matrices_dict["3_mxxmx"] + pod._translation_h00 #21
_matrix_3_mxmxx_h00_miss = pod.matrices_dict["3_mxmxx"] + pod._translation_h00 #22
_matrix_m3_xxx_h00_miss = pod.matrices_dict["m3_xxx"] + pod._translation_h00 #23
_matrix_m3_xmxmx_h00_miss = pod.matrices_dict["m3_xmxmx"] + pod._translation_h00 #24
_matrix_m3_mxxmx_h00_miss = pod.matrices_dict["m3_mxxmx"] + pod._translation_h00 #25
_matrix_m3_mxmxx_h00_miss = pod.matrices_dict["m3_mxmxx"] + pod._translation_h00 #26
_matrix_4_x00_h00_miss = pod.matrices_dict["4_x00"] + pod._translation_h00 #27
_matrix_4_0y0_h00_miss = pod.matrices_dict["4_0y0"] + pod._translation_h00 #28
_matrix_4_00z_h00_miss = pod.matrices_dict["4_00z"] + pod._translation_h00 #29
_matrix_m4_x00_h00_miss = pod.matrices_dict["-4_x00"] + pod._translation_h00 #30
_matrix_m4_0y0_h00_miss = pod.matrices_dict["-4_0y0"] + pod._translation_h00 #31
_matrix_m4_00z_h00_miss = pod.matrices_dict["-4_00z"] + pod._translation_h00 #32
_matrix_inv_000_0h0_miss = pod.matrices_dict["inv_000"] + pod._translation_0h0 #33
_matrix_m_0yz_0h0_miss = pod.matrices_dict["m_0yz"] + pod._translation_0h0 #34
_matrix_m_x0z_0h0_miss = pod.matrices_dict["m_x0z"] + pod._translation_0h0 #35
_matrix_m_xy0_0h0_miss = pod.matrices_dict["m_xy0"] + pod._translation_0h0 #36
_matrix_m_xmxz_0h0_miss = pod.matrices_dict["m_xmxz"] + pod._translation_0h0 #37
_matrix_m_xymy_0h0_miss = pod.matrices_dict["m_xymy"] + pod._translation_0h0 #38
_matrix_m_xymx_0h0_miss = pod.matrices_dict["m_xymx"] + pod._translation_0h0 #39
_matrix_m_xyx_0h0_miss = pod.matrices_dict["m_xyx"] + pod._translation_0h0 #40
_matrix_m_xxz_0h0_miss = pod.matrices_dict["m_xxz"] + pod._translation_0h0 #41
_matrix_m_xyy_0h0_miss = pod.matrices_dict["m_xyy"] + pod._translation_0h0 #42
_matrix_2_x00_0h0_miss = pod.matrices_dict["2_x00"] + pod._translation_0h0 #43
_matrix_2_0y0_0h0_miss = pod.matrices_dict["2_0y0"] + pod._translation_0h0 #44
_matrix_2_00z_0h0_miss = pod.matrices_dict["2_00z"] + pod._translation_0h0 #45
_matrix_2_xx0_0h0_miss = pod.matrices_dict["2_xx0"] + pod._translation_0h0 #46
_matrix_2_x0x_0h0_miss = pod.matrices_dict["2_x0x"] + pod._translation_0h0 #47
_matrix_2_0yy_0h0_miss = pod.matrices_dict["2_0yy"] + pod._translation_0h0 #48
_matrix_2_xmx0_0h0_miss = pod.matrices_dict["2_xmx0"] + pod._translation_0h0 #49
_matrix_2_mx0x_0h0_miss = pod.matrices_dict["2_mx0x"] + pod._translation_0h0 #50
_matrix_2_0myy_0h0_miss = pod.matrices_dict["2_0myy"] + pod._translation_0h0 #51
_matrix_3_xxx_0h0_miss = pod.matrices_dict["3_xxx"] + pod._translation_0h0 #52
_matrix_3_xmxmx_0h0_miss = pod.matrices_dict["3_xmxmx"] + pod._translation_0h0 #53
_matrix_3_mxxmx_0h0_miss = pod.matrices_dict["3_mxxmx"] + pod._translation_0h0 #54
_matrix_3_mxmxx_0h0_miss = pod.matrices_dict["3_mxmxx"] + pod._translation_0h0 #55
_matrix_m3_xxx_0h0_miss = pod.matrices_dict["m3_xxx"] + pod._translation_0h0 #56
_matrix_m3_xmxmx_0h0_miss = pod.matrices_dict["m3_xmxmx"] + pod._translation_0h0 #57
_matrix_m3_mxxmx_0h0_miss = pod.matrices_dict["m3_mxxmx"] + pod._translation_0h0 #58
_matrix_m3_mxmxx_0h0_miss = pod.matrices_dict["m3_mxmxx"] + pod._translation_0h0 #59
_matrix_4_x00_0h0_miss = pod.matrices_dict["4_x00"] + pod._translation_0h0 #60
_matrix_4_0y0_0h0_miss = pod.matrices_dict["4_0y0"] + pod._translation_0h0 #61
_matrix_4_00z_0h0_miss = pod.matrices_dict["4_00z"] + pod._translation_0h0 #62
_matrix_m4_x00_0h0_miss = pod.matrices_dict["-4_x00"] + pod._translation_0h0 #63
_matrix_m4_0y0_0h0_miss = pod.matrices_dict["-4_0y0"] + pod._translation_0h0 #64
_matrix_m4_00z_0h0_miss = pod.matrices_dict["-4_00z"] + pod._translation_0h0 #65
_matrix_inv_000_00h_miss = pod.matrices_dict["inv_000"] + pod._translation_00h #66
_matrix_m_0yz_00h_miss = pod.matrices_dict["m_0yz"] + pod._translation_00h #67
_matrix_m_x0z_00h_miss = pod.matrices_dict["m_x0z"] + pod._translation_00h #68
_matrix_m_xy0_00h_miss = pod.matrices_dict["m_xy0"] + pod._translation_00h #69
_matrix_m_xmxz_00h_miss = pod.matrices_dict["m_xmxz"] + pod._translation_00h #70
_matrix_m_xymy_00h_miss = pod.matrices_dict["m_xymy"] + pod._translation_00h #71
_matrix_m_xymx_00h_miss = pod.matrices_dict["m_xymx"] + pod._translation_00h #72
_matrix_m_xyx_00h_miss = pod.matrices_dict["m_xyx"] + pod._translation_00h #73
_matrix_m_xxz_00h_miss = pod.matrices_dict["m_xxz"] + pod._translation_00h #74
_matrix_m_xyy_00h_miss = pod.matrices_dict["m_xyy"] + pod._translation_00h #75
_matrix_2_x00_00h_miss = pod.matrices_dict["2_x00"] + pod._translation_00h #76
_matrix_2_0y0_00h_miss = pod.matrices_dict["2_0y0"] + pod._translation_00h #77
_matrix_2_00z_00h_miss = pod.matrices_dict["2_00z"] + pod._translation_00h #78
_matrix_2_xx0_00h_miss = pod.matrices_dict["2_xx0"] + pod._translation_00h #79
_matrix_2_x0x_00h_miss = pod.matrices_dict["2_x0x"] + pod._translation_00h #80
_matrix_2_0yy_00h_miss = pod.matrices_dict["2_0yy"] + pod._translation_00h #81
_matrix_2_xmx0_00h_miss = pod.matrices_dict["2_xmx0"] + pod._translation_00h #82
_matrix_2_mx0x_00h_miss = pod.matrices_dict["2_mx0x"] + pod._translation_00h #83
_matrix_2_0myy_00h_miss = pod.matrices_dict["2_0myy"] + pod._translation_00h #84
_matrix_3_xxx_00h_miss = pod.matrices_dict["3_xxx"] + pod._translation_00h #85
_matrix_3_xmxmx_00h_miss = pod.matrices_dict["3_xmxmx"] + pod._translation_00h #86
_matrix_3_mxxmx_00h_miss = pod.matrices_dict["3_mxxmx"] + pod._translation_00h #87
_matrix_3_mxmxx_00h_miss = pod.matrices_dict["3_mxmxx"] + pod._translation_00h #88
_matrix_m3_xxx_00h_miss = pod.matrices_dict["m3_xxx"] + pod._translation_00h #89
_matrix_m3_xmxmx_00h_miss = pod.matrices_dict["m3_xmxmx"] + pod._translation_00h #90
_matrix_m3_mxxmx_00h_miss = pod.matrices_dict["m3_mxxmx"] + pod._translation_00h #91
_matrix_m3_mxmxx_00h_miss = pod.matrices_dict["m3_mxmxx"] + pod._translation_00h #92
_matrix_4_x00_00h_miss = pod.matrices_dict["4_x00"] + pod._translation_00h #93
_matrix_4_0y0_00h_miss = pod.matrices_dict["4_0y0"] + pod._translation_00h #94
_matrix_4_00z_00h_miss = pod.matrices_dict["4_00z"] + pod._translation_00h #95
_matrix_m4_x00_00h_miss = pod.matrices_dict["-4_x00"] + pod._translation_00h #96
_matrix_m4_0y0_00h_miss = pod.matrices_dict["-4_0y0"] + pod._translation_00h #97
_matrix_m4_00z_00h_miss = pod.matrices_dict["-4_00z"] + pod._translation_00h #98
_matrix_inv_000_0hh_miss = pod.matrices_dict["inv_000"] + pod._translation_0hh #99
_matrix_m_0yz_0hh_miss = pod.matrices_dict["m_0yz"] + pod._translation_0hh #100
_matrix_m_x0z_0hh_miss = pod.matrices_dict["m_x0z"] + pod._translation_0hh #101
_matrix_m_xy0_0hh_miss = pod.matrices_dict["m_xy0"] + pod._translation_0hh #102
_matrix_m_xmxz_0hh_miss = pod.matrices_dict["m_xmxz"] + pod._translation_0hh #103
_matrix_m_xymy_0hh_miss = pod.matrices_dict["m_xymy"] + pod._translation_0hh #104
_matrix_m_xymx_0hh_miss = pod.matrices_dict["m_xymx"] + pod._translation_0hh #105
_matrix_m_xyx_0hh_miss = pod.matrices_dict["m_xyx"] + pod._translation_0hh #106
_matrix_m_xxz_0hh_miss = pod.matrices_dict["m_xxz"] + pod._translation_0hh #107
_matrix_m_xyy_0hh_miss = pod.matrices_dict["m_xyy"] + pod._translation_0hh #108
_matrix_2_x00_0hh_miss = pod.matrices_dict["2_x00"] + pod._translation_0hh #109
_matrix_2_0y0_0hh_miss = pod.matrices_dict["2_0y0"] + pod._translation_0hh #110
_matrix_2_00z_0hh_miss = pod.matrices_dict["2_00z"] + pod._translation_0hh #111
_matrix_2_xx0_0hh_miss = pod.matrices_dict["2_xx0"] + pod._translation_0hh #112
_matrix_2_x0x_0hh_miss = pod.matrices_dict["2_x0x"] + pod._translation_0hh #113
_matrix_2_0yy_0hh_miss = pod.matrices_dict["2_0yy"] + pod._translation_0hh #114
_matrix_2_xmx0_0hh_miss = pod.matrices_dict["2_xmx0"] + pod._translation_0hh #115
_matrix_2_mx0x_0hh_miss = pod.matrices_dict["2_mx0x"] + pod._translation_0hh #116
_matrix_2_0myy_0hh_miss = pod.matrices_dict["2_0myy"] + pod._translation_0hh #117
_matrix_3_xxx_0hh_miss = pod.matrices_dict["3_xxx"] + pod._translation_0hh #118
_matrix_3_xmxmx_0hh_miss = pod.matrices_dict["3_xmxmx"] + pod._translation_0hh #119
_matrix_3_mxxmx_0hh_miss = pod.matrices_dict["3_mxxmx"] + pod._translation_0hh #120
_matrix_3_mxmxx_0hh_miss = pod.matrices_dict["3_mxmxx"] + pod._translation_0hh #121
_matrix_m3_xxx_0hh_miss = pod.matrices_dict["m3_xxx"] + pod._translation_0hh #122
_matrix_m3_xmxmx_0hh_miss = pod.matrices_dict["m3_xmxmx"] + pod._translation_0hh #123
_matrix_m3_mxxmx_0hh_miss = pod.matrices_dict["m3_mxxmx"] + pod._translation_0hh #124
_matrix_m3_mxmxx_0hh_miss = pod.matrices_dict["m3_mxmxx"] + pod._translation_0hh #125
_matrix_4_x00_0hh_miss = pod.matrices_dict["4_x00"] + pod._translation_0hh #126
_matrix_4_0y0_0hh_miss = pod.matrices_dict["4_0y0"] + pod._translation_0hh #127
_matrix_4_00z_0hh_miss = pod.matrices_dict["4_00z"] + pod._translation_0hh #128
_matrix_m4_x00_0hh_miss = pod.matrices_dict["-4_x00"] + pod._translation_0hh #129
_matrix_m4_0y0_0hh_miss = pod.matrices_dict["-4_0y0"] + pod._translation_0hh #130
_matrix_m4_00z_0hh_miss = pod.matrices_dict["-4_00z"] + pod._translation_0hh #131
_matrix_inv_000_h0h_miss = pod.matrices_dict["inv_000"] + pod._translation_h0h #132
_matrix_m_0yz_h0h_miss = pod.matrices_dict["m_0yz"] + pod._translation_h0h #133
_matrix_m_x0z_h0h_miss = pod.matrices_dict["m_x0z"] + pod._translation_h0h #134
_matrix_m_xy0_h0h_miss = pod.matrices_dict["m_xy0"] + pod._translation_h0h #135
_matrix_m_xmxz_h0h_miss = pod.matrices_dict["m_xmxz"] + pod._translation_h0h #136
_matrix_m_xymy_h0h_miss = pod.matrices_dict["m_xymy"] + pod._translation_h0h #137
_matrix_m_xymx_h0h_miss = pod.matrices_dict["m_xymx"] + pod._translation_h0h #138
_matrix_m_xyx_h0h_miss = pod.matrices_dict["m_xyx"] + pod._translation_h0h #139
_matrix_m_xxz_h0h_miss = pod.matrices_dict["m_xxz"] + pod._translation_h0h #140
_matrix_m_xyy_h0h_miss = pod.matrices_dict["m_xyy"] + pod._translation_h0h #141
_matrix_2_x00_h0h_miss = pod.matrices_dict["2_x00"] + pod._translation_h0h #142
_matrix_2_0y0_h0h_miss = pod.matrices_dict["2_0y0"] + pod._translation_h0h #143
_matrix_2_00z_h0h_miss = pod.matrices_dict["2_00z"] + pod._translation_h0h #144
_matrix_2_xx0_h0h_miss = pod.matrices_dict["2_xx0"] + pod._translation_h0h #145
_matrix_2_x0x_h0h_miss = pod.matrices_dict["2_x0x"] + pod._translation_h0h #146
_matrix_2_0yy_h0h_miss = pod.matrices_dict["2_0yy"] + pod._translation_h0h #147
_matrix_2_xmx0_h0h_miss = pod.matrices_dict["2_xmx0"] + pod._translation_h0h #148
_matrix_2_mx0x_h0h_miss = pod.matrices_dict["2_mx0x"] + pod._translation_h0h #149
_matrix_2_0myy_h0h_miss = pod.matrices_dict["2_0myy"] + pod._translation_h0h #150
_matrix_3_xxx_h0h_miss = pod.matrices_dict["3_xxx"] + pod._translation_h0h #151
_matrix_3_xmxmx_h0h_miss = pod.matrices_dict["3_xmxmx"] + pod._translation_h0h #152
_matrix_3_mxxmx_h0h_miss = pod.matrices_dict["3_mxxmx"] + pod._translation_h0h #153
_matrix_3_mxmxx_h0h_miss = pod.matrices_dict["3_mxmxx"] + pod._translation_h0h #154
_matrix_m3_xxx_h0h_miss = pod.matrices_dict["m3_xxx"] + pod._translation_h0h #155
_matrix_m3_xmxmx_h0h_miss = pod.matrices_dict["m3_xmxmx"] + pod._translation_h0h #156
_matrix_m3_mxxmx_h0h_miss = pod.matrices_dict["m3_mxxmx"] + pod._translation_h0h #157
_matrix_m3_mxmxx_h0h_miss = pod.matrices_dict["m3_mxmxx"] + pod._translation_h0h #158
_matrix_4_x00_h0h_miss = pod.matrices_dict["4_x00"] + pod._translation_h0h #159
_matrix_4_0y0_h0h_miss = pod.matrices_dict["4_0y0"] + pod._translation_h0h #160
_matrix_4_00z_h0h_miss = pod.matrices_dict["4_00z"] + pod._translation_h0h #161
_matrix_m4_x00_h0h_miss = pod.matrices_dict["-4_x00"] + pod._translation_h0h #162
_matrix_m4_0y0_h0h_miss = pod.matrices_dict["-4_0y0"] + pod._translation_h0h #163
_matrix_m4_00z_h0h_miss = pod.matrices_dict["-4_00z"] + pod._translation_h0h #164
_matrix_inv_000_hh0_miss = pod.matrices_dict["inv_000"] + pod._translation_hh0 #165
_matrix_m_0yz_hh0_miss = pod.matrices_dict["m_0yz"] + pod._translation_hh0 #166
_matrix_m_x0z_hh0_miss = pod.matrices_dict["m_x0z"] + pod._translation_hh0 #167
_matrix_m_xy0_hh0_miss = pod.matrices_dict["m_xy0"] + pod._translation_hh0 #168
_matrix_m_xmxz_hh0_miss = pod.matrices_dict["m_xmxz"] + pod._translation_hh0 #169
_matrix_m_xymy_hh0_miss = pod.matrices_dict["m_xymy"] + pod._translation_hh0 #170
_matrix_m_xymx_hh0_miss = pod.matrices_dict["m_xymx"] + pod._translation_hh0 #171
_matrix_m_xyx_hh0_miss = pod.matrices_dict["m_xyx"] + pod._translation_hh0 #172
_matrix_m_xxz_hh0_miss = pod.matrices_dict["m_xxz"] + pod._translation_hh0 #173
_matrix_m_xyy_hh0_miss = pod.matrices_dict["m_xyy"] + pod._translation_hh0 #174
_matrix_2_x00_hh0_miss = pod.matrices_dict["2_x00"] + pod._translation_hh0 #175
_matrix_2_0y0_hh0_miss = pod.matrices_dict["2_0y0"] + pod._translation_hh0 #176
_matrix_2_00z_hh0_miss = pod.matrices_dict["2_00z"] + pod._translation_hh0 #177
_matrix_2_xx0_hh0_miss = pod.matrices_dict["2_xx0"] + pod._translation_hh0 #178
_matrix_2_x0x_hh0_miss = pod.matrices_dict["2_x0x"] + pod._translation_hh0 #179
_matrix_2_0yy_hh0_miss = pod.matrices_dict["2_0yy"] + pod._translation_hh0 #180
_matrix_2_xmx0_hh0_miss = pod.matrices_dict["2_xmx0"] + pod._translation_hh0 #181
_matrix_2_mx0x_hh0_miss = pod.matrices_dict["2_mx0x"] + pod._translation_hh0 #182
_matrix_2_0myy_hh0_miss = pod.matrices_dict["2_0myy"] + pod._translation_hh0 #183
_matrix_3_xxx_hh0_miss = pod.matrices_dict["3_xxx"] + pod._translation_hh0 #184
_matrix_3_xmxmx_hh0_miss = pod.matrices_dict["3_xmxmx"] + pod._translation_hh0 #185
_matrix_3_mxxmx_hh0_miss = pod.matrices_dict["3_mxxmx"] + pod._translation_hh0 #186
_matrix_3_mxmxx_hh0_miss = pod.matrices_dict["3_mxmxx"] + pod._translation_hh0 #187
_matrix_m3_xxx_hh0_miss = pod.matrices_dict["m3_xxx"] + pod._translation_hh0 #188
_matrix_m3_xmxmx_hh0_miss = pod.matrices_dict["m3_xmxmx"] + pod._translation_hh0 #189
_matrix_m3_mxxmx_hh0_miss = pod.matrices_dict["m3_mxxmx"] + pod._translation_hh0 #190
_matrix_m3_mxmxx_hh0_miss = pod.matrices_dict["m3_mxmxx"] + pod._translation_hh0 #191
_matrix_4_x00_hh0_miss = pod.matrices_dict["4_x00"] + pod._translation_hh0 #192
_matrix_4_0y0_hh0_miss = pod.matrices_dict["4_0y0"] + pod._translation_hh0 #193
_matrix_4_00z_hh0_miss = pod.matrices_dict["4_00z"] + pod._translation_hh0 #194
_matrix_m4_x00_hh0_miss = pod.matrices_dict["-4_x00"] + pod._translation_hh0 #195
_matrix_m4_0y0_hh0_miss = pod.matrices_dict["-4_0y0"] + pod._translation_hh0 #196
_matrix_m4_00z_hh0_miss = pod.matrices_dict["-4_00z"] + pod._translation_hh0 #197
_matrix_inv_000_hhh_miss = pod.matrices_dict["inv_000"] + pod._translation_hhh #198
_matrix_m_0yz_hhh_miss = pod.matrices_dict["m_0yz"] + pod._translation_hhh #199
_matrix_m_x0z_hhh_miss = pod.matrices_dict["m_x0z"] + pod._translation_hhh #200
_matrix_m_xy0_hhh_miss = pod.matrices_dict["m_xy0"] + pod._translation_hhh #201
_matrix_m_xmxz_hhh_miss = pod.matrices_dict["m_xmxz"] + pod._translation_hhh #202
_matrix_m_xymy_hhh_miss = pod.matrices_dict["m_xymy"] + pod._translation_hhh #203
_matrix_m_xymx_hhh_miss = pod.matrices_dict["m_xymx"] + pod._translation_hhh #204
_matrix_m_xyx_hhh_miss = pod.matrices_dict["m_xyx"] + pod._translation_hhh #205
_matrix_m_xxz_hhh_miss = pod.matrices_dict["m_xxz"] + pod._translation_hhh #206
_matrix_m_xyy_hhh_miss = pod.matrices_dict["m_xyy"] + pod._translation_hhh #207
_matrix_2_x00_hhh_miss = pod.matrices_dict["2_x00"] + pod._translation_hhh #208
_matrix_2_0y0_hhh_miss = pod.matrices_dict["2_0y0"] + pod._translation_hhh #209
_matrix_2_00z_hhh_miss = pod.matrices_dict["2_00z"] + pod._translation_hhh #210
_matrix_2_xx0_hhh_miss = pod.matrices_dict["2_xx0"] + pod._translation_hhh #211
_matrix_2_x0x_hhh_miss = pod.matrices_dict["2_x0x"] + pod._translation_hhh #212
_matrix_2_0yy_hhh_miss = pod.matrices_dict["2_0yy"] + pod._translation_hhh #213
_matrix_2_xmx0_hhh_miss = pod.matrices_dict["2_xmx0"] + pod._translation_hhh #214
_matrix_2_mx0x_hhh_miss = pod.matrices_dict["2_mx0x"] + pod._translation_hhh #215
_matrix_2_0myy_hhh_miss = pod.matrices_dict["2_0myy"] + pod._translation_hhh #216
_matrix_3_xxx_hhh_miss = pod.matrices_dict["3_xxx"] + pod._translation_hhh #217
_matrix_3_xmxmx_hhh_miss = pod.matrices_dict["3_xmxmx"] + pod._translation_hhh #218
_matrix_3_mxxmx_hhh_miss = pod.matrices_dict["3_mxxmx"] + pod._translation_hhh #219
_matrix_3_mxmxx_hhh_miss = pod.matrices_dict["3_mxmxx"] + pod._translation_hhh #220
_matrix_m3_xxx_hhh_miss = pod.matrices_dict["m3_xxx"] + pod._translation_hhh #221
_matrix_m3_xmxmx_hhh_miss = pod.matrices_dict["m3_xmxmx"] + pod._translation_hhh #222
_matrix_m3_mxxmx_hhh_miss = pod.matrices_dict["m3_mxxmx"] + pod._translation_hhh #223
_matrix_m3_mxmxx_hhh_miss = pod.matrices_dict["m3_mxmxx"] + pod._translation_hhh #224
_matrix_4_x00_hhh_miss = pod.matrices_dict["4_x00"] + pod._translation_hhh #225
_matrix_4_0y0_hhh_miss = pod.matrices_dict["4_0y0"] + pod._translation_hhh #226
_matrix_4_00z_hhh_miss = pod.matrices_dict["4_00z"] + pod._translation_hhh #227
_matrix_m4_x00_hhh_miss = pod.matrices_dict["-4_x00"] + pod._translation_hhh #228
_matrix_m4_0y0_hhh_miss = pod.matrices_dict["-4_0y0"] + pod._translation_hhh #229
_matrix_m4_00z_hhh_miss = pod.matrices_dict["-4_00z"] + pod._translation_hhh #230
_matrix_inv_000_qqq_miss = pod.matrices_dict["inv_000"] + pod._translation_qqq #231
_matrix_m_0yz_qqq_miss = pod.matrices_dict["m_0yz"] + pod._translation_qqq #232
_matrix_m_x0z_qqq_miss = pod.matrices_dict["m_x0z"] + pod._translation_qqq #233
_matrix_m_xy0_qqq_miss = pod.matrices_dict["m_xy0"] + pod._translation_qqq #234
_matrix_m_xmxz_qqq_miss = pod.matrices_dict["m_xmxz"] + pod._translation_qqq #235
_matrix_m_xymy_qqq_miss = pod.matrices_dict["m_xymy"] + pod._translation_qqq #236
_matrix_m_xymx_qqq_miss = pod.matrices_dict["m_xymx"] + pod._translation_qqq #237
_matrix_m_xyx_qqq_miss = pod.matrices_dict["m_xyx"] + pod._translation_qqq #238
_matrix_m_xxz_qqq_miss = pod.matrices_dict["m_xxz"] + pod._translation_qqq #239
_matrix_m_xyy_qqq_miss = pod.matrices_dict["m_xyy"] + pod._translation_qqq #240
_matrix_2_x00_qqq_miss = pod.matrices_dict["2_x00"] + pod._translation_qqq #241
_matrix_2_0y0_qqq_miss = pod.matrices_dict["2_0y0"] + pod._translation_qqq #242
_matrix_2_00z_qqq_miss = pod.matrices_dict["2_00z"] + pod._translation_qqq #243
_matrix_2_xx0_qqq_miss = pod.matrices_dict["2_xx0"] + pod._translation_qqq #244
_matrix_2_x0x_qqq_miss = pod.matrices_dict["2_x0x"] + pod._translation_qqq #245
_matrix_2_0yy_qqq_miss = pod.matrices_dict["2_0yy"] + pod._translation_qqq #246
_matrix_2_xmx0_qqq_miss = pod.matrices_dict["2_xmx0"] + pod._translation_qqq #247
_matrix_2_mx0x_qqq_miss = pod.matrices_dict["2_mx0x"] + pod._translation_qqq #248
_matrix_2_0myy_qqq_miss = pod.matrices_dict["2_0myy"] + pod._translation_qqq #249
_matrix_3_xxx_qqq_miss = pod.matrices_dict["3_xxx"] + pod._translation_qqq #250
_matrix_3_xmxmx_qqq_miss = pod.matrices_dict["3_xmxmx"] + pod._translation_qqq #251
_matrix_3_mxxmx_qqq_miss = pod.matrices_dict["3_mxxmx"] + pod._translation_qqq #252
_matrix_3_mxmxx_qqq_miss = pod.matrices_dict["3_mxmxx"] + pod._translation_qqq #253
_matrix_m3_xxx_qqq_miss = pod.matrices_dict["m3_xxx"] + pod._translation_qqq | |
from tkinter import *
from tkinter import messagebox
from tkinter import ttk
from datetime import *
import webbrowser
from tkcalendar import *
import sqlite3
# create connection to BMI database
try:
cn = sqlite3.connect("../bmil.db")
except:
cn = sqlite3.connect("bmil.db")
cr = cn.cursor()
# if there is no database here we created it
try:
cr.execute(
"""CREATE TABLE report(id_inc INTEGER PRIMARY KEY,
Name TEXT (25),
Weight INTEGER,
Height REAL,
B_Date TEXT);"""
)
ID = 0
Indextabl = 0
except:
print("Table Already Exists")
sqs = "SELECT * FROM report order by id_inc" # query to select (all(*)) from db table ordered by id
cr.execute(sqs) # executes the sqs to run the query
tbl = cr.fetchall() # fetchall is a query result set and returns a list of tuples
def table():
cr.execute("select * from report")
return cr.fetchall()
if len(table()) == 0:
ID = 0
Indextabl = 0
else:
ID = table()[-1][0] + 1
Indextabl = 1
# def exit for window protocol and for exit menu
def Exit():
cr.close() # close the cursor
cn.close() # close the connection
win.destroy() # destroys the window
def is_num(x):
try:
float(x)
except ValueError:
return False
else:
return True
# clearing al fields and results
def Clear(a=""):
v1.set("") # sets the stingvar of name entry ''(nothing)
v2.set("") # sets the stingvar of weight entry ''(nothing)
v3.set("") # sets the stingvar of height entry ''(nothing)
Clear_Lb() # change the color for the category result
e1.focus() # sets the name entry to enter data
# resetting result labels to be unshown
def Clear_Lb(a=""):
lb11.config(text=" ")
lb12.config(fg="lightgray")
lb13.config(fg="lightgray")
lb14.config(fg="lightgray")
lb15.config(fg="lightgray")
lb17.config(fg="lightgray")
lb18.config(fg="lightgray")
# saving every thing to database and checks if any field is empty or not
def Save(a=""):
if (not is_num(e2.get())) or float(e2.get()) <= 0:
# checks if weight entry isn't a number or float
e2.focus() # puts the mouse in the weight entry
v2.set("") # sets nothing in the weight entry
return
if (not is_num(e3.get())) or float(e2.get()) <= 0:
# checks if height entry isn't a number or float
e3.focus() # puts the mouse in the height entry
v3.set("") # sets nothing in the height entry
return
d2 = datetime.strptime(
e4.get(), "%d/%m/%Y"
) # strptime() method creates a datetime object from the given string
if todaydat <= d2: # if today date is less than or equal to date time of now
messagebox.showerror(
"Update", "Date should be < System date"
) # shows messagebox
return False
Calcul() # calculates the gives height and weight
quest = messagebox.askyesno(
"Save", "Do you want to save data ?"
) # asks yes or no if you really want to save
if quest == True: # if quest = yes then ...
global ID
sql = "INSERT INTO report(id_inc,Name,Weight,Height,B_Date) VALUES (%d, '%s', %s, %s, '%s');"
x = (
ID,
e1.get(),
e2.get(),
e3.get(),
e4.get(),
) # gets the name,weight,height,dateentry entries
cr.execute(sql % x)
cn.commit()
ID += 1
Clear() # clears all fields
# updates any record in database (getting it through name while clicking to view one and you can update the name)
def Update(a=""):
if (not is_num(e2.get())) or float(e2.get()) <= 0:
# checks if weight entry isn't number or float
e2.focus() # puts the mouse in the weight entry
v2.set("") # sets the weight entry string nothing
return
if (not is_num(e3.get())) or float(e2.get()) <= 0:
# checks if height entry isn't number or float
e3.focus() # puts the mouse in the height entry
v3.set("") # sets the height entry string nothing
return
d2 = datetime.strptime(
e4.get(), "%d/%m/%Y"
) # strptime() method creates a datetime object from the given string
print(e4.get())
if todaydat <= d2: # checks if today date is less than or equal to date time of now
messagebox.showerror(
"Update", "Date should be < System date"
) # shows messagebox
return False
Calcul() # calculates the current entered data of weight and height
quest = messagebox.askyesno(
"Update", "Sure to update data ?"
) # asks yes or no if you really want to update
if quest == True: # if quest = yes then...
sq = "update report set Weight=%s, Height=%s, B_Date='%s' where Name='%s'" # updates the current data entered where name = name entered
x = (
e2.get(),
e3.get(),
d2,
e1.get(),
)
# gets weight,height,dateentry and name entry
print(x)
cr.execute(sq % x) # execute the sq query and the x variable
cn.commit() # make changes in the database
Clear() # clearing all data in the fields
# gets the height and weight entry and calculate it and checks if height or weight is empty and if contains negative num
def Calcul(a=""):
Clear_Lb() # runs the clear_lb function whick cofigure the foreground of the category to be unshown
if (is_num(e2.get())) and float(
e2.get()
) > 0: # checks if weight entry is number and float
w = float(e2.get()) # gets the float of the weight
else: # if weight entry isn't number (float)
e2.focus() # puts the mouse in the weight entry
v2.set("") # sets nothing in the weight entry string
return
if (is_num(e3.get())) and float(
e3.get()
) > 0: # checks if height entry is number and float
h = float(e3.get()) # gets the float of the height
else: # if height entry isn't number (float)
e3.focus() # puts the mouse in the height entry
v3.set("") # sets nothing in the height entry string
return
r = float(w / (h ** 2)) # bmi calculation (weight / height*height)
lb11.config(text=str(round(r, 2))) # gives you the result of the calculation
# if results
if r < 18.5:
lb12.config(fg="red")
lb18.config(fg="red")
elif 18.5 <= r < 25:
lb13.config(fg="red")
lb17.config(fg="red")
elif 25 <= r < 30:
lb14.config(fg="red")
lb18.config(fg="red")
else:
lb15.config(fg="red")
lb18.config(fg="red")
# view all records from database in a listbox ordereb by name and you can view or delete any record
def VAll(rd: list = []):
global ls1 # globaling the list box
win2 = Tk() # new window for view all
win2.geometry("720x400") # geomatry for view all window
win2.title("View All Patient BMI") # title for view all window
y = [
"ID",
"Name",
"Weight",
"Height",
"Bith Date",
"BMI",
"Healthy",
] # titles for database records
s1 = "{:^7}{:^25}{:^8}{:^8}{:^15}{:^8}{:^8}".format(
y[0], y[1], y[2], y[3], y[4], y[5], y[6]
) # making spaces between fields
lb30 = Label(
win2, text=s1, bg="lightblue", font=("courier", 10)
) # label for spaces for titles with background
fr1 = Frame(win2) # creating a frame to put the list box
sb1 = Scrollbar(fr1) # scroll bar for the list box to see all records
ls1 = Listbox(
fr1, yscrollcommand=sb1.set, font=("courier", 10), width=80, height=15
) # list box to put records in
if not rd:
sq = "select * from report ORDER by Name"
# query for selecting all(*) from table ordered by name
cr.execute(sq) # executes the current query
rd = cr.fetchall()
# shows all rows of a query result set and returns a list of tuples
button1 = Button(
win2,
text="View it",
bg="green",
width=20,
command=lambda: view_selected(win2),
).place(x=400, y=350)
# view any selected record
button = Button(
win2, text="Delete it", bg="red", width=20, command=delete_selected
).place(x=200, y=350)
# delete any selected record
else:
button = Button(
win2, text="Delete it", bg="red", width=20, command=delete_selected
).place(x=300, y=350)
# delete any selected record
for row in rd:
# doing for loop for putting bmi result and if healthy or not without saving in into database
w = int(row[2]) # taking the integer of weight
h = float(row[3]) # taking the float of height
r = float(w / (h ** 2)) # result (bmi)
if 18.5 <= r < 25:
ht = "Yes" # healthy = yes
else:
ht = "No" # healthy = no
s2 = "{:^7}{:^25}{:^8}{:^8}{:^15}{:^8}{:^8}".format(
row[0], row[1], row[2], row[3], str(row[4]), round(r, 2), ht
) # formatting with spaces to print bmi result and if healthy without saving to db
ls1.insert(END, s2) # insert the data of the current format
sb1.config(command=ls1.yview)
lb30.place(x=30, y=30)
fr1.place(x=30, y=60)
ls1.pack(side=LEFT)
sb1.pack(side=LEFT, fill=Y)
win2.mainloop()
# get's the name you entered and printing the data on the fields place by place if record exists and checks if exist
def VOne(a=""):
Clear_Lb() # | |
module.exit_json(**result)
def validate_cer_connectivity():
url = 'https://' + hostname + ":" + api_port + '/cerappservices/export/authenticate/status/' + username + '/' + str(hashlib.sha256(password.encode()).hexdigest())
i = 0
cer_headers = {
'Host': hostname + ":" + api_port
}
while True:
try:
response = (requests.get(url, auth=(username,password), headers=cer_headers, timeout = 60, proxies=sock5Proxy, verify = False))
if (response.status_code == 200):
result['response'] = response.text
break
except Exception as err:
if (i > 100):
# Failed to connect for 60 minutes
result['changed'] = False
result['failed'] = True
module.fail_json(msg=str(err),**result)
else:
# Unable to connect, pausing for 1 minutes
time.sleep(60)
i = i + 1
continue
def run_module():
# define available arguments/parameters a user can pass to the module
module_args = dict(
vapp_ip=dict(type='str', required=True),
api_port=dict(type='str', required=False),
ssms_ip=dict(type='str', required=False),
ssms_port=dict(type='str', default=8443, required=False),
ip_address=dict(type='str', required=False),
username=dict(type='str', required=True),
password=dict(type='str', required=True, no_log=True),
token_description=dict(type='str', required=False),
model=dict(type='str', required=True),
version=dict(type='float', required=True),
use_proxy=dict(type='bool', required=True)
)
# seed the result dict in the object
# we primarily care about changed and the response data
# change is if this module effectively modified the target
# response is the data returned by TrafficJam
# status_code is the HTTP status code returned by the requests module
global result
result = dict(
changed=False,
response='',
status_code=''
)
global module
module = AnsibleModule(
argument_spec=module_args,
supports_check_mode=False
)
global pSession
# Collect Module Parameters
global vapp_ip
vapp_ip = module.params['vapp_ip']
global api_port
api_port = module.params['api_port']
global ssms_ip
ssms_ip = module.params['ssms_ip']
global ssms_port
ssms_port = module.params['ssms_port']
global ip_address
ip_address = module.params['ip_address']
global username
username = module.params['username']
global password
password = module.params['password']
global token_description
token_description = module.params['token_description']
global model
model = module.params['model']
global version
version = module.params['version']
global use_proxy
use_proxy = module.params['use_proxy']
# Set Hostname to use (if using proxy use ip_address, otherwise use vapp_ip)
global hostname
global sock5Proxy
if (use_proxy):
hostname = ip_address
sock5Proxy = {
'http': 'socks5h://' + vapp_ip + ':1080',
'https':'socks5h://' + vapp_ip + ':1080'
}
else:
hostname = vapp_ip
sock5Proxy = ''
if (model == "csr1k"):
# Verify CSR1K is responding to API requests
validate_csr1k_connectivity()
# Verify SSMS is responding to API requests
validate_ssms_connectivity()
# License CSR1000v
url = "https://" + hostname + ":" + api_port + "/restconf/data/cisco-smart-license:register-id-token"
CSRLicenseJSON = {}
CSRLicenseJSONChild = {}
CSRLicenseJSONChild['id-token'] = getSmartLicenseToken(token_description)
CSRLicenseJSONChild['force'] = True
CSRLicenseJSON['cisco-smart-license:register-id-token'] = CSRLicenseJSONChild
customHttpPost(url, json=CSRLicenseJSON, auth=(username,password), headers={'Content-Type': 'application/yang-data+json'},proxies=sock5Proxy, verify = False)
# Verify CSR1Kv is licensed
validate_csr1k_licenseStatus()
if (model == 'asav'):
# Verify ASAv is responding to API requests
validate_asav_connectivity()
# Verify SSMS is responding to API requests
validate_ssms_connectivity()
# License ASAv
url = "https://" + hostname + ":" + api_port + "/api/licensing/smart/asav/register"
ASALicenseJSON = {}
ASALicenseJSON['kind'] = 'object#SmartLicenseRegId'
ASALicenseJSON['idToken'] = getSmartLicenseToken(token_description)
ASALicenseJSON['force'] = True
customHttpPost(url, json=ASALicenseJSON, auth=(username,password), headers={'User-Agent': "REST API Agent" }, proxies=sock5Proxy, verify = False)
# Verify ASAv is licensed
validate_asav_licenseStatus()
if (model == 'cucm'):
# Verify ASAv is responding to API requests
validate_cucm_connectivity()
# Verify SSMS is responding to API requests
validate_ssms_connectivity()
# License CUCM
url = "https://" + hostname + ":" + api_port + "/axl/"
body = """
<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:ns="http://www.cisco.com/AXL/API/%version">
<soapenv:Header/>
<soapenv:Body>
<ns:doSmartLicenseRegister>
<token>%token</token>
<force>true</force>
</ns:doSmartLicenseRegister>
</soapenv:Body>
</soapenv:Envelope>"""
body = body.replace("%version",str(version))
body = body.replace("%token", getSmartLicenseToken(token_description))
if(format(version,".0f") == '12'):
customHttpPost(url, data=body, auth=(username,password), headers={'SOAPAction' : 'CUCM:DB ver=' + str(version) }, proxies=sock5Proxy, timeout=(300,300), verify = False)
elif((format(version,".0f") == '14')):
iHttp = 0
while True:
try:
response = requests.post(url, data=body, auth=(username,password),headers={'SOAPAction' : 'CUCM:DB ver=' + str(version) }, proxies=sock5Proxy, timeout=(300,300), verify = False)
except requests.exceptions.ConnectionError as err:
if ('RemoteDisconnected' in str(err)):
# Request Actually Succeeded (handling delay's and SOCKS issues)
time.sleep(120)
break
except Exception as err:
if (iHttp > 100):
# Failed to connect for 60 minutes
result['changed'] = False
result['failed'] = True
if 'response' in locals():
result['response'] = str(response.text)
module.fail_json(msg=str(err),**result)
else:
# Unable to connect, pausing for 1 minutes
time.sleep(60)
iHttp = iHttp + 1
print('fail ' + str(iHttp))
continue
# Verify CUCM is licensed
validate_cucm_licenseStatus()
if (model == 'cuc'):
# Verify cuc is responding to API requests
validate_cuc_connectivity()
# Verify SSMS is responding to API requests
validate_ssms_connectivity()
# License CUC
url = "https://" + hostname + ":" + api_port + "/vmrest/smartlicense/register"
CUCLicenseJSON = {}
CUCLicenseJSON['token'] = getSmartLicenseToken(token_description)
CUCLicenseJSON['force'] = True
customHttpPut(url, json=CUCLicenseJSON, auth=(username,password), proxies=sock5Proxy, verify = False)
# Verify CUC is licensed
validate_cuc_licenseStatus()
if (model == "uccx"):
# Verify UCCx is responding to API requests
validate_uccx_connectivity()
# Verify SSMS is responding to API requests
validate_ssms_connectivity()
# Get jSession Cookie
url = "https://" + hostname + ":" + api_port + "/appadmin/main"
uccx_headers = {
'Host': hostname + ":" + api_port
}
pSession.headers = uccx_headers
uccx_response = customSessionGet(url, 302, auth=(username,password), timeout=60, allow_redirects=False, proxies=sock5Proxy, verify=False)
# Get CSRF Token
url = 'https://' + hostname + ":" + api_port + '/appadmin/JavaScriptServlet'
uccx_headers = {
'Host': hostname + ":" + api_port,
'Origin': 'https://' + hostname + ':' + api_port,
'FETCH-CSRF-TOKEN': '1'
}
pSession.headers = uccx_headers
uccx_response = customSessionPost(url, 200, timeout=60, allow_redirects=False, proxies=sock5Proxy, verify=False)
CSRFToken = (uccx_response.text.split(':', 1)[1])
# Perform User Authentication
url = 'https://' + hostname + ':' + api_port + '/appadmin/j_security_check'
uccx_headers = {
'Host': hostname + ":" + api_port,
'Origin': 'https://' + hostname + ':' + api_port,
'Referer': 'https://' + hostname + ':' + api_port + '/appadmin/main',
'Upgrade-Insecure-Requests': '1'
}
uccx_body = {
'j_username': username,
'j_password': password,
'appNav': 'appadmin',
'CSRFTOKEN': CSRFToken
}
pSession.headers = uccx_headers
uccx_response = customSessionPost(url, 302,data=uccx_body, timeout=60, allow_redirects=False, proxies=sock5Proxy, verify=False)
# Perform Smart License Registration
url = 'https://' + hostname + ':' + api_port + '/appadmin/smartlicense/register.do'
uccx_headers = {
'Host': hostname + ":" + api_port,
'Refer': 'https://' + hostname + api_port + '/appadmin/smartlicense/registerdisplay.do?request_type=register',
'CSRFTOKEN': CSRFToken,
'Origin': 'https://' + hostname + ':' + api_port,
'X-Requested-With': 'XMLHttpRequest, XMLHttpRequest',
'Accept': 'application/json, text/javascript, */*; q=0.01',
'Content-Type': 'application/json; charset=utf-8'
}
uccx_json = {
'forceFlag': True,
'IdToken': getSmartLicenseToken(token_description)
}
pSession.headers = uccx_headers
uccx_response = customSessionPost(url, 200, json=uccx_json, timeout=60, allow_redirects=False, proxies=sock5Proxy, verify=False)
result['response'] = uccx_response.text
# Verify UCCx is licensed
validate_uccx_licenseStatus(uccx_response)
pSession.close()
if (model == 'expressway'):
# Verify Expressway is responding to API requests
validate_expw_connectivity()
# Verify SSMS is responding to API requests
validate_ssms_connectivity()
# License Expressway
url = "https://" + hostname + ":" + api_port + "/api/provisioning/common/smartlicensing/registration"
expw_LicenseJSON = {}
expw_LicenseJSON['Reregister'] = 'Yes'
expw_LicenseJSON['Token'] = getSmartLicenseToken(token_description)
customHttpPost(url, json=expw_LicenseJSON, auth=(username,password), proxies=sock5Proxy, verify = False)
# Verify Expressway is licensed
validate_expw_licenseStatus()
if (model == 'cmm'):
# Verify Cisco Meeting Manager is responding to API requests
validate_cmm_connectivity()
# Verify SSMS is responding to API requests
validate_ssms_connectivity()
# Get CSRF Token
url = 'https://' + hostname + ":" + api_port + '/api_login'
cmm_headers = {
'Host': hostname + ":" + api_port
}
pSession.headers = cmm_headers
iHttp = 0
while True:
try:
cmm_response = customSessionGet(url, 200, timeout=60, proxies=sock5Proxy, verify=False)
CSRFToken = (json.loads(cmm_response.text))['token']
break
except Exception as err:
if (iHttp > 100):
# Failed to connect for 60 minutes
result['changed'] = False
result['failed'] = True
if 'response' in locals():
result['response'] = str(cmm_response.text)
module.fail_json(msg=str(err),**result)
else:
# Unable to connect, pausing for 1 minutes
time.sleep(60)
iHttp = iHttp + 1
continue
# Perform User Authentication
url = 'https://' + hostname + ":" + api_port + '/api_login/'
cmm_headers = {
'Host': hostname + ":" + api_port,
'X-CSRFToken': CSRFToken,
'X-Requested-With': 'XMLHttpRequest'
}
cmm_body = {
'username': username,
'password': password,
'source': 'local'
}
pSession.headers = cmm_headers
iHttp = 0
while True:
try:
cmm_response = customSessionPost(url, 200, data=cmm_body, proxies=sock5Proxy, timeout=60, verify=False)
CSRFToken = json.loads(cmm_response.text)['token']
break
except Exception as err:
if (iHttp > 100):
# Failed to connect for 60 minutes
result['changed'] = False
result['failed'] = True
if 'response' in locals():
result['response'] = str(cmm_response.text)
module.fail_json(msg=str(err),**result)
else:
# Unable to connect, pausing for 1 minutes
time.sleep(60)
iHttp = iHttp + 1
continue
# Perform Smart License Registration
url = 'https://' + hostname + ":" + api_port + '/licensing/api/smart/register/'
cmm_headers = {
'Host': hostname + ":" + api_port,
'Origin': 'https://' + hostname + ":" + api_port,
'X-CSRFToken': CSRFToken,
'X-Requested-With': 'XMLHttpRequest'
}
cmm_LicenseJSON = {}
cmm_LicenseJSON['token'] = getSmartLicenseToken(token_description)
cmm_LicenseJSON['force'] = True
pSession.headers = cmm_headers
cmm_response = customSessionPost(url, 200, json=cmm_LicenseJSON, proxies=sock5Proxy, verify = False)
# Verify CMM is | |
= AttributeEventWait(self.getAttribute("state"))
evt_wait.lock()
try:
time_stamp = time.time()
try:
self.command_inout("ReleaseMacro")
except PyTango.DevFailed as df:
# Macro already finished - no need to release
if df.args[0].reason == "API_CommandNotAllowed":
return
evt_wait.waitForEvent((self.Running, ), equal=False,
after=time_stamp,
reactivity=self.InteractiveTimeout)
finally:
evt_wait.unlock()
evt_wait.disconnect()
def stop(self, synch=True):
if not synch:
self.command_inout("StopMacro")
return
evt_wait = AttributeEventWait(self.getAttribute("state"))
evt_wait.lock()
try:
time_stamp = time.time()
self.command_inout("StopMacro")
evt_wait.waitForEvent((self.Running, ), equal=False,
after=time_stamp,
reactivity=self.InteractiveTimeout)
finally:
evt_wait.unlock()
evt_wait.disconnect()
def _clearRunMacro(self):
# Clear the log buffer
list(map(LogAttr.clearLogBuffer, list(self._log_attr.values())))
self._running_macros = None
self._running_macro = None
self._user_xml = None
self._block_lines = 0
def _createMacroXml(self, macro_name, macro_params):
"""Creation of the macro XML object.
:param macro_name: (str) macro name
:param macro_params: (sequence[str]) list of parameter values,
if repeat parameters are used parameter values may be sequences
itself.
:return (lxml.etree._Element) macro XML element
"""
macro_info = self.macro_server.getMacroInfoObj(macro_name)
params_def = macro_info.parameters
macro_node = createMacroNode(macro_name, params_def, macro_params)
return macro_node.toXml()
def preRunMacro(self, obj, parameters):
self._clearRunMacro()
xml_root = None
if isinstance(obj, str):
if obj.startswith('<') and not parameters:
xml_root = etree.fromstring(obj)
else:
macros = []
if len(parameters) == 0:
macros_strs = obj.split('\n')
for m in macros_strs:
pars = m.split()
macros.append((pars[0], pars[1:]))
else:
parameters = recur_map(str, parameters)
macros.append((obj, parameters))
xml_root = xml_seq = etree.Element('sequence')
for m in macros:
macro_name = m[0]
macro_params = m[1]
xml_macro = self._createMacroXml(macro_name, macro_params)
xml_macro.set('id', str(uuid.uuid1()))
xml_seq.append(xml_macro)
elif etree.iselement(obj):
xml_root = obj
else:
raise TypeError('obj must be a string or a etree.Element')
self._running_macros = {}
for macro_xml in xml_root.xpath('//macro'):
id, name = macro_xml.get('id'), macro_xml.get('name')
self._running_macros[id] = Macro(self, name, id, macro_xml)
return xml_root
def postRunMacro(self, result, synch):
pass
def runMacro(self, obj, parameters=[], synch=False):
self._user_xml = self.preRunMacro(obj, parameters)
result = self._runMacro(self._user_xml, synch=synch)
return self.postRunMacro(result, synch)
def _runMacro(self, xml, synch=False):
if not synch:
return self.command_inout("RunMacro",
[etree.tostring(xml,
encoding='unicode')])
timeout = self.InteractiveTimeout
evt_wait = self._getEventWait()
evt_wait.connect(self.getAttribute("state"))
evt_wait.lock()
try:
evt_wait.waitForEvent((self.Running, ), equal=False,
reactivity=timeout)
# Clear event set to not confuse the value coming from the
# connection with the event of of end of the macro execution
# in the next wait event. This was observed on Windows where
# the time stamp resolution is not better than 1 ms.
evt_wait.clearEventSet()
ts = time.time()
result = self.command_inout("RunMacro",
[etree.tostring(xml,
encoding='unicode')])
evt_wait.waitForEvent((self.Running, ), after=ts,
reactivity=timeout)
if synch:
evt_wait.waitForEvent((self.Running, ), equal=False, after=ts,
reactivity=timeout)
finally:
self._clearRunMacro()
evt_wait.unlock()
evt_wait.disconnect()
return result
def stateChanged(self, s, t, v):
# In contrary to the Taurus3 the Taurus4 raises exceptions when the
# device server is getting down and we try to retrieve the state.
# In this case provide the same behavior as Taurus3 - assign None to
# the old state
try:
self._old_door_state = self.stateObj.rvalue
except PyTango.DevFailed:
self._old_door_state = None
self._old_sw_door_state = self.state
def resultReceived(self, log_name, result):
"""Method invoked by the arrival of a change event on the Result
attribute"""
if self._ignore_logs or self._running_macro is None:
return
self._running_macro.setResult(result)
return result
def putEnvironment(self, name, value):
self.macro_server.putEnvironment(name, value)
def putEnvironments(self, obj):
self.macro_server.putEnvironments(obj)
setEnvironment = putEnvironment
setEnvironments = putEnvironments
def getEnvironment(self, name=None):
return self.macro_server.getEnvironment(name=name)
def inputReceived(self, s, t, v):
if t not in CHANGE_EVT_TYPES:
return
if v is None or self._running_macros is None:
return
input_data = CodecFactory().decode(('json', v.value))
self.processInput(input_data)
def processInput(self, input_data):
TaurusManager().addJob(self._processInput, None, input_data)
def _processInput(self, input_data):
input_type = input_data['type']
if input_type == 'input':
result = self._input_handler.input(input_data)
if result['input'] == '' and 'default_value' in input_data:
result['input'] = input_data['default_value']
result = CodecFactory().encode('json', ('', result))[1]
self.write_attribute('Input', result)
elif input_type == 'timeout':
self._input_handler.input_timeout(input_data)
def recordDataReceived(self, s, t, v):
if t not in CHANGE_EVT_TYPES:
return
return self._processRecordData(v)
def _processRecordData(self, data):
if data is None or data.rvalue is None:
return
data = data.rvalue
size = len(data[1])
if size == 0:
return
format = data[0]
codec = CodecFactory().getCodec(format)
data = codec.decode(data)
return data
def processRecordData(self, data):
pass
def macroStatusReceived(self, s, t, v):
if v is None or self._running_macros is None:
return
if t not in CHANGE_EVT_TYPES:
return
v = v.value
if not len(v[1]):
return
format = v[0]
codec = CodecFactory().getCodec(format)
fmt, data = codec.decode(v)
for macro_status in data:
id = macro_status.get('id')
macro = self._running_macros.get(id)
self._last_running_macro = self._running_macro = macro
# if we don't have the ID it's because the macro is running a
# submacro or another client is connected to the same door (shame
# on him!) and executing a macro we discard this event
if macro is not None:
macro.__dict__.update(macro_status)
return data
def logReceived(self, log_name, output):
term_size = get_terminal_size()
max_chrs = term_size.columns if term_size else None
if not output or self._silent or self._ignore_logs:
return
if log_name == self.Debug and not self._debug:
return
o = self.log_start[log_name]
for line in output:
if not self._debug:
if line == self.BlockStart:
self._in_block = True
for i in range(self._block_lines):
if max_chrs is None:
nb_lines = 1
else:
nb_lines = _get_nb_lines(
self._len_last_data_line,
max_chrs)
# per each line: erase current line,
# go up one line and erase current line
o += '\x1b[2K\x1b[1A\x1b[2K' * nb_lines
self._block_lines = 0
continue
elif line == self.BlockFinish:
self._in_block = False
continue
else:
self._len_last_data_line = len(line)
if self._in_block:
self._block_lines += 1
else:
self._block_lines = 0
o += "%s\n" % line
o += self.log_stop[log_name]
self.write(o)
def write(self, msg, stream=None):
if self.isSilent():
return
self._output_stream = sys.stdout
out = self._output_stream
if stream is not None:
start, stop = self.log_start.get(stream), self.log_stop.get(stream)
if start is not None and stop is not None:
out.write(start)
out.write(msg)
out.write(stop)
out.flush()
return
out.write(msg)
out.flush()
def writeln(self, msg='', stream=None):
self.write("%s\n" % msg, stream=stream)
def getExperimentConfigurationObj(self):
return self._experiment_configuration
def getExperimentConfiguration(self):
return self._experiment_configuration.get()
def setExperimentConfiguration(self, config, mnt_grps=None):
self._experiment_configuration.set(config, mnt_grps=mnt_grps)
class UnknownMacroServerElementFormat(Exception):
pass
class MacroPath(object):
def __init__(self, ms):
self._ms = weakref.ref(ms)
self.refresh()
def refresh(self):
self.macro_path = mp = self._ms().get_property("MacroPath")[
"MacroPath"]
self.base_macro_path = osp.commonprefix(self.macro_path)
self.rel_macro_path = [osp.relpath for p in (mp, self.base_macro_path)]
class Environment(dict):
def __init__(self, macro_server):
dict.__setattr__(self, "_macro_server_", weakref.ref(macro_server))
def __setattr__(self, key, value):
ms = self._macro_server_()
if ms is not None:
ms.putEnvironment(key, value)
def __getattr__(self, key):
return self[key]
def __delattr__(self, key):
ms = self._macro_server_()
if ms is not None:
ms.removeEnvironment(key)
def __dir__(self):
return [key for key in list(self.keys()) if not key.startswith("_")]
class BaseMacroServer(MacroServerDevice):
"""Class encapsulating Macro Server device functionality."""
def __init__(self, name, **kw):
self._env = Environment(self)
self._elements = BaseSardanaElementContainer()
self.call__init__(MacroServerDevice, name, **kw)
self.__elems_attr = self.getAttribute("Elements")
try:
serialization_mode = TaurusSerializationMode.TangoSerial
except AttributeError:
serialization_mode = TaurusSerializationMode.Serial
self.__elems_attr.setSerializationMode(serialization_mode)
self.__elems_attr.addListener(self.on_elements_changed)
self.__elems_attr.setSerializationMode(
TaurusSerializationMode.Concurrent)
self.__env_attr = self.getAttribute('Environment')
try:
serialization_mode = TaurusSerializationMode.TangoSerial
except AttributeError:
serialization_mode = TaurusSerializationMode.Serial
self.__env_attr.setSerializationMode(serialization_mode)
self.__env_attr.addListener(self.on_environment_changed)
self.__env_attr.setSerializationMode(
TaurusSerializationMode.Concurrent)
NO_CLASS_TYPES = 'ControllerClass', 'ControllerLibrary', \
'MacroLibrary', 'Instrument', 'Meta', 'ParameterType'
def on_environment_changed(self, evt_src, evt_type, evt_value):
try:
return self._on_environment_changed(evt_src, evt_type, evt_value)
except Exception:
self.error("Exception occurred processing environment")
self.error("Details:", exc_info=1)
return set(), set(), set()
def _on_environment_changed(self, evt_src, evt_type, evt_value):
ret = added, removed, changed = set(), set(), set()
if evt_type not in CHANGE_EVT_TYPES:
return ret
env = CodecFactory().decode(evt_value.rvalue)
for key, value in list(env.get('new', {}).items()):
self._addEnvironment(key, value)
added.add(key)
for key in env.get('del', []):
self._removeEnvironment(key)
removed.add(key)
for key, value in list(env.get('change', {}).items()):
self._removeEnvironment(key)
self._addEnvironment(key, value)
changed.add(key)
return ret
def _addEnvironment(self, key, value):
self._env[key] = value
def _removeEnvironment(self, key):
try:
self._env.pop(key)
except KeyError:
pass
def putEnvironment(self, name, value):
self.putEnvironments({name: value})
def putEnvironments(self, obj):
obj = dict(new=obj)
codec = CodecFactory().getCodec('pickle')
self.write_attribute('Environment', codec.encode(('', obj)))
setEnvironment = putEnvironment
setEnvironments = putEnvironments
def getEnvironment(self, name=None):
if name is None:
return self._env
else:
return self._env[name]
def removeEnvironment(self, key):
keys = key,
return self.removeEnvironments(keys)
def removeEnvironments(self, keys):
obj = {'del': keys}
codec = CodecFactory().getCodec('pickle')
self.write_attribute('Environment', codec.encode(('', obj)))
def getObject(self, element_info):
elem_type = element_info.getType()
if elem_type in self.NO_CLASS_TYPES:
obj = object()
elif "MacroCode" in element_info.interfaces:
obj = self._createMacroClassObject(element_info)
else:
obj = self._createDeviceObject(element_info)
return obj
def _createMacroClassObject(self, element_info):
return MacroInfo(from_json=element_info._data)
def _createDeviceObject(self, element_info):
return Factory().getDevice(element_info.full_name)
def on_elements_changed(self, evt_src, evt_type, evt_value):
try:
return self._on_elements_changed(evt_src, evt_type, evt_value)
except Exception:
self.error("Exception occurred processing elements")
self.error("Details:", exc_info=1)
return set(), set(), set()
def _on_elements_changed(self, evt_src, evt_type, evt_value):
ret = added, removed, changed = set(), set(), set()
if evt_type not in CHANGE_EVT_TYPES:
return ret
try:
elems = CodecFactory().decode(evt_value.rvalue)
except:
self.error("Could not decode element info format=%s len=%s",
evt_value.rvalue[0], len(evt_value.rvalue[1]))
return ret
for element_data in elems.get('new', ()):
element_data['manager'] = self
element = self._addElement(element_data)
added.add(element)
for element_data in elems.get('del', ()):
element = self._removeElement(element_data)
removed.add(element)
for element_data in elems.get('change', ()):
element = self._removeElement(element_data)
element_data['manager'] = self
element = self._addElement(element_data)
changed.add(element)
return ret
def _addElement(self, element_data):
element | |
assert balance_maker == deploy_args[2] - _amount_make
assert balance_taker == _amount_take
assert commitment == _amount_make - _amount_take
# Assert: last_price
assert bond_exchange.lastPrice(bond_token.address) == 123
# 正常系2
# Make買、Take売
# ＜発行体＞新規発行 -> ＜投資家＞Make注文（買）
# -> ＜発行体＞Take注文（売） -> ＜決済業者＞決済処理
def test_confirmAgreement_normal_2(users,
bond_exchange, personal_info, payment_gateway):
_issuer = users['issuer']
_trader = users['trader']
_agent = users['agent']
personalinfo_register(personal_info, _issuer, _issuer)
payment_gateway_register(payment_gateway, _issuer, _agent)
payment_gateway_approve(payment_gateway, _issuer, _agent)
personalinfo_register(personal_info, _trader, _issuer)
payment_gateway_register(payment_gateway, _trader, _agent)
payment_gateway_approve(payment_gateway, _trader, _agent)
# 新規発行
bond_token, deploy_args = utils. \
issue_bond_token(users, bond_exchange.address, personal_info.address)
# 新規注文（買）：投資家
_price = 123
_amount_make = 100
bond_exchange.createOrder.transact(
bond_token.address, _amount_make, _price, True, _agent, {'from': _trader})
order_id = bond_exchange.latestOrderId()
# 預かりをExchangeへのデポジット：発行体
_amount_take = 50
bond_token.transfer.transact(bond_exchange.address, _amount_take, {'from': _issuer})
# Take注文（売）：発行体
bond_exchange.executeOrder.transact(order_id, _amount_take, False, {'from': _issuer})
agreement_id = bond_exchange.latestAgreementId(order_id)
# 決済承認：決済業者
bond_exchange.confirmAgreement.transact(
order_id, agreement_id, {'from': _agent})
orderbook = bond_exchange.getOrder(order_id)
agree = bond_exchange.getAgreement(order_id, agreement_id)
balance_maker = bond_token.balanceOf(_trader)
balance_taker = bond_token.balanceOf(_issuer)
commitment = bond_exchange.commitmentOf(_issuer, bond_token.address)
assert orderbook == [
_trader, to_checksum_address(bond_token.address),
_amount_make - _amount_take,
_price, True, _agent, False
]
assert agree[0:5] == [_issuer, _amount_take, _price, False, True]
assert balance_maker == _amount_take
assert balance_taker == deploy_args[2] - _amount_take
assert commitment == 0
# Assert: last_price
assert bond_exchange.lastPrice(bond_token.address) == 123
# エラー系1
# 入力値の型誤り（_orderId）
def test_confirmAgreement_error_1(users, bond_exchange):
_agent = users['agent']
# 決済承認：決済業者
with pytest.raises(OverflowError):
bond_exchange.confirmAgreement.transact(-1, 0, {'from': _agent})
with pytest.raises(OverflowError):
bond_exchange.confirmAgreement.transact(2 ** 256, 0, {'from': _agent})
with pytest.raises(TypeError):
bond_exchange.confirmAgreement.transact('abc', 0, {'from': _agent})
# エラー系2
# 入力値の型誤り（_agreementId）
def test_confirmAgreement_error_2(users, bond_exchange):
_agent = users['agent']
# 決済承認：決済業者
with pytest.raises(OverflowError):
bond_exchange.confirmAgreement.transact(0, -1, {'from': _agent})
with pytest.raises(OverflowError):
bond_exchange.confirmAgreement.transact(0, 2 ** 256, {'from': _agent})
with pytest.raises(TypeError):
bond_exchange.confirmAgreement.transact(0, 'abc', {'from': _agent})
# エラー系3
# 指定した注文番号が、直近の注文ID以上の場合
def test_confirmAgreement_error_3(users,
bond_exchange, personal_info, payment_gateway):
_issuer = users['issuer']
_trader = users['trader']
_agent = users['agent']
personalinfo_register(personal_info, _issuer, _issuer)
payment_gateway_register(payment_gateway, _issuer, _agent)
payment_gateway_approve(payment_gateway, _issuer, _agent)
personalinfo_register(personal_info, _trader, _issuer)
payment_gateway_register(payment_gateway, _trader, _agent)
payment_gateway_approve(payment_gateway, _trader, _agent)
# 新規発行
bond_token, deploy_args = utils. \
issue_bond_token(users, bond_exchange.address, personal_info.address)
# Exchangeへのデポジット：発行体
_amount_make = 100
bond_token.transfer.transact(bond_exchange.address, _amount_make, {'from': _issuer})
# Make注文（売）：発行体
_price = 123
bond_exchange.createOrder.transact(
bond_token.address, _amount_make, _price, False, _agent, {'from': _issuer})
# Take注文（買）：投資家
order_id = bond_exchange.latestOrderId()
_amount_take = 50
bond_exchange.executeOrder.transact(
order_id, _amount_take, True, {'from': _trader})
agreement_id = bond_exchange.latestAgreementId(order_id)
# 決済承認：決済業者
order_id_error = bond_exchange.latestOrderId() + 1
bond_exchange.confirmAgreement.transact(order_id_error, agreement_id, {'from': _agent}) # エラーになる
orderbook = bond_exchange.getOrder(order_id)
agreement = bond_exchange.getAgreement(order_id, agreement_id)
balance_maker = bond_token.balanceOf(_issuer)
balance_taker = bond_token.balanceOf(_trader)
commitment = bond_exchange.commitmentOf(_issuer, bond_token.address)
assert orderbook == [
_issuer, to_checksum_address(bond_token.address),
_amount_make - _amount_take,
_price, False, _agent, False
]
assert agreement[0:5] == [_trader, _amount_take, _price, False, False]
assert balance_maker == deploy_args[2] - _amount_make
assert balance_taker == 0
assert commitment == _amount_make
# Assert: last_price
assert bond_exchange.lastPrice(bond_token.address) == 0
# エラー系4
# 指定した約定IDが、直近の約定ID以上の場合
def test_confirmAgreement_error_4(users,
bond_exchange, personal_info, payment_gateway):
_issuer = users['issuer']
_trader = users['trader']
_agent = users['agent']
personalinfo_register(personal_info, _issuer, _issuer)
payment_gateway_register(payment_gateway, _issuer, _agent)
payment_gateway_approve(payment_gateway, _issuer, _agent)
personalinfo_register(personal_info, _trader, _issuer)
payment_gateway_register(payment_gateway, _trader, _agent)
payment_gateway_approve(payment_gateway, _trader, _agent)
# 新規発行
bond_token, deploy_args = utils. \
issue_bond_token(users, bond_exchange.address, personal_info.address)
# Exchangeへのデポジット：発行体
_amount_make = 100
bond_token.transfer.transact(bond_exchange.address, _amount_make, {'from': _issuer})
# Make注文（売）：発行体
_price = 123
bond_exchange.createOrder.transact(
bond_token.address, _amount_make, _price, False, _agent, {'from': _issuer})
# Take注文（買）：投資家
order_id = bond_exchange.latestOrderId()
_amount_take = 50
bond_exchange.executeOrder.transact(
order_id, _amount_take, True, {'from': _trader})
agreement_id = bond_exchange.latestAgreementId(order_id)
# 決済承認：決済業者
agreement_id_error = bond_exchange.latestAgreementId(order_id) + 1
bond_exchange.confirmAgreement.transact(order_id, agreement_id_error, {'from': _agent}) # エラーになる
orderbook = bond_exchange.getOrder(order_id)
agreement = bond_exchange.getAgreement(order_id, agreement_id)
balance_maker = bond_token.balanceOf(_issuer)
balance_taker = bond_token.balanceOf(_trader)
commitment = bond_exchange.commitmentOf(_issuer, bond_token.address)
assert orderbook == [
_issuer, to_checksum_address(bond_token.address),
_amount_make - _amount_take,
_price, False, _agent, False
]
assert agreement[0:5] == [_trader, _amount_take, _price, False, False]
assert balance_maker == deploy_args[2] - _amount_make
assert balance_taker == 0
assert commitment == _amount_make
# Assert: last_price
assert bond_exchange.lastPrice(bond_token.address) == 0
# エラー系5
# 指定した約定明細がすでに支払い済みの状態の場合
def test_confirmAgreement_error_5(users,
bond_exchange, personal_info, payment_gateway):
_issuer = users['issuer']
_trader = users['trader']
_agent = users['agent']
personalinfo_register(personal_info, _issuer, _issuer)
payment_gateway_register(payment_gateway, _issuer, _agent)
payment_gateway_approve(payment_gateway, _issuer, _agent)
personalinfo_register(personal_info, _trader, _issuer)
payment_gateway_register(payment_gateway, _trader, _agent)
payment_gateway_approve(payment_gateway, _trader, _agent)
# 新規発行
bond_token, deploy_args = utils. \
issue_bond_token(users, bond_exchange.address, personal_info.address)
# Exchangeへのデポジット：発行体
_amount_make = 100
bond_token.transfer.transact(bond_exchange.address, _amount_make, {'from': _issuer})
# Make注文（売）：発行体
_price = 123
bond_exchange.createOrder.transact(
bond_token.address, _amount_make, _price, False, _agent, {'from': _issuer})
# Take注文（買）：投資家
order_id = bond_exchange.latestOrderId()
_amount_take = 50
bond_exchange.executeOrder.transact(
order_id, _amount_take, True, {'from': _trader})
agreement_id = bond_exchange.latestAgreementId(order_id)
# 決済承認：決済業者
bond_exchange.confirmAgreement.transact(
order_id, agreement_id, {'from': _agent})
# 決済承認：決済業者（2回目）
bond_exchange.confirmAgreement.transact(order_id, agreement_id, {'from': _agent}) # エラーになる
orderbook = bond_exchange.getOrder(order_id)
agreement = bond_exchange.getAgreement(order_id, agreement_id)
balance_maker = bond_token.balanceOf(_issuer)
balance_taker = bond_token.balanceOf(_trader)
commitment = bond_exchange.commitmentOf(_issuer, bond_token.address)
assert orderbook == [
_issuer, to_checksum_address(bond_token.address),
_amount_make - _amount_take,
_price, False, _agent, False
]
assert agreement[0:5] == [_trader, _amount_take, _price, False, True]
assert balance_maker == deploy_args[2] - _amount_make
assert balance_taker == _amount_take
assert commitment == _amount_make - _amount_take
# Assert: last_price
assert bond_exchange.lastPrice(bond_token.address) == 123
# エラー系6
# 元注文で指定した決済業者ではない場合
def test_confirmAgreement_error_6(users,
bond_exchange, personal_info, payment_gateway):
_issuer = users['issuer']
_trader = users['trader']
_agent = users['agent']
personalinfo_register(personal_info, _issuer, _issuer)
payment_gateway_register(payment_gateway, _issuer, _agent)
payment_gateway_approve(payment_gateway, _issuer, _agent)
personalinfo_register(personal_info, _trader, _issuer)
payment_gateway_register(payment_gateway, _trader, _agent)
payment_gateway_approve(payment_gateway, _trader, _agent)
# 新規発行
bond_token, deploy_args = utils. \
issue_bond_token(users, bond_exchange.address, personal_info.address)
# Exchangeへのデポジット：発行体
_amount_make = 100
bond_token.transfer.transact(bond_exchange.address, _amount_make, {'from': _issuer})
# Make注文（売）：発行体
_price = 123
bond_exchange.createOrder.transact(
bond_token.address, _amount_make, _price, False, _agent, {'from': _issuer})
# Take注文（買）：投資家
order_id = bond_exchange.latestOrderId()
_amount_take = 50
bond_exchange.executeOrder.transact(
order_id, _amount_take, True, {'from': _trader})
agreement_id = bond_exchange.latestAgreementId(order_id)
# 決済承認：投資家（指定した決済業者ではない）
bond_exchange.confirmAgreement.transact(order_id, agreement_id, {'from': _trader}) # エラーになる
orderbook = bond_exchange.getOrder(order_id)
agreement = bond_exchange.getAgreement(order_id, agreement_id)
balance_maker = bond_token.balanceOf(_issuer)
balance_taker = bond_token.balanceOf(_trader)
commitment = bond_exchange.commitmentOf(_issuer, bond_token.address)
assert orderbook == [
_issuer, to_checksum_address(bond_token.address),
_amount_make - _amount_take,
_price, False, _agent, False
]
assert agreement[0:5] == [_trader, _amount_take, _price, False, False]
assert balance_maker == deploy_args[2] - _amount_make
assert balance_taker == 0
assert commitment == _amount_make
# Assert: last_price
assert bond_exchange.lastPrice(bond_token.address) == 0
# エラー系7
# 既に決済非承認済み（キャンセル済み）の場合
def test_confirmAgreement_error_7(users,
bond_exchange, personal_info, payment_gateway):
_issuer = users['issuer']
_trader = users['trader']
_agent = users['agent']
personalinfo_register(personal_info, _issuer, _issuer)
payment_gateway_register(payment_gateway, _issuer, _agent)
payment_gateway_approve(payment_gateway, _issuer, _agent)
personalinfo_register(personal_info, _trader, _issuer)
payment_gateway_register(payment_gateway, _trader, _agent)
payment_gateway_approve(payment_gateway, _trader, _agent)
# 新規発行
bond_token, deploy_args = utils. \
issue_bond_token(users, bond_exchange.address, personal_info.address)
# Exchangeへのデポジット：発行体
_amount_make = 100
bond_token.transfer.transact(bond_exchange.address, _amount_make, {'from': _issuer})
# Make注文（売）：発行体
_price = 123
bond_exchange.createOrder.transact(
bond_token.address, _amount_make, _price, False, _agent, {'from': _issuer})
# Take注文（買）：投資家
order_id = bond_exchange.latestOrderId()
_amount_take = 50
bond_exchange.executeOrder.transact(
order_id, _amount_take, True, {'from': _trader})
agreement_id = bond_exchange.latestAgreementId(order_id)
# 決済非承認：決済業者
bond_exchange.cancelAgreement.transact(
order_id, agreement_id, {'from': _agent})
# 決済承認：決済業者
bond_exchange.confirmAgreement.transact(order_id, agreement_id, {'from': _agent}) # エラーになる
orderbook = bond_exchange.getOrder(order_id)
agreement = bond_exchange.getAgreement(order_id, agreement_id)
balance_maker = bond_token.balanceOf(_issuer)
balance_taker = bond_token.balanceOf(_trader)
commitment = bond_exchange.commitmentOf(_issuer, bond_token.address)
assert orderbook == [
_issuer, to_checksum_address(bond_token.address),
_amount_make,
_price, False, _agent, False
]
assert agreement[0:5] == [_trader, _amount_take, _price, True, False]
assert balance_maker == deploy_args[2] - _amount_make
assert balance_taker == 0
assert commitment == _amount_make
# Assert: last_price
assert bond_exchange.lastPrice(bond_token.address) == 0
'''
TEST_決済非承認（cancelAgreement）
'''
# 正常系1
# Make売、Take買
# ＜発行体＞新規発行 -> ＜発行体＞Make注文（売）
# -> ＜投資家＞Take注文（買） -> ＜決済業者＞決済非承認
def test_cancelAgreement_normal_1(users,
bond_exchange, personal_info, payment_gateway):
_issuer = users['issuer']
_trader = users['trader']
_agent = users['agent']
personalinfo_register(personal_info, _issuer, _issuer)
payment_gateway_register(payment_gateway, _issuer, _agent)
payment_gateway_approve(payment_gateway, _issuer, _agent)
personalinfo_register(personal_info, _trader, _issuer)
payment_gateway_register(payment_gateway, _trader, _agent)
payment_gateway_approve(payment_gateway, _trader, _agent)
# 新規発行
bond_token, deploy_args = utils. \
issue_bond_token(users, bond_exchange.address, personal_info.address)
# Exchangeへのデポジット：発行体
_amount_make = 100
bond_token.transfer.transact(bond_exchange.address, _amount_make, {'from': _issuer})
# Make注文（売）：発行体
_price = 123
bond_exchange.createOrder.transact(
bond_token.address, _amount_make, _price, False, _agent, {'from': _issuer})
# Take注文（買）：投資家
order_id = bond_exchange.latestOrderId()
_amount_take = 50
bond_exchange.executeOrder.transact(
order_id, _amount_take, True, {'from': _trader})
agreement_id = bond_exchange.latestAgreementId(order_id)
# 決済非承認：決済業者
bond_exchange.cancelAgreement.transact(
order_id, agreement_id, {'from': _agent})
orderbook = bond_exchange.getOrder(order_id)
agreement = bond_exchange.getAgreement(order_id, agreement_id)
balance_maker = bond_token.balanceOf(_issuer)
balance_taker = bond_token.balanceOf(_trader)
commitment = bond_exchange.commitmentOf(_issuer, bond_token.address)
assert orderbook == [
_issuer, to_checksum_address(bond_token.address),
_amount_make,
_price, False, _agent, False
]
assert agreement[0:5] == [_trader, _amount_take, _price, True, False]
assert balance_maker == deploy_args[2] - _amount_make
assert balance_taker == 0
assert commitment == _amount_make
# 正常系2
# Make買、Take売
# ＜発行体＞新規発行 -> ＜投資家＞Make注文（買）
# -> ＜発行体＞Take注文（売） -> ＜決済業者＞決済非承認
def test_cancelAgreement_normal_2(users,
bond_exchange, personal_info, payment_gateway):
_issuer = users['issuer']
_trader = users['trader']
_agent = users['agent']
personalinfo_register(personal_info, _issuer, _issuer)
payment_gateway_register(payment_gateway, _issuer, _agent)
payment_gateway_approve(payment_gateway, _issuer, _agent)
personalinfo_register(personal_info, _trader, _issuer)
payment_gateway_register(payment_gateway, _trader, _agent)
payment_gateway_approve(payment_gateway, _trader, _agent)
# 新規発行
bond_token, deploy_args = utils. \
issue_bond_token(users, bond_exchange.address, personal_info.address)
# 新規注文（買）：投資家
_price = 123
_amount_make = 100
bond_exchange.createOrder.transact(
bond_token.address, _amount_make, _price, True, _agent, {'from': _trader})
order_id = bond_exchange.latestOrderId()
# 預かりをExchangeへのデポジット：発行体
_amount_take = 50
bond_token.transfer.transact(bond_exchange.address, _amount_take, {'from': _issuer})
# Take注文（売）：発行体
bond_exchange.executeOrder.transact(order_id, _amount_take, False, {'from': _issuer})
agreement_id = bond_exchange.latestAgreementId(order_id)
# 決済非承認：決済業者
bond_exchange.cancelAgreement.transact(
order_id, agreement_id, {'from': _agent})
orderbook = bond_exchange.getOrder(order_id)
agree = bond_exchange.getAgreement(order_id, agreement_id)
balance_maker = bond_token.balanceOf(_trader)
balance_taker = bond_token.balanceOf(_issuer)
commitment = bond_exchange.commitmentOf(_issuer, bond_token.address)
assert orderbook == [
_trader, to_checksum_address(bond_token.address),
_amount_make - _amount_take,
_price, True, | |
<filename>packages/python/plotly/plotly/graph_objs/layout/scene/__init__.py
from plotly.basedatatypes import BaseLayoutHierarchyType as _BaseLayoutHierarchyType
import copy as _copy
class ZAxis(_BaseLayoutHierarchyType):
# autorange
# ---------
@property
def autorange(self):
"""
Determines whether or not the range of this axis is computed in
relation to the input data. See `rangemode` for more info. If
`range` is provided, then `autorange` is set to False.
The 'autorange' property is an enumeration that may be specified as:
- One of the following enumeration values:
[True, False, 'reversed']
Returns
-------
Any
"""
return self["autorange"]
@autorange.setter
def autorange(self, val):
self["autorange"] = val
# backgroundcolor
# ---------------
@property
def backgroundcolor(self):
"""
Sets the background color of this axis' wall.
The 'backgroundcolor' property is a color and may be specified as:
- A hex string (e.g. '#ff0000')
- An rgb/rgba string (e.g. 'rgb(255,0,0)')
- An hsl/hsla string (e.g. 'hsl(0,100%,50%)')
- An hsv/hsva string (e.g. 'hsv(0,100%,100%)')
- A named CSS color:
aliceblue, antiquewhite, aqua, aquamarine, azure,
beige, bisque, black, blanchedalmond, blue,
blueviolet, brown, burlywood, cadetblue,
chartreuse, chocolate, coral, cornflowerblue,
cornsilk, crimson, cyan, darkblue, darkcyan,
darkgoldenrod, darkgray, darkgrey, darkgreen,
darkkhaki, darkmagenta, darkolivegreen, darkorange,
darkorchid, darkred, darksalmon, darkseagreen,
darkslateblue, darkslategray, darkslategrey,
darkturquoise, darkviolet, deeppink, deepskyblue,
dimgray, dimgrey, dodgerblue, firebrick,
floralwhite, forestgreen, fuchsia, gainsboro,
ghostwhite, gold, goldenrod, gray, grey, green,
greenyellow, honeydew, hotpink, indianred, indigo,
ivory, khaki, lavender, lavenderblush, lawngreen,
lemonchiffon, lightblue, lightcoral, lightcyan,
lightgoldenrodyellow, lightgray, lightgrey,
lightgreen, lightpink, lightsalmon, lightseagreen,
lightskyblue, lightslategray, lightslategrey,
lightsteelblue, lightyellow, lime, limegreen,
linen, magenta, maroon, mediumaquamarine,
mediumblue, mediumorchid, mediumpurple,
mediumseagreen, mediumslateblue, mediumspringgreen,
mediumturquoise, mediumvioletred, midnightblue,
mintcream, mistyrose, moccasin, navajowhite, navy,
oldlace, olive, olivedrab, orange, orangered,
orchid, palegoldenrod, palegreen, paleturquoise,
palevioletred, papayawhip, peachpuff, peru, pink,
plum, powderblue, purple, red, rosybrown,
royalblue, rebeccapurple, saddlebrown, salmon,
sandybrown, seagreen, seashell, sienna, silver,
skyblue, slateblue, slategray, slategrey, snow,
springgreen, steelblue, tan, teal, thistle, tomato,
turquoise, violet, wheat, white, whitesmoke,
yellow, yellowgreen
Returns
-------
str
"""
return self["backgroundcolor"]
@backgroundcolor.setter
def backgroundcolor(self, val):
self["backgroundcolor"] = val
# calendar
# --------
@property
def calendar(self):
"""
Sets the calendar system to use for `range` and `tick0` if this
is a date axis. This does not set the calendar for interpreting
data on this axis, that's specified in the trace or via the
global `layout.calendar`
The 'calendar' property is an enumeration that may be specified as:
- One of the following enumeration values:
['gregorian', 'chinese', 'coptic', 'discworld',
'ethiopian', 'hebrew', 'islamic', 'julian', 'mayan',
'nanakshahi', 'nepali', 'persian', 'jalali', 'taiwan',
'thai', 'ummalqura']
Returns
-------
Any
"""
return self["calendar"]
@calendar.setter
def calendar(self, val):
self["calendar"] = val
# categoryarray
# -------------
@property
def categoryarray(self):
"""
Sets the order in which categories on this axis appear. Only
has an effect if `categoryorder` is set to "array". Used with
`categoryorder`.
The 'categoryarray' property is an array that may be specified as a tuple,
list, numpy array, or pandas Series
Returns
-------
numpy.ndarray
"""
return self["categoryarray"]
@categoryarray.setter
def categoryarray(self, val):
self["categoryarray"] = val
# categoryarraysrc
# ----------------
@property
def categoryarraysrc(self):
"""
Sets the source reference on Chart Studio Cloud for
categoryarray .
The 'categoryarraysrc' property must be specified as a string or
as a plotly.grid_objs.Column object
Returns
-------
str
"""
return self["categoryarraysrc"]
@categoryarraysrc.setter
def categoryarraysrc(self, val):
self["categoryarraysrc"] = val
# categoryorder
# -------------
@property
def categoryorder(self):
"""
Specifies the ordering logic for the case of categorical
variables. By default, plotly uses "trace", which specifies the
order that is present in the data supplied. Set `categoryorder`
to *category ascending* or *category descending* if order
should be determined by the alphanumerical order of the
category names. Set `categoryorder` to "array" to derive the
ordering from the attribute `categoryarray`. If a category is
not found in the `categoryarray` array, the sorting behavior
for that attribute will be identical to the "trace" mode. The
unspecified categories will follow the categories in
`categoryarray`. Set `categoryorder` to *total ascending* or
*total descending* if order should be determined by the
numerical order of the values. Similarly, the order can be
determined by the min, max, sum, mean or median of all the
values.
The 'categoryorder' property is an enumeration that may be specified as:
- One of the following enumeration values:
['trace', 'category ascending', 'category descending',
'array', 'total ascending', 'total descending', 'min
ascending', 'min descending', 'max ascending', 'max
descending', 'sum ascending', 'sum descending', 'mean
ascending', 'mean descending', 'median ascending', 'median
descending']
Returns
-------
Any
"""
return self["categoryorder"]
@categoryorder.setter
def categoryorder(self, val):
self["categoryorder"] = val
# color
# -----
@property
def color(self):
"""
Sets default for all colors associated with this axis all at
once: line, font, tick, and grid colors. Grid color is
lightened by blending this with the plot background Individual
pieces can override this.
The 'color' property is a color and may be specified as:
- A hex string (e.g. '#ff0000')
- An rgb/rgba string (e.g. 'rgb(255,0,0)')
- An hsl/hsla string (e.g. 'hsl(0,100%,50%)')
- An hsv/hsva string (e.g. 'hsv(0,100%,100%)')
- A named CSS color:
aliceblue, antiquewhite, aqua, aquamarine, azure,
beige, bisque, black, blanchedalmond, blue,
blueviolet, brown, burlywood, cadetblue,
chartreuse, chocolate, coral, cornflowerblue,
cornsilk, crimson, cyan, darkblue, darkcyan,
darkgoldenrod, darkgray, darkgrey, darkgreen,
darkkhaki, darkmagenta, darkolivegreen, darkorange,
darkorchid, darkred, darksalmon, darkseagreen,
darkslateblue, darkslategray, darkslategrey,
darkturquoise, darkviolet, deeppink, deepskyblue,
dimgray, dimgrey, dodgerblue, firebrick,
floralwhite, forestgreen, fuchsia, gainsboro,
ghostwhite, gold, goldenrod, gray, grey, green,
greenyellow, honeydew, hotpink, indianred, indigo,
ivory, khaki, lavender, lavenderblush, lawngreen,
lemonchiffon, lightblue, lightcoral, lightcyan,
lightgoldenrodyellow, lightgray, lightgrey,
lightgreen, lightpink, lightsalmon, lightseagreen,
lightskyblue, lightslategray, lightslategrey,
lightsteelblue, lightyellow, lime, limegreen,
linen, magenta, maroon, mediumaquamarine,
mediumblue, mediumorchid, mediumpurple,
mediumseagreen, mediumslateblue, mediumspringgreen,
mediumturquoise, mediumvioletred, midnightblue,
mintcream, mistyrose, moccasin, navajowhite, navy,
oldlace, olive, olivedrab, orange, orangered,
orchid, palegoldenrod, palegreen, paleturquoise,
palevioletred, papayawhip, peachpuff, peru, pink,
plum, powderblue, purple, red, rosybrown,
royalblue, rebeccapurple, saddlebrown, salmon,
sandybrown, seagreen, seashell, sienna, silver,
skyblue, slateblue, slategray, slategrey, snow,
springgreen, steelblue, tan, teal, thistle, tomato,
turquoise, violet, wheat, white, whitesmoke,
yellow, yellowgreen
Returns
-------
str
"""
return self["color"]
@color.setter
def color(self, val):
self["color"] = val
# dtick
# -----
@property
def dtick(self):
"""
Sets the step in-between ticks on this axis. Use with `tick0`.
Must be a positive number, or special strings available to
"log" and "date" axes. If the axis `type` is "log", then ticks
are set every 10^(n*dtick) where n is the tick number. For
example, to set a tick mark at 1, 10, 100, 1000, ... set dtick
to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2.
To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to
log_10(5), or 0.69897000433. "log" has several special values;
"L<f>", where `f` is a positive number, gives ticks linearly
spaced in value (but not position). For example `tick0` = 0.1,
`dtick` = "L0.5" will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To
show powers of 10 plus small digits between, use "D1" (all
digits) or "D2" (only 2 and 5). `tick0` is ignored for "D1" and
"D2". If the axis `type` is "date", then you must convert the
time to milliseconds. For example, to set the interval between
ticks to one day, set `dtick` to 86400000.0. "date" also has
special values "M<n>" gives ticks spaced by a number of months.
`n` must be a positive integer. To set ticks on the 15th of
every third month, set `tick0` to "2000-01-15" and `dtick` to
"M3". To set ticks every 4 years, set `dtick` to "M48"
The 'dtick' property accepts values of any type
Returns
-------
Any
"""
return self["dtick"]
@dtick.setter
def dtick(self, val):
self["dtick"] = val
# exponentformat
# --------------
@property
def exponentformat(self):
"""
Determines a formatting rule for the tick exponents. For
example, consider the number 1,000,000,000. If "none", it
appears as 1,000,000,000. If "e", 1e+9. If "E", 1E+9. If
"power", 1x10^9 (with 9 in a super script). If "SI", 1G. If
"B", 1B.
The 'exponentformat' property is an enumeration that may be specified as:
- One of the following enumeration | |
#! usr/bin/python
from __future__ import print_function, division, absolute_import
from os import remove
from os.path import join, abspath
from sys import stdout, exit
from time import time
import multiprocessing as mp
from argparse import ArgumentParser
import logging
import numpy as np
from disvis import DisVis, PDB, Volume
from disvis.rotations import proportional_orientations, quat_to_rotmat
from disvis.helpers import mkdir_p
def parse_args():
"""Parse the command-line arguments."""
p = ArgumentParser()
p.add_argument('receptor', type=file,
help='PDB-file containing fixed chain.')
p.add_argument('ligand', type=file,
help='PDB-file containing scanning chain.')
p.add_argument('restraints', type=file,
help='File containing the distance restraints')
p.add_argument('-a', '--angle', dest='angle', type=float, default=15, metavar='<float>',
help='Rotational sampling density in degrees. Default is 15 degrees.')
p.add_argument('-vs', '--voxelspacing', dest='voxelspacing', metavar='<float>',
type=float, default=1,
help='Voxel spacing of search grid in angstrom. Default is 1A.')
p.add_argument('-ir', '--interaction-radius',
dest='interaction_radius', type=float, default=3.0, metavar='<float>',
help='Radius of the interaction space for each atom in angstrom. '
'Atoms are thus considered interacting if the distance is '
'larger than the vdW radius and shorther than or equal to '
'vdW + interaction_radius. Default is 3A.')
p.add_argument('-cv', '--max-clash',
dest='max_clash', type=float, default=200, metavar='<float>',
help='Maximum allowed volume of clashes. Increasing this '
'number results in more allowed complexes. '
'Default is 200 A^3.')
p.add_argument('-iv', '--min-interaction',
dest='min_interaction', type=float, default=300, metavar='<float>',
help='Minimal required interaction volume for a '
'conformation to be considered a '
'complex. Increasing this number results in a '
'stricter counting of complexes. '
'Default is 300 A^3.')
p.add_argument('-d', '--directory', dest='directory', metavar='<dir>',
type=abspath, default='.',
help='Directory where results are written to. '
'Default is current directory.')
p.add_argument('-p', '--nproc', dest='nproc', type=int, default=1, metavar='<int>',
help='Number of processors used during search.')
p.add_argument('-g', '--gpu', dest='gpu', action='store_true',
help='Use GPU-acceleration for search. If not available '
'the CPU-version will be used with the given number '
'of processors.')
help_msg = ("File containing residue number for which interactions will be counted. "
"The first line holds the receptor residue, "
"and the second line the ligand residue numbers.")
p.add_argument('-is', '--interaction-selection', metavar='<file>',
dest='interaction_selection', type=file, default=None,
help=help_msg)
help_msg = ("Number of minimal consistent restraints for which an interaction "
"or occupancy analysis will be performed. "
"Default is number of restraints minus 1.")
p.add_argument('-ic', '--interaction-restraints-cutoff', metavar='<int>',
dest='interaction_restraints_cutoff', type=int, default=None,
help=help_msg)
p.add_argument('-oa', '--occupancy-analysis', dest='occupancy_analysis',
action='store_true',
help=("Perform an occupancy analysis, ultimately providing "
"a volume where each grid point represents the "
"normalized probability of that spot being occupied by the ligand."
)
)
return p.parse_args()
def parse_interaction_selection(fid, pdb1, pdb2):
"""Parse the interaction selection file, i.e. all residues for which an
interaction analysis is performed."""
resi1 = [int(x) for x in fid.readline().split()]
resi2 = [int(x) for x in fid.readline().split()]
pdb1_sel = pdb1.select('name', ('CA', "O3'")).select('resi', resi1)
pdb2_sel = pdb2.select('name', ('CA', "O3'")).select('resi', resi2)
if (len(resi1) != pdb1_sel.natoms) or (len(resi2) != pdb2_sel.natoms):
msg = ("Some selected interaction residues where either missing in the PDB file "
"or had alternate conformers. Please check your input residues and remove alternate conformers.")
raise ValueError(msg)
return pdb1_sel, pdb2_sel
def parse_restraints(fid, pdb1, pdb2):
"""Parse the restraints file."""
dist_restraints = []
for line in fid:
# ignore comments and empty lines
line = line.strip()
if line.startswith('#') or not line:
continue
chain1, resi1, name1, chain2, resi2, name2, mindis, maxdis = line.split()
pdb1_sel = pdb1.select('chain', chain1).select('resi',
int(resi1)).select('name', name1).duplicate()
pdb2_sel = pdb2.select('chain', chain2).select('resi',
int(resi2)).select('name', name2).duplicate()
if pdb1_sel.natoms == 0 or pdb2_sel.natoms == 0:
raise ValueError("A restraint selection was not found in line:\n{:s}".format(str(line)))
dist_restraints.append([pdb1_sel, pdb2_sel, float(mindis), float(maxdis)])
fid.close()
return dist_restraints
class Joiner(object):
def __init__(self, directory):
self.directory = directory
def __call__(self, fname):
"""Join fname with set directory."""
return join(self.directory, fname)
class Results(object):
"""Simple container"""
pass
def run_disvis_instance(queue, receptor, ligand, distance_restraints, rotmat,
weights, n, pdb1_sel, pdb2_sel, args):
"""Run a single DisVis instance."""
dv = DisVis()
dv.receptor = receptor
dv.ligand = ligand
dv.distance_restraints = distance_restraints
dv.rotations = rotmat
dv.weights = weights
dv.voxelspacing = args.voxelspacing
dv.interaction_radius = args.interaction_radius
dv.max_clash = args.max_clash
dv.min_interaction = args.min_interaction
dv.interaction_restraints_cutoff = args.interaction_restraints_cutoff
if args.interaction_selection is not None:
dv.receptor_interaction_selection = pdb1_sel
dv.ligand_interaction_selection = pdb2_sel
dv.occupancy_analysis = args.occupancy_analysis
dv.search()
# Save results to file, to be combined later
joiner = Joiner(args.directory)
fname = joiner('accessible_interaction_space_{:d}.mrc').format(n)
dv.accessible_interaction_space.tofile(fname)
fname = joiner('violations_{:d}.npy').format(n)
np.save(fname, dv.violations)
if dv.interaction_matrix is not None:
fname = joiner('interaction_matrix_{:d}.npy'.format(n))
np.save(fname, dv.interaction_matrix)
if dv.occupancy_analysis:
for key, value in dv.occupancy_grids.iteritems():
fname = joiner('occupancy_{:d}_{:d}.mrc'.format(key, n))
value.tofile(fname)
queue.put(dv.accessible_complexes)
def mp_cpu_disvis(receptor, ligand, rotmat, weights, distance_restraints,
pdb1_sel, pdb2_sel, args):
"""Run several DisVis instances, each with a subset of all rotations."""
# multi-threaded CPU version
try:
max_cpu = mp.cpu_count()
jobs = min(max_cpu, args.nproc)
except NotImplementedError:
jobs = args.nproc
# in case more processes are requested than the number
# of rotations sampled
nrot = rotmat.shape[0]
if jobs > nrot:
jobs = nrot
nrot_per_job = nrot//jobs
write('Number of processors used: {:d}'.format(jobs))
write('Number of rotations per job: {:d}'.format(nrot_per_job))
write('Creating jobs')
queue = mp.Queue()
processes = []
for n in xrange(jobs):
# Determine the rotations that each job needs to sample
init_rot = n * nrot_per_job
end_rot = (n + 1) * nrot_per_job
if n == (jobs - 1):
end_rot = None
sub_rotmat = rotmat[init_rot: end_rot]
sub_weights = weights[init_rot: end_rot]
disvis_args = (queue, receptor, ligand, distance_restraints,
sub_rotmat, sub_weights, n, pdb1_sel, pdb2_sel, args)
process = mp.Process(target=run_disvis_instance, args=disvis_args)
processes.append(process)
write('Starting jobs')
for p in processes:
p.start()
write('Waiting for jobs to finish')
for p in processes:
p.join()
# Check whether the queue is empty, this indicates failure to run on
# multi-processor runs.
if queue.empty():
raise mp.Queue.Empty
write('Searching done. Combining results')
# Create dummy class with similar results attributes as DisVis class
results = Results()
joiner = Joiner(args.directory)
fname_interspace = joiner('accessible_interaction_space_{:d}.mrc')
fname_violations = joiner('violations_{:d}.npy')
fname_intermat = joiner('interaction_matrix_{:d}.npy')
accessible_complexes = np.asarray(queue.get(), dtype=np.float64)
accessible_interaction_space = Volume.fromfile(fname_interspace.format(0))
violations = np.load(fname_violations.format(0))
for n in xrange(1, jobs):
accessible_complexes += np.asarray(queue.get(), dtype=np.float64)
np.maximum(accessible_interaction_space.array,
Volume.fromfile(fname_interspace.format(n)).array,
accessible_interaction_space.array)
violations += np.load(fname_violations.format(n))
# Combine the occupancy grids
occupancy = None
if args.occupancy_analysis:
fname_occupancy = joiner('occupancy_{:d}_{:d}.mrc')
occupancy = {}
for consistent_restraints in xrange(args.interaction_restraints_cutoff,
len(distance_restraints) + 1):
occupancy[consistent_restraints] = Volume.fromfile(
fname_occupancy.format(consistent_restraints, 0))
for n in range(1, jobs):
occupancy[consistent_restraints]._array += (
Volume.fromfile(fname_occupancy.format(consistent_restraints, n))._array
)
# Combine the interaction analysis
results.interaction_matrix = None
if args.interaction_selection is not None:
interaction_matrix = np.load(fname_intermat.format(0))
for n in range(1, jobs):
interaction_matrix += np.load(fname_intermat.format(n))
results.interaction_matrix = interaction_matrix
# Remove the intermediate files
write('Cleaning')
for n in xrange(jobs):
remove(fname_interspace.format(n))
remove(fname_violations.format(n))
if args.interaction_selection is not None:
remove(fname_intermat.format(n))
if args.occupancy_analysis:
for consistent_restraints in xrange(
args.interaction_restraints_cutoff, len(distance_restraints) + 1):
remove(fname_occupancy.format(consistent_restraints, n))
results.accessible_interaction_space = accessible_interaction_space
results.accessible_complexes = accessible_complexes
results.violations = violations
results.occupancy_grids = occupancy
return results
def run_disvis(queue, receptor, ligand, rotmat, weights, distance_restraints,
pdb1_sel, pdb2_sel, args):
dv = DisVis()
dv.receptor = receptor
dv.ligand = ligand
dv.distance_restraints = distance_restraints
dv.rotations = rotmat
dv.weights = weights
dv.voxelspacing = args.voxelspacing
dv.interaction_radius = args.interaction_radius
dv.max_clash = args.max_clash
dv.min_interaction = args.min_interaction
dv.queue = queue
dv.occupancy_analysis = args.occupancy_analysis
dv.interaction_restraints_cutoff = args.interaction_restraints_cutoff
if not any([x is None for x in (pdb1_sel, pdb2_sel)]):
dv.receptor_interaction_selection = pdb1_sel
dv.ligand_interaction_selection = pdb2_sel
dv.search()
return dv
def write(line):
if stdout.isatty():
print(line)
logging.info(line)
def main():
args = parse_args()
mkdir_p(args.directory)
joiner = Joiner(args.directory)
logging.basicConfig(filename=joiner('disvis.log'),
level=logging.INFO, format='%(asctime)s %(message)s')
time0 = time()
queue = None
if args.gpu:
from disvis.helpers import get_queue
queue = get_queue()
if queue is None:
raise ValueError("No GPU queue was found.")
write('Reading fixed model from: {:s}'.format(args.receptor.name))
receptor = PDB.fromfile(args.receptor)
write('Reading scanning model from: {:s}'.format(args.ligand.name))
ligand = PDB.fromfile(args.ligand)
write('Reading in rotations.')
q, weights, a = proportional_orientations(args.angle)
rotmat = quat_to_rotmat(q)
write('Requested rotational sampling density: {:.2f}'.format(args.angle))
write('Real rotational sampling density: {:.2f}'.format(a))
write('Number of rotations: {:d}'.format(rotmat.shape[0]))
write('Reading in restraints from file: {:s}'.format(args.restraints.name))
distance_restraints = parse_restraints(args.restraints, receptor, ligand)
write('Number of distance restraints: {:d}'.format(len(distance_restraints)))
# If the interaction restraints cutoff is not specified, only calculate the
# interactions and occupancy grids for complexes consistent with at least 1
# restraints or more, with a limit of three.
if args.interaction_restraints_cutoff is None:
args.interaction_restraints_cutoff = max(len(distance_restraints) - 3, 1)
pdb1_sel = pdb2_sel = None
if args.interaction_selection is not None:
write('Reading in interaction selection from file: {:s}'
.format(args.interaction_selection.name))
pdb1_sel, pdb2_sel = parse_interaction_selection(
args.interaction_selection, receptor, ligand)
write('Number of receptor residues: {:d}'.format(pdb1_sel.natoms))
write('Number of ligand residues: {:d}'.format(pdb2_sel.natoms))
write('Voxel spacing set to: {:.2f}'.format(args.voxelspacing))
write('Interaction radius set to: {:.2f}'.format(args.interaction_radius))
write('Minimum required interaction volume: {:.2f}'.format(args.min_interaction))
write('Maximum allowed volume of clashes: {:.2f}'.format(args.max_clash))
if args.occupancy_analysis:
write('Performing occupancy analysis')
if queue is None:
# CPU-version
if args.nproc > 1:
try:
dv = mp_cpu_disvis(receptor, ligand, | |
200
self.assertContains(response, 'lang: fr')
self.assertContains(response, 'course name: test_template_3_course')
@override_settings(FEATURES=FEATURES_WITH_CUSTOM_CERTS_ENABLED)
@patch('lms.djangoapps.certificates.views.webview.get_course_run_details')
def test_certificate_custom_template_with_org_and_mode(self, mock_get_course_run_details):
"""
Tests custom template search if no template matches course_key, but a template does
match org and mode.
This test should check template matching when org={org}, course=Null, mode={mode}.
"""
mock_get_course_run_details.return_value = self.mock_course_run_details
othercourse = CourseFactory.create(
org='cstX', number='cst_22', display_name='custom template course'
)
self._add_course_certificates(count=1, signatory_count=2)
self._create_custom_named_template('test_template_1_course', org_id=1, mode='honor') # Correct template
self._create_custom_named_template( # wrong course key
'test_template_2_course',
org_id=1,
mode='honor',
course_key=str(othercourse.id)
)
self._create_custom_named_template('test_template_3_course', org_id=1, mode='verified') # wrong mode
self._create_custom_named_template('test_template_4_course', org_id=2, mode='honor') # wrong org
test_url = get_certificate_url(
user_id=self.user.id,
course_id=str(self.course.id),
uuid=self.cert.verify_uuid
)
with patch('lms.djangoapps.certificates.api.get_course_organization_id') as mock_get_org_id:
mock_get_org_id.side_effect = [1]
response = self.client.get(test_url)
assert response.status_code == 200
self.assertContains(response, 'course name: test_template_1_course')
@override_settings(FEATURES=FEATURES_WITH_CUSTOM_CERTS_ENABLED)
@patch('lms.djangoapps.certificates.views.webview.get_course_run_details')
def test_certificate_custom_template_with_org(self, mock_get_course_run_details):
"""
Tests custom template search when we have a single template for a organization.
This test should check template matching when org={org}, course=Null, mode=null.
"""
mock_get_course_run_details.return_value = self.mock_course_run_details
self._add_course_certificates(count=1, signatory_count=2)
self._create_custom_named_template('test_template_1_course', org_id=1, mode=None) # Correct template
self._create_custom_named_template('test_template_2_course', org_id=1, mode='verified') # wrong mode
self._create_custom_named_template('test_template_3_course', org_id=2, mode=None) # wrong org
test_url = get_certificate_url(
user_id=self.user.id,
course_id=str(self.course.id),
uuid=self.cert.verify_uuid
)
with patch('lms.djangoapps.certificates.api.get_course_organization_id') as mock_get_org_id:
mock_get_org_id.side_effect = [1]
response = self.client.get(test_url)
assert response.status_code == 200
self.assertContains(response, 'course name: test_template_1_course')
@override_settings(FEATURES=FEATURES_WITH_CUSTOM_CERTS_ENABLED)
@patch('lms.djangoapps.certificates.views.webview.get_course_run_details')
def test_certificate_custom_template_with_mode(self, mock_get_course_run_details):
"""
Tests custom template search if we have a single template for a course mode.
This test should check template matching when org=null, course=Null, mode={mode}.
"""
mock_get_course_run_details.return_value = self.mock_course_run_details
mode = 'honor'
self._add_course_certificates(count=1, signatory_count=2)
self._create_custom_named_template('test_template_1_course', org_id=None, mode=mode) # Correct template
self._create_custom_named_template('test_template_2_course', org_id=None, mode='verified') # wrong mode
self._create_custom_named_template('test_template_3_course', org_id=2, mode=mode) # wrong org
test_url = get_certificate_url(
user_id=self.user.id,
course_id=str(self.course.id),
uuid=self.cert.verify_uuid
)
with patch('lms.djangoapps.certificates.api.get_course_organization_id') as mock_get_org_id:
mock_get_org_id.return_value = None
response = self.client.get(test_url)
assert response.status_code == 200
self.assertContains(response, f'mode: {mode}')
self.assertContains(response, 'course name: test_template_1_course')
# Templates With Language tests
# 1
@override_settings(FEATURES=FEATURES_WITH_CUSTOM_CERTS_ENABLED)
@override_settings(LANGUAGE_CODE='fr')
@patch('lms.djangoapps.certificates.views.webview.get_course_run_details')
@patch('lms.djangoapps.certificates.api.get_course_organization_id')
def test_certificate_custom_language_template_with_org_mode_and_course_key(
self,
mock_get_org_id,
mock_get_course_run_details,
):
"""
Tests custom template search and rendering.
This test should check template matching when org={org}, course={course}, mode={mode}.
"""
DarkLangConfig(released_languages='es-419, fr', changed_by=self.user, enabled=True).save()
right_language = 'es'
wrong_language = 'fr'
mock_get_org_id.return_value = 1
course_run_details = self.mock_course_run_details
course_run_details.update({'content_language': 'es'})
mock_get_course_run_details.return_value = course_run_details
CertificateGenerationCourseSetting.objects.update_or_create(
course_key=self.course.id,
defaults={
'language_specific_templates_enabled': True
}
)
self._add_course_certificates(count=1, signatory_count=2)
test_url = get_certificate_url(
user_id=self.user.id,
course_id=str(self.course.id),
uuid=self.cert.verify_uuid
)
# Create an org_mode_and_coursekey template language=null
self._create_custom_named_template(
'test_null_lang_template', org_id=1, mode='honor', course_key=str(self.course.id), language=None,
)
# Verify return template lang = null
response = self.client.get(test_url)
assert response.status_code == 200
self.assertContains(response, 'course name: test_null_lang_template')
# Create an org_mode_and_coursekey template language=wrong_language
self._create_custom_named_template(
'test_wrong_lang_template',
org_id=1,
mode='honor',
course_key=str(self.course.id),
language=wrong_language,
)
# Verify returns null lang template
response = self.client.get(test_url)
assert response.status_code == 200
self.assertContains(response, 'course name: test_null_lang_template')
# Create an org_mode_and_coursekey template language=''
self._create_custom_named_template(
'test_all_languages_template',
org_id=1,
mode='honor',
course_key=str(self.course.id),
language='',
)
# Verify returns null lang template
response = self.client.get(test_url)
assert response.status_code == 200
self.assertContains(response, 'course name: test_all_languages_template')
# Create a org_mode_and_coursekey template language=lang
self._create_custom_named_template(
'test_right_lang_template',
org_id=1,
mode='honor',
course_key=str(self.course.id),
language=right_language,
)
# verify return right_language template
response = self.client.get(test_url)
assert response.status_code == 200
self.assertContains(response, 'course name: test_right_lang_template')
# 2
@override_settings(FEATURES=FEATURES_WITH_CUSTOM_CERTS_ENABLED)
@patch('lms.djangoapps.certificates.views.webview.get_course_run_details')
@patch('lms.djangoapps.certificates.api.get_course_organization_id')
def test_certificate_custom_language_template_with_org_and_mode(self, mock_get_org_id, mock_get_course_run_details):
"""
Tests custom template search if no template matches course_key, but a template does
match org and mode.
This test should check template matching when org={org}, course=Null, mode={mode}.
"""
DarkLangConfig(released_languages='es-419, fr', changed_by=self.user, enabled=True).save()
right_language = 'es'
wrong_language = 'fr'
mock_get_org_id.return_value = 1
course_run_details = self.mock_course_run_details
course_run_details.update({'content_language': 'es'})
mock_get_course_run_details.return_value = course_run_details
CertificateGenerationCourseSetting.objects.update_or_create(
course_key=self.course.id,
defaults={
'language_specific_templates_enabled': True
}
)
self._add_course_certificates(count=1, signatory_count=2)
test_url = get_certificate_url(
user_id=self.user.id,
course_id=str(self.course.id),
uuid=self.cert.verify_uuid
)
# Create a org and mode template language=null
self._create_custom_named_template('test_null_lang_template', org_id=1, mode='honor', language=None)
# Verify return template lang = null
response = self.client.get(test_url)
assert response.status_code == 200
self.assertContains(response, 'course name: test_null_lang_template')
# Create a org and mode template language=wrong_language
self._create_custom_named_template('test_wrong_lang_template', org_id=1, mode='honor', language=wrong_language)
# Verify returns null lang template
response = self.client.get(test_url)
assert response.status_code == 200
self.assertContains(response, 'course name: test_null_lang_template')
# Create an org and mode template language=''
self._create_custom_named_template('test_all_languages_template', org_id=1, mode='honor', language='')
# Verify returns All Languages template
response = self.client.get(test_url)
assert response.status_code == 200
self.assertContains(response, 'course name: test_all_languages_template')
# Create a org and mode template language=lang
self._create_custom_named_template('test_right_lang_template', org_id=1, mode='honor', language=right_language)
# Verify return right_language template
response = self.client.get(test_url)
assert response.status_code == 200
self.assertContains(response, 'course name: test_right_lang_template')
# 3
@override_settings(FEATURES=FEATURES_WITH_CUSTOM_CERTS_ENABLED)
@patch('lms.djangoapps.certificates.views.webview.get_course_run_details')
@patch('lms.djangoapps.certificates.api.get_course_organization_id')
def test_certificate_custom_language_template_with_org(self, mock_get_org_id, mock_get_course_run_details):
"""
Tests custom template search when we have a single template for a organization.
This test should check template matching when org={org}, course=Null, mode=null.
"""
DarkLangConfig(released_languages='es-419, fr', changed_by=self.user, enabled=True).save()
right_language = 'es'
wrong_language = 'fr'
mock_get_org_id.return_value = 1
course_run_details = self.mock_course_run_details
course_run_details.update({'content_language': 'es'})
mock_get_course_run_details.return_value = course_run_details
CertificateGenerationCourseSetting.objects.update_or_create(
course_key=self.course.id,
defaults={
'language_specific_templates_enabled': True
}
)
self._add_course_certificates(count=1, signatory_count=2)
test_url = get_certificate_url(
user_id=self.user.id,
course_id=str(self.course.id),
uuid=self.cert.verify_uuid
)
# Create a org template language=null
self._create_custom_named_template('test_null_lang_template', org_id=1, language=None)
# Verify return template lang = null
response = self.client.get(test_url)
assert response.status_code == 200
self.assertContains(response, 'course name: test_null_lang_template')
# Create a org template language=wrong_language
self._create_custom_named_template('test_wrong_lang_template', org_id=1, language=wrong_language)
# Verify returns null lang template
response = self.client.get(test_url)
assert response.status_code == 200
self.assertContains(response, 'course name: test_null_lang_template')
# Create an org template language=''
self._create_custom_named_template('test_all_languages_template', org_id=1, language='')
# Verify returns All Languages template
response = self.client.get(test_url)
assert response.status_code == 200
self.assertContains(response, 'course name: test_all_languages_template')
# Create a org template language=lang
self._create_custom_named_template('test_right_lang_template', org_id=1, language=right_language)
# Verify return right_language template
response = self.client.get(test_url)
assert response.status_code == 200
self.assertContains(response, 'course name: test_right_lang_template')
# 4
@override_settings(FEATURES=FEATURES_WITH_CUSTOM_CERTS_ENABLED)
@patch('lms.djangoapps.certificates.views.webview.get_course_run_details')
@patch('lms.djangoapps.certificates.api.get_course_organization_id')
def test_certificate_custom_language_template_with_mode(self, mock_get_org_id, mock_get_course_run_details):
"""
Tests custom template search if we have a single template for a course mode.
This test should check template matching when org=null, course=Null, mode={mode}.
"""
DarkLangConfig(released_languages='es-419, fr', changed_by=self.user, enabled=True).save()
right_language = 'es'
wrong_language = 'fr'
mock_get_org_id.return_value = 1
course_run_details = self.mock_course_run_details
course_run_details.update({'content_language': 'es'})
mock_get_course_run_details.return_value = course_run_details
CertificateGenerationCourseSetting.objects.update_or_create(
course_key=self.course.id,
defaults={
'language_specific_templates_enabled': True
}
)
self._add_course_certificates(count=1, signatory_count=2)
test_url = get_certificate_url(
user_id=self.user.id,
course_id=str(self.course.id),
uuid=self.cert.verify_uuid
)
# Create a mode template language=null
self._create_custom_named_template('test_null_lang_template', mode='honor', language=None)
# Verify return template with lang = null
response = self.client.get(test_url)
assert response.status_code == 200
self.assertContains(response, 'course name: test_null_lang_template')
# Create a mode template language=wrong_language
self._create_custom_named_template('test_wrong_lang_template', mode='honor', language=wrong_language)
# Verify returns null lang template
response = self.client.get(test_url)
assert response.status_code == 200
self.assertContains(response, 'course name: test_null_lang_template')
# Create a mode template language=''
self._create_custom_named_template('test_all_languages_template', mode='honor', language='')
# Verify returns All Languages template
response = self.client.get(test_url)
assert response.status_code == 200
self.assertContains(response, 'course name: test_all_languages_template')
# Create a mode template language=lang
self._create_custom_named_template('test_right_lang_template', mode='honor', language=right_language)
# Verify return right_language template
response = self.client.get(test_url)
assert response.status_code == 200
self.assertContains(response, 'course name: test_right_lang_template')
@override_settings(FEATURES=FEATURES_WITH_CUSTOM_CERTS_ENABLED)
@patch('lms.djangoapps.certificates.views.webview.get_course_run_details')
@patch('lms.djangoapps.certificates.api.get_course_organization_id')
def test_certificate_custom_language_template_with_locale_language_from_catalogue(
self,
mock_get_org_id,
mock_get_course_run_details,
):
"""
Tests custom template search if we have a single template for a course mode.
This test should check template matching when org=null, course=Null, mode={mode}.
"""
DarkLangConfig(released_languages='es-419, fr', changed_by=self.user, enabled=True).save()
right_language = 'es'
wrong_language = 'fr'
mock_get_org_id.return_value = 1
course_run_details = self.mock_course_run_details
course_run_details.update({'content_language': 'es-419'})
mock_get_course_run_details.return_value = course_run_details
CertificateGenerationCourseSetting.objects.update_or_create(
course_key=self.course.id,
defaults={
'language_specific_templates_enabled': True
}
)
self._add_course_certificates(count=1, signatory_count=2)
test_url = get_certificate_url(
user_id=self.user.id,
course_id=str(self.course.id),
uuid=self.cert.verify_uuid
)
# Create a mode template language=null
self._create_custom_named_template('test_null_lang_template', org_id=1, mode='honor', language=None)
# Verify return template with lang = null
response = self.client.get(test_url)
assert response.status_code == 200
self.assertContains(response, 'course name: test_null_lang_template')
# Create a mode template language=wrong_language
self._create_custom_named_template('test_wrong_lang_template', org_id=1, mode='honor', language=wrong_language)
# Verify returns null lang template
response = self.client.get(test_url)
assert response.status_code == 200
self.assertContains(response, 'course name: test_null_lang_template')
# Create a mode template language=''
self._create_custom_named_template('test_all_languages_template', org_id=1, mode='honor', language='')
# Verify returns All Languages template
response = self.client.get(test_url)
assert response.status_code == 200
self.assertContains(response, 'course name: test_all_languages_template')
# Create a mode template language=lang
self._create_custom_named_template('test_right_lang_template', org_id=1, mode='honor', language=right_language)
# verify return right_language template
response = self.client.get(test_url)
assert response.status_code == 200
self.assertContains(response, 'course name: test_right_lang_template')
@override_settings(FEATURES=FEATURES_WITH_CUSTOM_CERTS_ENABLED)
@ddt.data(True, False)
@patch('lms.djangoapps.certificates.views.webview.get_course_run_details')
@patch('lms.djangoapps.certificates.api.get_course_organization_id')
def test_certificate_custom_template_with_hours_of_effort(
self,
include_effort,
mock_get_org_id,
mock_get_course_run_details,
):
"""
Tests custom template properly retrieves and calculates Hours of Effort when the feature is enabled
"""
# mock the response data from Discovery that updates the context for template lookup and rendering
mock_get_course_run_details.return_value = self.mock_course_run_details
mock_get_org_id.return_value = 1
CertificateGenerationCourseSetting.objects.update_or_create(
course_key=self.course.id,
defaults={
'include_hours_of_effort': include_effort
}
)
self._add_course_certificates(count=1, signatory_count=2)
self._create_custom_template_with_hours_of_effort(org_id=1, language=None)
test_url = get_certificate_url(
user_id=self.user.id,
course_id=str(self.course.id),
uuid=self.cert.verify_uuid
)
response = self.client.get(test_url)
assert response.status_code == 200
if include_effort:
self.assertContains(response, 'hours of effort: 40')
else:
self.assertNotContains(response, 'hours of effort')
@ddt.data(True, False)
@patch('lms.djangoapps.certificates.views.webview.get_course_run_details')
def | |
data[resource]
actions.update({resource: {'action': 'subtract', 'amount': data[resource]}})
tgtactions.update({resource: {'action': 'add', 'amount': data[resource]}})
freighters = world.freighters - world.freightersinuse
required_freighters = (required_capacity / v.freighter_capacity['total'])+ 1
if len(resources) == 0: #pure budget aid
pass
elif freighters >= required_freighters:
#gots enough freighters
delay = (1 if world.sector == target.sector else 2)
outcometime = datetime=v.now() + time.timedelta(hours=delay)
actions.update({
'freightersinuse': {'action': 'add', 'amount': required_freighters},
})
utilities.atomic_world(world.pk, actions)
taskdetails = taskdata.directaidarrival(world, resources)
task = Task.objects.create(target=target,
content=taskdetails, datetime=outcometime)
newtask.directaid.apply_async(args=(world.pk, target.pk,
task.pk, resources, freighters), eta=outcometime)
if data['budget'] > 0:
resources = [['GEU', data['budget']]] + resources
#create logs!
log = ResourceLog.objects.create(owner=world, target=target, sent=True)
for resource in resources:
Logresource.objects.create(resource=resource[0], amount=resource[1], log=log)
hour = ('hours' if delay == 2 else 'hour')
if len(message):
message = message[:-1] + " and will recieve %s in %s %s!" % (
utilities.resource_text(resources), delay, hour)
else:
message = "%s will recieve %s in %s %s!" % (
target.name, utilities.resource_text(resources), delay, hour)
else: #not enough freighters
message = "We do not have enough freighters, we have %s and need %s" % (freighters, required_freighters)
if 'shipaid' in form:
form = Shipaidform(world, form)
if form.is_valid():
data = form.cleaned_data
ship = data['ship_choice']
amount = data['amount']
delay = (4 if target.sector == world.sector else 8)
outcometime = datetime=v.now() + time.timedelta(minutes=1)
if data['amount'] > data['fleet_choice'].__dict__[data['ship_choice']]:
message = "%s doesn't have that many %s!" % (data['fleet_choice'].name, ship)
else: #is all good
action = {'subtractships': {data['ship_choice']: amount}}
utilities.atomic_fleet(data['fleet_choice'].pk, action)
log = ResourceLog.objects.create(owner=world, target=target, sent=True)
shipname = (ship.replace('_', ' ') if amount > 1 else ship[:-1].replace('_', ' ')) #to plural or not plural
Logresource.objects.create(resource=shipname, amount=amount, log=log)
#more stuff
ref = fleet()
ref.__dict__[ship] = amount
training = data['fleet_choice'].maxtraining() * data['fleet_choice'].ratio()
taskdetails = taskdata.shipaidarrival(world, shipname, amount)
task = Task.objects.create(target=target,
content=taskdetails, datetime=outcometime)
newtask.shipaid.apply_async(args=(world.pk, target.pk,
task.pk, ship, amount, training), eta=outcometime)
message = "%s %s is en route to %s from %s" % (
amount, shipname, target.name, data['fleet_choice'].name)
if "infiltrate" in form:
form = SelectSpyForm(world, request.POST)
if form.is_valid():
data = form.cleaned_data
spyid = data['spyselect']
try:
spy = Spy.objects.get(pk=spyid)
except:
message = "There is no such spy!"
else:
if target.preferences.vacation:
message = 'This world is in vacation mode. You cannot infiltrate it.'
elif spy.owner != world:
message = "This spy does not belong to your intelligence services!"
elif Spy.objects.filter(owner=world, location=target).exists():
message = "You already have a spy in this world!"
elif spy.location != world:
message = "This spy is not at your home world!"
elif spy.nextaction > v.now():
message = "This spy is currently recovering and unavailable for missions."
else:
message = infiltrate(spy, target)
if "propaganda" in form:
try:
spy = Spy.objects.get(owner=world, location=target)
except ObjectDoesNotExist:
message = "You have no spy in this world!"
else:
if spy.nextaction > v.now():
message = "This spy is currently recovering and unavailable for missions."
elif world.budget < 250:
message = outcomes.nomoney()
else:
spy.nextaction = v.now() + time.timedelta(hours=8)
spy.save(update_fields=['nextaction'])
actions = {'budget': {'action': 'subtract', 'amount': 250}}
utilities.atomic_world(world.pk, actions)
message = propaganda(spy, target)
if "gunrun" in form:
try:
spy = Spy.objects.get(owner=world, location=target)
except ObjectDoesNotExist:
message = "You have no spy in this world!"
else:
if spy.nextaction > v.now():
message = "This spy is currently recovering and unavailable for missions."
elif world.millevel < 1000:
message = outcomes.gunrun('NoTech')
else:
spy.nextaction = v.now() + time.timedelta(hours=8)
spy.save(update_fields=['nextaction'])
world.millevel = F('millevel') - 1000
world.save(update_fields=['millevel'])
message = gunrun(spy, target)
if "intel" in form:
try:
spy = Spy.objects.get(owner=world, location=target)
except ObjectDoesNotExist:
message = "You have no spy in this world!"
else:
if spy.nextaction > v.now():
message = "This spy is currently recovering and unavailable for missions."
elif world.budget < 200:
message = outcomes.nomoney()
else:
spy.nextaction = v.now() + time.timedelta(hours=8)
spy.save(update_fields=['nextaction'])
actions = {'budget': {'action': 'subtract', 'amount': 200}}
utilities.atomic_world(world.pk, actions)
message = intel(spy, target)
if "sabyard" in form:
try:
spy = Spy.objects.get(owner=world, location=target)
except ObjectDoesNotExist:
message = "You have no spy in this world!"
else:
if spy.nextaction > v.now():
message = "This spy is currently recovering and unavailable for missions."
elif world.budget < 2000:
message = outcomes.nomoney()
elif target.shipyards - target.shipyardsinuse == 0:
message = outcomes.sabotage('NoFreeYards')
else:
spy.nextaction = v.now() + time.timedelta(hours=8)
spy.save(update_fields=['nextaction'])
actions = {'budget': {'action': 'subtract', 'amount': 2000}}
utilities.atomic_world(world.pk, actions)
message = sabyard(spy, target)
if "sabfuel" in form:
try:
spy = Spy.objects.get(owner=world, location=target)
except ObjectDoesNotExist:
message = "You have no spy in this world!"
else:
if spy.nextaction > v.now():
message = "This spy is currently recovering and unavailable for missions."
elif world.budget < 2000:
message = outcomes.nomoney()
elif target.warpfuelprod < 10:
message = outcomes.sabotage('NoFuelProd')
else:
spy.nextaction = v.now() + time.timedelta(hours=8)
spy.save(update_fields=['nextaction'])
actions = {'budget': {'action': 'subtract', 'amount': 2000}}
utilities.atomic_world(world.pk, actions)
message = sabfuel(spy, target)
if "sabdur" in form:
try:
spy = Spy.objects.get(owner=world, location=target)
except ObjectDoesNotExist:
message = "You have no spy in this world!"
else:
if spy.nextaction > v.now():
message = "This spy is currently recovering and unavailable for missions."
elif world.budget < 2000:
message = outcomes.nomoney()
elif target.duraniumprod < 5:
message = outcomes.sabotage('NoDurProd')
else:
spy.nextaction = v.now() + time.timedelta(hours=8)
spy.save(update_fields=['nextaction'])
actions = {'budget': {'action': 'subtract', 'amount': 2000}}
utilities.atomic_world(world.pk, actions)
message = sabdur(spy, target)
if "sabtrit" in form:
try:
spy = Spy.objects.get(owner=world, location=target)
except ObjectDoesNotExist:
message = "You have no spy in this world!"
else:
if spy.nextaction > v.now():
message = "This spy is currently recovering and unavailable for missions."
elif world.budget < 2000:
message = outcomes.nomoney()
elif target.tritaniumprod < 2:
message = outcomes.sabotage('NoTritProd')
else:
spy.nextaction = v.now() + time.timedelta(hours=8)
spy.save(update_fields=['nextaction'])
actions = {'budget': {'action': 'subtract', 'amount': 2000}}
utilities.atomic_world(world.pk, actions)
message = sabtrit(spy, target)
if "sabadam" in form:
try:
spy = Spy.objects.get(owner=world, location=target)
except ObjectDoesNotExist:
message = "You have no spy in this world!"
else:
if spy.nextaction > v.now():
message = "This spy is currently recovering and unavailable for missions."
elif world.budget < 2000:
message = outcomes.nomoney()
elif target.adamantiumprod < 1:
message = outcomes.sabotage('NoAdamProd')
else:
spy.nextaction = v.now() + time.timedelta(hours=8)
spy.save(update_fields=['nextaction'])
actions = {'budget': {'action': 'subtract', 'amount': 2000}}
utilities.atomic_world(world.pk, actions)
message = sabadam(spy, target)
if "sabhangars" in form:
try:
spy = Spy.objects.get(owner=world, location=target)
except ObjectDoesNotExist:
message = "You have no spy in this world!"
else:
if spy.nextaction > v.now():
message = "This spy is currently recovering and unavailable for missions."
elif world.budget < 2000:
message = outcomes.nomoney()
else:
spy.nextaction = v.now() + time.timedelta(hours=8)
spy.save(update_fields=['nextaction'])
actions = {'budget': {'action': 'subtract', 'amount': 2000}}
utilities.atomic_world(world.pk, actions)
message = sabhangars(spy, target)
if "withdraw" in form:
try:
spy = Spy.objects.get(owner=world, location=target)
except ObjectDoesNotExist:
message = "You have no spy in this world!"
else:
if spy.nextaction > v.now():
message = "This spy is currently recovering and unavailable."
else:
spy.inteltime = v.now()
spy.location = spy.owner
spy.nextaction = v.now() + time.timedelta(hours=8)
spy.timespent = 0
spy.save()
message = 'You have successfully withdrawn your spy from the enemy world!'
if world.pk in War.objects.filter(defender=target).values_list('attacker', flat=True):
atwar = True
war = War.objects.get(attacker=world, defender=target)
if war.peaceofferbyatk is not None:
peaceoffer = True
elif world.pk in War.objects.filter(attacker=target).values_list('defender', flat=True):
atwar = True
war = War.objects.get(attacker=target, defender=world)
if war.peaceofferbydef is not None:
peaceoffer = True
spyform = SelectSpyForm(world)
# recalculate variables in case an action has changed them
if v.now() < world.warprotection:
warprotection = True
if target.gdp > 3 * world.gdp:
gdpprotection = True
if v.now() < target.warprotection:
targetprotection = True
if Spy.objects.filter(owner=world, location=world).count() == 0:
nospies = True
if Spy.objects.filter(owner=world).filter(location=target).count() == 1:
spyintarget = Spy.objects.filter(owner=world, location=target)[0]
if spyintarget.inteltime > v.now():
spyintel = True
timediff = spyintarget.inteltime - v.now()
hours, minutes, seconds = utilities.timedeltadivide(timediff)
timeforintel = 'You have %s:%s:%s of intel remaining.' % (hours, minutes, seconds)
#if the two worlds are at war
#calculate what fleets can attack where and what buttons to render
attackforms = []
if atwar:
worldfleets = world.controlled_fleets.all().exclude(sector='warping').exclude(sector='hangar')
targetfleets = target.controlled_fleets.all().exclude(sector='warping').exclude(sector='hangar')
sectors = {'amyntas': 0, 'bion': 0, 'cleon': 0, 'draco': 0}
for unit in worldfleets:
sectors[unit.sector] = 1
if unit.sector == target.sector:
sectors[unit.sector] = 2
for unit in targetfleets:
sectors[unit.sector] += 1
for sector in v.sectors: #organised list so it shows amyntas -> draco
if sectors[sector] >= 2: #both worlds has fleets in given sector
attackforms.append({'form': attackform(world, sector), | |
# Boolean indices
out_aet = x_aet[x_aet < 0]
assert isinstance(out_aet.owner.op, aet_subtensor.AdvancedSubtensor)
out_fg = FunctionGraph([], [out_aet])
compare_jax_and_py(out_fg, [])
# Advanced indexing
out_aet = x_aet[[1, 2]]
assert isinstance(out_aet.owner.op, aet_subtensor.AdvancedSubtensor1)
out_fg = FunctionGraph([], [out_aet])
compare_jax_and_py(out_fg, [])
out_aet = x_aet[[1, 2], [2, 3]]
assert isinstance(out_aet.owner.op, aet_subtensor.AdvancedSubtensor)
out_fg = FunctionGraph([], [out_aet])
compare_jax_and_py(out_fg, [])
# Advanced and basic indexing
out_aet = x_aet[[1, 2], :]
assert isinstance(out_aet.owner.op, aet_subtensor.AdvancedSubtensor1)
out_fg = FunctionGraph([], [out_aet])
compare_jax_and_py(out_fg, [])
out_aet = x_aet[[1, 2], :, [3, 4]]
assert isinstance(out_aet.owner.op, aet_subtensor.AdvancedSubtensor)
out_fg = FunctionGraph([], [out_aet])
compare_jax_and_py(out_fg, [])
def test_jax_IncSubtensor():
x_np = np.random.uniform(-1, 1, size=(3, 4, 5)).astype(config.floatX)
x_aet = aet.arange(3 * 4 * 5).reshape((3, 4, 5)).astype(config.floatX)
# "Set" basic indices
st_aet = aet.as_tensor_variable(np.array(-10.0, dtype=config.floatX))
out_aet = aet_subtensor.set_subtensor(x_aet[1, 2, 3], st_aet)
assert isinstance(out_aet.owner.op, aet_subtensor.IncSubtensor)
out_fg = FunctionGraph([], [out_aet])
compare_jax_and_py(out_fg, [])
st_aet = aet.as_tensor_variable(np.r_[-1.0, 0.0].astype(config.floatX))
out_aet = aet_subtensor.set_subtensor(x_aet[:2, 0, 0], st_aet)
assert isinstance(out_aet.owner.op, aet_subtensor.IncSubtensor)
out_fg = FunctionGraph([], [out_aet])
compare_jax_and_py(out_fg, [])
out_aet = aet_subtensor.set_subtensor(x_aet[0, 1:3, 0], st_aet)
assert isinstance(out_aet.owner.op, aet_subtensor.IncSubtensor)
out_fg = FunctionGraph([], [out_aet])
compare_jax_and_py(out_fg, [])
# "Set" advanced indices
st_aet = aet.as_tensor_variable(
np.random.uniform(-1, 1, size=(2, 4, 5)).astype(config.floatX)
)
out_aet = aet_subtensor.set_subtensor(x_aet[np.r_[0, 2]], st_aet)
assert isinstance(out_aet.owner.op, aet_subtensor.AdvancedIncSubtensor1)
out_fg = FunctionGraph([], [out_aet])
compare_jax_and_py(out_fg, [])
st_aet = aet.as_tensor_variable(np.r_[-1.0, 0.0].astype(config.floatX))
out_aet = aet_subtensor.set_subtensor(x_aet[[0, 2], 0, 0], st_aet)
assert isinstance(out_aet.owner.op, aet_subtensor.AdvancedIncSubtensor)
out_fg = FunctionGraph([], [out_aet])
compare_jax_and_py(out_fg, [])
st_aet = aet.as_tensor_variable(x_np[[0, 2], 0, :3])
out_aet = aet_subtensor.set_subtensor(x_aet[[0, 2], 0, :3], st_aet)
assert isinstance(out_aet.owner.op, aet_subtensor.AdvancedIncSubtensor)
out_fg = FunctionGraph([], [out_aet])
compare_jax_and_py(out_fg, [])
# "Set" boolean indices
mask_aet = aet.as_tensor_variable(x_np) > 0
out_aet = aet_subtensor.set_subtensor(x_aet[mask_aet], 0.0)
assert isinstance(out_aet.owner.op, aet_subtensor.AdvancedIncSubtensor)
out_fg = FunctionGraph([], [out_aet])
compare_jax_and_py(out_fg, [])
# "Increment" basic indices
st_aet = aet.as_tensor_variable(np.array(-10.0, dtype=config.floatX))
out_aet = aet_subtensor.inc_subtensor(x_aet[1, 2, 3], st_aet)
assert isinstance(out_aet.owner.op, aet_subtensor.IncSubtensor)
out_fg = FunctionGraph([], [out_aet])
compare_jax_and_py(out_fg, [])
st_aet = aet.as_tensor_variable(np.r_[-1.0, 0.0].astype(config.floatX))
out_aet = aet_subtensor.inc_subtensor(x_aet[:2, 0, 0], st_aet)
assert isinstance(out_aet.owner.op, aet_subtensor.IncSubtensor)
out_fg = FunctionGraph([], [out_aet])
compare_jax_and_py(out_fg, [])
out_aet = aet_subtensor.set_subtensor(x_aet[0, 1:3, 0], st_aet)
assert isinstance(out_aet.owner.op, aet_subtensor.IncSubtensor)
out_fg = FunctionGraph([], [out_aet])
compare_jax_and_py(out_fg, [])
# "Increment" advanced indices
st_aet = aet.as_tensor_variable(
np.random.uniform(-1, 1, size=(2, 4, 5)).astype(config.floatX)
)
out_aet = aet_subtensor.inc_subtensor(x_aet[np.r_[0, 2]], st_aet)
assert isinstance(out_aet.owner.op, aet_subtensor.AdvancedIncSubtensor1)
out_fg = FunctionGraph([], [out_aet])
compare_jax_and_py(out_fg, [])
st_aet = aet.as_tensor_variable(np.r_[-1.0, 0.0].astype(config.floatX))
out_aet = aet_subtensor.inc_subtensor(x_aet[[0, 2], 0, 0], st_aet)
assert isinstance(out_aet.owner.op, aet_subtensor.AdvancedIncSubtensor)
out_fg = FunctionGraph([], [out_aet])
compare_jax_and_py(out_fg, [])
st_aet = aet.as_tensor_variable(x_np[[0, 2], 0, :3])
out_aet = aet_subtensor.inc_subtensor(x_aet[[0, 2], 0, :3], st_aet)
assert isinstance(out_aet.owner.op, aet_subtensor.AdvancedIncSubtensor)
out_fg = FunctionGraph([], [out_aet])
compare_jax_and_py(out_fg, [])
# "Increment" boolean indices
mask_aet = aet.as_tensor_variable(x_np) > 0
out_aet = aet_subtensor.set_subtensor(x_aet[mask_aet], 1.0)
assert isinstance(out_aet.owner.op, aet_subtensor.AdvancedIncSubtensor)
out_fg = FunctionGraph([], [out_aet])
compare_jax_and_py(out_fg, [])
def test_jax_ifelse():
true_vals = np.r_[1, 2, 3]
false_vals = np.r_[-1, -2, -3]
x = ifelse(np.array(True), true_vals, false_vals)
x_fg = FunctionGraph([], [x])
compare_jax_and_py(x_fg, [])
a = dscalar("a")
a.tag.test_value = np.array(0.2, dtype=config.floatX)
x = ifelse(a < 0.5, true_vals, false_vals)
x_fg = FunctionGraph([a], [x]) # I.e. False
compare_jax_and_py(x_fg, [get_test_value(i) for i in x_fg.inputs])
def test_jax_CAReduce():
a_aet = vector("a")
a_aet.tag.test_value = np.r_[1, 2, 3].astype(config.floatX)
x = aet_sum(a_aet, axis=None)
x_fg = FunctionGraph([a_aet], [x])
compare_jax_and_py(x_fg, [np.r_[1, 2, 3].astype(config.floatX)])
a_aet = matrix("a")
a_aet.tag.test_value = np.c_[[1, 2, 3], [1, 2, 3]].astype(config.floatX)
x = aet_sum(a_aet, axis=0)
x_fg = FunctionGraph([a_aet], [x])
compare_jax_and_py(x_fg, [np.c_[[1, 2, 3], [1, 2, 3]].astype(config.floatX)])
x = aet_sum(a_aet, axis=1)
x_fg = FunctionGraph([a_aet], [x])
compare_jax_and_py(x_fg, [np.c_[[1, 2, 3], [1, 2, 3]].astype(config.floatX)])
a_aet = matrix("a")
a_aet.tag.test_value = np.c_[[1, 2, 3], [1, 2, 3]].astype(config.floatX)
x = prod(a_aet, axis=0)
x_fg = FunctionGraph([a_aet], [x])
compare_jax_and_py(x_fg, [np.c_[[1, 2, 3], [1, 2, 3]].astype(config.floatX)])
x = aet_all(a_aet)
x_fg = FunctionGraph([a_aet], [x])
compare_jax_and_py(x_fg, [np.c_[[1, 2, 3], [1, 2, 3]].astype(config.floatX)])
def test_jax_MakeVector():
x = aet.make_vector(1, 2, 3)
x_fg = FunctionGraph([], [x])
compare_jax_and_py(x_fg, [])
def test_jax_Reshape():
a = vector("a")
x = reshape(a, (2, 2))
x_fg = FunctionGraph([a], [x])
compare_jax_and_py(x_fg, [np.r_[1.0, 2.0, 3.0, 4.0].astype(config.floatX)])
# Test breaking "omnistaging" changes in JAX.
# See https://github.com/tensorflow/probability/commit/782d0c64eb774b9aac54a1c8488e4f1f96fbbc68
x = reshape(a, (a.shape[0] // 2, a.shape[0] // 2))
x_fg = FunctionGraph([a], [x])
compare_jax_and_py(x_fg, [np.r_[1.0, 2.0, 3.0, 4.0].astype(config.floatX)])
@pytest.mark.xfail(reason="jax.numpy.arange requires concrete inputs")
def test_jax_Reshape_nonconcrete():
a = vector("a")
b = iscalar("b")
x = reshape(a, (b, b))
x_fg = FunctionGraph([a, b], [x])
compare_jax_and_py(x_fg, [np.r_[1.0, 2.0, 3.0, 4.0].astype(config.floatX), 2])
def test_jax_Dimshuffle():
a_aet = matrix("a")
x = a_aet.T
x_fg = FunctionGraph([a_aet], [x])
compare_jax_and_py(x_fg, [np.c_[[1.0, 2.0], [3.0, 4.0]].astype(config.floatX)])
x = a_aet.dimshuffle([0, 1, "x"])
x_fg = FunctionGraph([a_aet], [x])
compare_jax_and_py(x_fg, [np.c_[[1.0, 2.0], [3.0, 4.0]].astype(config.floatX)])
a_aet = tensor(dtype=config.floatX, broadcastable=[False, True])
x = a_aet.dimshuffle((0,))
x_fg = FunctionGraph([a_aet], [x])
compare_jax_and_py(x_fg, [np.c_[[1.0, 2.0, 3.0, 4.0]].astype(config.floatX)])
a_aet = tensor(dtype=config.floatX, broadcastable=[False, True])
x = aet_elemwise.DimShuffle([False, True], (0,), inplace=True)(a_aet)
x_fg = FunctionGraph([a_aet], [x])
compare_jax_and_py(x_fg, [np.c_[[1.0, 2.0, 3.0, 4.0]].astype(config.floatX)])
def test_jax_variadic_Scalar():
mu = vector("mu", dtype=config.floatX)
mu.tag.test_value = np.r_[0.1, 1.1].astype(config.floatX)
tau = vector("tau", dtype=config.floatX)
tau.tag.test_value = np.r_[1.0, 2.0].astype(config.floatX)
res = -tau * mu
fgraph = FunctionGraph([mu, tau], [res])
compare_jax_and_py(fgraph, [get_test_value(i) for i in fgraph.inputs])
res = -tau * (tau - mu) ** 2
fgraph = FunctionGraph([mu, tau], [res])
compare_jax_and_py(fgraph, [get_test_value(i) for i in fgraph.inputs])
def test_jax_logp():
mu = vector("mu")
mu.tag.test_value = np.r_[0.0, 0.0].astype(config.floatX)
tau = vector("tau")
tau.tag.test_value = np.r_[1.0, 1.0].astype(config.floatX)
sigma = vector("sigma")
sigma.tag.test_value = (1.0 / get_test_value(tau)).astype(config.floatX)
value = vector("value")
value.tag.test_value = np.r_[0.1, -10].astype(config.floatX)
logp = (-tau * (value - mu) ** 2 + log(tau / np.pi / 2.0)) / 2.0
conditions = [sigma > 0]
alltrue = aet_all([aet_all(1 * val) for val in conditions])
normal_logp = aet.switch(alltrue, logp, -np.inf)
fgraph = FunctionGraph([mu, tau, sigma, value], [normal_logp])
compare_jax_and_py(fgraph, [get_test_value(i) for i in fgraph.inputs])
def test_jax_multioutput():
x = vector("x")
x.tag.test_value = np.r_[1.0, 2.0].astype(config.floatX)
y = vector("y")
y.tag.test_value = np.r_[3.0, 4.0].astype(config.floatX)
w = cosh(x ** 2 + y / 3.0)
v = cosh(x / 3.0 + y ** 2)
fgraph = FunctionGraph([x, y], [w, v])
compare_jax_and_py(fgraph, [get_test_value(i) for i in fgraph.inputs])
def test_nnet():
x = vector("x")
x.tag.test_value = np.r_[1.0, 2.0].astype(config.floatX)
out = aet_nnet.sigmoid(x)
fgraph = FunctionGraph([x], [out])
compare_jax_and_py(fgraph, [get_test_value(i) for i in fgraph.inputs])
out = aet_nnet.ultra_fast_sigmoid(x)
fgraph = FunctionGraph([x], [out])
compare_jax_and_py(fgraph, [get_test_value(i) for i in fgraph.inputs])
out = aet_nnet.softplus(x)
fgraph = FunctionGraph([x], [out])
compare_jax_and_py(fgraph, [get_test_value(i) for i in fgraph.inputs])
out = aet_nnet.softmax(x)
fgraph = FunctionGraph([x], [out])
compare_jax_and_py(fgraph, [get_test_value(i) for i in fgraph.inputs])
def test_tensor_basics():
y = vector("y")
y.tag.test_value = np.r_[1.0, 2.0].astype(config.floatX)
x = vector("x")
x.tag.test_value = np.r_[3.0, 4.0].astype(config.floatX)
A = matrix("A")
A.tag.test_value = np.empty((2, 2), dtype=config.floatX)
alpha = scalar("alpha")
alpha.tag.test_value = np.array(3.0, dtype=config.floatX)
beta = scalar("beta")
beta.tag.test_value = np.array(5.0, dtype=config.floatX)
# This should be converted into a `Gemv` `Op` when the non-JAX compatible
# optimizations are turned on; however, when using JAX mode, it should
# leave the expression alone.
out = y.dot(alpha * A).dot(x) + beta * y
fgraph = FunctionGraph([y, x, A, alpha, beta], [out])
compare_jax_and_py(fgraph, [get_test_value(i) for i in fgraph.inputs])
out = maximum(y, x)
fgraph = FunctionGraph([y, x], [out])
compare_jax_and_py(fgraph, [get_test_value(i) for i in fgraph.inputs])
out = aet_max(y)
fgraph = FunctionGraph([y], [out])
compare_jax_and_py(fgraph, [get_test_value(i) for i in fgraph.inputs])
@pytest.mark.xfail(reason="jax.numpy.arange requires concrete inputs")
def test_arange_nonconcrete():
a = scalar("a")
a.tag.test_value = 10
out = aet.arange(a)
fgraph = FunctionGraph([a], [out])
compare_jax_and_py(fgraph, [get_test_value(i) for i in fgraph.inputs])
@pytest.mark.xfail(reason="jax.numpy.arange requires concrete inputs")
def test_unique_nonconcrete():
a = matrix("a")
a.tag.test_value = np.arange(6, dtype=config.floatX).reshape((3, 2))
out = aet_extra_ops.Unique()(a)
fgraph = FunctionGraph([a], [out])
compare_jax_and_py(fgraph, [get_test_value(i) for i in fgraph.inputs])
def test_identity():
a = scalar("a")
a.tag.test_value = 10
out = aes.identity(a)
fgraph = FunctionGraph([a], [out])
compare_jax_and_py(fgraph, [get_test_value(i) for i in fgraph.inputs])
def test_second():
a0 = scalar("a0")
b = scalar("b")
out = aes.second(a0, b)
fgraph = FunctionGraph([a0, b], [out])
compare_jax_and_py(fgraph, [10.0, 5.0])
a1 = vector("a1")
out = aet.second(a1, b)
fgraph = FunctionGraph([a1, b], [out])
compare_jax_and_py(fgraph, [np.zeros([5], dtype=config.floatX), 5.0])
def test_jax_BatchedDot():
# tensor3 . tensor3
a = tensor3("a")
a.tag.test_value = (
np.linspace(-1, 1, 10 * 5 * 3).astype(config.floatX).reshape((10, 5, 3))
)
b = tensor3("b")
b.tag.test_value = (
np.linspace(1, -1, 10 * 3 * 2).astype(config.floatX).reshape((10, 3, 2))
)
out = aet_blas.BatchedDot()(a, b)
fgraph = FunctionGraph([a, b], [out])
compare_jax_and_py(fgraph, [get_test_value(i) for i in fgraph.inputs])
# A dimension mismatch should raise a TypeError for compatibility
inputs = [get_test_value(a)[:-1], get_test_value(b)]
opts = Query(include=[None], exclude=["cxx_only", "BlasOpt"])
jax_mode = Mode(JAXLinker(), opts)
aesara_jax_fn = function(fgraph.inputs, fgraph.outputs, mode=jax_mode)
with pytest.raises(TypeError):
aesara_jax_fn(*inputs)
# matrix . matrix
a = matrix("a")
a.tag.test_value = np.linspace(-1, 1, 5 * 3).astype(config.floatX).reshape((5, 3))
b = matrix("b")
b.tag.test_value = np.linspace(1, -1, 5 * 3).astype(config.floatX).reshape((5, 3))
out = aet_blas.BatchedDot()(a, b)
fgraph = FunctionGraph([a, b], [out])
compare_jax_and_py(fgraph, [get_test_value(i) for i in fgraph.inputs])
def | |
<reponame>fengwang/jax
# Copyright 2021 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from dataclasses import dataclass
from functools import partial
import itertools as it
from typing import Union, Optional, Callable, Dict
import numpy as np
import jax.numpy as jnp
from jax import core
from jax import linear_util as lu
from jax.api_util import flatten_fun
from jax.interpreters import partial_eval as pe
from jax.tree_util import tree_flatten, tree_unflatten, register_pytree_node
from jax._src import source_info_util, traceback_util
from jax import lax
from jax._src.util import as_hashable_function, unzip2, split_list
source_info_util.register_exclusion(__file__)
traceback_util.register_exclusion(__file__)
## Utils
def popattr(obj, attrname):
val = getattr(obj, attrname)
delattr(obj, attrname)
return val
def setnewattr(obj, name, val):
sentinel = object()
assert getattr(obj, name, sentinel) is sentinel
setattr(obj, name, val)
## Error value data type and functional assert.
@dataclass(frozen=True)
class Error:
err: Union[bool, core.Tracer]
code: Union[int, core.Tracer]
msgs: Dict[int, str]
def get(self) -> Optional[str]:
assert np.shape(self.err) == np.shape(self.code)
if np.size(self.err) == 1:
if self.err:
return self.msgs[int(self.code)]
else:
return '\n'.join(f'at mapped index {", ".join(map(str, idx))}: ' # type: ignore
f'{self.msgs[int(self.code[idx])]}' # type: ignore
for idx, e in np.ndenumerate(self.err) if e) or None
return None
register_pytree_node(Error,
lambda e: ((e.err, e.code), tuple(sorted(e.msgs.items()))),
lambda msgs, data: Error(*data, dict(msgs))) # type: ignore
init_error = Error(False, 0, {})
next_code = it.count(1).__next__ # globally unique ids, could be uuid4
Bool = Union[bool, core.Tracer]
Int = Union[int, core.Tracer]
def assert_func(error: Error, pred: Bool, msg: str) -> Error:
code = next_code()
out_err = error.err | jnp.logical_not(pred)
out_code = lax.select(error.err, error.code, code)
return Error(out_err, out_code, {code: msg, **error.msgs})
## Checkify transformation for plumbing functional error values.
class ErrorTracer(core.Tracer):
def __init__(self, trace, val):
self._trace = trace
self.val = val
core.get_aval(val), val
aval = property(lambda self: core.get_aval(self.val))
full_lower = lambda self: self
class ErrorTrace(core.Trace):
pure = lift = lambda self, val: ErrorTracer(self, val)
def sublift(self, tracer):
return ErrorTracer(self, tracer.val)
def process_primitive(self, primitive, tracers, params):
in_vals = [t.val for t in tracers]
rule = error_checks.get(primitive)
if rule:
out, self.main.error = rule(self.main.error, *in_vals, **params) # type: ignore
else:
out = primitive.bind(*in_vals, **params)
if primitive.multiple_results:
return [ErrorTracer(self, x) for x in out]
else:
return ErrorTracer(self, out)
def process_call(self, primitive, f, tracers, params):
in_vals = [t.val for t in tracers]
e = popattr(self.main, 'error')
f, msgs = check_errors_subtrace(f, self.main, tuple(e.msgs.items()))
params_ = dict(params, donated_invars=(False, False, *params['donated_invars']))
err, code, *out_vals = primitive.bind(f, e.err, e.code, *in_vals, **params_)
setnewattr(self.main, 'error', Error(err, code, msgs()))
return [ErrorTracer(self, x) for x in out_vals]
def process_map(self, primitive, f, tracers, params):
in_vals = [t.val for t in tracers]
e = popattr(self.main, 'error')
f, msgs = check_errors_subtrace(f, self.main, tuple(e.msgs.items()))
@as_hashable_function(closure=params['out_axes_thunk'])
def new_out_axes_thunk():
return (0, 0, *params['out_axes_thunk']())
params_ = dict(params, in_axes=(None, None, *params['in_axes']),
out_axes_thunk=new_out_axes_thunk,
donated_invars=(False, False, *params['donated_invars']))
errs, codes, *outs = primitive.bind(f, e.err, e.code, *in_vals, **params_)
err, code = _reduce_any_error(errs, codes)
setnewattr(self.main, 'error', Error(err, code, msgs()))
return [ErrorTracer(self, x) for x in outs]
def post_process_call(self, primitive, tracers, params):
vals = [t.val for t in tracers]
main = self.main
e = popattr(self.main, 'error')
err, code, main.msgs = e.err, e.code, e.msgs
def todo(vals):
trace = main.with_cur_sublevel()
err, code, *vals = vals
return [ErrorTracer(trace, x) for x in vals]
return (err, code, *vals), todo
def post_process_map(self, primitive, tracers, params):
vals = [t.val for t in tracers]
main = self.main
e = popattr(self.main, 'error')
err, code, main.msgs = e.err, e.code, e.msgs
def todo(vals):
trace = main.with_cur_sublevel()
err, code, *vals = vals
return [ErrorTracer(trace, x) for x in vals]
def out_axes_transform(out_axes):
return (0, 0, *out_axes)
return (err, code, *vals), (todo, out_axes_transform)
def _reduce_any_error(errs, codes):
errs_, codes_ = lax.sort_key_val(errs, codes, dimension=0)
return errs_[-1], codes_[-1]
ErrorCheckRule = Callable
error_checks: Dict[core.Primitive, ErrorCheckRule] = {}
def check_errors_flat(fun: lu.WrappedFun, *args):
fun, msgs = check_errors_subtrace(fun)
fun = check_errors_toplevel(fun)
err, code, *out_vals = fun.call_wrapped(*args)
return (err, code, out_vals), msgs()
@lu.transformation
def check_errors_toplevel(*args):
error = init_error
with core.new_main(ErrorTrace) as main:
msgs = tuple(error.msgs.items())
outs = yield (main, msgs, error.err, error.code, *args), {}
del main
yield outs
@lu.transformation_with_aux
def check_errors_subtrace(main, msgs, err, code, *args):
setnewattr(main, 'error', Error(err, code, dict(msgs)))
trace = main.with_cur_sublevel()
in_tracers = [ErrorTracer(trace, x) for x in args]
out = yield in_tracers, {}
out_tracers = map(trace.full_raise, out)
out_vals = [t.val for t in out_tracers]
err, code, msgs = main.error.err, main.error.code, main.error.msgs
del main.error
yield (err, code, *out_vals), msgs
def checkify_fun_to_jaxpr(f, error, in_avals):
f, msgs = check_errors_subtrace(f)
f = check_errors_traceable(f, tuple(error.msgs.items()))
err_aval = core.raise_to_shaped(core.get_aval(error.err))
code_aval = core.raise_to_shaped(core.get_aval(error.code))
avals_in = [err_aval, code_aval, *in_avals]
jaxpr_out, _, literals_out = pe.trace_to_jaxpr_dynamic(f, avals_in)
return core.ClosedJaxpr(jaxpr_out, literals_out), msgs()
# TODO take (error_aval, code_aval) instead of error here?
def checkify_jaxpr(jaxpr, error):
f = lu.wrap_init(core.jaxpr_as_fun(jaxpr))
return checkify_fun_to_jaxpr(f, error, jaxpr.in_avals)
# TODO dedup with check_errors_toplevel
@lu.transformation
def check_errors_traceable(msgs, err, code, *args):
with core.new_main(ErrorTrace) as main:
outs = yield (main, msgs, err, code, *args), {}
del main
yield outs
## assert primitive
def assert_(pred: Bool, msg: str) -> None:
if not is_scalar_pred(pred):
raise TypeError(f"assert_ takes a scalar pred as argument, got {pred}")
code = next_code()
return assert2_(pred, code, {code: msg})
def is_scalar_pred(pred) -> bool:
return (isinstance(pred, bool) or
isinstance(pred, jnp.ndarray) and pred.shape == () and
pred.dtype == jnp.dtype('bool'))
def assert2_(pred: Bool, code: Int, msgs: Dict[int, str]) -> None:
return assert_p.bind(pred, code, msgs=msgs)
assert_p = core.Primitive('assert')
assert_p.multiple_results = True # zero results
@assert_p.def_impl
def assert_impl(pred, code, *, msgs):
assert pred, msgs[int(code)]
return []
@assert_p.def_abstract_eval
def assert_abstract_eval(pred, code, *, msgs):
raise Exception("can't be staged!")
## checkify rules
def summary() -> str:
return str(source_info_util.summarize(source_info_util.current()))
def nan_error_check(prim, error, *in_vals, **params):
out = prim.bind(*in_vals, **params)
no_nans = jnp.logical_not(jnp.any(jnp.isnan(out)))
msg = f"nan generated by primitive {prim.name} at {summary()}"
return out, assert_func(error, no_nans, msg)
def gather_error_check(error, operand, start_indices, *,
dimension_numbers, slice_sizes, unique_indices,
indices_are_sorted, mode, fill_value):
out = lax.gather_p.bind(
operand, start_indices, dimension_numbers=dimension_numbers,
slice_sizes=slice_sizes, unique_indices=unique_indices,
indices_are_sorted=indices_are_sorted, mode=mode, fill_value=fill_value)
# compare to OOB masking logic in lax._gather_translation_rule
dnums = dimension_numbers
operand_dims = np.array(operand.shape)
upper_bound = operand_dims[np.array(dnums.start_index_map)]
upper_bound -= np.array(slice_sizes)[np.array(dnums.start_index_map)]
all_inbounds = jnp.all((start_indices >= 0) & (start_indices <= upper_bound))
msg = f"out-of-bounds indexing at {summary()}"
return out, assert_func(error, all_inbounds, msg)
error_checks[lax.gather_p] = gather_error_check
def cond_error_check(error, index, *ops, branches, linear):
new_branches, msgs_ = unzip2(checkify_jaxpr(jxpr, error) for jxpr in branches)
new_linear = (False, False, *linear)
err, code, *outs = lax.cond_p.bind(
index, error.err, error.code, *ops,
branches=tuple(new_branches), linear=new_linear)
new_msgs = {k:v for d in it.chain([error.msgs], msgs_) for k, v in d.items()}
return outs, Error(err, code, new_msgs)
error_checks[lax.cond_p] = cond_error_check
def scan_error_check(error, *in_flat, reverse, length, jaxpr, num_consts, num_carry, linear, unroll):
consts, carry, xs = split_list(in_flat, [num_consts, num_carry])
checked_jaxpr, msgs_ = checkify_jaxpr(jaxpr, error)
new_linear = (False, False, *linear)
new_in_flat = [*consts, error.err, error.code, *carry, *xs]
err, code, *outs = lax.scan_p.bind(
*consts, *new_in_flat,
reverse=reverse, length=length, jaxpr=checked_jaxpr,
num_consts=len(consts), num_carry=len(carry)+2,
linear=new_linear, unroll=unroll)
new_msgs = {**error.msgs, **msgs_}
return outs, Error(err, code, new_msgs)
error_checks[lax.scan_p] = scan_error_check
def checkify_while_body_jaxpr(cond_jaxpr, body_jaxpr, error):
cond_f = core.jaxpr_as_fun(cond_jaxpr)
body_f = core.jaxpr_as_fun(body_jaxpr)
def new_body_f(*vals):
out = body_f(*vals)
_ = cond_f(*out) # this checks if the next cond application will error
return out
return checkify_fun_to_jaxpr(lu.wrap_init(new_body_f), error, body_jaxpr.in_avals)
def ignore_errors_jaxpr(jaxpr, error):
"""Constructs a jaxpr which takes two extra args but ignores them."""
err_aval = core.raise_to_shaped(core.get_aval(error.err))
code_aval = core.raise_to_shaped(core.get_aval(error.code))
consts = jaxpr.consts
jaxpr = jaxpr.jaxpr
new_vars = core.gensym([jaxpr])
new_invars = (new_vars(err_aval), new_vars(code_aval), *jaxpr.invars)
new_jaxpr = core.Jaxpr(jaxpr.constvars, new_invars,
jaxpr.outvars, jaxpr.eqns)
return core.ClosedJaxpr(new_jaxpr, consts)
def while_loop_error_check(error, *in_flat, cond_nconsts, cond_jaxpr, body_nconsts, body_jaxpr):
checked_cond_jaxpr, msgs_cond = checkify_jaxpr(cond_jaxpr, error)
checked_cond_fun = core.jaxpr_as_fun(checked_cond_jaxpr)
# Check if the first cond application will error.
cond_err, cond_code, _ = checked_cond_fun(error.err, error.code, *in_flat)
checked_body_jaxpr, msgs_body = checkify_while_body_jaxpr(cond_jaxpr, body_jaxpr, error)
compat_cond_jaxpr = ignore_errors_jaxpr(cond_jaxpr, error)
c_consts, b_consts, carry = split_list(in_flat, [cond_nconsts, body_nconsts])
new_in_flat = [*c_consts, *b_consts, cond_err, cond_code, *carry]
err, code, *out = lax.while_p.bind(
*new_in_flat,
cond_nconsts=cond_nconsts,
cond_jaxpr=compat_cond_jaxpr,
body_nconsts=body_nconsts,
body_jaxpr=checked_body_jaxpr)
new_msgs = {**error.msgs, **msgs_body, **msgs_cond}
return out, Error(err, code, new_msgs)
error_checks[lax.while_p] = while_loop_error_check
# TODO(mattjj,lenamartens): currently we bundle effectful-assert-discharging
# with the error-check-adding transformation (checkify), but they could be
# separated into two orthogonal transformations.
def assert_discharge_rule(error, pred, code, *, msgs):
out_err = error.err | jnp.logical_not(pred)
out_code = lax.select(error.err, error.code, code)
return [], Error(out_err, out_code, {**error.msgs, **msgs})
error_checks[assert_p] = assert_discharge_rule
## checkify api
def checkify(fun: Callable) -> Callable:
@traceback_util.api_boundary
def checked_fun(*args, **kwargs):
args_flat, in_tree = tree_flatten((args, kwargs))
f, out_tree = flatten_fun(lu.wrap_init(fun), in_tree)
(err, code, out_flat), msgs | |
"""
.. codeauthor:: <NAME> <<EMAIL>>
"""
import datetime
import ipaddress
import sys
from decimal import Decimal
import pytest
from termcolor import colored
from typepy import (
Bool,
DateTime,
Dictionary,
Integer,
Nan,
RealNumber,
StrictLevel,
String,
Typecode,
)
from dataproperty import (
MIN_STRICT_LEVEL_MAP,
Align,
DataProperty,
DefaultValue,
Format,
LineBreakHandling,
Preprocessor,
)
from .common import get_strict_level_map
dateutil = pytest.importorskip("dateutil", minversion="2.7")
DATATIME_DATA = datetime.datetime(2017, 1, 2, 3, 4, 5)
nan = float("nan")
inf = float("inf")
class Test_DataPeroperty_eq:
@pytest.mark.parametrize(
["lhs", "rhs", "expected"],
[
[1, 1, True],
[1, 2, False],
[1, 0.1, False],
[1, True, False],
[1.1, 1.1, True],
[1, nan, False],
[nan, nan, True],
[None, None, True],
],
)
def test_normal(self, lhs, rhs, expected):
lhs = DataProperty(lhs)
rhs = DataProperty(rhs)
assert (lhs == rhs) == expected
assert (lhs != rhs) == (not expected)
class Test_DataPeroperty_data_typecode:
@pytest.mark.parametrize(
["value", "expected_data", "expected_typecode"],
[
["-0.00284241876820074", Decimal("-0.00284241876820074"), Typecode.REAL_NUMBER],
],
)
def test_normal(self, value, expected_data, expected_typecode):
dp = DataProperty(value)
assert dp == dp
assert dp.data == expected_data
assert dp.typecode == expected_typecode
@pytest.mark.parametrize(
["value", "is_convert", "expected_data", "expected_typecode"],
[
[1.0, True, 1, Typecode.INTEGER],
[sys.maxsize, True, sys.maxsize, Typecode.INTEGER],
[-sys.maxsize, False, -sys.maxsize, Typecode.INTEGER],
[str(-sys.maxsize), True, -sys.maxsize, Typecode.INTEGER],
[str(sys.maxsize), False, str(sys.maxsize), Typecode.STRING],
[1.1, True, 1, Typecode.INTEGER],
[-1.1, False, Decimal("-1.1"), Typecode.REAL_NUMBER],
[Decimal("1.1"), False, Decimal("1.1"), Typecode.REAL_NUMBER],
["1.1", True, 1, Typecode.INTEGER],
["-1.1", False, "-1.1", Typecode.STRING],
["a", True, "a", Typecode.STRING],
["a", False, "a", Typecode.STRING],
["", True, "", Typecode.NULL_STRING],
["", False, "", Typecode.NULL_STRING],
[" ", True, " ", Typecode.NULL_STRING],
[" ", False, " ", Typecode.NULL_STRING],
["3.3.5", True, "3.3.5", Typecode.STRING],
["51.0.2704.106", True, "51.0.2704.106", Typecode.STRING],
[True, True, 1, Typecode.INTEGER],
[False, False, False, Typecode.BOOL],
["100-0002", False, "100-0002", Typecode.STRING],
["127.0.0.1", True, ipaddress.IPv4Address("127.0.0.1"), Typecode.IP_ADDRESS],
["127.0.0.1", False, "127.0.0.1", Typecode.STRING],
["::1", True, ipaddress.IPv6Address("::1"), Typecode.IP_ADDRESS],
["::1", False, "::1", Typecode.STRING],
[[], True, [], Typecode.LIST],
[[], False, [], Typecode.LIST],
[{}, True, {}, Typecode.DICTIONARY],
[{}, False, {}, Typecode.DICTIONARY],
[
"2017-01-02 03:04:05",
True,
datetime.datetime(2017, 1, 2, 3, 4, 5),
Typecode.DATETIME,
],
[DATATIME_DATA, True, DATATIME_DATA, Typecode.DATETIME],
["2017-01-02 03:04:05", False, "2017-01-02 03:04:05", Typecode.STRING],
[None, True, None, Typecode.NONE],
[None, False, None, Typecode.NONE],
["None", True, "None", Typecode.STRING],
["None", False, "None", Typecode.STRING],
[inf, True, inf, Typecode.INFINITY],
[inf, False, Decimal(inf), Typecode.INFINITY],
["inf", True, Decimal(inf), Typecode.INFINITY],
["inf", False, "inf", Typecode.STRING],
["nan", False, "nan", Typecode.STRING],
[
"Høgskolen i Østfold er et eksempel...",
True,
"Høgskolen i Østfold er et eksempel...",
Typecode.STRING,
],
[
"Høgskolen i Østfold er et eksempel...",
False,
"Høgskolen i Østfold er et eksempel...",
Typecode.STRING,
],
["新しいテキスト ドキュメント.txt".encode(), True, "新しいテキスト ドキュメント.txt", Typecode.STRING],
],
)
def test_normal_strict_map(self, value, is_convert, expected_data, expected_typecode):
dp = DataProperty(value, strict_level_map=get_strict_level_map(not is_convert))
assert dp == dp
assert dp != DataProperty("test for __ne__")
assert dp.data == expected_data
assert dp.typecode == expected_typecode
@pytest.mark.parametrize(
["value", "strip_str", "is_strict", "expected_data", "expected_typecode"],
[
['"1"', '"', False, 1, Typecode.INTEGER],
['"1"', "", False, '"1"', Typecode.STRING],
['"1"', '"', True, "1", Typecode.STRING],
['"1"', "", False, '"1"', Typecode.STRING],
[b"hoge", "a", False, "hoge", Typecode.STRING],
["hogea", b"a", False, "hoge", Typecode.STRING],
],
)
def test_normal_strip_str(self, value, strip_str, is_strict, expected_data, expected_typecode):
dp = DataProperty(
value,
preprocessor=Preprocessor(strip_str=strip_str),
strict_level_map=get_strict_level_map(is_strict),
)
assert dp.data == expected_data
assert dp.typecode == expected_typecode
@pytest.mark.parametrize(
["value", "type_hint", "strict_level", "expected_typecode"],
[
["2017-01-02 03:04:05", None, StrictLevel.MIN, Typecode.DATETIME],
["2017-01-02 03:04:05", None, StrictLevel.MAX, Typecode.STRING],
["2017-01-02 03:04:05", DateTime, StrictLevel.MIN, Typecode.DATETIME],
["2017-01-02 03:04:05", DateTime, StrictLevel.MAX, Typecode.DATETIME],
["2017-01-02 03:04:05", Integer, StrictLevel.MIN, Typecode.DATETIME],
["2017-01-02 03:04:05", Integer, StrictLevel.MAX, Typecode.STRING],
["1,000,000,000,000", None, StrictLevel.MAX, Typecode.STRING],
["1,000,000,000,000", None, StrictLevel.MIN + 1, Typecode.INTEGER],
["1,000,000,000,000", None, StrictLevel.MIN, Typecode.INTEGER],
["1,000,000,000,000", Integer, StrictLevel.MAX, Typecode.INTEGER],
["1,000,000,000,000", Integer, StrictLevel.MIN, Typecode.INTEGER],
[DATATIME_DATA, None, StrictLevel.MIN, Typecode.DATETIME],
[DATATIME_DATA, None, StrictLevel.MAX, Typecode.DATETIME],
[DATATIME_DATA, String, StrictLevel.MIN, Typecode.STRING],
[DATATIME_DATA, String, StrictLevel.MAX, Typecode.STRING],
["100-0002", None, StrictLevel.MIN, Typecode.STRING],
["45e76582", None, StrictLevel.MIN, Typecode.INTEGER],
["45e76582", None, StrictLevel.MAX, Typecode.STRING],
["4.5e-4", None, StrictLevel.MIN, Typecode.INTEGER],
["4.5e-4", None, StrictLevel.MIN + 1, Typecode.REAL_NUMBER],
["4.5e-4", None, StrictLevel.MAX, Typecode.STRING],
[1, String, StrictLevel.MAX, Typecode.STRING],
[1, String, StrictLevel.MIN, Typecode.STRING],
[float("inf"), RealNumber, StrictLevel.MAX, Typecode.INFINITY],
[float("inf"), RealNumber, StrictLevel.MIN, Typecode.INFINITY],
[1, RealNumber, StrictLevel.MAX, Typecode.INTEGER],
[1, RealNumber, StrictLevel.MIN, Typecode.INTEGER],
[1.1, Integer, StrictLevel.MAX, Typecode.INTEGER],
[1.1, Integer, StrictLevel.MIN, Typecode.INTEGER],
["true", None, StrictLevel.MAX, Typecode.STRING],
["false", None, StrictLevel.MAX, Typecode.STRING],
["true", None, StrictLevel.MIN, Typecode.BOOL],
["false", None, StrictLevel.MIN, Typecode.BOOL],
["true", Bool, StrictLevel.MIN, Typecode.BOOL],
["false", Bool, StrictLevel.MIN, Typecode.BOOL],
[b"hoge", None, StrictLevel.MAX, Typecode.STRING],
[b"hoge", None, StrictLevel.MIN, Typecode.STRING],
['{"foo": 10}', None, StrictLevel.MAX, Typecode.STRING],
['{"foo": 10}', None, StrictLevel.MIN, Typecode.DICTIONARY],
['{"foo": 10}', Dictionary, StrictLevel.MAX, Typecode.DICTIONARY],
['{"foo": 10}', Dictionary, StrictLevel.MIN, Typecode.DICTIONARY],
[{"foo": 10}, None, StrictLevel.MAX, Typecode.DICTIONARY],
[{"foo": 10}, None, StrictLevel.MIN, Typecode.LIST],
],
)
def test_normal_type_hint(self, value, type_hint, strict_level, expected_typecode):
dp = DataProperty(value, type_hint=type_hint, strict_level_map={"default": strict_level})
assert dp.typecode == expected_typecode
@pytest.mark.parametrize(
["value", "is_convert", "expected_data", "expected_typecode"],
[
[nan, True, nan, Typecode.NAN],
[nan, False, nan, Typecode.NAN],
["nan", True, nan, Typecode.NAN],
],
)
def test_normal_nan(self, value, is_convert, expected_data, expected_typecode):
dp = DataProperty(value, strict_level_map=get_strict_level_map(not is_convert))
assert Nan(dp.data).is_type()
assert dp.typecode == expected_typecode
class Test_DataPeroperty_to_str:
@pytest.mark.parametrize(
["value", "type_hint", "is_strict", "expected_data", "expected_str"],
[
[float("inf"), None, True, Decimal("inf"), "Infinity"],
[float("inf"), None, False, Decimal("inf"), "Infinity"],
[float("inf"), RealNumber, True, Decimal("inf"), "Infinity"],
[float("inf"), RealNumber, False, Decimal("inf"), "Infinity"],
[float("inf"), String, False, "inf", "inf"],
],
)
def test_normal(self, value, type_hint, is_strict, expected_data, expected_str):
dp = DataProperty(
value, type_hint=type_hint, strict_level_map=get_strict_level_map(is_strict)
)
assert dp.data == expected_data
assert dp.to_str() == expected_str
@pytest.mark.parametrize(
["value", "format_flags", "expected"], [[1234567, Format.THOUSAND_SEPARATOR, "1,234,567"]]
)
def test_normal_format_str(self, value, format_flags, expected):
dp = DataProperty(value, format_flags=format_flags)
assert dp.to_str() == expected
class Test_DataPeroperty_set_data:
@pytest.mark.parametrize(
["value", "is_convert", "replace_tabs_with_spaces", "tab_length", "expected"],
[
["a\tb", True, True, 2, "a b"],
["\ta\t\tb\tc\t", True, True, 2, " a b c "],
["a\tb", True, True, 4, "a b"],
["a\tb", True, False, 4, "a\tb"],
["a\tb", True, True, None, "a\tb"],
],
)
def test_normal_tab(self, value, is_convert, replace_tabs_with_spaces, tab_length, expected):
preprocessor = Preprocessor(
replace_tabs_with_spaces=replace_tabs_with_spaces,
tab_length=tab_length,
)
dp = DataProperty(
value, preprocessor=preprocessor, strict_level_map=get_strict_level_map(not is_convert)
)
assert dp.data == expected
class Test_DataPeroperty_is_escape_html_tag:
@pytest.mark.parametrize(
["value", "is_escape_html_tag", "expected"],
[
[
"<a href='https://google.com'>test</a>",
True,
"<a href='https://google.com'>test</a>",
],
[
"<a href='https://google.com'>test</a>",
False,
"<a href='https://google.com'>test</a>",
],
[True, True, True],
],
)
def test_normal_tab(self, value, is_escape_html_tag, expected):
dp = DataProperty(value, preprocessor=Preprocessor(is_escape_html_tag=is_escape_html_tag))
assert dp.data == expected
class Test_DataPeroperty_float_type:
@pytest.mark.parametrize(
["value", "float_type", "expected"], [[1.1, float, 1.1], [1.1, Decimal, Decimal("1.1")]]
)
def test_normal_tab(self, value, float_type, expected):
dp = DataProperty(value, float_type=float_type)
assert isinstance(dp.data, float_type)
assert dp.data == expected
class Test_DataPeroperty_align:
@pytest.mark.parametrize(
["value", "expected"],
[
[1, Align.RIGHT],
[1.1, Align.RIGHT],
["a", Align.LEFT],
[True, Align.LEFT],
[DATATIME_DATA, Align.LEFT],
[None, Align.LEFT],
[inf, Align.LEFT],
[nan, Align.LEFT],
],
)
def test_normal(self, value, expected):
dp = DataProperty(value)
assert dp.align == expected
class Test_DataPeroperty_len:
@pytest.mark.parametrize(
["value", "expected_acw", "expected_len"],
[
[1, 1, None],
[-1, 2, None],
[1.0, 1, None],
[-1.0, 2, None],
[1.1, 3, None],
[-1.1, 4, None],
[12.34, 5, None],
["000", 1, None],
["123456789", 9, None],
["-123456789", 10, None],
["45e76582", 8, 8],
["a", 1, 1],
["a" * 1000, 1000, 1000],
["あ", 2, 1],
[True, 4, None],
[None, 4, None],
[inf, 8, None],
[nan, 3, None],
],
)
def test_normal(self, value, expected_acw, expected_len):
dp = DataProperty(value)
assert dp.ascii_char_width == expected_acw
assert dp.length == expected_len
@pytest.mark.parametrize(
["value", "expected_acw", "expected_len"],
[
[colored(0, "red"), 1, 10],
[colored(12.34, "red"), 5, 14],
[colored("abc", "green"), 3, 12],
],
)
def test_normal_ascii_escape_sequence(self, value, expected_acw, expected_len):
dp = DataProperty(value)
assert dp.ascii_char_width == expected_acw
assert dp.length == expected_len
@pytest.mark.parametrize(
["value", "eaaw", "expected_acw", "expected_len"], [["øø", 1, 2, 2], ["øø", 2, 4, 2]]
)
def test_normal_eaaw(self, value, eaaw, expected_acw, expected_len):
dp = DataProperty(value, east_asian_ambiguous_width=eaaw)
assert dp.ascii_char_width == expected_acw
assert dp.length == expected_len
@pytest.mark.parametrize(["value", "expected"], [[nan, nan]])
def test_abnormal(self, value, expected):
Nan(DataProperty(value).length).is_type()
@pytest.mark.parametrize(
["value", "eaaw", "expected"],
[["øø", None, ValueError], ["øø", 0, ValueError], ["øø", 3, ValueError]],
)
def test_exception_eaaw(self, value, eaaw, expected):
with pytest.raises(expected):
DataProperty(value, east_asian_ambiguous_width=eaaw).ascii_char_width
class Test_DataPeroperty_is_include_ansi_escape:
@pytest.mark.parametrize(
["value", "expected_acw"],
[
[0, False],
[colored(0, "red"), True],
[12.34, False],
[colored(12.34, "red"), True],
["abc", False],
[colored("abc", "green"), True],
],
)
def test_normal(self, value, expected_acw):
assert DataProperty(value).is_include_ansi_escape == expected_acw
class Test_DataPeroperty_line_break_handling:
@pytest.mark.parametrize(
["value", "line_break_handling", "expected"],
[
["a\nb", LineBreakHandling.NOP, "a\nb"],
["a\nb", LineBreakHandling.REPLACE, "a b"],
["a\nb", LineBreakHandling.ESCAPE, "a\\nb"],
["a\r\nb", LineBreakHandling.ESCAPE, "a\\r\\nb"],
[123, LineBreakHandling.ESCAPE, 123],
],
)
def test_normal(self, value, line_break_handling, expected):
preprocessor = Preprocessor(line_break_handling=line_break_handling)
assert DataProperty(value, preprocessor=preprocessor).data == expected
class Test_DataPeroperty_line_break_repl:
@pytest.mark.parametrize(
["value", "line_break_handling", "line_break_repl", "expected"],
[
["a\nb", LineBreakHandling.REPLACE, "<br>", "a<br>b"],
["a\n\r\n\nb", LineBreakHandling.REPLACE, "<br>", "a<br><br><br>b"],
["a\nb", LineBreakHandling.NOP, "<br>", "a\nb"],
],
)
def test_normal(self, value, line_break_handling, line_break_repl, expected):
preprocessor = Preprocessor(
line_break_handling=line_break_handling, line_break_repl=line_break_repl
)
assert DataProperty(value, preprocessor=preprocessor).data == expected
class Test_DataPeroperty_escape_formula_injection:
@pytest.mark.parametrize(
["value", "escape_formula_injection", "expected"],
[
["a+b", True, "a+b"],
["=a+b", True, "'=a+b"],
["=a+b", False, "=a+b"],
["-a+b", True, "'-a+b"],
["-a+b", False, "-a+b"],
["+a+b", True, "'+a+b"],
["+a+b", False, "+a+b"],
["@a+b", True, "'@a+b"],
["@a+b", False, "@a+b"],
],
)
def test_normal(self, value, escape_formula_injection, expected):
preprocessor = Preprocessor(is_escape_formula_injection=escape_formula_injection)
assert DataProperty(value, preprocessor=preprocessor).data == expected
@pytest.mark.parametrize(
| |
import logging
import cv2
import numpy as np
import pytesseract
import os
import time
import json
import re
from multiprocessing import Pool
from Levenshtein import distance
from .input_handler import InputHandler
from .grabscreen import grab_screen
from .utils import get_config, filter_mod
# This is a position of the inventory as fraction of the resolution
OWN_INVENTORY_ORIGIN = (0.6769531, 0.567361)
# These are the sockets positions as measured on 2560x1440 resolution
# with X_SCALE and Y_SCALE applied, i.e., scale * SOCKETS[i] is the i:th
# sockets absolute pixel position with origin in the middle of the skill tree
# I think the SCALE variables are in fact useless and a relics from the
# positions initially being measured at a view which wasn't zoomed out maximally
SOCKETS = {
1: (-650.565, -376.013),
2: (648.905, -396.45),
3: (6.3354, 765.658),
4: (-1700.9, 2424.17),
5: (-2800.66, -215.34),
6: (-1435.02, -2635.39),
7: (1855.53, -2360.1),
8: (2835.84, 230.5361),
9: (1225.37, 2625.76),
10: (-120.12471, 5195.44),
11: (-3580.19, 5905.92),
12: (-5395.86, 2120.42),
13: (-6030.95, -115.7007),
14: (-5400.59, -1985.18),
15: (-3035.14, -5400.87),
16: (160.10728, -5196.32),
17: (3382.05, -5195.21),
18: (5730.2, -1625.75),
19: (6465.24, 190.3341),
20: (5542.76, 1690.07),
21: (3322.76, 6090.5),
}
# The offsets are specified in the same fashion as SOCKETS and are rough
# guesses which allow us to move to the general area and later refine the
# position of the socket through template matching
SOCKET_MOVE_OFFSET = {
1: (0, 150),
2: (0, 150),
3: (0, 200),
4: (0, 150),
5: (-300, 200),
6: (-100, 150),
7: (-150, 0),
8: (0, -150),
9: (-100, -125),
10: (170, 0),
11: (-400, -900),
12: (0, 300),
13: (400, 200),
14: (-250, -150),
15: (-100, -150),
16: (150, -150),
17: (150, 500), #
18: (-300, 400),
19: (-1000, -150),
20: (-500, 500),
21: (100, -1000),
}
# Scalers for the SOCKETS positions to convert them to 2560x1440 pixel positions
X_SCALE = 0.2
Y_SCALE = 0.2
CIRCLE_EFFECTIVE_RADIUS = 300
IMAGE_FOLDER = "data/images/"
# We're using a lot of template matching and all templates are defined here
# with matching thresholds (scores) and sizes per resolution
TEMPLATES = {
"AmbidexterityCluster.png": {
"1440p_size": (34, 34),
"1440p_threshold": 0.95,
"1080p_size": (26, 26),
"1080p_threshold": 0.95,
},
"FreeSpace.png": {
"1440p_size": (41, 41),
"1440p_threshold": 0.98,
"1080p_size": (30, 30),
"1080p_threshold": 0.98,
},
"Notable.png": {
"1440p_size": (30, 30),
"1440p_threshold": 0.89,
"1080p_size": (23, 23),
"1080p_threshold": 0.85,
},
"NotableAllocated.png": {
"1440p_size": (30, 30),
"1440p_threshold": 0.93,
"1080p_size": (23, 23),
"1080p_threshold": 0.90,
},
"Jewel.png": {
"1440p_size": (30, 30),
"1440p_threshold": 0.92,
"1080p_size": (23, 23),
"1080p_threshold": 0.92,
},
"JewelSocketed.png": {
"1440p_size": (30, 30),
"1440p_threshold": 0.9,
"1080p_size": (23, 23),
"1080p_threshold": 0.9,
},
"LargeJewel.png": {
"1440p_size": (39, 39),
"1440p_threshold": 0.9,
"1080p_size": (30, 30),
"1080p_threshold": 0.88,
},
"LargeJewelSocketed.png": {
"1440p_size": (39, 39),
"1440p_threshold": 0.9,
"1080p_size": (30, 30),
"1080p_threshold": 0.88,
},
"Skill.png": {
"1440p_size": (21, 21),
"1440p_threshold": 0.87,
"1080p_size": (15, 15),
"1080p_threshold": 0.91,
},
"SkillAllocated.png": {
"1440p_size": (21, 21),
"1440p_threshold": 0.93,
"1080p_size": (15, 15),
"1080p_threshold": 0.91,
},
}
# Defines the position of the text box which is cropped out and OCR'd per node
TXT_BOX = {"x": 32, "y": 0, "w": 900, "h": 320}
mod_files = {
"passives": "data/passives.json",
"passivesAlt": "data/passivesAlternatives.json",
"passivesAdd": "data/passivesAdditions.json",
"passivesVaalAdd": "data/passivesVaalAdditions.json",
}
class TreeNavigator:
def __init__(self, resolution, halt_value):
self.resolution = resolution
self.input_handler = InputHandler(self.resolution)
logging.basicConfig(
level=logging.INFO,
format="%(asctime)s %(message)s",
datefmt="[%H:%M:%S %d-%m-%Y]",
)
self.log = logging.getLogger("tree_nav")
self.config = get_config("tree_nav")
self.find_mod_value_re = re.compile("(\(?(?:[0-9]*\.?[0-9]-?)+\)?)")
self.nonalpha_re = re.compile("[^a-zA-Z]")
self.origin_pos = (self.resolution[0] / 2, self.resolution[1] / 2)
self.ingame_pos = [0, 0]
self.px_multiplier = self.resolution[0] / 2560
self.resolution_prefix = str(self.resolution[1]) + "p_"
self.templates_and_masks = self.load_templates()
self.passive_mods, self.passive_names = self.generate_good_strings(mod_files)
self.passive_nodes = list(self.passive_mods.keys()) + list(
self.passive_names.keys()
)
self.halt = halt_value
self.first_run = True
def _run(self):
return not bool(self.halt.value)
def eval_jewel(self, item_location):
self.ingame_pos = [0, 0]
item_name, item_desc = self._setup(item_location, copy=True)
pool = Pool(self.config["ocr_threads"])
jobs = {}
if self.first_run:
# We just initiated the module and not sure where we are
# Thus, we better rectify our position estimate before starting
self._refind_position(SOCKETS[1])
self.first_run = False
for socket_id in sorted(SOCKETS.keys()):
if not self._run():
return None, None, None
found_socket = self._move_screen_to_socket(socket_id)
if not found_socket and socket_id == 1:
self.log.info("We are lost - trying to find known location")
# We just initiated the search and have no clue where we are
# Thus, we better rectify our position estimate before starting
self._refind_position(SOCKETS[1])
socket_nodes = self._analyze_nodes(socket_id)
# Convert stats for the socket from image to lines in separate process
self.log.info("Performing asynchronous OCR")
jobs[socket_id] = pool.map_async(OCR.node_to_strings, socket_nodes)
self.log.info("Analyzed socket %s" % socket_id)
# Return to socket 1 to ease next search
self._move_to_tree_pos_using_spaces(SOCKETS[1])
self._setup(item_location)
self.log.info("Waiting for last OCR to finish")
item_stats = [
{
"socket_id": socket_id,
"socket_nodes": self._filter_ocr_lines(
jobs[socket_id].get(timeout=300)
),
}
for socket_id in jobs
]
pool.close()
pool.join()
return item_name, item_desc, item_stats
def load_templates(self, threshold=128):
templates_and_masks = {}
for template_name in TEMPLATES.keys():
template_path = os.path.join(IMAGE_FOLDER, template_name)
img = cv2.imread(template_path, cv2.IMREAD_UNCHANGED)
size = TEMPLATES[template_name][self.resolution_prefix + "size"]
channels = cv2.split(img)
mask = None
if len(channels) > 3:
mask = np.array(channels[3])
mask[mask <= threshold] = 0
mask[mask > threshold] = 255
mask = cv2.resize(mask, size)
img = cv2.imread(template_path, 0)
img = cv2.resize(img, size)
templates_and_masks[template_name] = {"image": img, "mask": mask}
return templates_and_masks
def _move_screen_to_socket(self, socket_id):
self.log.debug("Moving close to socket %s" % socket_id)
move_offset_tx, move_offset_ty = SOCKET_MOVE_OFFSET[socket_id]
move_offset = self._tree_pos_to_xy(
[move_offset_tx, move_offset_ty], offset=True
)
socket_tx, socket_ty = SOCKETS[socket_id]
socket_xy = self._tree_pos_to_xy([socket_tx, socket_ty])
compensation_offset = self._find_socket(socket_xy)
if compensation_offset is None:
found_socket = False
compensation_offset = [0, 0]
else:
found_socket = True
self.log.debug("Compensated navigation with %s" % compensation_offset)
move_to = [
socket_xy[0] + compensation_offset[0] + move_offset[0],
socket_xy[1] + compensation_offset[1] + move_offset[1],
]
x_offset = move_to[0] - self.resolution[0] / 2
y_offset = move_to[1] - self.resolution[1] / 2
self.input_handler.click(
*move_to, *move_to, button=None, raw=True, speed_factor=1
)
self.input_handler.drag(self.origin_pos[0], self.origin_pos[1], speed_factor=1)
self.input_handler.rnd_sleep(min=200, mean=300, sigma=100)
self.ingame_pos = [socket_tx + move_offset_tx, socket_ty + move_offset_ty]
return found_socket
def _refind_position(self, desired_tree_pos):
# If the current location has been determined to be incorrect
# we can go to the bottom right corner and find a cluster close
# to socket 21, namely the Ambidexterity cluster
# This is a known location, which can then be used to calculate
# our way to a desired position
self.log.debug("Centering screen position")
# Correct our tree position to a known value
self._locate_screen_using_ambidexterity()
# Find our way to the desired position
self._move_to_tree_pos_using_spaces(desired_tree_pos)
def _move_to_tree_pos_using_spaces(self, desired_tree_pos, max_position_error=5):
dx = desired_tree_pos[0] - self.ingame_pos[0]
dy = desired_tree_pos[1] - self.ingame_pos[1]
self.log.debug("Moving to tree pos using spaces. Deltas: ({}, {})".format(dx, dy))
while (abs(dx) + abs(dy)) > max_position_error:
# Choose quadrant to find spaces in based on dx, dy
right, bottom = dx >= 0, dy >= 0
if right and not bottom:
quadrant = 0
elif not right and not bottom:
quadrant = 1
elif not right and bottom:
quadrant = 2
elif right and bottom:
quadrant = 3
# Find empty spaces that we can drag from
spaces = self._find_empty_space(quadrant)
if spaces is None:
raise ValueError("Could not find an empty space, quitting.")
# Choose a random empty space for maximum drag
chosen_space = spaces[np.random.randint(spaces.shape[0])]
# How far to drag the window to end up in the optimal place
screen_move_x, screen_move_y = self._tree_pos_to_xy([dx, dy],
offset=True)
# Calculate where our drag should end up to perform the move
drag_x = chosen_space[0] - screen_move_x
drag_y = chosen_space[1] - screen_move_y
# We should only drag within the screen's resolution
# Additionally, we use 100px margin to not trigger tree scroll
drag_x = np.clip(drag_x, 100, self.resolution[0] - 100)
drag_y = np.clip(drag_y, 100, self.resolution[1] - 100)
# Drag
self.input_handler.click(
*chosen_space, *chosen_space, button=None, raw=True, speed_factor=1
)
self.input_handler.drag(drag_x, drag_y, speed_factor=1)
self.input_handler.rnd_sleep(min=200, mean=300, sigma=100)
# Calculate how far we've actually moved
effective_move_x = chosen_space[0] - drag_x
effective_move_y = chosen_space[1] - drag_y
# Update our internal tree position
self.ingame_pos = self._add_xy_offset_to_tree_pos(
[effective_move_x, effective_move_y]
)
# Figure out how much we have left to move
dx = desired_tree_pos[0] - self.ingame_pos[0]
dy = desired_tree_pos[1] - self.ingame_pos[1]
def _locate_screen_using_ambidexterity(self):
# Essentially, this is _move_to_tree_pos_using_spaces but
# only used to find the tree position by navigating to a known point
self.log.debug("Moving to ambidexterity")
ambidexterity_position = None
assumed_ambidexterity_position = (0.25234375, 0.20555556)
while ambidexterity_position is None:
# Find empty spaces that we can drag from
spaces = self._find_empty_space(3)
if spaces is None:
raise ValueError("Could not | |
<reponame>nudglabs/books-python-wrappers
#$Id$
from books.model.Address import Address
class Organization:
"""This class is used to create object for organization."""
def __init__(self):
"""Initialize parameters for organization object. """
self.organization_id = ''
self.name = ''
self.is_default_org = None
self.account_created_date = ''
self.time_zone = ''
self.language_code = ''
self.date_format = ''
self.field_separator = ''
self.fiscal_year_start_month = ''
self.contact_name = ''
self.industry_type = ''
self.industry_size = ''
self.company_id_label = ''
self.company_id_value = ''
self.tax_id_label = ''
self.tax_id_value = ''
self.currency_id = ''
self.currency_code = ''
self.currency_symbol = ''
self.currency_format = ''
self.price_precision = 0
self.address = Address()
self.org_address = ''
self.remit_to_address = ''
self.phone = ''
self.fax = ''
self.website = ''
self.email = ''
self.tax_basis = ''
self.is_org_active = None
self.name = ''
self.value = ''
self.version = ''
self.plan_type = 0
self.plane_name = ''
self.plan_period = ''
self.tax_group_enabled = None
self.account_created_date_formatted = ""
self.zi_migration_status = 0
self.user_role = ''
self.custom_fields = []
self.is_new_customer_custom_fields = None
self.is_portal_enabled = None
self.portal_name = ''
self.tax_type = ''
def set_organization_id(self, organization_id):
"""Set organization id.
Args:
organization_id(str): Organization id.
"""
self.organization_id = organization_id
def get_organization_id(self):
"""Get organization id.
Returns:
str: Organization id.
"""
return self.organization_id
def set_name(self, name):
"""Set name.
Args:
name(str): Name.
"""
self.name = name
def set_is_default_org(self, is_default_org):
"""Set whether it is default organization.
Args:
is_default_org(bool): True if it is default organization else false.
"""
self.is_default_org = is_default_org
def get_is_default_org(self):
"""Get whether it is default organization.
Returns:
bool: True if it is default organization else false.
"""
return self.is_default_org
def set_account_created_date(self, account_created_date):
"""Set account created date.
Args:
account_created_date(str): Account created date.
"""
self.account_created_date = account_created_date
def get_account_created_date(self):
"""Get account created date.
Returns:
str: Account created date.
"""
return self.account_created_date
def set_time_zone(self, time_zone):
"""Set time zone.
Args:
time_zone(str): Time zone.
"""
self.time_zone = time_zone
def get_time_zone(self):
"""Get time zone.
Returns:
str: Time zone.
"""
return self.time_zone
def set_language_code(self, language_code):
"""Set language code.
Args:
language_code(str): Language code.
"""
self.language_code = language_code
def get_language_code(self):
"""Get language code.
Returns:
str: Language code.
"""
return self.language_code
def set_date_format(self, date_format):
"""Set date format.
Args:
date_format(str): Date format.
"""
self.date_format = date_format
def get_date_format(self):
"""Get date format.
Returns:
str: Date format.
"""
return self.date_format
def set_field_separator(self, field_separator):
"""Set field separator.
Args:
field_separator(str): Field separator.
"""
self.field_separator = field_separator
def get_field_separator(self):
"""Get field separator.
Returns:
str: Field separator.
"""
return self.field_separator
def set_fiscal_year_start_month(self, fiscal_year_start_month):
"""Set fiscal year field separator.
Args:
fiscal_year_start_month(str): Fiscal year start month.
"""
self.fiscal_year_start_month = fiscal_year_start_month
def get_fiscal_year_start_month(self):
"""Get fiscal year start month.
Returns:
str: Fiscal year start month.
"""
return self.fiscal_year_start_month
def set_contact_name(self, contact_name):
"""Set contact name.
Args:
contact_name(str): Contact name.
"""
self.contact_name = contact_name
def get_contact_name(self):
"""Get contact name.
Returns:
str: Contact name.
"""
return self.contact_name
def set_industry_type(self, industry_type):
"""Set industry type.
Args:
industry_type(str): Industry type.
"""
self.industry_type = industry_type
def get_industry_type(self):
"""Get industry type.
Returns:
str: Industry type.
"""
return self.industry_type
def set_industry_size(self, industry_size):
"""Set industry size.
Args:
industry_size(str): Industry size.
"""
self.industry_size = industry_size
def get_industry_size(self):
"""Get industry size.
Returns:
str: Industry size.
"""
return self.industry_size
def set_company_id_label(self, company_id_label):
"""Set company id label.
Args:
company_id_label(str): Company id label.
"""
self.company_id_label = company_id_label
def get_company_id_label(self):
"""Get company id label.
Returns:
str: Company id label.
"""
return self.company_id_label
def set_company_id_value(self, company_id_value):
"""Set company id value.
Args:
company_id_value(str): Company id value.
"""
self.company_id_value = company_id_value
def get_company_id_value(self):
"""Get company id value.
Returns:
str: Company id value.
"""
return self.company_id_value
def set_tax_id_label(self, tax_id_label):
"""Set tax id label.
Args:
tax_id_label(str): Tax id label.
"""
self.tax_id_label = tax_id_label
def get_tax_id_label(self):
"""Get tax id label.
Retruns:
str: Tax id label.
"""
return self.tax_id_label
def set_tax_id_value(self, tax_id_value):
"""Set tax id value.
Args:
tax_id_value(str): Tax id value.
"""
self.tax_id_value = tax_id_value
def get_tax_id_value(self):
"""Get atx id value.
Returns:
str: Tax id value.
"""
return self.tax_id_value
def set_currency_id(self, currency_id):
"""Set currency id.
Args:
currency_id(str): Currency id.
"""
self.currency_id = currency_id
def get_currency_id(self):
"""Get currency id.
Returns:
str: Currency id.
"""
return self.currency_id
def set_currency_code(self, currency_code):
"""Set currency code.
Args:
currency_code(str): Currency code.
"""
self.currency_code = currency_code
def get_currency_code(self):
"""Get currency code.
Returns:
str: Currency code.
"""
return self.currency_code
def set_currency_symbol(self, currency_symbol):
"""Set currency symbol.
Args:
currency_symbol(str): Currency symbol.
"""
self.currency_symbol = currency_symbol
def get_currency_symbol(self):
"""Get currency symbol.
Returns:
str: Currency symbol.
"""
return self.currency_symbol
def set_currency_format(self, currency_format):
"""Set currency format.
Args:
currency_format(str): Currency format.
"""
self.currency_format = currency_format
def get_currency_format(self):
"""Get currency format.
Retruns:
str: Currency format.
"""
return self.currency_format
def set_price_precision(self, price_precision):
"""Set price precision.
Args:
price_precision(int): Price precision.
"""
self.price_precision = price_precision
def set_address(self, address):
"""Set address.
Args:
address(instance): Address
"""
self.address = address
def get_address(self):
"""Get address.
Returns:
instance: Address.
"""
return self.address
def set_org_address(self, org_address):
"""Set organization address.
Args:
org_address(str): Organization address.
"""
self.org_address = org_address
def get_org_address(self):
"""Get organization address.
Returns:
str: Organization address.
"""
return self.org_address
def set_remit_to_address(self, remit_to_address):
"""Set remit to address.
Args:
remit_to_address(str): Remit to address.
"""
self.remit_to_address = remit_to_address
def get_remit_to_address(self):
"""Get remit to address.
Returns:
str: Remit to address.
"""
return self.remit_to_address
def set_phone(self, phone):
"""Set phone.
Args:
phone(str): Phone.
"""
self.phone = phone
def get_phone(self):
"""Get phone.
Returns:
str: Phone.
"""
return self.phone
def set_fax(self, fax):
"""Set fax.
Args:
fax(str): Fax.
"""
self.fax = fax
def get_fax(self):
"""Get fax.
Returns:
str: Fax.
"""
return self.fax
def set_website(self, website):
"""Set website.
Args:
website(str): Website.
"""
self.website = website
def set_email(self, email):
"""Set email.
Args:
email(str): Email.
"""
self.email = email
def get_email(self):
"""Get email.
Returns:
str: Email.
"""
return self.email
def set_tax_basis(self, tax_basis):
"""Set tax basis.
Args:
tax_basis(str): Tax basis.
"""
self.tax_basis = tax_basis
def get_tax_basis(self):
"""Get tax basis.
Returns:
str: Tax basis.
"""
return self.tax_basis
def set_is_org_active(self, is_org_active):
"""Set whether it the organization is active or not.
Args:
is_org_active(bool): True if organization is active else false.
"""
self.is_org_active = is_org_active
def set_name(self, name):
"""Set name.
Args:
name(str): Name.
"""
self.name = name
def get_name(self):
"""Get name.
Returns:
str: Name.
"""
return self.name
def set_value(self, value):
"""Set value.
Args:
value(str): Value.
"""
self.value = value
def get_value(self):
"""Get value.
Returns:
str: Value.
"""
return self.value
def set_version(self, version):
"""Set version.
Args:
version(str): Version
"""
self.version = version
def get_version(self):
"""Get version.
Returns:
str: Version.
"""
return self.version
def set_plan_type(self, plan_type):
"""Set plan type.
Args:
plan_type(int): Plan type.
"""
self.plan_type = plan_type
def get_plan_type(self):
"""Get plan type.
Returns:
int: Plan type.
"""
return self.plan_type
def set_plan_name(self, plan_name):
"""Set plan name.
Args:
plan_name(str): Plan name.
"""
self.plan_name = plan_name
def get_plan_name(self):
"""Get plan name.
Args:
str: Plan name.
"""
return self.plan_name
def set_plan_period(self, plan_period):
"""Set plan period.
Args:
plan_period(str): Plan period.
"""
self.plan_period = plan_period
def get_plan_period(self):
"""Get plan period.
Returns:
str: Plan period.
"""
return self.plan_period
def set_tax_group_enabled(self, tax_group_enabled):
"""Set tax group enabled.
Args:
tax_group_enabled(bool): Tax group enabled.
"""
self.tax_group_enabled = tax_group_enabled
def get_tax_group_enabled(self):
"""Get tax group enabled.
Returns:
bool: Tax group enabled.
"""
return self.tax_group_enabled
def set_account_created_date_formatted(self, account_created_date_formatted):
"""Set account created date formatted.
Args:
account_created_date_formatted(str): Account created date formatted.
"""
self.account_created_date_formatted = account_created_date_formatted
def get_account_created_date_formatted(self):
"""Get account created date formatted.
Returns:
str: Account created date formatted.
"""
return self.account_created_date_formatted
def set_zi_migration_status(self, zi_migration_status):
"""Set zi migration status.
Args:
zi_migration_status(int): Zi migration status.
"""
self.zi_migration_status = zi_migration_status
def get_zi_migration_status(self):
"""Get zi migration status .
Returns:
int: Zi migration status.
"""
return self.zi_migration_status
def set_custom_fields(self, custom_field):
"""Set custom fields.
Args:
custom_field(instance): Custom field.
"""
self.custom_fields.append(custom_field)
def get_custom_fields(self):
"""Get custom fields.
Returns:
list of instance: List of custom fields object.
"""
return self.custom_fields
def set_user_role(self, user_role):
"""Set user role.
Args:
user_role(str): User role.
"""
self.user_role = user_role
def get_user_role(self):
"""Get user role.
Returns:
str: User role.
"""
return self.user_role
def set_is_new_customer_custom_fields(self, is_new_customer_custom_fields):
"""Set whether new customer custom fields or not.
Args:
is_new_customer_custom_fields(bool): True if new customer custom fields else False.
"""
self.is_new_customer_custom_fields = is_new_customer_custom_fields
def get_is_new_customer_custom_fields(self):
"""Get whether new customer custom fields or not.
Returns:
bool: True if new customer custom fields | |
"""
Base class for the contexts as used in the paper "How to Train Your
Differentiable Filter". Contains code that is shared between all three
contexts.
"""
# this code only works with tensorflow 1
import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()
import numpy as np
import os
import csv
from differentiable_filters.contexts import base_context as base
import differentiable_filters.utils.tensorflow_compatability as compat
class PaperBaseContext(base.BaseContext):
def __init__(self, param, mode):
"""
Base class for the contexts used in the paper containing shared
functions.
Parameters
----------
param : dict
A dictionary of arguments
mode : string
determines which parts of the model are trained. Use "filter" for
the whole model, "pretrain_obs" for pretraining the observation
related functions of the context in isolation or "pretrain_proc"
for pretrainign the process-related functions of the context.
"""
super(base.BaseContext, self).__init__()
# determine the loss function
self.loss = param['loss']
self.batch_size = param['batch_size']
self.mixture_std = param['mixture_std']
self.debug = param['debug']
self.param = param
self.update_ops = []
# if we extract more than one training example from one record in the
# dataset, we need to indicate this
self.train_multiplier = 1
self.test_multiplier = 1
self.epoch_size = 1
self.mode = mode
self.scale = param['scale']
self.sl = param['sequence_length']
###########################################################################
# observation models
###########################################################################
def run_sensor_model(self, raw_observations, training):
"""
Process raw observations and return the predicted observations z
for the filter and an encoding for predicting the observation noise
Parameters
----------
raw_observations : list of tensors
Raw sensory observations
training : boolean tensor
flag that indicates if model is in training or test mode
Returns
-------
z : tensor [batch_size, dim_z]
Low-dimensional observations
enc : tensor or list of tensors
An encoding of the raw observations that can be used for predicting
heteroscedastic observation noise or the learned observation update
of the particle filter
"""
z, enc = self.sensor_model_layer(raw_observations, training)
return z, enc
def get_observation_noise(self, encoding, training):
"""
Observation noise model
Parameters
----------
encoding : ensor or list of tensors
An encoding of the raw observations that can be used for predicting
heteroscedastic observation
training : bool
training or testing?
Returns
-------
R : tensor [batch_size, dim_z, dim_z]
Observation noise covariance matrix
"""
if not self.param['learn_r']:
return tf.tile(self.R[None, :, :], [self.batch_size, 1, 1])
if self.param['hetero_r']:
if self.param['diagonal_covar']:
return self.observation_noise_hetero_diag(encoding, training)
else:
return self.observation_noise_hetero_full(encoding, training)
else:
if self.param['diagonal_covar']:
return self.observation_noise_const_diag(encoding, training)
else:
return self.observation_noise_const_full(encoding, training)
def get_observation_likelihood(self, particles, encoding, training):
"""
Learned observation update for the particle filter.
Consumes an encoding of the raw observatuions and the predicted
particles and returns the likelihood of each particle
Parameters
----------
particles : tensor [batch_size, num_particles, dim_z]
Predicted observations for the particles
encoding : tensor or list of tensors
An encoding of the raw observations
training : bool
training or testing?
Returns
-------
tf.keras.layer
A layer that predicts the likelihood of the observations under each
particle
"""
return self.likelihood_layer([particles, encoding], training)
def run_observation_model(self, state, training):
"""
Predicts the observations for a given state
Parameters
----------
state : tensor [batch_size, dim_x]
the predicted state
training : bool
training or testing?
Returns
-------
tf.keras.layer
A layer that computes the expected observations for the input
state and the Jacobian of the observation model
"""
return self.observation_model_layer(state, training)
###########################################################################
# process models
###########################################################################
def run_process_model(self, old_state, action, training):
"""
Predicts the next state given the old state and actions performed
Parameters
----------
old_state : tensor [batch_size, dim_x]
the previous state
action : tensor [batch_size, dim_u]
the performed actions
training : bool
training or testing?
Returns
-------
new_state : tensor [batch_size, dim_x]
the predicted next state
F : tensor [batch_size, dim_x, dim_x]
the jacobian of the process model
"""
if self.param['learn_process']:
new_state, F = \
self.process_model_learned_layer([old_state, action], training)
else:
new_state, F = \
self.process_model_analytical_layer([old_state, action],
training)
new_state = self.correct_state(new_state, diff=False)
return new_state, F
def get_process_noise(self, old_state, action, training):
"""
Consumes the old state and action and predicts the process
noise with the desired attributs
Parameters
----------
old_state : tensor [batch_size, dim_x]
the previous state
action : tensor [batch_size, dim_u]
the performed actions
training : bool
training or testing?
Returns
-------
tf.keras.layer
A layer that computes the desired process noise
"""
if not self.param['learn_q']:
return tf.tile(self.Q[None, :, :], [self.batch_size, 1, 1])
if self.param['learn_process']:
if self.param['hetero_q']:
if self.param['diagonal_covar']:
return self.process_noise_hetero_diag_lrn([old_state,
action],
training)
else:
return self.process_noise_hetero_full_lrn([old_state,
action],
training)
else:
if self.param['diagonal_covar']:
return self.process_noise_const_diag_lrn([old_state,
action],
training)
else:
return self.process_noise_const_full_lrn([old_state,
action],
training)
else:
if self.param['hetero_q']:
if self.param['diagonal_covar']:
return self.process_noise_hetero_diag_ana([old_state,
action],
training)
else:
return self.process_noise_hetero_full_ana([old_state,
action],
training)
else:
if self.param['diagonal_covar']:
return self.process_noise_const_diag_ana([old_state,
action],
training)
else:
return self.process_noise_const_full_ana([old_state,
action],
training)
###########################################################################
# loss functions
###########################################################################
def get_filter_loss(self, prediction, label, step, training):
"""
Compute the loss for the filtering application - defined in the context
Args:
prediction: list of predicted tensors
label: list of label tensors
step: training step
training: boolean tensor, indicates if we compute a loss for
training or testing
Returns:
loss: the total loss for training the filtering application
metrics: additional metrics we might want to log for evaluation
metric-names: the names for those metrics
"""
raise NotImplementedError("Please implement this method")
def get_observation_loss(self, prediction, label, step, training):
"""
Compute the loss for the observation functions - defined in the context
Args:
prediction: list of predicted tensors
label: list of label tensors
step: training step
training: boolean tensor, indicates if we compute a loss for
training or testing
Returns:
loss: the total loss for training the observation preprocessing
metrics: additional metrics we might want to log for evaluation
metric-names: the names for those metrics
"""
raise NotImplementedError("Please implement this method")
def get_process_loss(self, prediction, label, step, training):
"""
Compute the loss for the process functions - defined in the context
Args:
prediction: list of predicted tensors
label: list of label tensors
step: training step
training: boolean tensor, indicates if we compute a loss for
training or testing
Returns:
loss: the total loss for training the process model
metrics: additional metrics we might want to log for evaluation
metric-names: the names for those metrics
"""
raise NotImplementedError("Please implement this method")
###########################################################################
# loss functions
###########################################################################
def _mixture_likelihood(self, diffs, weights, reduce_mean=False):
"""
Compute the negative log likelihood of y under a a gaussian
mixture model defined by a set of particles and their weights.
Parameters
----------
diffs : tensor
difference between y and the states of the particles
weights : tensor
weights of the particles
reduce_mean : bool, optional
if true, return the mean likelihood loss over the complete tensor.
The default is False.
Returns
-------
likelihood : tensor
the negative log likelihood
"""
dim = compat.get_dim_int(diffs, -1)
num = compat.get_dim_int(diffs, -2)
# remove nans and infs and replace them with high values/zeros
diffs = tf.where(tf.math.is_finite(diffs), diffs,
tf.ones_like(diffs)*1e5/self.scale)
weights = tf.where(tf.math.is_finite(weights), weights,
tf.zeros_like(weights))
weights /= tf.reduce_sum(weights, axis=-1, keepdims=True)
covar = np.ones(dim, dtype=np.float32)
for k in range(dim):
covar[k] *= self.mixture_std/self.scale
covar = tf.linalg.diag(tf.square(covar))
if len(diffs.get_shape().as_list()) > 3:
sl = compat.get_dim_int(diffs, 1)
diffs = tf.reshape(diffs, [self.batch_size, -1, num, dim, 1])
covar = tf.tile(covar[None, None, None, :, :],
[self.batch_size, sl, num, 1, 1])
else:
sl = 1
diffs = tf.reshape(diffs, [self.batch_size, num, dim, 1])
covar = tf.tile(covar[None, None, :, :],
[self.batch_size, num, 1, 1])
# transfer to float 64 for higher accuracy
covar = tf.cast(covar, tf.float64)
diffs = tf.cast(diffs, tf.float64)
weights = tf.cast(weights, tf.float64)
exponent = tf.matmul(tf.matmul(tf.linalg.matrix_transpose(diffs),
tf.linalg.inv(covar)), diffs)
exponent = tf.reshape(exponent, [self.batch_size, sl, num])
normalizer = tf.math.log(tf.linalg.det(covar)) + \
tf.cast(dim * tf.log(2*np.pi), tf.float64)
log_like = -0.5 * (exponent + normalizer)
log_like = tf.reshape(log_like, [self.batch_size, sl, num])
log_like = tf.where(tf.greater_equal(log_like, -500), log_like,
tf.ones_like(log_like)*-500)
exp = tf.exp(log_like)
# the per particle likelihoods are weighted and summed in the particle
# dimension
weighted = weights * exp
weighted = tf.reduce_sum(weighted, axis=-1)
# compute the negative logarithm and undo the bias
likelihood = - (tf.math.log(tf.maximum(weighted, 1e-300)))
if reduce_mean:
likelihood = tf.reduce_mean(likelihood)
likelihood = tf.cast(likelihood, tf.float32)
return likelihood
######################################
# Evaluation
######################################
def save_log(self, log_dict, out_dir, step, num=0, mode='filter'):
"""
A helper to save the results of testing a filter on a a given problem.
Parameters
----------
log_dict : dict
dictionary of the losses that should be | |
<filename>python/webgme_bindings/webgme_bindings/test.py<gh_stars>0
"""
To run with coverage first:
pip install coverage
Then from <rootDir>/python/webgme_bindings:
coverage run -m unittest discover -s <rootDir>/python/webgme_bindings/webgme_bindings -p test.py -t <rootDir>/python/webgme_bindings
coverage html
coverage run -m unittest discover -s C:/Users/patrik85/GIT/webgme-core-bindings/python/webgme_bindings/webgme_bindings -p test.py -t C:/Users/patrik85/GIT/webgme-core-bindings/python/webgme_bindings
"""
import unittest
import os
import signal
import subprocess
import time
import logging
from .webgme import WebGME
from .exceptions import JSError, CoreIllegalArgumentError, CoreIllegalOperationError
from .pluginbase import PluginBase
logger = logging.getLogger('test-logger')
logger.setLevel(logging.ERROR)
# Stuff needed for calling webgme from nodejs
WEBGME_IMPORT_BIN = 'node_modules/webgme-engine/src/bin/import.js'
SEED_FILE = 'node_modules/webgme-engine/seeds/EmptyProject.webgmex'
TEST_PROJECT = 'PythonTestProject'
PORT = '5555'
dir_path = os.path.dirname(os.path.realpath(__file__))
root_dir = os.path.join(dir_path, '..', '..', '..')
my_env = os.environ.copy()
my_env['NODE_ENV'] = 'test'
COREZMQ_SERVER_FILE = os.path.join(root_dir, 'bin', 'corezmq_server.js')
def node_dict_sort(n_dict):
return n_dict['nodePath']
class ConnectedTestClass(unittest.TestCase):
def setUp(self):
if 'DO_NOT_START_SERVER' in my_env:
self.node_process = None
else:
self.node_process = subprocess.Popen(['node', COREZMQ_SERVER_FILE, TEST_PROJECT, '-p', PORT],
env=my_env, cwd=root_dir)
self.webgme = WebGME(PORT, logger)
self.project = self.webgme.project
self.core = self.webgme.core
self.util = self.webgme.util
def tearDown(self):
self.webgme.disconnect()
if self.node_process is not None:
self.node_process.send_signal(signal.SIGTERM)
# class ProjectTests(object):
class ProjectTests(ConnectedTestClass):
def test_constants(self):
const = self.project.CONSTANTS
self.assertTrue(const['COMMIT_TYPE'] == 'commit')
const2 = self.project.CONSTANTS
self.assertTrue(const is const2) # Referencing the same object
def test_metadata_related(self):
self.assertEqual(self.project.get_user_id(), 'guest')
p_info = self.project.get_project_info()
self.assertEqual(p_info['owner'], 'guest')
self.assertEqual(p_info['_id'], 'guest+{0}'.format(TEST_PROJECT))
self.assertTrue('info' in p_info)
self.assertTrue('branches' in p_info)
self.assertTrue('rights' in p_info)
self.assertTrue('hooks' in p_info)
def test_commit_related(self):
branch_hash = self.project.get_branch_hash('master')
root_hash = self.project.get_root_hash('master')
commit_obj = self.project.get_commit_object('master')
self.assertTrue('_id' in commit_obj)
self.assertTrue('time' in commit_obj)
self.assertTrue('updater' in commit_obj)
self.assertTrue('parents' in commit_obj)
self.assertTrue('message' in commit_obj)
self.assertEqual(commit_obj['_id'], branch_hash)
self.assertEqual(commit_obj['root'], root_hash)
c_res1 = self.project.make_commit(None, [branch_hash], root_hash, {}, 'commit1')
c_res2 = self.project.make_commit(None, [branch_hash], root_hash, {}, 'commit2')
common = self.project.get_common_ancestor_commit(c_res1['hash'], c_res2['hash'])
self.assertEqual(common, branch_hash)
hist = self.project.get_history(c_res1['hash'], 100)
self.assertEqual(len(hist), 2)
time_ms = int(time.time() * 1000)
hist = self.project.get_commits(time_ms, 100)
self.assertTrue(len(hist) > 2)
hist = self.project.get_history([c_res1['hash'], c_res2['hash']], 100)
self.assertEqual(len(hist), 3)
def test_branch_related(self):
init_branches = self.project.get_branches()
self.assertEqual(len(init_branches.keys()), 1)
self.assertEqual(list(init_branches.keys())[0], 'master')
branch_hash = self.project.get_branch_hash('master')
self.assertEqual(init_branches['master'], branch_hash)
self.project.create_branch('new_branch', branch_hash)
res = self.project.create_branch('new_branch2', branch_hash)
self.assertEqual(res['hash'], branch_hash)
self.assertEqual(len(self.project.get_branches().keys()), 3)
root_hash = self.project.get_root_hash('new_branch')
res = self.project.make_commit('new_branch', [branch_hash], root_hash, {}, 'Test commit')
self.project.set_branch_hash('new_branch2', res['hash'], branch_hash)
self.assertDictEqual(self.project.get_branches(), {'new_branch': res['hash'],
'new_branch2': res['hash'],
'master': branch_hash,
})
self.project.delete_branch('new_branch', branch_hash)
res = self.project.delete_branch('new_branch2', branch_hash)
self.assertEqual(res['hash'], '')
self.assertEqual(len(self.project.get_branches().keys()), 1)
def test_tag_related(self):
init_tags = self.project.get_tags()
self.assertEqual(len(init_tags.keys()), 0)
branch_hash = self.project.get_branch_hash('master')
self.project.create_tag('tage', branch_hash)
self.project.create_tag('tage2', branch_hash)
self.assertDictEqual(self.project.get_tags(), {'tage': branch_hash,
'tage2': branch_hash,
})
self.project.delete_tag('tage')
self.project.delete_tag('tage2')
self.assertDictEqual(self.project.get_tags(), {})
def test_exceptions(self):
# All should throw JSError
self.assertRaises(JSError, self.project.create_branch, 1, 1)
self.assertRaises(JSError, self.project.create_tag, 1, 1)
self.assertRaises(JSError, self.project.delete_branch, 1, 1)
self.assertRaises(JSError, self.project.delete_tag, 1)
self.assertRaises(JSError, self.project.get_branch_hash, 1)
# self.assertRaises(JSError, self.project.get_branches)
self.assertRaises(JSError, self.project.get_commit_object, 1)
self.assertRaises(JSError, self.project.get_commits, 'Herro', 1)
self.assertRaises(JSError, self.project.get_common_ancestor_commit, 1, 1)
self.assertRaises(JSError, self.project.get_history, 1, 1)
# self.assertRaises(JSError, self.project.get_project_info)
self.assertRaises(JSError, self.project.get_root_hash, 1)
# self.assertRaises(JSError, self.project.get_tags)
# self.assertRaises(JSError, self.project.get_user_id)
self.assertRaises(JSError, self.project.make_commit, 1, 1, 1, 1, 1)
self.assertRaises(JSError, self.project.set_branch_hash, 1, 1, 1)
# class CoreTests(object):
class CoreTests(ConnectedTestClass):
def equal(self, node1, node2):
return self.util.equal(node1, node2)
def setUp(self):
super(CoreTests, self).setUp()
root_hash = self.project.get_root_hash('master')
self.root = self.core.load_root(root_hash)
self.fco = self.core.get_fco(self.root)
self.child = self.core.create_child(self.root, self.fco)
self.core.set_attribute(self.child, 'name', 'child')
self.child2 = self.core.create_child(self.root, self.fco)
self.core.set_attribute(self.child2, 'name', 'child2')
self.child_instance = self.core.create_child(self.root, self.child)
self.core.set_attribute(self.child_instance, 'name', 'child_instance')
def tearDown(self):
self.util.unload_root(self.root)
super(CoreTests, self).tearDown()
# @unittest.skip("Temp")
def test_constants(self):
const = self.core.CONSTANTS
self.assertTrue(const['META_SET_NAME'] == 'MetaAspectSet')
const2 = self.core.CONSTANTS
self.assertTrue(const is const2) # Referencing the same object
# @unittest.skip("Temp")
def test_load_by_path(self):
node = self.core.load_by_path(self.root, self.core.get_path(self.child))
self.assertTrue(self.equal(node, self.child))
# @unittest.skip("Temp")
def test_basic_properties(self):
self.core.set_attribute(self.child, 'intAttr', 1)
self.core.set_attribute(self.child, 'floatAttr', 1.1)
self.core.set_attribute(self.child, 'boolAttr', True)
self.core.set_attribute(self.child_instance, 'boolAttr', False)
self.core.set_registry(self.child, 'intReg', 1)
self.core.set_registry(self.child, 'floatReg', 1.1)
self.core.set_registry(self.child, 'boolReg', True)
self.core.set_registry(self.child_instance, 'boolReg', False)
# General properties
relid = self.core.get_relid(self.child)
self.assertEqual(self.core.get_path(self.child), '/{0}'.format(relid))
self.assertEqual(len(self.core.get_guid(self.child)), 36)
self.assertEqual(len(self.core.get_hash(self.fco)), 41)
self.assertFalse(self.core.is_abstract(self.child))
self.assertFalse(self.core.is_connection(self.child))
# Attributes
self.assertEqual(self.core.get_attribute(self.child, 'name'), 'child')
self.assertEqual(self.core.get_attribute(self.child_instance, 'intAttr'), 1)
self.assertEqual(self.core.get_attribute(self.child_instance, 'floatAttr'), 1.1)
self.assertEqual(self.core.get_attribute(self.child_instance, 'boolAttr'), False)
self.assertEqual(self.core.get_own_attribute(self.child_instance, 'intAttr'), None)
attrs = self.core.get_attribute_names(self.child_instance)
own_attrs = self.core.get_own_attribute_names(self.child_instance)
valid_attrs = self.core.get_valid_attribute_names(self.child_instance)
own_valid_attrs = self.core.get_own_valid_attribute_names(self.child_instance)
self.assertEqual(len(attrs), 4)
self.assertEqual(len(own_attrs), 2)
self.assertEqual(len(valid_attrs), 1)
self.assertEqual(len(own_valid_attrs), 0)
self.core.del_attribute(self.child_instance, 'boolAttr')
self.assertEqual(len(self.core.get_own_attribute_names(self.child_instance)), 1)
self.core.rename_attribute(self.child, 'intAttr', 'intAttrNew')
self.assertEqual(self.core.get_attribute(self.child_instance, 'intAttrNew'), 1)
self.assertEqual(self.core.get_registry(self.child_instance, 'intAttr'), None)
# Registry
self.assertEqual(self.core.get_registry(self.child_instance, 'intReg'), 1)
self.assertEqual(self.core.get_registry(self.child_instance, 'floatReg'), 1.1)
self.assertEqual(self.core.get_registry(self.child_instance, 'boolReg'), False)
self.assertEqual(self.core.get_own_registry(self.child_instance, 'intReg'), None)
regs = self.core.get_registry_names(self.child_instance)
own_regs = self.core.get_own_registry_names(self.child_instance)
self.assertEqual(len(regs), 5)
self.assertEqual(len(own_regs), 1)
self.core.del_registry(self.child_instance, 'boolReg')
self.assertEqual(len(self.core.get_own_registry_names(self.child_instance)), 0)
self.core.rename_registry(self.child, 'intReg', 'intRegNew')
self.assertEqual(self.core.get_registry(self.child_instance, 'intRegNew'), 1)
self.assertEqual(self.core.get_registry(self.child_instance, 'intReg'), None)
# @unittest.skip("Temp")
def test_node_creation_deletion(self):
self.assertEqual(len(self.core.load_children(self.child_instance)), 0)
new_child = self.core.create_child(self.child_instance, self.fco)
self.assertEqual(len(self.core.load_children(self.child_instance)), 1)
new_child2 = self.core.copy_node(new_child, self.child_instance)
self.assertEqual(len(self.core.load_children(self.child_instance)), 2)
new_child3 = self.core.create_node({'parent': self.child_instance, 'base': self.fco})
self.assertEqual(len(self.core.load_children(self.child_instance)), 3)
new_children = self.core.copy_nodes([new_child, new_child2], self.child_instance)
self.assertEqual(len(self.core.load_children(self.child_instance)), 5)
self.core.delete_node(new_child)
self.core.delete_node(new_child2)
self.core.delete_node(new_child3)
self.assertEqual(len(self.core.load_children(self.child_instance)), 2)
self.core.move_node(new_children[0], self.child2)
self.core.move_node(new_children[1], self.child2)
self.assertEqual(len(self.core.load_children(self.child_instance)), 0)
self.assertEqual(len(self.core.load_children(self.child2)), 2)
# @unittest.skip("Temp")
def test_child_parent_related(self):
self.assertEqual(self.core.get_parent(self.root), None)
self.assertTrue(self.equal(self.core.get_root(self.fco), self.root))
children = self.core.load_children(self.root)
own_children = self.core.load_own_children(self.root)
child_paths = self.core.get_children_paths(self.root)
own_child_paths = self.core.get_own_children_paths(self.root)
child_relids = self.core.get_children_relids(self.root)
own_child_relids = self.core.get_own_children_relids(self.root)
tree_nodes = self.core.load_sub_tree(self.root)
own_tree_nodes = self.core.load_own_sub_tree(self.root)
self.assertEqual(len(children), 4)
self.assertEqual(len(children), len(child_paths))
self.assertEqual(len(children), len(child_relids))
self.assertEqual(len(children), len(tree_nodes) - 1) # root included in tree
children.sort(key=node_dict_sort)
own_children.sort(key=node_dict_sort)
child_paths.sort()
own_child_paths.sort()
child_relids.sort()
own_child_relids.sort()
tree_nodes.sort(key=node_dict_sort)
own_tree_nodes.sort(key=node_dict_sort)
self.assertEqual(children, own_children)
self.assertEqual(own_child_paths, child_paths)
self.assertEqual(own_child_relids, child_relids)
self.assertEqual(tree_nodes, own_tree_nodes)
name_to_child = {}
for child in children:
rel_id = self.core.get_relid(child)
self.assertTrue(self.util.equal(self.core.load_child(self.root, rel_id), child))
name_to_child[self.core.get_attribute(child, 'name')] = child
self.assertTrue(self.util.equal(self.core.get_parent(child), self.root))
def_info = self.core.get_child_definition_info(self.root, child)
self.assertTrue(self.util.equal(def_info['ownerNode'], self.root))
self.assertTrue(self.util.equal(def_info['targetNode'], self.fco))
self.assertEqual(len(name_to_child.keys()), 4)
self.assertEqual(len(self.core.get_children_hashes(self.root).keys()), 4)
self.assertTrue(self.equal(self.core.get_common_parent(children), self.root))
self.assertEqual(self.core.get_common_parent([children[0]]), self.root)
self.assertEqual(self.core.get_common_parent([self.root]), None)
self.assertTrue(self.core.is_valid_new_parent(self.child2, self.child))
self.assertFalse(self.core.is_valid_new_parent(self.child2, self.fco))
self.assertTrue(self.core.is_valid_new_child(self.child2, self.child))
self.assertFalse(self.core.is_valid_new_child(self.fco, self.fco))
# @unittest.skip("Temp")
def test_instance_base_related(self):
self.assertEqual(self.core.get_base(self.fco), None)
self.assertEqual(self.core.get_type_root(self.fco), None)
self.assertTrue(self.equal(self.core.get_type_root(self.child), self.fco))
self.assertTrue(self.equal(self.core.get_base(self.child_instance), self.child))
instances = self.core.load_instances(self.child)
instance_paths = self.core.get_instance_paths(self.child)
self.assertEqual(len(instances), 1)
self.assertEqual(len(instance_paths), 1)
self.assertEqual(instance_paths[0], self.core.get_path(self.child_instance))
self.assertTrue(self.equal(instances[0], self.child_instance))
self.assertTrue(self.core.is_instance_of(self.child_instance, self.child))
self.assertTrue(self.core.is_type_of(self.child_instance, self.child))
self.assertTrue(self.core.is_instance_of(self.child_instance, self.core.get_path(self.child)))
self.assertTrue(self.core.is_type_of(self.child_instance, self.core.get_path(self.child)))
self.assertFalse(self.core.is_instance_of(self.child, self.child_instance))
self.assertFalse(self.core.is_type_of(self.child, self.child_instance))
self.assertTrue(self.equal(self.fco, self.core.get_base_root(self.child_instance)))
self.assertTrue(self.equal(self.fco, self.core.get_base_type(self.child_instance)))
self.assertTrue(self.equal(self.fco, self.core.get_meta_type(self.child_instance)))
self.assertTrue(self.equal(self.core.get_base_root(self.root), self.root))
self.assertEqual(self.core.get_base_type(self.root), None)
self.assertEqual(self.core.get_meta_type(self.root), None)
fco_instances = self.core.load_instances(self.fco)
self.assertTrue(self.equal(self.core.get_common_base(fco_instances), self.fco))
self.assertEqual(self.core.get_common_base([self.root, self.fco]), None)
self.assertEqual(self.core.get_common_base([self.fco]), None)
base_types = self.core.get_base_types(self.child)
self.assertEqual(len(base_types), 1)
self.assertTrue(self.equal(base_types[0], self.fco))
self.assertTrue(self.core.is_valid_new_base(self.child_instance, self.child2))
self.assertFalse(self.core.is_valid_new_base(self.child, self.child_instance))
self.core.set_base(self.child_instance, self.child2)
self.assertTrue(self.equal(self.core.get_base(self.child_instance), self.child2))
# @unittest.skip("Temp")
def test_pointer_related(self):
self.core.set_pointer(self.child, 'ptr', self.fco)
ptr_target = self.core.load_pointer(self.child_instance, 'ptr')
ptr_path = self.core.get_pointer_path(self.child_instance, 'ptr')
self.assertTrue(self.core.get_path(ptr_target), ptr_path)
self.assertEqual(self.core.get_own_pointer_path(self.child_instance, 'ptr'), None)
ptr_names = self.core.get_pointer_names(self.child_instance)
own_ptr_names = self.core.get_own_pointer_names(self.child_instance)
self.assertEqual(len(ptr_names), 2)
ptr_names.sort()
own_ptr_names.sort()
self.assertEqual(len(ptr_names), 2)
self.assertEqual(len(own_ptr_names), 1)
self.assertEqual(ptr_names[0], own_ptr_names[0])
coll_names = self.core.get_collection_names(self.fco)
self.assertEqual(len(coll_names), 2)
coll_names.sort()
self.assertEqual(coll_names, ['base', 'ptr'])
coll = self.core.load_collection(self.fco, 'ptr')
coll_paths = self.core.get_collection_paths(self.fco, 'ptr')
self.assertEqual(len(coll), 1)
self.assertEqual(len(coll_paths), 1)
self.assertEqual(self.core.get_path(coll[0]), coll_paths[0])
self.core.rename_pointer(self.child, 'ptr', 'new_ptr')
self.assertEqual(self.core.load_pointer(self.child, 'ptr'), None)
self.assertTrue(self.equal(self.core.load_pointer(self.child, 'new_ptr'), self.fco))
self.core.del_pointer(self.child, 'new_ptr')
self.assertEqual(self.core.load_pointer(self.child, 'new_ptr'), None)
self.core.set_pointer(self.child, 'ptr', self.fco)
self.assertTrue(self.equal(self.core.load_pointer(self.child, 'ptr'), self.fco))
self.core.delete_pointer(self.child, 'ptr')
self.assertEqual(self.core.load_pointer(self.child, 'ptr'), None)
# @unittest.skip("Temp")
def test_set_related(self):
self.core.create_set(self.child, 'set')
self.core.add_member(self.child, 'set', self.child2)
members = self.core.load_members(self.child_instance, 'set')
own_members = self.core.load_own_members(self.child_instance, 'set')
member_paths = self.core.get_member_paths(self.child_instance, 'set')
own_member_paths = self.core.get_own_member_paths(self.child_instance, 'set')
self.assertEqual(len(members), 1)
self.assertEqual(len(own_members), 0)
self.assertEqual(len(own_member_paths), 0)
self.assertEqual([self.core.get_path(members[0])], member_paths)
# Set attrs and regs
self.core.set_set_attribute(self.child, 'set', 'attr', 'val')
self.assertEqual(self.core.get_set_attribute_names(self.child_instance, 'set'), ['attr'])
self.assertEqual(self.core.get_own_set_attribute_names(self.child_instance, 'set'), [])
self.assertEqual(self.core.get_set_attribute(self.child_instance, 'set', 'attr'), 'val')
self.assertEqual(self.core.get_own_set_attribute(self.child_instance, 'set', 'attr'), None)
self.core.del_set_attribute(self.child, 'set', 'attr')
self.assertEqual(self.core.get_set_attribute(self.child_instance, 'set', 'attr'), None)
self.core.set_set_registry(self.child, 'set', 'reg', 'val')
self.assertEqual(self.core.get_set_registry_names(self.child_instance, 'set'), ['reg'])
self.assertEqual(self.core.get_own_set_registry_names(self.child_instance, 'set'), [])
self.assertEqual(self.core.get_set_registry(self.child_instance, 'set', 'reg'), 'val')
self.assertEqual(self.core.get_own_set_registry(self.child_instance, 'set', 'reg'), None)
self.core.del_set_registry(self.child, 'set', 'reg')
self.assertEqual(self.core.get_set_registry(self.child_instance, 'set', 'reg'), None)
# Set-member attrs and regs
p = member_paths[0]
self.core.set_member_attribute(self.child, 'set', p, 'attr', 'val')
self.assertEqual(self.core.get_member_attribute_names(self.child_instance, 'set', p), ['attr'])
self.assertEqual(self.core.get_member_own_attribute_names(self.child_instance, 'set', p), [])
self.assertEqual(self.core.get_member_attribute(self.child_instance, 'set', p, 'attr'), 'val')
self.assertEqual(self.core.get_member_own_attribute(self.child_instance, 'set', p, 'attr'), None)
self.core.del_member_attribute(self.child, 'set', p, 'attr')
self.assertEqual(self.core.get_member_attribute(self.child_instance, 'set', p, 'attr'), None)
self.core.set_member_registry(self.child, 'set', p, 'reg', 'val')
self.assertEqual(self.core.get_member_registry_names(self.child_instance, 'set', p), ['reg'])
self.assertEqual(self.core.get_member_own_registry_names(self.child_instance, 'set', p), [])
self.assertEqual(self.core.get_member_registry(self.child_instance, 'set', p, 'reg'), 'val')
self.assertEqual(self.core.get_member_own_registry(self.child_instance, 'set', p, 'reg'), None)
self.core.del_member_registry(self.child, 'set', p, 'reg')
self.assertEqual(self.core.get_member_registry(self.child_instance, 'set', p, 'reg'), None)
# Renaming, deletions etc.
self.core.rename_set(self.child, 'set', 'newSet')
self.assertEqual(self.core.get_set_names(self.child_instance), ['newSet'])
self.assertEqual(self.core.get_own_set_names(self.child_instance), [])
self.core.del_member(self.child, 'newSet', p)
self.assertEqual(self.core.load_members(self.child, 'newSet'), [])
self.core.del_set(self.child, 'newSet')
self.assertEqual(self.core.get_set_names(self.child), [])
self.core.create_set(self.child, 'set')
self.core.create_set(self.child, 'set2')
self.core.add_member(self.child, 'set', self.child2)
self.assertEqual(self.core.get_set_names(self.child), ['set', 'set2'])
self.assertEqual(self.core.get_member_paths(self.child, 'set'), [p])
self.assertEqual(self.core.get_member_paths(self.child, 'set2'), [])
self.core.move_member(self.child, p, 'set', 'set2')
# TODO: Should move_member delete the set when its the last member?
# self.assertEqual(self.core.get_member_paths(self.child, 'set'), [])
self.assertEqual(self.core.get_member_paths(self.child, 'set2'), [p])
self.core.delete_set(self.child, 'set')
self.core.delete_set(self.child, 'set2')
self.assertEqual(self.core.get_set_names(self.child), [])
# @unittest.skip("Temp")
def test_meta_and_mixin_related(self):
p = self.core.get_path(self.child)
p2 = self.core.get_path(self.child2)
self.assertFalse(self.core.is_meta_node(self.child))
self.core.add_member(self.root, 'MetaAspectSet', self.child)
self.core.add_member(self.root, 'MetaAspectSet', self.child2)
self.core.add_mixin(self.child, self.core.get_path(self.child2))
self.assertTrue(self.core.is_meta_node(self.child))
all_meta_nodes = self.core.get_all_meta_nodes(self.root)
meta_nodes_paths = [p, p2]
meta_nodes_paths.sort()
self.assertEqual(len(list(all_meta_nodes.keys())), 3)
self.assertTrue(self.equal(self.core.get_meta_type(self.child_instance), self.child))
self.assertTrue(self.equal(self.core.get_base_type(self.child_instance), self.child))
base_types = list(map(lambda b: self.core.get_path(b), self.core.get_base_types(self.child_instance)))
base_types.sort()
self.assertEqual(base_types, meta_nodes_paths)
# Containment
self.core.set_child_meta(self.child, self.child2)
child_meta = self.core.get_children_meta(self.child)
self.assertEqual(len(list(child_meta.keys())), 1)
self.assertEqual(child_meta[p2], {'max': -1, 'min': -1})
self.assertTrue(self.core.is_valid_child_of(self.child2, self.child))
self.assertEqual(self.core.get_valid_children_paths(self.child), child_meta.keys())
child_info = self.core.get_child_definition_info(self.child_instance, self.child2)
self.assertTrue(self.equal(child_info['ownerNode'], self.child))
self.assertTrue(self.equal(child_info['targetNode'], self.child2))
valid_children = self.core.get_valid_children_meta_nodes({'node': self.child_instance})
self.assertEqual(len(valid_children), 2)
valid_children = list(map(lambda c: self.core.get_path(c), valid_children))
valid_children.sort()
self.assertEqual(valid_children, meta_nodes_paths)
self.core.set_children_meta_limits(self.child, 1, 2)
child_meta = self.core.get_children_meta(self.child)
self.assertEqual(len(list(child_meta.keys())), 3)
self.assertEqual(child_meta[p2], {'max': -1, 'min': -1})
self.assertEqual(child_meta['min'], 1)
self.assertEqual(child_meta['max'], 2)
# Attributes
self.assertEqual(self.core.get_valid_attribute_names(self.child_instance), ['name'])
self.core.set_attribute_meta(self.child, 'attr', {'type': 'string', 'default': 'val'})
self.assertEqual(len(self.core.get_valid_attribute_names(self.child_instance)), 2)
self.assertEqual(self.core.get_own_valid_attribute_names(self.child_instance), [])
self.assertTrue(self.core.is_valid_attribute_value_of(self.child_instance, 'attr', 'aString'))
self.assertFalse(self.core.is_valid_attribute_value_of(self.child_instance, 'attr', 1))
self.assertTrue(self.equal(self.core.get_attribute_definition_owner(self.child_instance, 'attr'), self.child))
self.core.rename_attribute_meta(self.child, 'attr', 'newAttr')
self.assertEqual(self.core.get_own_valid_attribute_names(self.child), ['newAttr'])
attr_meta = self.core.get_attribute_meta(self.child, 'newAttr')
self.assertEqual(attr_meta, {'type': 'string'})
# Pointers
self.core.set_pointer_meta_target(self.child, 'ptr', | |
# -*- coding: utf-8 -*-
''' Some Tools for Pip-In - Verbose Documentation '''
# ##################################################################################
# MG ILLUMINATION #
# First Crazy Debroussailleur : jDepoortere #
# Author : cPOTTIER #
# Last Update : 27-06-2016 #
# ##################################################################################
#================================================================================================================================== PRIMARY CLASS
import sys, ink.proto
path_modules = '/u/'+ink.io.ConnectUserInfo()[2]+'/Users/COM/InK/Scripts/Python/proj/pipe/ink/exemples'
sys.path.append(path_modules)
if '__InK__connect' in sys.modules:
del(sys.modules["__InK__connect"])
import __InK__connect
from __InK__connect import *
else:
import __InK__connect
from __InK__connect import *
#==================================================================================================================== Ink external useful CLASSES
__PIPEIN_GRAPH = __InK__connect.__PIPEIN_GRAPH__(graphs.DEFAULT, None) # protograph, verbose mode
#================================================================================================================================================
# =========================================================================================================================== AK02_LAYOUT_BuildCameraModel
def AK02_LAYOUT_BuildCameraModel(autoload='True',autosave='True',save_private='False',cat='MAIN',all_cats='True',_cat=None):
'''
| /
| \ Tool - Last update 27-06-2016
----------------------------------------------------------------------
- Organize MODEL Context Layout
- autosave graphs in :
MODELING/CHARS/MODTECH/
-> M_MAIN.inkGraph
-> M_SECONDARY.inkGraph
-> M_TERTIARY.inkGraph
- Auto Execution or Select CAMERA-Actor_ModChars-Ok.a7
----------------------------------------------------------------------
todo :
- release gestion filters = None
- r&d : check len name for ecart auto optimal
'''
# PARAMS MODIFIABLES ############################################################################################
A7refPos_X = None # X origin a7 ref - None for not Used
A7refPos_Y = None # Y origin a7 ref - None for not Used
offset_X = 6 # 4 # relative to X origin a7 ref - can be negative
offset_Y = 3 # 0 # relative to Y origin a7 ref - can be negative
ecart_a7_X = 'Auto' # 3 # X space between streams a7 , if = 'Auto', space depends of A7 name longer
ecart_a7_Y = None # 2 # Y space between streams a7
n_A7_perColumn = None # 6 # max n streams vertically
n_A7_perRow = None # 6 # max n streams horizontally - None for not Used
X_space_betweenColumns = 2
quinconce = None # True False # boolean, decale les a7 une fois sur 2
quinconce_X = None # 0.5 # x offset, 0.5/-0.5 left-right, min max
quinconce_start = None # 0 # switch first quinconce_X value to modulo 0.5 to -0.5
n_col_byGroup = None # 2 # n column by a7 grouped
X_space_betweenGroup = 2 # ecart_a7_X*2 # subjectif, to do better in relation with n assets, n group etc
n_groups_grouded = None # todo paquet de groups - None for not Used
# DONT TOUCH ###################################################################################################
params = {}
if A7refPos_X != None :
params['A7refPos_X'] = A7refPos_X
if A7refPos_Y != None :
params['A7refPos_Y'] = A7refPos_Y
if offset_X != None :
params['offset_X'] = offset_X
if offset_Y != None :
params['offset_Y'] = offset_Y
if ecart_a7_X != None :
params['ecart_a7_X'] = ecart_a7_X
if ecart_a7_Y != None :
params['ecart_a7_Y'] = ecart_a7_Y
if n_A7_perColumn != None :
params['n_A7_perColumn'] = n_A7_perColumn
if n_A7_perRow != None :
params['n_A7_perRow'] = n_A7_perRow
if X_space_betweenColumns != None :
params['X_space_betweenColumns'] = X_space_betweenColumns
if quinconce != None :
params['quinconce'] = quinconce
if quinconce_X != None :
params['quinconce_X'] = quinconce_X
if quinconce_start != None :
params['quinconce_start'] = quinconce_start
if n_col_byGroup != None :
params['n_col_byGroup'] = n_col_byGroup
if X_space_betweenGroup != None :
params['X_space_betweenGroup'] = X_space_betweenGroup
if n_groups_grouded != None :
params['n_groups_grouded'] = n_groups_grouded
#=========
autoLoadA7ref = False
if autoload == 'True':
autoLoadA7ref = True # in 2 variables because this script can be call external
# Functions ###################################################################################################
def showStream(protoGraph,assetProto,typeStreams,catFamily,A7posRef=None):
''' show a7 streams '''
A7pos = None
Filters = {'type': ['Model']}
family = ['CHARS']
family.append(catFamily[0])
Filters['family'] = family
# Filters = {'family': ['CHARS', 'MAIN'] , 'type': ['Model']} # Ordre Important pour family filters 1-CHARS 2-MAIN etc
StreamProtoList = __PIPEIN_GRAPH.GetStreams(typeStreams,protoGraph,layout,assetProto,Filters)
return StreamProtoList
# End Functions ################################################################################################
#=========
cat_array = []
catFamily = [] # for external request
if _cat != None :
cat = _cat[0]
for a in _catFamily:
catFamily.append(a)
if _cat == None :
catFamily.append(cat)
cat = cat
cat_array.append(cat)
if all_cats == 'True':
cat_array = ['MAIN', 'SECONDARY', 'TERTIARY']
for cat_in_Array in cat_array:
A7R = 'CAMERA-Actor_ModChars-Ok.a7'
A7RefPath = 'LIB/CAMERAS/CAMERA/Ok/'+A7R
myG = 'M_'+cat_in_Array+'.inkGraph'
myGraph = 'MODELING/CHARS/MODTECH/'+myG
myGraphLocal = LOCALPATH+'M_'+cat_in_Array+'.inkGraph' # for debug
catFamily = []
catFamily.append(cat_in_Array)
#======================================================================
#========= Declare protograph
#======================================================================
protoGraph = ink.proto.Graph( graphs.DEFAULT )
layout = protoGraph.GetLayout()
#======================================================================
#========= Add Get Ref A7
#======================================================================
if autoLoadA7ref == True:
__PIPEIN_GRAPH.add_A7('dirPath',A7RefPath,True) # _type, A7(str,list,dic), A7Select[optional], A7position[optional]
protoGraph.Show()
protoGraph.Apply()
protoGraph.SelectAll()
if autoLoadA7ref == False:
layout = protoGraph.GetLayout()
selection = protoGraph.GetSelection()
if not selection:
raise Exception('Please select '+A7R+' !')
#======================================================================
#========= Get Selection and move to center graph
#======================================================================
layout = protoGraph.GetLayout()
selection = protoGraph.GetSelection()
layout.SetPos(A7RefPath, (0,0) )
protoGraph.Show()
protoGraph.Apply()
protoGraph.SelectAll()
#======================================================================
#========= Retrieve ref.a7 Pos
#======================================================================
for pa in selection:
A7_infos = __PIPEIN_GRAPH.getA7_infos(pa)
nm_asset = A7_infos['nm_asset']
a_types = A7_infos['a_types']
if str(pa) == str(A7RefPath):
ProtoA7 = pa
#======================================================================
#========= get Refa7 position
#======================================================================
A7refPos = __PIPEIN_GRAPH.getPosition(pa,layout)
#======================================================================
#========= show a7 Downstreams
#======================================================================
StreamProtoList = showStream(protoGraph,ProtoA7,'GetDownstreams',catFamily)
#========= apply and refresh graph
protoGraph.Show()
protoGraph.Apply()
protoGraph.SelectAll()
#======================================================================
#========= set position .a7 Downstreams
#======================================================================
#========= R&D for auto-ecart, check longest name for ecart optimal
if str(ecart_a7_X).upper() == 'AUTO':
params = __PIPEIN_GRAPH.get_autoEcart_X(StreamProtoList,params)
#========= set position .a7 Downstreams
n_streams = len(StreamProtoList)
__PIPEIN_GRAPH.move_StreamProtoList(n_streams,StreamProtoList,layout,A7refPos,params)
#========= apply and refresh graph
protoGraph.Show()
#========= save Graph
if str(save_private) == 'True':
myGraph = myGraphLocal
if str(autosave) == 'True' and str(save_private) == 'True':
# __PIPEIN_GRAPH.SaveGraph(myGraph) # to do , to debug
protoGraph.Write(myG, private=True)
print '[ OK ] ' + myG + ' have been saved -> ' + myGraph
if str(autosave) == 'True' and str(save_private) == 'False':
# __PIPEIN_GRAPH.SaveGraph(myGraph) # to do , to debug
protoGraph.Write(str(myGraph), private=False)
print '[ OK ] ' + myG + ' have been saved -> ' + myGraph
if str(autosave) == 'False':
print '[ OK ] You can save : ' + myG
# #=========================== UI
AK02_LAYOUT_BuildCameraModel.__category__ = 'A - PIPE-IN TOOLZ'
AK02_LAYOUT_BuildCameraModel.__author__ = 'cpottier'
AK02_LAYOUT_BuildCameraModel.__textColor__ = '#6699ff'
AK02_LAYOUT_BuildCameraModel.__paramsType__ = {
'autoload' : ( 'bool', 'True' , ['True', 'False'] ),
'autosave' : ( 'bool', 'True' , ['True', 'False'] ),
'save_private' : ( 'bool', 'False' , ['True', 'False'] ),
'cat' : ( 'enum', 'MAIN',['MAIN', 'SECONDARY', 'TERTIARY'] ),
'all_cats' : ( 'bool', 'True' , ['True', 'False'] )
}
def AK03_LAYOUT_BuildHumanShape(autoload='True',autosave='True',save_private='False',cat='MAIN',all_cats='True',_cat=None):
'''
| /
| \ Tool - Last update 27-06-2016
----------------------------------------------------------------------
- Organize FACIAL Context Layout
- autosave graphs in :
MODELING/CHARS/MODTECH/
-> F_MAIN.inkGraph
-> F_SECONDARY.inkGraph
-> F_TERTIARY.inkGraph
- Auto Execution or Select Human-Shape_BcsTpl.a7
----------------------------------------------------------------------
todo :
- release gestion Filters = None
- r&d : check len name for ecart auto optimal
'''
# PARAMS MODIFIABLES ############################################################################################
A7refPos_X = None # X origin a7 ref - None for not Used
A7refPos_Y = None # Y origin a7 ref - None for not Used
offset_X = 8 # 4 # relative to X origin a7 ref - can be negative
offset_Y = 3 # 0 # relative to Y origin a7 ref - can be negative
ecart_a7_X = 'Auto' # 3 # X space between streams a7 , if = 'Auto', space depends of A7 name longer
ecart_a7_Y = None # 2 # Y space between streams a7
n_A7_perColumn = None # 6 # max n streams vertically
n_A7_perRow = None # 6 # max n streams horizontally - None for not Used
X_space_betweenColumns = 3
quinconce = None # True False # boolean, decale les a7 une fois sur 2
quinconce_X = None # 0.5 # x offset, 0.5/-0.5 left-right, min max
quinconce_start = None # 0 # switch first quinconce_X value to modulo 0.5 to -0.5
n_col_byGroup = None # 2 # n column by a7 grouped
X_space_betweenGroup = 3 # ecart_a7_X*2 # subjectif, to do better in relation with n assets, n group etc
n_groups_grouded = None # todo paquet de groups - None for not Used
# DONT TOUCH ###################################################################################################
params = {}
if A7refPos_X != None :
params['A7refPos_X'] = A7refPos_X
if A7refPos_Y != None :
params['A7refPos_Y'] = A7refPos_Y
if offset_X != None :
params['offset_X'] = offset_X
if offset_Y != None :
params['offset_Y'] = offset_Y
if ecart_a7_X != None :
params['ecart_a7_X'] = ecart_a7_X
if ecart_a7_Y != None :
params['ecart_a7_Y'] = ecart_a7_Y
if n_A7_perColumn != None :
params['n_A7_perColumn'] = n_A7_perColumn
if n_A7_perRow != None :
params['n_A7_perRow'] = n_A7_perRow
if X_space_betweenColumns != None :
params['X_space_betweenColumns'] = X_space_betweenColumns
if quinconce != None :
params['quinconce'] = quinconce
if quinconce_X | |
your least favorite subject at school?',
'Who is your dream dinner guest?',
'Would you rather publish a book or release an album?',
'Have you ever met someone famous?',
'Have you ever had a supernatural experience?',
'Who is your favorite superhero?',
'What job would you be doing if computers had not been invented?',
'What is the best holiday you have ever been on?',
'In the book of your life, what is the best chapter?',
'Can you play a musical instrument?',
'It is late, you are hungry., What shameful snack will you prepare?',
'Make the noise of your favorite animal',
'If you could only eat one type of food for the rest of your life, what would it be?',
'Day off. What do you do to relax?',
'Have you ever been in a newspaper?',
'If you could ban any word or phrase, what would it be?',
'What was your favorite TV show when growing up?',
'Which famous sporting moment would you like to have been part of?',
'Do you have superstitions?',
'Have you ever walked out of a cinema before a movie has finished?',
'What was the one thing you always wanted as a kid, but never got?',
'What was the first movie you saw at the cinema?',
'You are put in charge of the country. What is the first thing you do?',
'What do you like most about coming to work?',
'What is your favorite animal?',
'What’s the best thing that’s happened to you this week?',
'What was the worst present you’ve received?',
'Which skill would you love to learn?',
'Would you rather be clever or beautiful?',
'Would you rather be really hairy or bald?',
'Would you like to be taller or shorter?',
'What irritates you the most?',
'Have you gone out with mismatched socks or shoes on?',
'What flavor ice cream you like the most?',
'What is your favorite drink?',
'Have you ever locked yourself out of the house?',
'Have you gone in to a room and forgotten why?',
'Given the choice of anyone in the world, whom would you want as a dinner guest?',
'Would you like to be famous? In what way?',
'Before making a telephone call, do you ever rehearse what you are going to say? Why?',
'What would constitute a “perfect” day for you?',
'When did you last sing to yourself? To someone else?',
'If you were able to live to the age of 90 and retain either the mind or body of a 30-year-old for the last 60 years of your life, which would you want?',
'Name three things you and a team mate appear to have in common.',
'For what in your life do you feel most grateful?',
'If you could wake up tomorrow having gained any one quality or ability, what would it be?',
'If a crystal ball could tell you the truth about yourself, your life, the future or anything else, what would you want to know?',
'Is there something that you’ve dreamed of doing for a long time? Why haven’t you done it?',
'What is the greatest accomplishment of your life?',
'What do you value most in a friendship?',
'What is your most treasured memory?',
'What does friendship mean to you?',
'Alternate sharing something you consider a positive characteristic of each person in your team.',
'Make a true “we” statements. For instance, “We are both in this room feeling ... “',
'Share an embarrassing moment in your life.',
'What, if anything, is too serious to be joked about?',
'Your house, containing everything you own, catches fire. After saving your loved ones and pets, you have time to safely make a final dash to save any one item. What would it be? Why?',
'Texting or talking?',
'Favorite day of the week?',
'Nickname your parents used to call you?',
'Last song you listened to?',
'Would you rather be able to speak every language in the world or be able to talk to animals?',
'Favorite holiday?',
'How long does it take you to get ready?',
'Scale of 1-10, how good of a driver are you?',
'At what age do you want to retire?',
'Invisibility or super strength?',
'Is it wrong for a vegetarian to eat animal shaped crackers?',
'Scale of 1-10, how good are you at keeping secrets?',
'Dawn or dusk?',
'Do you snore?',
'Place you most want to travel?',
'Favorite junk food?',
'Favorite season?',
'Last Halloween or Carnival costume?',
'Cake or pie?',
'Do you ever post inspirational quotes on social media?',
'Favorite ice cream flavor?',
'Say a word in Spanish.',
'Favorite number?',
'Have you ever worn socks with sandals?',
'Try to tickle yourself. Can you?',
'What’s the best age?',
'If Voldemort offered you a hug, would you accept?',
'Would you rather cuddle with a baby panda or a baby penguin?',
'Would you want to live forever?',
'What will you have for dinner tonight?',
'How many pull-ups can you do in a row?',
'Favorite type of tea?',
'Say something in an Asian language.',
'What is the fastest speed you have ever driven in a car?',
'Star Trek or Star Wars?',
'How many times did you sneeze in the last 7 days?',
'Big dogs or small dogs?',
'How many hours of sleep do you need?',
'Say "Gday mate" in an Australian accent.',
'What is your favorite carb: bread, pasta, rice, or potatoes?',
'How many kids would you like to have?',
'Are rats cute?',
'What is your favorite car?',
'Do you know how to salsa dance?',
'How many cups of coffee do you drink per day?',
'What is your ideal outside temperature?',
'Favorite type of muffin?',
'Giving presents or getting presents?',
'From 1-10, how hot do you like your shower water?',
'If <NAME> and <NAME> were both drowning and you could only save one, who would it be?',
'Do you like the smell of gasoline?',
'Can you touch your toes without bending your knees?',
'Have you ever tasted soap?',
'Do you currently own any stuffed animals?',
'Tapas or pasta?',
'Ask permission or ask forgiveness?',
'How many redheads are you friends with?',
'Name a word in English that starts with the letter Q',
'Climb a mountain or jump from a plane?',
'If you were really hungry, would you eat a bug?',
'How long can you hold your breath for?',
'Have you ever seen a kangaroo in person?',
'When people stand up for a standing ovation, are you usually one of the earlier people to stand up or one of the later?',
'What type of milk do you put in your cereal?',
'Did you ever believe in Santa Claus?',
'Have you ever been to Africa?',
'What is the most number of hours you have watched TV in a single day?',
'Do you Instagram your food?',
'What sound does a seal make?',
'Would you rather lose all your hair or gain 50% more hair?',
'If there is a spider in your house, do you kill it or set it free?',
'What is something you could eat for a week straight?',
'Would you rather wake up to an air horn blowing in your ear every day, or wake up and have to run 4 miles every day?',
'Dark Chocolate or Milk Chocolate?',
'Would you go to a cinema alone?',
'What is a country you would be okay never visiting in your life?',
'Would you rather eat some smoky gnocchi or some delish fish?',
'If you were given the opportunity to fly into space given current technology, would you take it?',
'When was the last time you stayed up past 4 in the morning?',
'When you fly on a plane, do you wear a neck pillow?',
'Do you like Disneyland?',
'How would you rate your karaoke skills on a scale of 1 to Mariah Carey?',
'Are tomatoes a fruit or a | |
'
'"path /usr/libexec/argo-monitoring/probes/argo", '
'"interval 5", "retryInterval 3"]'
)
self.assertEqual(metric.attribute, '["argo.api_TOKEN --token"]')
self.assertEqual(metric.dependancy, '')
self.assertEqual(metric.flags, '["OBSESS 1"]')
self.assertEqual(metric.files, '')
self.assertEqual(metric.parameter, '')
self.assertEqual(metric.fileparameter, '')
mt_history = poem_models.TenantHistory.objects.filter(
object_repr='argo.API-Check'
).order_by('-date_created')
self.assertEqual(mt_history.count(), 1)
self.assertEqual(
mt_history[0].comment, 'Initial version.'
)
serialized_data = json.loads(mt_history[0].serialized_data)[0]['fields']
self.assertEqual(serialized_data['name'], metric.name)
self.assertEqual(serialized_data['mtype'], ['Active'])
self.assertEqual(
serialized_data['probekey'], ['argo-web-api', '0.1.7']
)
self.assertEqual(serialized_data['group'], ['TEST'])
self.assertEqual(serialized_data['parent'], metric.parent)
self.assertEqual(
serialized_data['probeexecutable'], metric.probeexecutable
)
self.assertEqual(serialized_data['config'], metric.config)
self.assertEqual(serialized_data['attribute'], metric.attribute)
self.assertEqual(serialized_data['dependancy'], metric.dependancy)
self.assertEqual(serialized_data['flags'], metric.flags)
self.assertEqual(serialized_data['files'], metric.files)
self.assertEqual(serialized_data['parameter'], metric.parameter)
self.assertEqual(serialized_data['fileparameter'], metric.fileparameter)
def test_put_probe_with_new_version_without_metrictemplate_update_tn_sprusr(
self
):
data = {
'id': self.probe2.id,
'name': 'web-api',
'package': 'nagios-plugins-argo (0.1.11)',
'comment': 'New version.',
'docurl':
'https://github.com/ARGOeu/nagios-plugins-argo2/blob/'
'master/README.md',
'description': 'Probe is checking AR and status reports.',
'repository': 'https://github.com/ARGOeu/nagios-plugins-'
'argo2',
'update_metrics': False
}
content, content_type = encode_data(data)
request = self.factory.put(self.url, content, content_type=content_type)
request.tenant = self.tenant
force_authenticate(request, user=self.tenant_superuser)
response = self.view(request)
self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
self.assertEqual(
response.data['detail'],
'You do not have permission to change probes.'
)
probe = admin_models.Probe.objects.get(id=self.probe2.id)
self.assertEqual(
admin_models.ProbeHistory.objects.filter(object_id=probe).count(), 1
)
version = admin_models.ProbeHistory.objects.get(
object_id=probe, package__version=probe.package.version
)
self.assertEqual(probe.name, 'argo-web-api')
self.assertEqual(probe.package, self.package1)
self.assertEqual(probe.comment, 'Initial version.')
self.assertEqual(
probe.docurl,
'https://github.com/ARGOeu/nagios-plugins-argo/blob/master/'
'README.md',
)
self.assertEqual(
probe.description,
'This is a probe for checking AR and status reports are properly '
'working.'
)
self.assertEqual(
probe.repository, 'https://github.com/ARGOeu/nagios-plugins-argo'
)
self.assertEqual(version.name, probe.name)
self.assertEqual(version.package, probe.package)
self.assertEqual(version.comment, probe.comment)
self.assertEqual(version.docurl, probe.docurl)
self.assertEqual(version.description, probe.description)
self.assertEqual(version.repository, probe.repository)
self.assertEqual(version.version_comment, 'Initial version.')
mt = admin_models.MetricTemplate.objects.get(name='argo.API-Check')
self.assertEqual(mt.probekey, version)
metric = poem_models.Metric.objects.get(name='argo.API-Check')
self.assertEqual(metric.group.name, 'TEST')
self.assertEqual(metric.parent, '')
self.assertEqual(metric.probeexecutable, '["web-api"]')
self.assertEqual(metric.probekey, version)
self.assertEqual(
metric.config,
'["maxCheckAttempts 3", "timeout 120", '
'"path /usr/libexec/argo-monitoring/probes/argo", '
'"interval 5", "retryInterval 3"]'
)
self.assertEqual(metric.attribute, '["argo.api_TOKEN --token"]')
self.assertEqual(metric.dependancy, '')
self.assertEqual(metric.flags, '["OBSESS 1"]')
self.assertEqual(metric.files, '')
self.assertEqual(metric.parameter, '')
self.assertEqual(metric.fileparameter, '')
mt_history = poem_models.TenantHistory.objects.filter(
object_repr='argo.API-Check'
).order_by('-date_created')
self.assertEqual(mt_history.count(), 1)
self.assertEqual(
mt_history[0].comment, 'Initial version.'
)
serialized_data = json.loads(mt_history[0].serialized_data)[0]['fields']
self.assertEqual(serialized_data['name'], metric.name)
self.assertEqual(serialized_data['mtype'], ['Active'])
self.assertEqual(
serialized_data['probekey'], ['argo-web-api', '0.1.7']
)
self.assertEqual(serialized_data['group'], ['TEST'])
self.assertEqual(serialized_data['parent'], metric.parent)
self.assertEqual(
serialized_data['probeexecutable'], metric.probeexecutable
)
self.assertEqual(serialized_data['config'], metric.config)
self.assertEqual(serialized_data['attribute'], metric.attribute)
self.assertEqual(serialized_data['dependancy'], metric.dependancy)
self.assertEqual(serialized_data['flags'], metric.flags)
self.assertEqual(serialized_data['files'], metric.files)
self.assertEqual(serialized_data['parameter'], metric.parameter)
self.assertEqual(serialized_data['fileparameter'], metric.fileparameter)
def test_put_probe_with_new_version_without_metrictemplate_update_tn_user(
self
):
data = {
'id': self.probe2.id,
'name': 'web-api',
'package': 'nagios-plugins-argo (0.1.11)',
'comment': 'New version.',
'docurl':
'https://github.com/ARGOeu/nagios-plugins-argo2/blob/'
'master/README.md',
'description': 'Probe is checking AR and status reports.',
'repository': 'https://github.com/ARGOeu/nagios-plugins-'
'argo2',
'update_metrics': False
}
content, content_type = encode_data(data)
request = self.factory.put(self.url, content, content_type=content_type)
request.tenant = self.tenant
force_authenticate(request, user=self.tenant_user)
response = self.view(request)
self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
self.assertEqual(
response.data['detail'],
'You do not have permission to change probes.'
)
probe = admin_models.Probe.objects.get(id=self.probe2.id)
self.assertEqual(
admin_models.ProbeHistory.objects.filter(object_id=probe).count(), 1
)
version = admin_models.ProbeHistory.objects.get(
object_id=probe, package__version=probe.package.version
)
self.assertEqual(probe.name, 'argo-web-api')
self.assertEqual(probe.package, self.package1)
self.assertEqual(probe.comment, 'Initial version.')
self.assertEqual(
probe.docurl,
'https://github.com/ARGOeu/nagios-plugins-argo/blob/master/'
'README.md',
)
self.assertEqual(
probe.description,
'This is a probe for checking AR and status reports are properly '
'working.'
)
self.assertEqual(
probe.repository, 'https://github.com/ARGOeu/nagios-plugins-argo'
)
self.assertEqual(version.name, probe.name)
self.assertEqual(version.package, probe.package)
self.assertEqual(version.comment, probe.comment)
self.assertEqual(version.docurl, probe.docurl)
self.assertEqual(version.description, probe.description)
self.assertEqual(version.repository, probe.repository)
self.assertEqual(version.version_comment, 'Initial version.')
mt = admin_models.MetricTemplate.objects.get(name='argo.API-Check')
self.assertEqual(mt.probekey, version)
metric = poem_models.Metric.objects.get(name='argo.API-Check')
self.assertEqual(metric.group.name, 'TEST')
self.assertEqual(metric.parent, '')
self.assertEqual(metric.probeexecutable, '["web-api"]')
self.assertEqual(metric.probekey, version)
self.assertEqual(
metric.config,
'["maxCheckAttempts 3", "timeout 120", '
'"path /usr/libexec/argo-monitoring/probes/argo", '
'"interval 5", "retryInterval 3"]'
)
self.assertEqual(metric.attribute, '["argo.api_TOKEN --token"]')
self.assertEqual(metric.dependancy, '')
self.assertEqual(metric.flags, '["OBSESS 1"]')
self.assertEqual(metric.files, '')
self.assertEqual(metric.parameter, '')
self.assertEqual(metric.fileparameter, '')
mt_history = poem_models.TenantHistory.objects.filter(
object_repr='argo.API-Check'
).order_by('-date_created')
self.assertEqual(mt_history.count(), 1)
self.assertEqual(
mt_history[0].comment, 'Initial version.'
)
serialized_data = json.loads(mt_history[0].serialized_data)[0]['fields']
self.assertEqual(serialized_data['name'], metric.name)
self.assertEqual(serialized_data['mtype'], ['Active'])
self.assertEqual(
serialized_data['probekey'], ['argo-web-api', '0.1.7']
)
self.assertEqual(serialized_data['group'], ['TEST'])
self.assertEqual(serialized_data['parent'], metric.parent)
self.assertEqual(
serialized_data['probeexecutable'], metric.probeexecutable
)
self.assertEqual(serialized_data['config'], metric.config)
self.assertEqual(serialized_data['attribute'], metric.attribute)
self.assertEqual(serialized_data['dependancy'], metric.dependancy)
self.assertEqual(serialized_data['flags'], metric.flags)
self.assertEqual(serialized_data['files'], metric.files)
self.assertEqual(serialized_data['parameter'], metric.parameter)
self.assertEqual(serialized_data['fileparameter'], metric.fileparameter)
def test_put_probe_with_new_version_with_metrictemplate_update_sp_spruser(
self
):
data = {
'id': self.probe2.id,
'name': 'web-api',
'package': 'nagios-plugins-argo (0.1.11)',
'comment': 'New version.',
'docurl':
'https://github.com/ARGOeu/nagios-plugins-argo2/blob/'
'master/README.md',
'description': 'Probe is checking AR and status reports.',
'repository': 'https://github.com/ARGOeu/nagios-plugins-'
'argo2',
'update_metrics': True
}
content, content_type = encode_data(data)
request = self.factory.put(
self.url, content, content_type=content_type
)
request.tenant = self.super_tenant
force_authenticate(request, user=self.superuser)
response = self.view(request)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
probe = admin_models.Probe.objects.get(id=self.probe2.id)
versions = admin_models.ProbeHistory.objects.filter(
object_id=self.probe2
).order_by('-date_created')
self.assertEqual(versions.count(), 2)
self.assertEqual(probe.name, 'web-api')
self.assertEqual(probe.package, self.package2)
self.assertEqual(probe.comment, 'New version.')
self.assertEqual(
probe.docurl,
'https://github.com/ARGOeu/nagios-plugins-argo2/blob/master/'
'README.md',
)
self.assertEqual(
probe.description,
'Probe is checking AR and status reports.'
)
self.assertEqual(
probe.repository,
'https://github.com/ARGOeu/nagios-plugins-argo2',
)
self.assertEqual(versions[0].name, probe.name)
self.assertEqual(versions[0].package, probe.package)
self.assertEqual(versions[0].comment, probe.comment)
self.assertEqual(versions[0].docurl, probe.docurl)
self.assertEqual(versions[0].description, probe.description)
self.assertEqual(versions[0].repository, probe.repository)
mt = admin_models.MetricTemplate.objects.get(name='argo.API-Check')
self.assertEqual(mt.probekey, versions[0])
metric = poem_models.Metric.objects.get(name='argo.API-Check')
self.assertEqual(metric.group.name, 'TEST')
self.assertEqual(metric.parent, '')
self.assertEqual(metric.probeexecutable, '["web-api"]')
self.assertEqual(metric.probekey, versions[1])
self.assertEqual(
metric.config,
'["maxCheckAttempts 3", "timeout 120", '
'"path /usr/libexec/argo-monitoring/probes/argo", '
'"interval 5", "retryInterval 3"]'
)
self.assertEqual(metric.attribute, '["argo.api_TOKEN --token"]')
self.assertEqual(metric.dependancy, '')
self.assertEqual(metric.flags, '["OBSESS 1"]')
self.assertEqual(metric.files, '')
self.assertEqual(metric.parameter, '')
self.assertEqual(metric.fileparameter, '')
mt_history = poem_models.TenantHistory.objects.filter(
object_repr='argo.API-Check'
).order_by('-date_created')
self.assertEqual(mt_history.count(), 1)
self.assertEqual(
mt_history[0].comment, 'Initial version.'
)
serialized_data = json.loads(mt_history[0].serialized_data)[0]['fields']
self.assertEqual(serialized_data['name'], metric.name)
self.assertEqual(serialized_data['mtype'], ['Active'])
self.assertEqual(
serialized_data['probekey'], ['argo-web-api', '0.1.7']
)
self.assertEqual(serialized_data['group'], ['TEST'])
self.assertEqual(serialized_data['parent'], metric.parent)
self.assertEqual(
serialized_data['probeexecutable'], metric.probeexecutable
)
self.assertEqual(serialized_data['config'], metric.config)
self.assertEqual(serialized_data['attribute'], metric.attribute)
self.assertEqual(serialized_data['dependancy'], metric.dependancy)
self.assertEqual(serialized_data['flags'], metric.flags)
self.assertEqual(serialized_data['files'], metric.files)
self.assertEqual(serialized_data['parameter'], metric.parameter)
self.assertEqual(serialized_data['fileparameter'], metric.fileparameter)
def test_put_probe_with_new_version_with_metrictemplate_update_sp_user(
self
):
data = {
'id': self.probe2.id,
'name': 'web-api',
'package': 'nagios-plugins-argo (0.1.11)',
'comment': 'New version.',
'docurl':
'https://github.com/ARGOeu/nagios-plugins-argo2/blob/'
'master/README.md',
'description': 'Probe is checking AR and status reports.',
'repository': 'https://github.com/ARGOeu/nagios-plugins-'
'argo2',
'update_metrics': True
}
content, content_type = encode_data(data)
request = self.factory.put(
self.url, content, content_type=content_type
)
request.tenant = self.super_tenant
force_authenticate(request, user=self.user)
response = self.view(request)
self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
self.assertEqual(
response.data['detail'],
'You do not have permission to change probes.'
)
probe = admin_models.Probe.objects.get(id=self.probe2.id)
versions = admin_models.ProbeHistory.objects.filter(
object_id=self.probe2
).order_by('-date_created')
self.assertEqual(versions.count(), 1)
self.assertEqual(probe.name, 'argo-web-api')
self.assertEqual(probe.package, self.package1)
self.assertEqual(probe.comment, 'Initial version.')
self.assertEqual(
probe.docurl,
'https://github.com/ARGOeu/nagios-plugins-argo/blob/master/'
'README.md',
)
self.assertEqual(
probe.description,
'This is a probe for checking AR and status reports are properly '
'working.'
)
self.assertEqual(
probe.repository,
'https://github.com/ARGOeu/nagios-plugins-argo'
)
self.assertEqual(versions[0].name, probe.name)
self.assertEqual(versions[0].package, probe.package)
self.assertEqual(versions[0].comment, probe.comment)
self.assertEqual(versions[0].docurl, probe.docurl)
self.assertEqual(versions[0].description, probe.description)
self.assertEqual(versions[0].repository, probe.repository)
mt = admin_models.MetricTemplate.objects.get(name='argo.API-Check')
self.assertEqual(mt.probekey, versions[0])
metric = poem_models.Metric.objects.get(name='argo.API-Check')
self.assertEqual(metric.group.name, 'TEST')
self.assertEqual(metric.parent, '')
self.assertEqual(metric.probeexecutable, '["web-api"]')
self.assertEqual(metric.probekey, versions[0])
self.assertEqual(
metric.config,
'["maxCheckAttempts 3", "timeout 120", '
'"path /usr/libexec/argo-monitoring/probes/argo", '
'"interval 5", "retryInterval 3"]'
)
self.assertEqual(metric.attribute, '["argo.api_TOKEN --token"]')
self.assertEqual(metric.dependancy, '')
self.assertEqual(metric.flags, '["OBSESS 1"]')
self.assertEqual(metric.files, '')
self.assertEqual(metric.parameter, '')
self.assertEqual(metric.fileparameter, '')
mt_history = poem_models.TenantHistory.objects.filter(
object_repr='argo.API-Check'
).order_by('-date_created')
self.assertEqual(mt_history.count(), 1)
self.assertEqual(
mt_history[0].comment, 'Initial version.'
)
serialized_data = json.loads(mt_history[0].serialized_data)[0]['fields']
self.assertEqual(serialized_data['name'], metric.name)
self.assertEqual(serialized_data['mtype'], ['Active'])
self.assertEqual(
serialized_data['probekey'], ['argo-web-api', '0.1.7']
)
self.assertEqual(serialized_data['group'], ['TEST'])
self.assertEqual(serialized_data['parent'], metric.parent)
self.assertEqual(
serialized_data['probeexecutable'], metric.probeexecutable
)
self.assertEqual(serialized_data['config'], metric.config)
self.assertEqual(serialized_data['attribute'], metric.attribute)
self.assertEqual(serialized_data['dependancy'], metric.dependancy)
self.assertEqual(serialized_data['flags'], metric.flags)
self.assertEqual(serialized_data['files'], metric.files)
self.assertEqual(serialized_data['parameter'], metric.parameter)
self.assertEqual(serialized_data['fileparameter'], metric.fileparameter)
def test_put_probe_with_new_version_with_metrictemplate_update_tennt_sprusr(
self
):
data = {
'id': self.probe2.id,
'name': 'web-api',
'package': 'nagios-plugins-argo (0.1.11)',
'comment': 'New version.',
'docurl':
'https://github.com/ARGOeu/nagios-plugins-argo2/blob/'
'master/README.md',
'description': 'Probe is checking AR and status reports.',
'repository': 'https://github.com/ARGOeu/nagios-plugins-'
'argo2',
'update_metrics': True
}
content, content_type = encode_data(data)
request = self.factory.put(
self.url, content, content_type=content_type
)
request.tenant = self.tenant
force_authenticate(request, user=self.tenant_superuser)
response = self.view(request)
self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
self.assertEqual(
response.data['detail'],
'You do not have permission to change probes.'
)
probe = admin_models.Probe.objects.get(id=self.probe2.id)
versions = admin_models.ProbeHistory.objects.filter(
object_id=self.probe2
).order_by('-date_created')
self.assertEqual(versions.count(), 1)
self.assertEqual(probe.name, 'argo-web-api')
self.assertEqual(probe.package, self.package1)
self.assertEqual(probe.comment, 'Initial version.')
self.assertEqual(
probe.docurl,
'https://github.com/ARGOeu/nagios-plugins-argo/blob/master/'
'README.md',
)
self.assertEqual(
probe.description,
'This is a probe for checking AR and status reports are properly '
'working.'
)
self.assertEqual(
probe.repository,
'https://github.com/ARGOeu/nagios-plugins-argo'
)
self.assertEqual(versions[0].name, probe.name)
self.assertEqual(versions[0].package, probe.package)
self.assertEqual(versions[0].comment, probe.comment)
self.assertEqual(versions[0].docurl, probe.docurl)
self.assertEqual(versions[0].description, probe.description)
self.assertEqual(versions[0].repository, probe.repository)
mt = admin_models.MetricTemplate.objects.get(name='argo.API-Check')
self.assertEqual(mt.probekey, versions[0])
metric = poem_models.Metric.objects.get(name='argo.API-Check')
self.assertEqual(metric.group.name, 'TEST')
self.assertEqual(metric.parent, '')
self.assertEqual(metric.probeexecutable, '["web-api"]')
self.assertEqual(metric.probekey, versions[0])
self.assertEqual(
metric.config,
'["maxCheckAttempts 3", "timeout 120", '
'"path /usr/libexec/argo-monitoring/probes/argo", '
'"interval 5", "retryInterval 3"]'
)
self.assertEqual(metric.attribute, '["argo.api_TOKEN --token"]')
self.assertEqual(metric.dependancy, '')
self.assertEqual(metric.flags, '["OBSESS 1"]')
self.assertEqual(metric.files, '')
self.assertEqual(metric.parameter, '')
self.assertEqual(metric.fileparameter, '')
mt_history = poem_models.TenantHistory.objects.filter(
object_repr='argo.API-Check'
).order_by('-date_created')
self.assertEqual(mt_history.count(), 1)
self.assertEqual(
mt_history[0].comment, 'Initial version.'
)
serialized_data = json.loads(mt_history[0].serialized_data)[0]['fields']
self.assertEqual(serialized_data['name'], metric.name)
self.assertEqual(serialized_data['mtype'], ['Active'])
self.assertEqual(
serialized_data['probekey'], ['argo-web-api', '0.1.7']
)
self.assertEqual(serialized_data['group'], ['TEST'])
self.assertEqual(serialized_data['parent'], metric.parent)
self.assertEqual(
serialized_data['probeexecutable'], metric.probeexecutable
)
self.assertEqual(serialized_data['config'], metric.config)
self.assertEqual(serialized_data['attribute'], metric.attribute)
self.assertEqual(serialized_data['dependancy'], metric.dependancy)
self.assertEqual(serialized_data['flags'], metric.flags)
self.assertEqual(serialized_data['files'], metric.files)
self.assertEqual(serialized_data['parameter'], metric.parameter)
self.assertEqual(serialized_data['fileparameter'], metric.fileparameter)
def test_put_probe_with_new_version_with_metrictemplate_update_tenant_user(
self
):
data = {
'id': self.probe2.id,
'name': 'web-api',
'package': 'nagios-plugins-argo (0.1.11)',
'comment': 'New version.',
'docurl':
'https://github.com/ARGOeu/nagios-plugins-argo2/blob/'
'master/README.md',
'description': 'Probe is checking AR and status reports.',
'repository': 'https://github.com/ARGOeu/nagios-plugins-'
'argo2',
'update_metrics': True
}
content, content_type = encode_data(data)
request = self.factory.put(
self.url, content, content_type=content_type
)
request.tenant = self.tenant
force_authenticate(request, user=self.tenant_user)
response = self.view(request)
self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
self.assertEqual(
response.data['detail'],
'You do not have permission to change probes.'
)
probe = admin_models.Probe.objects.get(id=self.probe2.id)
versions = admin_models.ProbeHistory.objects.filter(
object_id=self.probe2
).order_by('-date_created')
self.assertEqual(versions.count(), 1)
self.assertEqual(probe.name, 'argo-web-api')
self.assertEqual(probe.package, self.package1)
self.assertEqual(probe.comment, 'Initial version.')
self.assertEqual(
probe.docurl,
'https://github.com/ARGOeu/nagios-plugins-argo/blob/master/'
'README.md',
)
self.assertEqual(
probe.description,
'This is a probe for checking AR and status reports are properly '
'working.'
)
self.assertEqual(
probe.repository,
'https://github.com/ARGOeu/nagios-plugins-argo'
)
self.assertEqual(versions[0].name, probe.name)
self.assertEqual(versions[0].package, probe.package)
self.assertEqual(versions[0].comment, probe.comment)
self.assertEqual(versions[0].docurl, probe.docurl)
self.assertEqual(versions[0].description, probe.description)
self.assertEqual(versions[0].repository, probe.repository)
mt = admin_models.MetricTemplate.objects.get(name='argo.API-Check')
self.assertEqual(mt.probekey, versions[0])
metric = poem_models.Metric.objects.get(name='argo.API-Check')
self.assertEqual(metric.group.name, 'TEST')
self.assertEqual(metric.parent, '')
self.assertEqual(metric.probeexecutable, '["web-api"]')
self.assertEqual(metric.probekey, versions[0])
self.assertEqual(
metric.config,
'["maxCheckAttempts 3", "timeout 120", '
'"path /usr/libexec/argo-monitoring/probes/argo", '
'"interval 5", "retryInterval 3"]'
)
self.assertEqual(metric.attribute, '["argo.api_TOKEN --token"]')
self.assertEqual(metric.dependancy, '')
self.assertEqual(metric.flags, '["OBSESS 1"]')
self.assertEqual(metric.files, | |
edge mask using adaptive thresholding
"""
img_edges = cv2.adaptiveThreshold(src=img_blur, maxValue=255,
adaptiveMethod=adaptive_method,
thresholdType=thresh_method,
blockSize=thresh_bsize, C=thresh_C)
"""
step 4. combine color image with edge mask
"""
if (nb_channels == 3):
img_edges = cv2.cvtColor(img_edges, cv2.COLOR_GRAY2RGB)
img_cartoon = cv2.bitwise_and(img_color, img_edges)
transformed_images.append(img_cartoon/255.)
transformed_images = np.stack(transformed_images, axis=0)
if (nb_channels == 1):
transformed_images = transformed_images.reshape((nb_images, img_rows, img_cols, nb_channels))
return transformed_images
def _quant_trans(original_images, trans_args):
"""
Adapted from tutorial
https://www.pyimagesearch.com/2014/07/07/color-quantization-opencv-using-k-means-clustering/
:param original_images:
:param transformation:
:return:
"""
if len(original_images.shape) == 4:
nb_images, img_rows, img_cols, nb_channels = original_images.shape
else:
nb_images, img_rows, img_cols = original_images.shape
nb_channels = 1
nb_clusters = trans_args.get('nb_clusters', 4)
transformed_images = []
for img in original_images:
img_type = img.dtype
"""
Convert gray scale images to RGB color space such that
we can further convert the image to LAB color space.
This function will return a 3-channel gray image that
each channel is a copy of the original gray image.
"""
if (nb_channels == 1):
img = cv2.cvtColor(img, cv2.COLOR_GRAY2RGB)
"""
Convert the image from the RGB color space to the LAB color space,
since we will be clustering using k-means which is based on
the euclidean distance, we will use the LAB color space where
the euclidean distance implies perceptual meaning.
"""
img = cv2.cvtColor(img, cv2.COLOR_RGB2LAB)
"""
reshape the image into a feature vector so that k-mean can be applied
"""
img = img.reshape((img_rows * img_cols, 3))
"""
apply k-means using the specified number of clusters and then
create the quantized image based on the predictions.
"""
cluster = MiniBatchKMeans(n_clusters=nb_clusters)
labels = cluster.fit_predict(img)
quant = cluster.cluster_centers_[labels]
"""
reshape the feature vectors back to image
"""
quant = quant.reshape((img_rows, img_cols, 3))
"""
convert from LAB back to RGB
"""
quant = cv2.cvtColor(quant, cv2.COLOR_Lab2RGB)
"""
convert from RGB back to grayscale
"""
if (nb_channels == 1):
quant = cv2.cvtColor(quant, cv2.COLOR_RGB2GRAY)
transformed_images.append(quant.astype(img_type))
transformed_images = np.stack(transformed_images, axis=0)
if (nb_channels == 1):
# reshape a 3d array to a 4d array
transformed_images = transformed_images.reshape((nb_images, img_rows, img_cols, nb_channels))
return transformed_images
def _distort_trans(original_images, trans_args):
if len(original_images.shape) == 4:
nb_images, img_rows, img_cols, nb_channels = original_images.shape
else:
nb_images, img_rows, img_cols = original_images.shape
nb_channels = 1
distort_trans = trans_args.get('subtype')
transformed_images = []
if distort_trans in [trans_configs.DISTORT_TRANSFORMATIONS.X.value,
trans_configs.DISTORT_TRANSFORMATIONS.Y.value,]:
r1 = trans_args.get('r1', 5.)
r2 = trans_args.get('r2', 2.)
c = trans_args.get('c', 28.)
a = c / r1
w = r2 / c
shift_func = lambda x: a * np.sin(np.pi * x * w)
shift_func = trans_args.get('shift_func', shift_func)
if distort_trans == trans_configs.DISTORT_TRANSFORMATIONS.X.value:
for img in original_images:
for i in range(img_rows):
img[:, i] = np.roll(img[:, i], int(shift_func(i)))
transformed_images.append(img)
else:
for img in original_images:
for i in range(img_cols):
img[i, :] = np.roll(img[i, :], int(shift_func(i)))
transformed_images.append(img)
elif distort_trans == trans_configs.DISTORT_TRANSFORMATIONS.PIXELATE.value:
new_size = trans_args.get('new_size', (16, 16))
resample = trans_args.get('resample')
resample_method = trans_configs.get_distort_resample(resample)
for img in original_images:
img = Image.fromarray(img, 'RGB')
# resize smoothly down
img = img.resize(new_size, resample=resample_method)
img = img.resize((img_rows, img_cols), resample=resample_method)
img = np.array(img)
transformed_images.append(img)
elif distort_trans == trans_configs.DISTORT_TRANSFORMATIONS.CONTRAST.value:
c = trans_args.get('c', 0.1)
min_pixel_val = trans_args.get('min_pixel_val', 0.)
max_pixel_val = trans_args.get('max_pixel_val', 1.)
if nb_channels == 1:
for img in original_images:
means = np.mean(img, axis=0, keepdims=True)
img = np.clip((img - means) * c + means, min_pixel_val, max_pixel_val)
transformed_images.append(img)
else:
original_images *= 255.
max_pixel_val *= 255.
for img in original_images:
means = np.mean(img, axis=(0, 1), keepdims=True)
img = np.clip((img - means) * c + means, min_pixel_val, max_pixel_val)
transformed_images.append(img/255.)
elif distort_trans == trans_configs.DISTORT_TRANSFORMATIONS.BRIGHTNESS.value:
c = trans_args.get('c', 0.99)
min_pixel_val = trans_args.get('min_pixel_val', 0.)
max_pixel_val = trans_args.get('max_pixel_val', 1.)
if nb_channels == 1:
for img in original_images:
img = cv2.cvtColor(img, cv2.COLOR_GRAY2RGB)
img = color.rgb2hsv(img)
img[:, :, 2] = np.clip(img[:, :, 2] + c, min_pixel_val, max_pixel_val)
img = color.hsv2rgb(img)
img = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
transformed_images.append(img)
else:
original_images *= 255.
max_pixel_val *= 255.
for img in original_images:
img = color.rgb2hsv(img)
img[:, :, 2] = np.clip(img[:, :, 2] + c, min_pixel_val, max_pixel_val)
img = color.hsv2rgb(img)
transformed_images.append(img/255.)
else:
raise ValueError('{} is not supported.'.format(distort_trans))
transformed_images = np.stack(transformed_images, axis=0)
if nb_channels == 1:
transformed_images = transformed_images.reshape((nb_images, img_rows, img_cols, nb_channels))
return transformed_images
def _noise_trans(original_images, trans_args):
"""
Adding noise to given images.
:param original_images:
:param transformation:
:return:
"""
if len(original_images.shape) == 4:
nb_images, img_rows, img_cols, nb_channels = original_images.shape
else:
nb_images, img_rows, img_cols = original_images.shape
nb_channels = 1
noise = trans_args.get('noise')
transformed_images = []
for img in original_images:
img = util.random_noise(img, mode=noise)
transformed_images.append(img)
transformed_images = np.stack(transformed_images, axis=0)
if (nb_channels == 1):
transformed_images = transformed_images.reshape((nb_images, img_rows, img_cols, nb_channels))
return transformed_images
def _filter_trans(original_images, trans_args):
if len(original_images.shape) == 4:
nb_images, img_rows, img_cols, nb_channels = original_images.shape
else:
nb_images, img_rows, img_cols = original_images.shape
nb_channels = 1
filter_trans = trans_args.get('subtype')
op = trans_configs.get_filter_op(filter_trans)
transformed_images = []
if filter_trans in [trans_configs.FILTER_TRANSFORMATION.SOBEL.value,
trans_configs.FILTER_TRANSFORMATION.ROBERTS.value,
trans_configs.FILTER_TRANSFORMATION.SCHARR.value,
trans_configs.FILTER_TRANSFORMATION.PREWITT.value,
trans_configs.FILTER_TRANSFORMATION.SKELETONIZE.value]:
for img in original_images:
if (nb_channels == 3):
img = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
img = img.reshape(img_rows, img_cols)
img = op(img)
if (nb_channels == 3):
img = cv2.cvtColor(img, cv2.COLOR_GRAY2RGB)
transformed_images.append(img)
elif filter_trans in [trans_configs.FILTER_TRANSFORMATION.MEDIAN.value,
trans_configs.FILTER_TRANSFORMATION.MINIMUM.value,
trans_configs.FILTER_TRANSFORMATION.MAXIMUM.value,
trans_configs.FILTER_TRANSFORMATION.SATO.value,
trans_configs.FILTER_TRANSFORMATION.FRANGI.value,
trans_configs.FILTER_TRANSFORMATION.HESSIAN.value]:
size = trans_args.get('size', 3)
for img in original_images:
img = op(img, size=size)
transformed_images.append(img)
elif filter_trans == trans_configs.FILTER_TRANSFORMATION.RANK.value:
size = trans_args.get('size', 3)
rank = trans_args.get('rank', 15)
for img in original_images:
img = op(img, rank=rank, size=size)
transformed_images.append(img)
elif filter_trans == trans_configs.FILTER_TRANSFORMATION.GAUSSIAN.value:
sigma = trans_args.get('sigma', 1)
for img in original_images:
img = op(img, sigma=sigma)
transformed_images.append(img)
elif filter_trans == trans_configs.FILTER_TRANSFORMATION.MEIJERING.value:
sigmas = trans_args.get('sigmas', [0.01])
for img in original_images:
if nb_channels == 1:
img = cv2.cvtColor(img, cv2.COLOR_GRAY2RGB)
img = op(img, sigmas=sigmas)
if nb_channels == 1:
img = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
transformed_images.append(img)
elif filter_trans == trans_configs.FILTER_TRANSFORMATION.ENTROPY.value:
radius = trans_args.get('radius', 2)
for img in original_images:
if (nb_channels == 3):
img = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
img = img.reshape((img_rows, img_cols))
# requires values in range [-1., 1.]
img = (img - 0.5) / 2.
# skimage-entropy returns values in float64,
# however, opencv supports only float32.
img = np.float32(op(img, disk(radius=radius)))
# rescale to [0., 1.]
img = (img / 2.) + 0.5
if (nb_channels == 3):
img = cv2.cvtColor(img, cv2.COLOR_GRAY2RGB)
transformed_images.append(img)
elif filter_trans == trans_configs.FILTER_TRANSFORMATION.THIN.value:
max_iter = trans_args.get('max_iter', 100)
for img in original_images:
if (nb_channels == 3):
img = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
img = img.reshape((img_rows, img_cols))
img = op(img, max_iter=max_iter)
if (nb_channels == 3):
img = cv2.cvtColor(img, cv2.COLOR_GRAY2RGB)
transformed_images.append(img)
else:
raise ValueError('{} is not supported.'.format(filter_trans))
transformed_images = np.stack(transformed_images, axis=0)
if (nb_channels == 1):
transformed_images = transformed_images.reshape((nb_images, img_rows, img_cols, nb_channels))
return transformed_images
def _compression_trans(original_images, trans_args):
"""
:param original_images:
:param transformation:
:return:
"""
if len(original_images.shape) == 4:
nb_images, img_rows, img_cols, nb_channels = original_images.shape
else:
nb_images, img_rows, img_cols = original_images.shape
nb_channels = 1
format = trans_args.get('format', trans_configs.COMPRESS_FORMAT.PNG)
rate = trans_args.get('rate', 80)
encode_param = trans_configs.get_compress_encoder(format, rate)
transformed_images = []
for img in original_images:
img *= 255.
result, encoded_img = cv2.imencode(ext=format, img=img, params=encode_param)
if False == result:
print('Failed to encode image to {} format.'.format(format))
quit()
# decode the image from encoded image
decoded_img = cv2.imdecode(buf=encoded_img, flags=1)
if (nb_channels == 1):
decoded_img = cv2.cvtColor(decoded_img, cv2.COLOR_RGB2GRAY)
transformed_images.append(decoded_img/255.)
transformed_images = np.stack(transformed_images, axis=0)
if (nb_channels == 1):
transformed_images = transformed_images.reshape((nb_images, img_rows, img_cols, nb_channels))
return transformed_images
def _denoise_trans(original_images, trans_args):
"""
denoising transformation
:param original_images:
:param transformation:
:return:
"""
if len(original_images.shape) == 4:
nb_images, img_rows, img_cols, nb_channels = original_images.shape
else:
nb_images, img_rows, img_cols = original_images.shape
nb_channels = 1
denoise_trans = trans_args.get('subtype')
transformed_images = []
if denoise_trans == trans_configs.DENOISE_TRANSFORMATIONS.WAVELET.value:
method = trans_args.get('method', 'VisuShrink') # any option in ['VisuShrink', 'BayesShrink']
mode = trans_args.get('mode', 'soft') # any option in ['soft', 'hard']
wavelet = trans_args.get('wavelet', 'db1') # any option in pywt.wavelist
sigma = trans_args.get('sigma', None) # float or list, optional
for img in original_images:
if sigma is None:
sigma_est = estimate_sigma(img, multichannel=True, average_sigmas=True)
else:
sigma_est = sigma
img = denoise_wavelet(img, wavelet=wavelet, multichannel=True,
convert2ycbcr=False, method=method, mode=mode,
sigma=sigma_est)
transformed_images.append(img)
elif denoise_trans == trans_configs.DENOISE_TRANSFORMATIONS.TV_CHAMBOLLE.value:
# default 0.4 (grayscale); 0.07 (color image)
weight = trans_args.get('weight', 0.4)
epsilon = trans_args.get('epsilon', 2.e-4)
max_iter = trans_args.get('max_iter', 200)
for img in original_images:
img = denoise_tv_chambolle(img, weight=weight, eps=epsilon,
n_iter_max=max_iter, multichannel=True)
transformed_images.append(img)
elif denoise_trans == trans_configs.DENOISE_TRANSFORMATIONS.TV_BREGMAN.value:
# default 2 (grayscale); 15 (color image)
weight = trans_args.get('weight', 2)
epsilon = trans_args.get('epsilon', 1e-6)
max_iter = trans_args.get('max_iter', 50)
for img in original_images:
img_trans = denoise_tv_bregman(img, eps=epsilon, max_iter=max_iter, weight=weight)
transformed_images.append(img_trans)
elif denoise_trans == trans_configs.DENOISE_TRANSFORMATIONS.BILATERAL.value:
sigma_color = np.double(trans_args.get('sigma_color', 0.05))
sigma_spatial = np.double(trans_args.get('sigma_spatial', 15.0))
for img in original_images:
| |
pass
def MItMeshPolygon_getUVArea(*args, **kwargs):
pass
def MFnNumericData_getData2Double(*args, **kwargs):
pass
def MArrayDataHandle_setClean(*args, **kwargs):
pass
def MFnCamera_postProjectionMatrix(*args, **kwargs):
pass
def MDGContext_isNormal(*args, **kwargs):
pass
def MItDag_root(*args, **kwargs):
pass
def MFnArrayAttrsData_list(*args, **kwargs):
pass
def MGlobal_isZAxisUp(*args, **kwargs):
pass
def MGlobal_removeOptionVar(*args, **kwargs):
pass
def MVectorArray_set(*args, **kwargs):
pass
def MFnDagNode_drawOverrideEnabled(*args, **kwargs):
pass
def MTrimBoundaryArray_remove(*args, **kwargs):
pass
def MRampAttribute_swigregister(*args, **kwargs):
pass
def MMeshIsectAccelParams_swigregister(*args, **kwargs):
pass
def MNamespace_namespaceExists(*args, **kwargs):
pass
def MPointArray_insert(*args, **kwargs):
pass
def MComputation_setProgress(*args, **kwargs):
pass
def MFnUint64SingleIndexedComponent_className(*args, **kwargs):
pass
def MCacheFormatDescription_getChannelStartTime(*args, **kwargs):
pass
def delete_MContainerMessage(*args, **kwargs):
pass
def MPlug_child(*args, **kwargs):
pass
def MFloatPoint_className(*args, **kwargs):
pass
def MFnDependencyNode_attribute(*args, **kwargs):
pass
def MDagPath_inclusiveMatrixInverse(*args, **kwargs):
pass
def MMessageNode_fSubClientPtr_set(*args, **kwargs):
pass
def MArgList_asPoint(*args, **kwargs):
pass
def MFnMesh_hasColorChannels(*args, **kwargs):
pass
def MDataHandle_asDouble3(*args, **kwargs):
pass
def MAttributeSpec___eq__(*args, **kwargs):
pass
def MScriptUtil_asInt2Ptr(*args, **kwargs):
pass
def MFloatArray_setSizeIncrement(*args, **kwargs):
pass
def MQuaternion_x_set(*args, **kwargs):
pass
def new_MTesselationParams(*args, **kwargs):
pass
def MQuaternion_log(*args, **kwargs):
pass
def MFnReference_isExportEditsFile(*args, **kwargs):
pass
def MFnComponentListData_swigregister(*args, **kwargs):
pass
def MFnGeometryData_swiginit(*args, **kwargs):
pass
def MUserEventMessage_swiginit(*args, **kwargs):
pass
def MDoubleArray___add__(*args, **kwargs):
pass
def MFnLambertShader_setRefractedRayDepthLimit(*args, **kwargs):
pass
def MEvaluationNodeIterator_swigregister(*args, **kwargs):
pass
def MFnCamera_cameraScale(*args, **kwargs):
pass
def MFnNurbsSurface_swigregister(*args, **kwargs):
pass
def MItMeshEdge_className(*args, **kwargs):
pass
def MItMeshVertex_updateSurface(*args, **kwargs):
pass
def MFnCamera_horizontalRollPivot(*args, **kwargs):
pass
def MIteratorType_setObjectType(*args, **kwargs):
pass
def MTransformationMatrix_setRotationQuaternion(*args, **kwargs):
pass
def MFnSubd_levelMaxCurrent(*args, **kwargs):
pass
def MArrayDataHandle_assign(*args, **kwargs):
pass
def MFnLight_opticalFXvisibility(*args, **kwargs):
pass
def MDagPath_swigregister(*args, **kwargs):
pass
def MProfiler_getColor(*args, **kwargs):
pass
def MFnAreaLight_className(*args, **kwargs):
pass
def MProfiler_getCPUId(*args, **kwargs):
pass
def MGlobal_setSelectionMode(*args, **kwargs):
pass
def MIffFile_beginReadGroup(*args, **kwargs):
pass
def MFnDagNode_transformationMatrix(*args, **kwargs):
pass
def MImage_haveDepth(*args, **kwargs):
pass
def MFnNurbsSurface_removeKnotInV(*args, **kwargs):
pass
def MQuaternion_setToXAxis(*args, **kwargs):
pass
def MMatrix_assign(*args, **kwargs):
pass
def MFnMesh_componentTypeName(*args, **kwargs):
pass
def MPointArray___getitem__(*args, **kwargs):
pass
def MArgParser_numberOfFlagUses(*args, **kwargs):
pass
def MQuaternion___getitem__(*args, **kwargs):
pass
def MBoundingBox_swiginit(*args, **kwargs):
pass
def MItMeshVertex_getColor(*args, **kwargs):
pass
def MItDependencyGraph_setCurrentFilter(*args, **kwargs):
pass
def MFloatPoint___eq__(*args, **kwargs):
pass
def new_MMessageNode(*args, **kwargs):
pass
def MFnCamera_getPortFieldOfView(*args, **kwargs):
pass
def MFnCamera_focalLength(*args, **kwargs):
pass
def MFnAmbientLight_setCastSoftShadows(*args, **kwargs):
pass
def MColor_set(*args, **kwargs):
pass
def MFnCompoundAttribute_getAddAttrCmds(*args, **kwargs):
pass
def MArgParser_flagArgumentString(*args, **kwargs):
pass
def MDataHandle_asAddr(*args, **kwargs):
pass
def MFnSpotLight_setStartDistance(*args, **kwargs):
pass
def MScriptUtil_getShort(*args, **kwargs):
pass
def MSyntax_setMaxObjects(*args, **kwargs):
pass
def MFnSubd_polygonHasChildren(*args, **kwargs):
pass
def MFnPhongEShader_swiginit(*args, **kwargs):
pass
def MFnBlinnShader_swigregister(*args, **kwargs):
pass
def MFnComponent_weight(*args, **kwargs):
pass
def delete_MUserData(*args, **kwargs):
pass
def MFnSet_clear(*args, **kwargs):
pass
def MDoubleArray_insert(*args, **kwargs):
pass
def MFnAttribute_parent(*args, **kwargs):
pass
def MEvaluationManager_swigregister(*args, **kwargs):
pass
def MFnNurbsSurface_numUVs(*args, **kwargs):
pass
def MFnTransform_getTranslation(*args, **kwargs):
pass
def MItMeshEdge_center(*args, **kwargs):
pass
def MFloatVectorArray_swiginit(*args, **kwargs):
pass
def MRenderPassDef_swigregister(*args, **kwargs):
pass
def MItGeometry_component(*args, **kwargs):
pass
def MFnMesh_getUVAtPoint(*args, **kwargs):
pass
def new_MFnSubdData(*args, **kwargs):
pass
def new_MFnLight(*args, **kwargs):
pass
def MDagPath_assign(*args, **kwargs):
pass
def delete_MFnDependencyNode(*args, **kwargs):
pass
def MGlobal_clearSelectionList(*args, **kwargs):
pass
def MFnExpression_expression(*args, **kwargs):
pass
def MFnDagNode_hasChild(*args, **kwargs):
pass
def MFnNurbsSurface_numNonZeroSpansInU(*args, **kwargs):
pass
def MItSubdVertex_isValid(*args, **kwargs):
pass
def new_MMeshIsectAccelParams(*args, **kwargs):
pass
def MFnMesh_extrudeFaces(*args, **kwargs):
pass
def MObject___eq__(*args, **kwargs):
pass
def MDataHandle_swigregister(*args, **kwargs):
pass
def MTypeId_id(*args, **kwargs):
pass
def MItSelectionList_className(*args, **kwargs):
pass
def MFileObject_swigregister(*args, **kwargs):
pass
def MItDag_swiginit(*args, **kwargs):
pass
def MFloatPointArray_swiginit(*args, **kwargs):
pass
def MMessageNode_fHeadNode_get(*args, **kwargs):
pass
def MFnVectorArrayData_className(*args, **kwargs):
pass
def MFnNumericData_setData2Short(*args, **kwargs):
pass
def MFnGeometryData_matrixIsNotIdentity(*args, **kwargs):
pass
def MURI_setFileName(*args, **kwargs):
pass
def new_MArgDatabase(*args, **kwargs):
pass
def MScriptUtil_setInt3ArrayItem(*args, **kwargs):
pass
def MDataHandle_isGeneric(*args, **kwargs):
pass
def new_intPtr(*args, **kwargs):
pass
def new_MFnSpotLight(*args, **kwargs):
pass
def MURI_getPassword(*args, **kwargs):
pass
def MDGModifier_undoIt(*args, **kwargs):
pass
def MAttributePatternArray_sizeIncrement(*args, **kwargs):
pass
def MMatrixArray_assign(*args, **kwargs):
pass
def MTesselationParams_setFitTolerance(*args, **kwargs):
pass
def MFnSubd_edgeVertices(*args, **kwargs):
pass
def MFnCamera_setVerticalPan(*args, **kwargs):
pass
def delete_MItDependencyNodes(*args, **kwargs):
pass
def MTime___iadd__(*args, **kwargs):
pass
def MFnUnitAttribute_setMin(*args, **kwargs):
pass
def MFnCamera_tumblePivot(*args, **kwargs):
pass
def delete_boolPtr(*args, **kwargs):
pass
def MURI_getAllQueryItemKeys(*args, **kwargs):
pass
def MDataHandle_asDouble(*args, **kwargs):
pass
def MFnPointArrayData_create(*args, **kwargs):
pass
def MFloatVector___call__(*args, **kwargs):
pass
def MFnNonExtendedLight_setDepthMapFilterSize(*args, **kwargs):
pass
def MDistance_setUIUnit(*args, **kwargs):
pass
def MFnBase_className(*args, **kwargs):
pass
def MFnAttribute_setKeyable(*args, **kwargs):
pass
def MNodeClass_getAttributes(*args, **kwargs):
pass
def MFnNurbsSurface_isTrimmedSurface(*args, **kwargs):
pass
def MFnTransform_className(*args, **kwargs):
pass
def MItMeshEdge_isSmooth(*args, **kwargs):
pass
def MObjectArray_copy(*args, **kwargs):
pass
def MTimerMessage_className(*args, **kwargs):
pass
def delete_MAttributeSpecArray(*args, **kwargs):
pass
def MItGeometry_setPosition(*args, **kwargs):
pass
def MFnMesh_setCurrentUVSetName(*args, **kwargs):
pass
def MFnStringArrayData_array(*args, **kwargs):
pass
def delete_MFnContainerNode(*args, **kwargs):
pass
def MProfiler_swigregister(*args, **kwargs):
pass
def MFloatVector_x_set(*args, **kwargs):
pass
def MGlobal_deleteNode(*args, **kwargs):
pass
def MFnNurbsSurface_setCVs(*args, **kwargs):
pass
def MFnComponent_componentType(*args, **kwargs):
pass
def MMatrix_inverse(*args, **kwargs):
pass
def MFnMeshData_swiginit(*args, **kwargs):
pass
def MAngle_setUnit(*args, **kwargs):
pass
def MDataHandle_asGenericShort(*args, **kwargs):
pass
def MItMeshPolygon_tangentIndex(*args, **kwargs):
pass
def MItSubdVertex_reset(*args, **kwargs):
pass
def MFileObject_resolvedFullName(*args, **kwargs):
pass
def MItDependencyGraph_isTraversingOverWorldSpaceDependents(*args, **kwargs):
pass
def MFloatPointArray___getitem__(*args, **kwargs):
pass
def new_MDagModifier(*args, **kwargs):
pass
def MArrayDataHandle_inputArrayValue(*args, **kwargs):
pass
def MFnGenericAttribute_create(*args, **kwargs):
pass
def MUintArray___radd__(*args, **kwargs):
pass
def MItCurveCV_currentItem(*args, **kwargs):
pass
def MScriptUtil_getUint3ArrayItem(*args, **kwargs):
pass
def MEulerRotation_order_get(*args, **kwargs):
pass
def MFnSingleIndexedComponent_getElements(*args, **kwargs):
pass
def MDGModifier_newPlugValueBool(*args, **kwargs):
pass
def MAttributeSpec_name(*args, **kwargs):
pass
def MNamespace_currentNamespace(*args, **kwargs):
pass
def MDagPath_className(*args, **kwargs):
pass
def MTesselationParams_setStdFractionalTolerance(*args, **kwargs):
pass
def MFnCamera_horizontalShake(*args, **kwargs):
pass
def MFnLambertShader_setIncandescence(*args, **kwargs):
pass
def MTime_unit(*args, **kwargs):
pass
def doublePtr_value(*args, **kwargs):
pass
def MURI_setPort(*args, **kwargs):
pass
def MMeshSmoothOptions_setDivisions(*args, **kwargs):
pass
def MFnPluginData_className(*args, **kwargs):
pass
def MDistance_assign(*args, **kwargs):
pass
def MFnAttribute_isExtension(*args, **kwargs):
pass
def MPointOnNurbs_getPoint(*args, **kwargs):
pass
def MAttributeIndex_setUpper(*args, **kwargs):
pass
def MFnDependencyNode_swiginit(*args, **kwargs):
pass
def MFnAssembly_getRepNamespace(*args, **kwargs):
pass
def MTime_className(*args, **kwargs):
pass
def MFnMesh_getVertexNormal(*args, **kwargs):
pass
def MRenderPassRegistry_swigregister(*args, **kwargs):
pass
def MFnDagNode_drawOverrideColor(*args, **kwargs):
pass
def MFnMesh_isPolygonConvex(*args, **kwargs):
pass
def new_MDagPath(*args, **kwargs):
pass
def MFnMesh_isEdgeSmooth(*args, **kwargs):
pass
def MFnTransform_rotationOrder(*args, **kwargs):
pass
def array3dFloat_swiginit(*args, **kwargs):
pass
def MFnComponent_setComplete(*args, **kwargs):
pass
def MSelectionList_swigregister(*args, **kwargs):
pass
def MFnGeometryData_getMatrix(*args, **kwargs):
pass
def MFloatVector___iadd__(*args, **kwargs):
pass
def new_MRampAttribute(*args, **kwargs):
pass
def MFnNurbsSurfaceData_className(*args, **kwargs):
pass
def MItSubdVertex_index(*args, **kwargs):
pass
def MFnDoubleIndexedComponent_setCompleteData(*args, **kwargs):
pass
def delete_MFnMatrixData(*args, **kwargs):
pass
def MVector_z_get(*args, **kwargs):
pass
def MDataHandle_set2Short(*args, **kwargs):
pass
def MURI_removeQueryItem(*args, **kwargs):
pass
def MItMeshFaceVertex_className(*args, **kwargs):
pass
def MItSelectionList_isDone(*args, **kwargs):
pass
def MFileIO_swiginit(*args, **kwargs):
pass
def MItMeshPolygon_getEdges(*args, **kwargs):
pass
def MFnCamera_computeDepthOfField(*args, **kwargs):
pass
def MFnExpression_swiginit(*args, **kwargs):
pass
def MArrayDataHandle_jumpToElement(*args, **kwargs):
pass
def MUintArray_insert(*args, **kwargs):
pass
def MURI_removeAllQueryItems(*args, **kwargs):
pass
def MInt64Array_remove(*args, **kwargs):
pass
def MQuaternion_setAxisAngle(*args, **kwargs):
pass
def MEulerRotation_boundIt(*args, **kwargs):
pass
def MFnSet_intersectsWith(*args, **kwargs):
pass
def new_MDGModifier(*args, **kwargs):
pass
def MIntArray_className(*args, **kwargs):
pass
def MMatrixArray_swiginit(*args, **kwargs):
pass
def MStreamUtils_writeCharBuffer(*args, **kwargs):
pass
def MFnCamera_horizontalFilmAperture(*args, **kwargs):
pass
def MPointArray_swigregister(*args, **kwargs):
pass
def MURI_isEmpty(*args, **kwargs):
pass
def delete_MFnTypedAttribute(*args, **kwargs):
pass
def uIntPtr_swiginit(*args, **kwargs):
pass
def MMeshIntersector_getClosestPoint(*args, **kwargs):
pass
def MFnPhongEShader_highlightSize(*args, **kwargs):
pass
def MFnAnisotropyShader_setCorrelationX(*args, **kwargs):
pass
def MNurbsIntersector_getIntersects(*args, **kwargs):
pass
def MFnDependencyNode_getExternalContent(*args, **kwargs):
pass
def MFnAssembly_getTopLevelAssemblies(*args, **kwargs):
pass
def MFnPluginData_create(*args, **kwargs):
pass
def MFnMesh_getDoubleBlindData(*args, **kwargs):
pass
def MPlugArray_swiginit(*args, **kwargs):
pass
def MFnMesh_getVertices(*args, **kwargs):
pass
def MRampAttribute_className(*args, **kwargs):
pass
def MDAGDrawOverrideInfo_fDisplayType_set(*args, **kwargs):
pass
def MScriptUtil_asShort(*args, **kwargs):
pass
def new_array3dFloat(*args, **kwargs):
pass
def MFloatMatrix___ne__(*args, **kwargs):
pass
def MSelectionMask_swiginit(*args, **kwargs):
pass
def MFloatVectorArray_get(*args, **kwargs):
pass
def MFloatArray_sizeIncrement(*args, **kwargs):
pass
def MURI_clear(*args, **kwargs):
pass
def MQuaternion_invertIt(*args, **kwargs):
pass
def MCacheFormatDescription_getChannelName(*args, **kwargs):
pass
def MFnLayeredShader_hardwareColor(*args, **kwargs):
pass
def MFnDoubleArrayData___getitem__(*args, **kwargs):
pass
def MFnMatrixArrayData_length(*args, **kwargs):
pass
def MVector_rotateBy(*args, **kwargs):
pass
def MDataHandle_asPluginData(*args, **kwargs):
pass
def MVectorArray_insert(*args, **kwargs):
pass
def MFileIO_isSavingReference(*args, **kwargs):
pass
def MItMeshPolygon_getNormal(*args, **kwargs):
pass
def MFileIO_resetError(*args, **kwargs):
pass
def MItSubdVertex_swigregister(*args, **kwargs):
pass
def MFnFloatArrayData___getitem__(*args, **kwargs):
pass
def MArgParser_isQuery(*args, **kwargs):
pass
def MFnCamera_setNearClippingPlane(*args, **kwargs):
pass
def MArrayDataHandle_elementIndex(*args, **kwargs):
pass
def MDGMessage_addNodeChangeUuidCheckCallback(*args, **kwargs):
pass
def MInt64Array_assign(*args, **kwargs):
pass
def MFnAttribute_isReadable(*args, **kwargs):
pass
def MEulerRotation___sub__(*args, **kwargs):
pass
def MFnAnisotropyShader_rotateAngle(*args, **kwargs):
pass
def MMeshSmoothOptions_setBoundaryRule(*args, **kwargs):
pass
def MImageFileInfo_hasMipMaps(*args, **kwargs):
pass
def MImage_writeToFile(*args, **kwargs):
pass
def MModelMessage_addCallback(*args, **kwargs):
pass
def MFnNumericData_create(*args, **kwargs):
pass
def MFnCamera_upDirection(*args, **kwargs):
pass
def MPlane_setPlane(*args, **kwargs):
pass
def MTesselationParams_setUNumber(*args, **kwargs):
pass
def MFnUint64SingleIndexedComponent_element(*args, **kwargs):
pass
def floatPtr_frompointer(*args, **kwargs):
pass
def MCallbackIdArray_setSizeIncrement(*args, **kwargs):
pass
def charPtr_frompointer(*args, **kwargs):
pass
def MFnPointArrayData_className(*args, **kwargs):
pass
def MFnAmbientLight_castSoftShadows(*args, **kwargs):
pass
def MPlug_setInt64(*args, **kwargs):
pass
def MNurbsIntersector_swigregister(*args, **kwargs):
pass
def MFnDependencyNode_deallocateFlag(*args, **kwargs):
pass
def MFnLambertShader_refractiveIndex(*args, **kwargs):
pass
def MFnNurbsCurve_normal(*args, **kwargs):
pass
def MFnMesh_clearColors(*args, **kwargs):
pass
def MPlugArray_length(*args, **kwargs):
pass
def MArgList_addArg(*args, **kwargs):
pass
def MFnMesh_cachedIntersectionAcceleratorInfo(*args, **kwargs):
pass
def MQuaternion_conjugateIt(*args, **kwargs):
pass
def MDagPathArray_setLength(*args, **kwargs):
pass
def MScriptUtil_asDouble(*args, **kwargs):
pass
def delete_MFloatMatrix(*args, **kwargs):
pass
def MSceneMessage_addConnectionFailedCallback(*args, **kwargs):
pass
def MRampAttribute_isCurveRamp(*args, **kwargs):
pass
def MFnDirectionalLight_create(*args, **kwargs):
pass
def MFnLatticeData_lattice(*args, **kwargs):
pass
def MFnFloatArrayData_create(*args, **kwargs):
pass
def MFnCameraSet_setLayerSceneData(*args, **kwargs):
pass
def MVector_assign(*args, **kwargs):
pass
def intPtr_swigregister(*args, **kwargs):
pass
def MFileIO_exportSelectedAnimFromReference(*args, **kwargs):
pass
def MItMeshPolygon_hasValidTriangulation(*args, **kwargs):
pass
def MItMeshFaceVertex_getNormal(*args, **kwargs):
pass
def MItMeshVertex_getConnectedFaces(*args, **kwargs):
pass
def MFnAnisotropyShader_anisotropicReflectivity(*args, **kwargs):
pass
def MFnCamera_setDisplayGateMask(*args, **kwargs):
pass
def MTrimBoundaryArray_clear(*args, **kwargs):
pass
def MFnSubd_vertexBaseMeshGetWithId(*args, **kwargs):
pass
def MAttributeIndex_className(*args, **kwargs):
pass
def MDGContext_getTime(*args, **kwargs):
pass
def MItCurveCV_reset(*args, **kwargs):
pass
def MFnArrayAttrsData_checkArrayExist(*args, **kwargs):
pass
def MFnCamera_projectionMatrix(*args, **kwargs):
pass
def MGlobal_setZAxisUp(*args, **kwargs):
pass
def MGlobal_errorLogPathName(*args, **kwargs):
pass
def MFnDagNode_drawOverrideIsReference(*args, **kwargs):
pass
def MImage_className(*args, **kwargs):
pass
def MFnCamera_setClippingPlanes(*args, **kwargs):
pass
def MFnPointArrayData_set(*args, **kwargs):
pass
def MItMeshPolygon_index(*args, **kwargs):
pass
def MFnMesh_componentTypeFromName(*args, **kwargs):
pass
def MPointArray_setLength(*args, **kwargs):
pass
def MComputation_progress(*args, **kwargs):
pass
def MFnSubdNames_levelOneFaceIndexFromId(*args, **kwargs):
pass
def MCacheFormatDescription_getChannelEndTime(*args, **kwargs):
pass
def MContainerMessage_swigregister(*args, **kwargs):
pass
def MPlug_isConnected(*args, **kwargs):
pass
def MFloatPoint_swigregister(*args, **kwargs):
pass
def MFnDependencyNode_attributeClass(*args, **kwargs):
pass
def MFloatPoint_x_set(*args, **kwargs):
pass
def MMessageNode_fSubClientPtr_get(*args, **kwargs):
pass
def MArgDatabase_getFlagArgument(*args, **kwargs):
pass
def MFnMesh_hasAlphaChannels(*args, **kwargs):
pass
def MDataHandle_asVector(*args, **kwargs):
pass
def MAttributeSpec_swigregister(*args, **kwargs):
pass
def MScriptUtil_setFloatArray(*args, **kwargs):
pass
def MProfiler_getEventDuration(*args, **kwargs):
pass
def delete_MAttributeIndex(*args, **kwargs):
pass
def MFnSubd_updateSubdSurface(*args, **kwargs):
pass
def MQuaternion___imul__(*args, **kwargs):
pass
def MFnReference_swigregister(*args, **kwargs):
pass
def MFnComponentListData_swiginit(*args, **kwargs):
pass
def delete_MFnIntArrayData(*args, **kwargs):
pass
def new_MUuid(*args, **kwargs):
pass
def MFnDirectionalLight_useLightPosition(*args, **kwargs):
pass
def MVectorArray_setLength(*args, **kwargs):
pass
def MQuaternion___eq__(*args, **kwargs):
pass
def MEvaluationNodeIterator_swiginit(*args, **kwargs):
pass
def MFnNurbsSurface_swiginit(*args, **kwargs):
pass
def MItMeshEdge_swigregister(*args, **kwargs):
pass
def MItMeshPolygon_zeroUVArea(*args, **kwargs):
pass
def MTransformationMatrix_setShear(*args, **kwargs):
pass
def MFnCamera_setVerticalRollPivot(*args, **kwargs):
pass
def MItEdits_reset(*args, **kwargs):
pass
def MTransformationMatrix_translation(*args, **kwargs):
pass
def MFnSubd_levelMaxAllowed(*args, **kwargs):
pass
def MArrayDataBuilder_assign(*args, **kwargs):
pass
def MFnPointArrayData_swiginit(*args, **kwargs):
pass
def MFnLight_setOpticalFXvisibility(*args, **kwargs):
pass
def MDagPath_swiginit(*args, **kwargs):
pass
def new_MFnAreaLight(*args, **kwargs):
pass
def MProfiler_getDescription(*args, **kwargs):
pass
def MIffTag_swigregister(*args, **kwargs):
pass
def MTime___sub__(*args, **kwargs):
pass
def MIntArray_sizeIncrement(*args, **kwargs):
pass
def MMatrix_isSingular(*args, **kwargs):
pass
def MFnNumericAttribute_child(*args, **kwargs):
pass
def MPlug_className(*args, **kwargs):
pass
def new_MFnNonAmbientLight(*args, **kwargs):
pass
def MArgParser_flagArgumentBool(*args, **kwargs):
pass
def MCommandResult_resultType(*args, **kwargs):
pass
def array3dDouble_swigregister(*args, **kwargs):
pass
def MParentingEdit_parent(*args, **kwargs):
pass
def MCacheFormatDescription_setDistribution(*args, **kwargs):
pass
def delete_MItSubdVertex(*args, **kwargs):
pass
def MItDag_fullPathName(*args, **kwargs):
pass
def MPlug_setDouble(*args, **kwargs):
pass
def MFloatPoint___ne__(*args, **kwargs):
pass
def MFnDagNode_isIntermediateObject(*args, **kwargs):
pass
def delete_MFnNurbsSurface(*args, **kwargs):
pass
def MFnNurbsCurveData_swiginit(*args, **kwargs):
pass
def MDataHandle_asShort2(*args, **kwargs):
pass
def MFnGenericAttribute_addNumericDataAccept(*args, **kwargs):
pass
def delete_charPtr(*args, **kwargs):
pass
def MArgParser_commandArgumentMAngle(*args, **kwargs):
pass
def MDataHandle_asFloat(*args, **kwargs):
pass
def MFnSpotLight_endDistance(*args, **kwargs):
pass
def MAttributePatternArray_assign(*args, **kwargs):
pass
def MScriptUtil_getFloat(*args, **kwargs):
pass
def MSyntax_className(*args, **kwargs):
pass
def MFnSubd_polygonChildren(*args, **kwargs):
pass
def delete_MFnCompoundAttribute(*args, **kwargs):
pass
def MFnBlinnShader_swiginit(*args, **kwargs):
pass
def MFnComponent_setWeight(*args, **kwargs):
pass
def MUserData_deleteAfterUse(*args, **kwargs):
pass
def MFnSet_getMembers(*args, **kwargs):
pass
def MDoubleArray_append(*args, **kwargs):
pass
def MFnAttribute_name(*args, **kwargs):
pass
def delete_MEvaluationNode(*args, **kwargs):
pass
def MFnNurbsSurface_setUVs(*args, **kwargs):
pass
def MFnTransform_setTranslation(*args, **kwargs):
pass
def MItInstancer_instancerPath(*args, **kwargs):
pass
def MQuaternion_setToZAxis(*args, **kwargs):
pass
def MTransformationMatrix_addScale(*args, **kwargs):
pass
def MRenderPassDef_addFloatParameter(*args, **kwargs):
pass
def delete_MIteratorType(*args, **kwargs):
pass
def MFnMesh_getAxisAtPoint(*args, **kwargs):
pass
def MFnSubdData_create(*args, **kwargs):
pass
def MFnLight_color(*args, **kwargs):
pass
def MDagPath___eq__(*args, **kwargs):
pass
def MProfiler_setCategoryRecording(*args, **kwargs):
pass
def MFnDependencyNode_className(*args, **kwargs):
pass
def MGlobal_setMiscSelectionMask(*args, | |
import torch
from torch import nn
from torch.nn import functional as F
from torch.nn.modules.utils import _pair
from detectron2.layers.wrappers import _NewEmptyTensorOp
from ..spatial_conv import _SpatialConv
__all__ = [
"R4ConvF", "R4Conv",#"R4ConvL", "R4TConv", "ginterpolate"
]
spatial_conv = _SpatialConv.apply
class GConvF(nn.Module):
def __init__(
self,
in_channels,
out_channels,
kernel_type="3x3",
stride=1,
padding=0,
dilation=1,
bias=False,
norm=None,
activation=None,
):
"""
kernel_type (int): skel, 3x3
norm (nn.Module, optional): a normalization layer
activation (callable(Tensor) -> Tensor): a callable activation function
"""
super(GConvF, self).__init__()
assert not bias
self.in_channels = in_channels
self.out_channels = out_channels
self.stride = _pair(stride)
self.padding = _pair(padding)
self.dilation = _pair(dilation)
self.norm = norm
self.activation = activation
if kernel_type == "skel":
self.kernel_type = 0
self.num_kernel = 5
elif kernel_type == "3x3":
self.kernel_type = 1
self.num_kernel = 9
else:
self.kernel_type = 2
self.num_kernel = 3
self.weight = nn.Parameter(
torch.Tensor(out_channels, in_channels, self.num_kernel), requires_grad=True
)
self.bias = None
nn.init.kaiming_uniform_(self.weight, nonlinearity="relu")
def forward(self, x):
if x.numel() == 0:
output_shape = [
(i + 2 * p - (di * (k - 1) + 1)) // s + 1
for i, p, di, k, s in zip(
x.shape[-2:], self.padding, self.dilation, (3, 3), self.stride
)
]
output_shape = [x.shape[0], self.weight.shape[0]] + output_shape + [4]
return _NewEmptyTensorOp.apply(x, output_shape)
x_1 = spatial_conv(x, self.weight, self.kernel_type, self.num_kernel, 0, self.stride, self.padding, self.dilation).sum(0)
x_2 = spatial_conv(x, self.weight, self.kernel_type, self.num_kernel, 2, self.stride, self.padding, self.dilation).sum(0)
x_3 = spatial_conv(x, self.weight, self.kernel_type, self.num_kernel, 4, self.stride, self.padding, self.dilation).sum(0)
x_4 = spatial_conv(x, self.weight, self.kernel_type, self.num_kernel, 6, self.stride, self.padding, self.dilation).sum(0)
if self.norm != None:
x_1 = self.norm(x_1)
x_2 = self.norm(x_2)
x_3 = self.norm(x_3)
x_4 = self.norm(x_4)
x_out = torch.stack([x_1, x_2, x_3, x_4], dim=4)
if self.activation is not None:
x_out = self.activation(x_out)
return x_out
def extra_repr(self):
tmpstr = "in_channels=" + str(self.in_channels)
tmpstr += ", out_channels=" + str(self.out_channels)
tmpstr += ", kernel_type=" + str(self.kernel_type)
tmpstr += ", stride=" + str(self.stride)
tmpstr += ", padding=" + str(self.padding)
tmpstr += ", dilation=" + str(self.dilation)
tmpstr += ", bias=False"
return tmpstr
class GConv(nn.Module):
def __init__(
self,
in_channels,
out_channels,
kernel_type="3x3",
stride=1,
padding=0,
dilation=1,
bias=False,
norm=None,
activation=None,
with_1x1=False,
):
"""
kernel_type (int): skel, ex-skel, 3x3
norm (nn.Module, optional): a normalization layer
activation (callable(Tensor) -> Tensor): a callable activation function
"""
super(GConv, self).__init__()
assert not bias
self.in_channels = in_channels
self.out_channels = out_channels
self.stride = _pair(stride)
self.padding = _pair(padding)
self.dilation = _pair(dilation)
self.norm = norm
self.activation = activation
self.with_1x1 = with_1x1
in_channels = in_channels if with_1x1 else 4 * in_channels
if kernel_type == "skel":
self.kernel_type = 0
self.num_kernel = 5
elif kernel_type == "3x3":
self.kernel_type = 1
self.num_kernel = 9
else:
self.kernel_type = 2
self.num_kernel = 3
self.weight = nn.Parameter(
torch.Tensor(out_channels, in_channels, self.num_kernel), requires_grad=True
)
self.bias = None
nn.init.kaiming_uniform_(self.weight, nonlinearity="relu")
def forward(self, x_tensor):
if x_tensor.numel() == 0:
output_shape = [
(i + 2 * p - (di * (k - 1) + 1)) // s + 1
for i, p, di, k, s in zip(
x_tensor.shape[-2:], self.padding, self.dilation, (3, 3), self.stride
)
]
output_shape = [x_tensor.shape[0], self.weight.shape[0]] + output_shape + [4]
return _NewEmptyTensorOp.apply(x_tensor, output_shape)
if self.with_1x1:
x_1 = x_tensor[:, :, :, :, 0]
x_2 = x_tensor[:, :, :, :, 1]
x_3 = x_tensor[:, :, :, :, 2]
x_4 = x_tensor[:, :, :, :, 3]
else:
x_in = [x_tensor[:, :, :, :, 0], x_tensor[:, :, :, :, 1], x_tensor[:, :, :, :, 2], x_tensor[:, :, :, :, 3]]
x_1 = torch.cat([x_in[0], x_in[1], x_in[2], x_in[3]], dim=1)
x_2 = torch.cat([x_in[1], x_in[2], x_in[3], x_in[0]], dim=1)
x_3 = torch.cat([x_in[2], x_in[3], x_in[0], x_in[1]], dim=1)
x_4 = torch.cat([x_in[3], x_in[0], x_in[1], x_in[2]], dim=1)
x_1 = spatial_conv(x_1, self.weight, self.kernel_type, self.num_kernel, 0, self.stride, self.padding, self.dilation).sum(0)
x_2 = spatial_conv(x_2, self.weight, self.kernel_type, self.num_kernel, 2, self.stride, self.padding, self.dilation).sum(0)
x_3 = spatial_conv(x_3, self.weight, self.kernel_type, self.num_kernel, 4, self.stride, self.padding, self.dilation).sum(0)
x_4 = spatial_conv(x_4, self.weight, self.kernel_type, self.num_kernel, 6, self.stride, self.padding, self.dilation).sum(0)
if self.norm != None:
x_1 = self.norm(x_1)
x_2 = self.norm(x_2)
x_3 = self.norm(x_3)
x_4 = self.norm(x_4)
x_out = torch.stack([x_1, x_2, x_3, x_4], dim=4)
if self.activation is not None:
x_out = self.activation(x_out)
return x_out
def extra_repr(self):
tmpstr = "in_channels=" + str(self.in_channels)
tmpstr += ", out_channels=" + str(self.out_channels)
tmpstr += ", kernel_type=" + str(self.kernel_type)
tmpstr += ", stride=" + str(self.stride)
tmpstr += ", padding=" + str(self.padding)
tmpstr += ", dilation=" + str(self.dilation)
tmpstr += ", bias=False"
return tmpstr
class GConvL(nn.Module):
def __init__(
self,
in_channels,
out_channels,
kernel_size,
groups,
stride=1,
padding=0,
dilation=1,
bias=False,
norm=None,
activation=None,
):
super(GConvL, self).__init__()
self.in_channels = in_channels
self.out_channels = out_channels
self.kernel_size = _pair(kernel_size)
self.stride = _pair(stride)
self.groups = groups
self.with_bias = bias
self.padding = padding
self.dilations = dilation
self.norm = norm
self.activation = activation
self.weight = nn.Parameter(torch.Tensor(out_channels, groups * in_channels, *self.kernel_size))
if bias:
self.bias = nn.Parameter(torch.Tensor(out_channels))
else:
self.bias = None
nn.init.kaiming_uniform_(self.weight, nonlinearity="relu")
if self.bias is not None:
nn.init.constant_(self.bias, 0)
def forward(self, x_tensor):
x_in = [x_tensor[:, :, :, :, 0], x_tensor[:, :, :, :, 1], x_tensor[:, :, :, :, 2], x_tensor[:, :, :, :, 3]]
x = torch.cat([x_in[0], x_in[1], x_in[2], x_in[3]], dim=1)
x = F.conv2d(x, weight=self.weight, bias=self.bias, stride=self.stride, padding=self.padding, dilation=self.dilations)
if self.norm != None:
x = self.norm(x)
if self.activation != None:
x = self.activation(x)
return x
def extra_repr(self):
tmpstr = "in_channels=" + str(self.in_channels)
tmpstr += ", out_channels=" + str(self.out_channels)
tmpstr += ", kernel_size=" + str(self.kernel_size)
tmpstr += ", stride=" + str(self.stride)
tmpstr += ", padding=" + str(self.padding)
tmpstr += ", dilation=" + str(self.dilations)
tmpstr += ", groups=" + str(self.groups)
tmpstr += ", bias=" + str(self.with_bias)
return tmpstr
class R4ConvF(GConvF):
def __init__(
self,
in_channels,
out_channels,
kernel_type="3x3",
stride=1,
padding=0,
dilation=1,
bias=False,
norm=None,
activation=None,
):
super(R4ConvF, self).__init__(
in_channels,
out_channels,
kernel_type,
stride,
padding,
dilation,
bias,
norm,
activation)
class R4Conv(GConv):
def __init__(
self,
in_channels,
out_channels,
kernel_type="3x3",
stride=1,
padding=0,
dilation=1,
bias=False,
norm=None,
activation=None,
with_1x1=False,
):
super(R4Conv, self).__init__(
in_channels,
out_channels,
kernel_type,
stride,
padding,
dilation,
bias,
norm,
activation,
with_1x1)
# class R4ConvL(GConvL):
# def __init__(
# self,
# in_channels,
# out_channels,
# kernel_size,
# stride=1,
# padding=0,
# dilation=1,
# groups=4,
# bias=False,
# norm=None,
# activation=None,
# ):
# super(R4ConvL, self).__init__(
# in_channels,
# out_channels,
# kernel_size,
# groups,
# stride,
# padding,
# dilation,
# bias,
# norm,
# activation)
#
# class GTConv(nn.Module):
# def __init__(
# self,
# in_channels,
# out_channels,
# kernel_size,
# groups,
# stride=1,
# paddings=0,
# dilations=1,
# num_branch=1,
# test_branch_idx=-1,
# bias=False,
# norm=None,
# activation=None,
# ):
# super(GTConv, self).__init__()
# self.in_channels = in_channels
# self.out_channels = out_channels
# self.kernel_size = _pair(kernel_size)
# self.num_branch = num_branch
# self.stride = _pair(stride)
# self.groups = groups
# self.with_bias = bias
# if isinstance(paddings, int):
# paddings = [paddings] * self.num_branch
# if isinstance(dilations, int):
# dilations = [dilations] * self.num_branch
# self.paddings = [_pair(padding) for padding in paddings]
# self.dilations = [_pair(dilation) for dilation in dilations]
# self.test_branch_idx = test_branch_idx
# self.norm = norm
# self.activation = activation
#
# assert len({self.num_branch, len(self.paddings), len(self.dilations)}) == 1
#
# self.weight = nn.Parameter(torch.Tensor(out_channels, groups * in_channels, *self.kernel_size))
#
# if bias:
# self.bias = nn.Parameter(torch.Tensor(out_channels))
# else:
# self.bias = None
#
# nn.init.kaiming_uniform_(self.weight, nonlinearity="relu")
# if self.bias is not None:
# nn.init.constant_(self.bias, 0)
#
# def forward(self, inputs):
# num_branch = self.num_branch if self.training or self.test_branch_idx == -1 else 1
# assert len(inputs) == num_branch
#
# if inputs[0].numel() == 0:
# output_shape = [
# (i + 2 * p - (di * (k - 1) + 1)) // s + 1
# for i, p, di, k, s in zip(
# inputs[0].shape[-2:], self.padding, self.dilation, self.kernel_size, self.stride
# )
# ]
# output_shape = [inputs[0].shape[0], self.weight.shape[0]] + output_shape
# return [_NewEmptyTensorOp.apply(input, output_shape) for input in inputs]
#
# if self.training or self.test_branch_idx == -1:
# outputs = []
# for x_tensor, dilation, padding in zip(inputs, self.dilations, self.paddings):
# x_in = [x_tensor[:, :, :, :, 0], x_tensor[:, :, :, :, 1], x_tensor[:, :, :, :, 2],
# x_tensor[:, :, :, :, 3]]
#
# weight_1 = self.weight
# weight_2 = self.weight.rot90(1, [2, 3])
# weight_3 = self.weight.rot90(2, [2, 3])
# weight_4 = self.weight.rot90(3, [2, 3])
#
# x_1 = torch.cat([x_in[0], x_in[1], x_in[2], x_in[3]], dim=1)
# x_2 = torch.cat([x_in[1], x_in[2], x_in[3], x_in[0]], dim=1)
# x_3 = torch.cat([x_in[2], x_in[3], x_in[0], x_in[1]], dim=1)
# x_4 = torch.cat([x_in[3], x_in[0], x_in[1], x_in[2]], dim=1)
#
# x_1 = F.conv2d(x_1, weight=weight_1, bias=self.bias, stride=self.stride, padding=padding,
# dilation=dilation)
# x_2 = F.conv2d(x_2, weight=weight_2, bias=self.bias, stride=self.stride, padding=padding,
# dilation=dilation)
# x_3 = F.conv2d(x_3, weight=weight_3, bias=self.bias, stride=self.stride, padding=padding,
# dilation=dilation)
# x_4 = F.conv2d(x_4, weight=weight_4, bias=self.bias, stride=self.stride, padding=padding,
# dilation=dilation)
#
# if self.norm != None:
# x_1 = self.norm(x_1)
# x_2 = self.norm(x_2)
# x_3 = self.norm(x_3)
# x_4 = self.norm(x_4)
#
# x_out = torch.stack([x_1, x_2, x_3, x_4], dim=4)
#
# if self.activation != None:
# x_out = self.activation(x_out)
# outputs.append(x_out)
#
# else:
# outputs = []
# x_tensor = inputs[0]
# x_in = [x_tensor[:, :, :, :, 0], x_tensor[:, :, :, :, 1], x_tensor[:, :, :, :, 2],
# x_tensor[:, :, :, :, 3]]
#
# weight_1 | |
values (default: %(default)s)')
parser.add_argument('--synthesis-bool-only', action='store_true',
help='synthesize only boolean expressions (default: %(default)s)')
parser.add_argument('--max-z3-trials', metavar='NUM', type=int, default=2,
help='maxium Z3 trials when using SemFix synthesizer (default: %(default)s)')
parser.add_argument('--dump-only', action='store_true',
help='dump actual outputs for given tests (default: %(default)s)')
parser.add_argument('--synthesis-only', metavar="FILE", default=None,
help='synthesize and validate patch from angelic forest (default: %(default)s)')
parser.add_argument('--invalid-localization', action='store_true',
help='[deprecated] use tests that fail in golden version for localization (default: %(default)s)')
parser.add_argument('--verbose', action='store_true',
help='print compilation and KLEE messages (default: %(default)s)')
parser.add_argument('--mute-config-message', action='store_true',
help='mute configure message (default: %(default)s)')
parser.add_argument('--mute-build-message', action='store_true',
help='mute build message (default: %(default)s)')
parser.add_argument('--quiet', action='store_true',
help='print only errors (default: %(default)s)')
parser.add_argument('--gobble-klee-message', action='store_true',
help='Gobble klee message (default: %(default)s)')
parser.add_argument('--mute-test-message', action='store_true',
help='mute test message (default: %(default)s)')
parser.add_argument('--show-test-message', action='store_true',
help='show test message (default: %(default)s)')
parser.add_argument('--show-oracle-contents', action='store_true',
help='show the contents of the oracle (default: %(default)s)')
parser.add_argument('--show-syn-message', action='store_true',
help='show synthesis message (default: %(default)s)')
parser.add_argument('--mute-warning', action='store_true',
help='mute warning message (default: %(default)s)')
parser.add_argument('--ignore-lines', action='store_true',
help='[deprecated] ignore --lines options (default: %(default)s)')
parser.add_argument('--ignore-instrument', action='store_true',
help='default: %(default)s')
parser.add_argument('--ignore-unmatched-execution', action='store_true',
help='default: %(default)s')
parser.add_argument('--all-suspicious', action='store_true',
help='consider all suspicious locations (default: %(default)s)')
parser.add_argument('--show-suspicious-locations', action='store_true',
help='show all suspicious locations and their scores \
(default: %(default)s)')
parser.add_argument('--tests-summary', action='store_true',
help='run validation and golden tests and summarize the tests (default: %(default)s)')
parser.add_argument('--compilation-db-file',
help='Use the provided compilation db file')
parser.add_argument('--keep-angelix-dir', action='store_true',
help='keep .angelix dir (default: %(default)s)')
parser.add_argument('--skip-configure', action='store_true',
help='skip configure (default: %(default)s)')
parser.add_argument('--skip-build', action='store_true',
help='skip build (default: %(default)s)')
parser.add_argument('--angelic-search-strategy', metavar='STRATEGY', default='guided',
choices=ANGELIC_SEARCH_STRATEGIES,
help='angelic search strategy. choices: '
+ ', '.join(ANGELIC_SEARCH_STRATEGIES))
parser.add_argument('--step-method', metavar='STEP', default='metropolis',
choices=STEP_METHODS,
help='step method. choices: '
+ ', '.join(STEP_METHODS))
parser.add_argument('--search-max-trials', metavar='NUM', type=int, default=100,
help='max number of search trials (default: %(default)s)')
parser.add_argument('--max-same-cost-iter', metavar='NUM', type=int, default=20,
help='possible max iteration of the same cost (default: %(default)s)')
parser.add_argument('--one-bit-flip-prob', metavar='NUM', type=float, default=0.5,
help='probability that one bit flips (default: %(default)s)')
parser.add_argument('--mcmc-beta', metavar='NUM', type=float, default=0.8,
help='MCMC beta (default: %(default)s)')
parser.add_argument('--chunk-bits', metavar='NUM', type=int, default=32,
help='the number of bits for a chunk (default: %(default)s)')
parser.add_argument('--max-bits', metavar='NUM', type=int, default=100,
help='max number of bits (default: %(default)s)')
parser.add_argument('--max-resample', metavar='NUM', type=int, default=3,
help='max resample (default: %(default)s)')
parser.add_argument('--block-expand-factor', metavar='NUM', type=float, default=2,
help='block expand factor (default: %(default)s)')
parser.add_argument('--inc-fix', action='store_true', default=False,
help='allow incremental fix (default: %(default)s)')
parser.add_argument('--fixed-bv-len', action='store_true', default=False,
help='use a fixed the bitvector length (default: %(default)s)')
parser.add_argument('--max-syn-attempts', metavar='NUM', type=float, default=2,
help='maximum synthesis attempts (default: %(default)s)')
parser.add_argument('--max-repair-attempts', metavar='NUM', type=float, default=2,
help='maximum repair attempts for each location group \
(default: %(default)s)')
parser.add_argument('--default-max-cost', metavar='NUM', type=float, default=2,
help='default max cost (default: %(default)s)')
parser.add_argument('--error-cost', metavar='NUM', type=str, default="0",
help='error cost (default: %(default)s)')
parser.add_argument('--warning-cost', metavar='NUM', type=str, default="0",
help='warning cost (default: %(default)s)')
parser.add_argument('--penalty1', metavar='NUM', type=str, default="1",
help='penalty1 (default: %(default)s)')
parser.add_argument('--penalty2', metavar='NUM', type=str, default="1",
help='penalty2 (default: %(default)s)')
parser.add_argument('--default-non-zero-cost', metavar='NUM', type=str, default="1",
help='Used when test fails to generate non-zero cost. \
(default: %(default)s)')
parser.add_argument('--timeout-cost', metavar='NUM', type=str, default="1",
help='cost used when timeout occurs. \
(default: %(default)s)')
parser.add_argument('--log', metavar='LOG', default=None,
choices=['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'],
help='set the logging level')
parser.add_argument('--parallel-testing', action='store_true',
help='perform testing in parallel (default: %(default)s)')
parser.add_argument('--mutate', metavar='NUM', type=str, default="0",
help='mutate the golden version (default: %(default)s)')
parser.add_argument('--epsilon', metavar='NUM', type=float, default="1",
help='cost difference less than epsilon is considered the same.\
(default: %(default)s)')
parser.add_argument('--default-susp-score', metavar='NUM', type=float, default="0.5",
help='default suspiciousness score.\
(default: %(default)s)')
parser.add_argument('--additional-susp-locs', metavar='DC:NUM-NUM-NUM-NUM',
type=str, nargs='+', default=None,
help='additional suspicious locations.(default: %(default)s)')
parser.add_argument('--always-accept', action='store_true',
help='always accept a proposal in MCMC (default: %(default)s)')
parser.add_argument('--random-cost', action='store_true',
help='use random cost in MCMC. (default: %(default)s)')
parser.add_argument('--max-random-cost', metavar='NUM', type=str, default="0",
help='maxium random cost. (default: %(default)s)')
parser.add_argument('--skip-dd', action='store_true',
help='skip delta debugging for spec inference (default: %(default)s)')
parser.add_argument('--finish-after-fault-localize', action='store_true',
help='finish after fault localization (default: %(default)s)')
parser.add_argument('--version', action='version', version='Angelix 1.1')
args = parser.parse_args()
working_dir = join(os.getcwd(), ".angelix")
if not args.keep_angelix_dir:
if exists(working_dir):
shutil.rmtree(working_dir, onerror=rm_force)
os.mkdir(working_dir)
rootLogger = logging.getLogger()
FORMAT = logging.Formatter('%(levelname)-8s %(name)-15s %(message)s')
if args.quiet:
rootLogger.setLevel(logging.WARNING)
elif args.log is not None:
log_level = getattr(logging, args.log, None)
rootLogger.setLevel(log_level)
else:
rootLogger.setLevel(logging.INFO)
fileHandler = logging.FileHandler("{0}/{1}.log".format(working_dir, 'angelix'))
fileHandler.setFormatter(FORMAT)
rootLogger.addHandler(fileHandler)
consoleHandler = logging.StreamHandler()
consoleHandler.setFormatter(FORMAT)
rootLogger.addHandler(consoleHandler)
if is_subdir(args.src, os.getcwd()):
logger.error('angelix must be run outside of the source directory')
exit(1)
if vars(args)['assert'] is not None and not args.dump_only:
with open(vars(args)['assert']) as output_file:
asserts = json.load(output_file)
else:
asserts = None
if 'guards' in args.defect and 'assignments' in args.defect:
logger.error('\'guards\' and \'assignments\' defect classes are currently incompatible')
exit(1)
if args.dump_only:
if args.golden is not None:
logger.warning('--dump-only disables --golden option')
if asserts is not None:
logger.warning('--dump-only disables --assert option')
config = dict()
config['initial_tests'] = args.initial_tests
config['all_tests'] = args.all_tests
config['max_z3_trials'] = args.max_z3_trials
config['defect'] = args.defect
config['test_timeout'] = args.test_timeout
config['single_group'] = args.single_group
config['group_size'] = args.group_size
config['group_by_score'] = args.group_by_score
config['localize_from_bottom'] = args.localize_from_bottom
config['suspicious'] = args.suspicious
config['localization'] = args.localization
config['ignore_trivial'] = args.ignore_trivial
config['path_solving_timeout'] = args.path_solving_timeout
config['timeout'] = args.timeout
config['max_angelic_paths'] = args.max_angelic_paths
config['klee_max_forks'] = args.klee_max_forks
config['klee_max_depth'] = args.klee_max_depth
config['klee_search'] = args.klee_search
config['klee_timeout'] = args.klee_timeout
config['klee_out_dir_timeout'] = args.klee_out_dir_timeout
config['klee_solver_timeout'] = args.klee_solver_timeout
config['klee_debug'] = args.klee_debug
config['klee_ignore_errors'] = args.klee_ignore_errors
config['ignore_trans_errors'] = args.ignore_trans_errors
config['ignore_infer_errors'] = args.ignore_infer_errors
config['ignore_instrument'] = args.ignore_instrument
config['ignore_unmatched_execution'] = args.ignore_unmatched_execution
config['ignore_z3_exception'] = args.ignore_z3_exception
config['skip_validating_angelic_path'] = args.skip_validating_angelic_path
config['use_nsynth'] = args.use_nsynth
config['use_osynth'] = args.use_osynth
config['use_gcc'] = args.use_gcc
config['use_frontend_for_test'] = args.use_frontend_for_test
config['keep_positive_behavior'] = args.keep_positive_behavior
config['synthesis_timeout'] = args.synthesis_timeout
config['synthesis_levels'] = args.synthesis_levels
config['synthesis_global_vars'] = args.synthesis_global_vars
config['synthesis_func_params'] = args.synthesis_func_params
config['synthesis_used_vars'] = True # for backward compatibility
config['synthesis_ptr_vars'] = args.synthesis_ptr_vars
config['synthesis_bool_only'] = args.synthesis_bool_only
config['forced_to_use_bool'] = args.forced_to_use_bool
config['empty_env_exps'] = args.empty_env_exps
config['exclude_member_exp'] = args.exclude_member_exp
config['generate_all'] = args.generate_all
config['init_uninit_vars'] = args.init_uninit_vars
config['verbose'] = args.verbose
config['build_before_instr'] = args.build_before_instr
config['instr_printf'] = args.instr_printf
config['mute_config_message'] = args.mute_config_message
config['mute_build_message'] = args.mute_build_message
config['mute_test_message'] = args.mute_test_message
config['show_test_message'] = args.show_test_message
config['show_oracle_contents'] = args.show_oracle_contents
config['show_syn_message'] = args.show_syn_message
config['mute_warning'] = args.mute_warning
config['show_suspicious_locations'] = args.show_suspicious_locations
config['invalid_localization'] = args.invalid_localization
config['angelic_search_strategy'] = args.angelic_search_strategy
config['step_method'] = args.step_method
config['compilation_db_file'] = args.compilation_db_file
config['keep_angelix_dir'] = args.keep_angelix_dir
config['skip_configure'] = args.skip_configure
config['skip_build'] = args.skip_build
config['gobble_klee_message'] = args.gobble_klee_message
config['lines'] = args.lines
config['search_max_trials'] = args.search_max_trials
config['max_same_cost_iter'] = args.max_same_cost_iter
config['mcmc_beta'] = args.mcmc_beta
config['one_bit_flip_prob'] = args.one_bit_flip_prob
config['chunk_bits'] = args.chunk_bits
config['max_bits'] = args.max_bits
config['max_resample'] = args.max_resample
config['block_expand_factor'] = args.block_expand_factor
config['inc_fix'] = args.inc_fix
config['fixed_bv_len'] = args.fixed_bv_len
config['default_max_cost'] = args.default_max_cost
config['error_cost'] = args.error_cost
config['warning_cost'] = args.warning_cost
config['max_syn_attempts'] = args.max_syn_attempts
config['max_repair_attempts'] = args.max_repair_attempts
config['penalty1'] = args.penalty1
config['penalty2'] = args.penalty2
config['parallel_testing'] = args.parallel_testing
config['all_suspicious'] = args.all_suspicious
config['mutate'] = int(args.mutate)
config['epsilon'] = float(args.epsilon)
config['always_accept'] = args.always_accept
config['random_cost'] = args.random_cost
config['max_random_cost'] = float(args.max_random_cost)
config['skip_dd'] = args.skip_dd
config['spec_from_only_negative'] = args.spec_from_only_negative
config['finish_after_fault_localize'] = args.finish_after_fault_localize
config['default_susp_score'] = args.default_susp_score
config['additional_susp_locs'] = args.additional_susp_locs
config['default_non_zero_cost'] = args.default_non_zero_cost
config['timeout_cost'] = args.timeout_cost
logger.debug('tests: {}'.format(args.tests))
if args.verbose:
logger.info('arg oracle = {}'.format(args.oracle))
for key, value in config.items():
logger.info('option {} = {}'.format(key, value))
statistics.init(working_dir, config)
if args.ignore_lines:
args.lines = None
tool = Angelix(working_dir,
src=args.src,
buggy=args.buggy,
oracle=abspath(args.oracle),
tests=args.tests,
golden=args.golden,
asserts=asserts,
lines=args.lines,
build=args.build,
configure=args.configure,
config=config)
if args.dump_only:
try:
dump = tool.dump_outputs()
with open('dump.json', 'w') as output_file:
asserts = json.dump(dump, output_file, indent=2)
logger.info('outputs successfully dumped (see dump.json)')
exit(0)
except (CompilationError, TransformationError):
logger.info('failed to dump outputs')
exit(1)
if args.tests_summary:
# run validation tests
positive, negative = tool.evaluate_ts(tool.validation_src, args.tests)
val_test_result = {'positive': sorted(positive), 'negative': sorted(negative)}
logger.info('positive: {}, negative: {}'.format(positive, negative))
# run golden tests
src = tool.golden_src
src.configure()
src.build()
positive, negative = tool.evaluate_ts(src, args.tests)
golden_test_result = {'positive': sorted(positive), 'negative': sorted(negative)}
logger.info('positive: {}, negative: {}'.format(positive, negative))
# delta
negative = list(set(val_test_result['negative']).difference(set(golden_test_result['negative'])))
delta = {'positive': val_test_result['positive'], 'negative': sorted(negative)}
logger.info('positive: {}, negative: {}'.format(delta['positive'], delta['negative']))
summary = {'validation': val_test_result,
'golden': golden_test_result,
'delta': delta }
summary_file = join(working_dir, "tests-summary.json")
with open(summary_file, "w") as write_file:
json.dump(summary, write_file, indent=4)
exit(0)
if config['mutate'] > 0:
mutate(config, args.buggy, working_dir, args.golden,
args.build, args.configure)
exit(0)
logger.debug('start to measure time')
start = time.time()
try:
if args.timeout is not None:
with time_limit(args.timeout):
patches = repair()
else:
patches = repair()
except TimeoutException:
logger.info("failed to generate patch (timeout)")
print('TIMEOUT')
statistics.data['patch_found'] = False
statistics.data['timeout_occurred'] = True
statistics.data['time']['total'] = args.timeout
statistics.save()
exit(0)
except (CompilationError, InferenceError, TransformationError):
logger.info("failed to generate patch")
print('FAIL')
statistics.data['patch_found'] = False
statistics.save()
exit(1)
end = time.time()
elapsed = format_time(end - start)
statistics.data['time']['total'] = end - start
statistics.save()
if not patches:
logger.info("no patch generated in {}".format(elapsed))
print('FAIL')
statistics.data['patch_found'] = False
statistics.save()
exit(0)
else:
if config['generate_all']:
patch_dir = basename(abspath(args.src)) + '-' + time.strftime("%Y-%b%d-%H%M%S")
if not exists(patch_dir):
os.mkdir(patch_dir)
for idx, patch in enumerate(patches):
patch_file = os.path.join(patch_dir, str(idx) + '.patch')
with open(patch_file, 'w+') as file:
for line in patch:
file.write(line)
logger.info("patches successfully generated in {} (see {})".format(elapsed, patch_dir))
else:
patch_file = basename(abspath(args.src)) + '-' + time.strftime("%Y-%b%d-%H%M%S") + '.patch'
logger.info("patch successfully generated in {} (see {})".format(elapsed, patch_file))
with open(patch_file, 'w+') as file:
for line in patches[0]:
file.write(line)
print('SUCCESS')
statistics.data['src'] = args.src
statistics.data['buggy'] = args.buggy
statistics.data['patch_found'] | |
to Slice.
to_slice([int] v, bool ind1) -> Slice
Construct from an index vector (requires is_slice(v) to be true)
to_slice(IM x, bool ind1) -> Slice
> to_slice(IM x, bool ind1)
------------------------------------------------------------------------
Convert IM to Slice.
> to_slice([int] v, bool ind1)
------------------------------------------------------------------------
Construct from an index vector (requires is_slice(v) to be true)
"""
return _casadi.to_slice(*args)
class DM(MatrixCommon, GenericExpressionCommon, GenDM, PrintableCommon):
"""
"""
__swig_setmethods__ = {}
for _s in [MatrixCommon, GenericExpressionCommon, GenDM, PrintableCommon]:
__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
__setattr__ = lambda self, name, value: _swig_setattr(self, DM, name, value)
__swig_getmethods__ = {}
for _s in [MatrixCommon, GenericExpressionCommon, GenDM, PrintableCommon]:
__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
__getattr__ = lambda self, name: _swig_getattr(self, DM, name)
__repr__ = _swig_repr
def sanity_check(self, *args):
"""
[DEPRECATED] Correctness is checked during construction
sanity_check(self, bool complete)
"""
return _casadi.DM_sanity_check(self, *args)
def has_nz(self, *args):
"""
Returns true if the matrix has a non-zero at location rr, cc.
has_nz(self, int rr, int cc) -> bool
"""
return _casadi.DM_has_nz(self, *args)
def __nonzero__(self, *args):
"""
[INTERNAL]
__nonzero__(self) -> bool
"""
return _casadi.DM___nonzero__(self, *args)
def get(self, *args):
"""
get(self, bool ind1, Sparsity sp) -> DM
get(self, bool ind1, Slice rr) -> DM
get(self, bool ind1, IM rr) -> DM
get(self, bool ind1, Slice rr, Slice cc) -> DM
get(self, bool ind1, Slice rr, IM cc) -> DM
get(self, bool ind1, IM rr, Slice cc) -> DM
get(self, bool ind1, IM rr, IM cc) -> DM
"""
return _casadi.DM_get(self, *args)
def set(self, *args):
"""
set(self, DM m, bool ind1, Sparsity sp)
set(self, DM m, bool ind1, Slice rr)
set(self, DM m, bool ind1, IM rr)
set(self, DM m, bool ind1, Slice rr, Slice cc)
set(self, DM m, bool ind1, Slice rr, IM cc)
set(self, DM m, bool ind1, IM rr, Slice cc)
set(self, DM m, bool ind1, IM rr, IM cc)
"""
return _casadi.DM_set(self, *args)
def get_nz(self, *args):
"""
get_nz(self, bool ind1, Slice k) -> DM
get_nz(self, bool ind1, IM k) -> DM
"""
return _casadi.DM_get_nz(self, *args)
def set_nz(self, *args):
"""
set_nz(self, DM m, bool ind1, Slice k)
set_nz(self, DM m, bool ind1, IM k)
"""
return _casadi.DM_set_nz(self, *args)
def __pos__(self, *args):
"""
__pos__(self) -> DM
"""
return _casadi.DM___pos__(self, *args)
def __neg__(self, *args):
"""
__neg__(self) -> DM
"""
return _casadi.DM___neg__(self, *args)
def binary(*args):
"""
binary(int op, DM x, DM y) -> DM
"""
return _casadi.DM_binary(*args)
binary = staticmethod(binary)
def unary(*args):
"""
unary(int op, DM x) -> DM
"""
return _casadi.DM_unary(*args)
unary = staticmethod(unary)
def scalar_matrix(*args):
"""
scalar_matrix(int op, DM x, DM y) -> DM
"""
return _casadi.DM_scalar_matrix(*args)
scalar_matrix = staticmethod(scalar_matrix)
def matrix_scalar(*args):
"""
matrix_scalar(int op, DM x, DM y) -> DM
"""
return _casadi.DM_matrix_scalar(*args)
matrix_scalar = staticmethod(matrix_scalar)
def matrix_matrix(*args):
"""
matrix_matrix(int op, DM x, DM y) -> DM
"""
return _casadi.DM_matrix_matrix(*args)
matrix_matrix = staticmethod(matrix_matrix)
def printme(self, *args):
"""
printme(self, DM y) -> DM
"""
return _casadi.DM_printme(self, *args)
def set_max_depth(*args):
"""
set_max_depth(int eq_depth)
"""
return _casadi.DM_set_max_depth(*args)
set_max_depth = staticmethod(set_max_depth)
def get_max_depth(*args):
"""
get_max_depth() -> int
"""
return _casadi.DM_get_max_depth(*args)
get_max_depth = staticmethod(get_max_depth)
def get_input(*args):
"""
get_input(Function f) -> [DM]
"""
return _casadi.DM_get_input(*args)
get_input = staticmethod(get_input)
def get_free(*args):
"""
get_free(Function f) -> [DM]
"""
return _casadi.DM_get_free(*args)
get_free = staticmethod(get_free)
def type_name(*args):
"""
type_name() -> str
"""
return _casadi.DM_type_name(*args)
type_name = staticmethod(type_name)
def print_split(self, *args):
"""
print_split(self) -> ([str] OUTPUT, [str] OUTPUT)
"""
return _casadi.DM_print_split(self, *args)
def disp(self, *args):
"""
Print a representation of the object.
disp(self, bool more)
"""
return _casadi.DM_disp(self, *args)
def str(self, *args):
"""
Get string representation.
str(self, bool more) -> str
"""
return _casadi.DM_str(self, *args)
def print_scalar(self, *args):
"""
Print scalar.
print_scalar(self)
"""
return _casadi.DM_print_scalar(self, *args)
def print_vector(self, *args):
"""
Print vector-style.
print_vector(self, bool truncate)
"""
return _casadi.DM_print_vector(self, *args)
def print_dense(self, *args):
"""
Print dense matrix-stype.
print_dense(self, bool truncate)
"""
return _casadi.DM_print_dense(self, *args)
def print_sparse(self, *args):
"""
Print sparse matrix style.
print_sparse(self, bool truncate)
"""
return _casadi.DM_print_sparse(self, *args)
def clear(self, *args):
"""
clear(self)
"""
return _casadi.DM_clear(self, *args)
def resize(self, *args):
"""
resize(self, int nrow, int ncol)
"""
return _casadi.DM_resize(self, *args)
def reserve(self, *args):
"""
reserve(self, int nnz)
reserve(self, int nnz, int ncol)
"""
return _casadi.DM_reserve(self, *args)
def erase(self, *args):
"""
Erase a submatrix (leaving structural zeros in its place) Erase elements of
erase(self, [int] rr, bool ind1)
erase(self, [int] rr, [int] cc, bool ind1)
Erase a submatrix (leaving structural zeros in its place) Erase rows and/or
a matrix.
> erase(self, [int] rr, bool ind1)
------------------------------------------------------------------------
Erase a submatrix (leaving structural zeros in its place) Erase elements of
a matrix.
> erase(self, [int] rr, [int] cc, bool ind1)
------------------------------------------------------------------------
Erase a submatrix (leaving structural zeros in its place) Erase rows and/or
columns of a matrix.
"""
return _casadi.DM_erase(self, *args)
def remove(self, *args):
"""
Remove columns and rows Remove/delete rows and/or columns of a matrix.
remove(self, [int] rr, [int] cc)
"""
return _casadi.DM_remove(self, *args)
def enlarge(self, *args):
"""
Enlarge matrix Make the matrix larger by inserting empty rows and columns,
enlarge(self, int nrow, int ncol, [int] rr, [int] cc, bool ind1)
keeping the existing non-zeros.
"""
return _casadi.DM_enlarge(self, *args)
def sparsity(self, *args):
"""
Get an owning reference to the sparsity pattern.
sparsity(self) -> Sparsity
"""
return _casadi.DM_sparsity(self, *args)
def triplet(*args):
"""
triplet([int] row, [int] col, DM d) -> DM
triplet([int] row, [int] col, DM d, (int,int) rc) -> DM
triplet([int] row, [int] col, DM d, int nrow, int ncol) -> DM
"""
return _casadi.DM_triplet(*args)
triplet = staticmethod(triplet)
def inf(*args):
"""
create a matrix with all inf
inf(int nrow, int ncol) -> DM
inf((int,int) rc) -> DM
inf(Sparsity sp) -> DM
"""
return _casadi.DM_inf(*args)
inf = staticmethod(inf)
def nan(*args):
"""
create a matrix with all nan
nan(int nrow, int ncol) -> DM
nan((int,int) rc) -> DM
nan(Sparsity sp) -> DM
"""
return _casadi.DM_nan(*args)
nan = staticmethod(nan)
def eye(*args):
"""
eye(int ncol) -> DM
"""
return _casadi.DM_eye(*args)
eye = staticmethod(eye)
def element_hash(self, *args):
"""
element_hash(self) -> int
"""
return _casadi.DM_element_hash(self, *args)
def is_regular(self, *args):
"""
is_regular(self) -> bool
"""
return _casadi.DM_is_regular(self, *args)
def is_smooth(self, *args):
"""
is_smooth(self) -> bool
"""
return _casadi.DM_is_smooth(self, *args)
def is_leaf(self, *args):
"""
is_leaf(self) -> bool
"""
return _casadi.DM_is_leaf(self, *args)
def is_commutative(self, *args):
"""
is_commutative(self) -> bool
"""
return _casadi.DM_is_commutative(self, *args)
def is_symbolic(self, *args):
"""
is_symbolic(self) -> bool
"""
return _casadi.DM_is_symbolic(self, *args)
def is_valid_input(self, *args):
"""
is_valid_input(self) -> bool
"""
return _casadi.DM_is_valid_input(self, *args)
def has_duplicates(self, *args):
"""
has_duplicates(self) -> bool
"""
return _casadi.DM_has_duplicates(self, *args)
def reset_input(self, *args):
"""
reset_input(self)
"""
return _casadi.DM_reset_input(self, *args)
def is_constant(self, *args):
"""
Check if the matrix is constant (note that false negative answers are
is_constant(self) -> bool
possible)
"""
return _casadi.DM_is_constant(self, *args)
def is_integer(self, *args):
"""
Check if the matrix is integer-valued (note that false negative answers are
is_integer(self) -> bool
possible)
"""
return _casadi.DM_is_integer(self, *args)
def is_zero(self, *args):
"""
check if the matrix is 0 (note that false negative answers are possible)
is_zero(self) -> bool
"""
return _casadi.DM_is_zero(self, *args)
def is_one(self, *args):
"""
check if the matrix is 1 (note that false negative answers are possible)
is_one(self) -> bool
"""
return _casadi.DM_is_one(self, *args)
def is_minus_one(self, *args):
"""
check if the matrix is -1 (note that false negative answers are possible)
is_minus_one(self) -> bool
"""
return _casadi.DM_is_minus_one(self, *args)
def is_eye(self, *args):
"""
check if the matrix is an identity matrix (note that false negative answers
is_eye(self) -> bool
are possible)
"""
return _casadi.DM_is_eye(self, *args)
def op(self, *args):
"""
op(self) -> int
"""
return _casadi.DM_op(self, *args)
def is_op(self, *args):
"""
is_op(self, int op) -> bool
"""
return _casadi.DM_is_op(self, *args)
def has_zeros(self, *args):
"""
Check if the matrix has any zero entries which are not structural zeros.
has_zeros(self) -> bool
"""
return _casadi.DM_has_zeros(self, *args)
def nonzeros(self, *args):
"""
Get all nonzeros.
nonzeros(self) -> [float]
Implementation of Matrix::get_nonzeros (in public API)
"""
return _casadi.DM_nonzeros(self, *args)
def elements(self, *args):
"""
Get all elements.
elements(self) -> [float]
"""
return _casadi.DM_elements(self, *args)
def __float__(self, *args):
"""
__float__(self) -> float
"""
return _casadi.DM___float__(self, *args)
def __int__(self, *args):
"""
__int__(self) -> int
"""
return _casadi.DM___int__(self, | |
matrices')
return self._new(L), self._new(D)
def liupc(self):
"""Liu's algorithm, for pre-determination of the Elimination Tree of
the given matrix, used in row-based symbolic Cholesky factorization.
Examples
========
>>> from sympy.matrices import SparseMatrix
>>> S = SparseMatrix([
... [1, 0, 3, 2],
... [0, 0, 1, 0],
... [4, 0, 0, 5],
... [0, 6, 7, 0]])
>>> S.liupc()
([[0], [], [0], [1, 2]], [4, 3, 4, 4])
References
==========
Symbolic Sparse Cholesky Factorization using Elimination Trees,
<NAME> (1999)
http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.39.7582
"""
# Algorithm 2.4, p 17 of reference
# get the indices of the elements that are non-zero on or below diag
R = [[] for r in range(self.rows)]
for r, c, _ in self.row_list():
if c <= r:
R[r].append(c)
inf = len(R) # nothing will be this large
parent = [inf]*self.rows
virtual = [inf]*self.rows
for r in range(self.rows):
for c in R[r][:-1]:
while virtual[c] < r:
t = virtual[c]
virtual[c] = r
c = t
if virtual[c] == inf:
parent[c] = virtual[c] = r
return R, parent
def multiply(self, other):
"""Fast multiplication exploiting the sparsity of the matrix.
Examples
========
>>> from sympy.matrices import SparseMatrix, ones
>>> A, B = SparseMatrix(ones(4, 3)), SparseMatrix(ones(3, 4))
>>> A.multiply(B) == 3*ones(4)
True
See Also
========
add
"""
A = self
B = other
# sort B's row_list into list of rows
Blist = [[] for i in range(B.rows)]
for i, j, v in B.row_list():
Blist[i].append((j, v))
Cdict = defaultdict(int)
for k, j, Akj in A.row_list():
for n, Bjn in Blist[j]:
temp = Akj*Bjn
Cdict[k, n] += temp
rv = self.zeros(A.rows, B.cols)
rv._smat = {k: v for k, v in Cdict.items() if v}
return rv
def nnz(self):
"""Returns the number of non-zero elements in Matrix."""
return len(self._smat)
def reshape(self, rows, cols):
"""Reshape matrix while retaining original size.
Examples
========
>>> from sympy.matrices import SparseMatrix
>>> S = SparseMatrix(4, 2, range(8))
>>> S.reshape(2, 4)
Matrix([
[0, 1, 2, 3],
[4, 5, 6, 7]])
"""
if len(self) != rows*cols:
raise ValueError("Invalid reshape parameters %d %d" % (rows, cols))
smat = {}
for k, v in self._smat.items():
i, j = k
n = i*self.cols + j
ii, jj = divmod(n, cols)
smat[(ii, jj)] = self._smat[(i, j)]
return self._new(rows, cols, smat)
def row_list(self):
"""Returns a row-sorted list of non-zero elements of the matrix.
Examples
========
>>> from sympy.matrices import SparseMatrix
>>> a = SparseMatrix(((1, 2), (3, 4)))
>>> a
Matrix([
[1, 2],
[3, 4]])
>>> a.RL
[(0, 0, 1), (0, 1, 2), (1, 0, 3), (1, 1, 4)]
See Also
========
row_op
col_list
"""
return [tuple(k + (self[k],)) for k in
sorted(list(self._smat.keys()), key=lambda k: list(k))]
def row_structure_symbolic_cholesky(self):
"""Symbolic cholesky factorization, for pre-determination of the
non-zero structure of the Cholesky factororization.
Examples
========
>>> from sympy.matrices import SparseMatrix
>>> S = SparseMatrix([
... [1, 0, 3, 2],
... [0, 0, 1, 0],
... [4, 0, 0, 5],
... [0, 6, 7, 0]])
>>> S.row_structure_symbolic_cholesky()
[[0], [], [0], [1, 2]]
References
==========
Symbolic Sparse Cholesky Factorization using Elimination Trees,
<NAME> (1999)
http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.39.7582
"""
R, parent = self.liupc()
inf = len(R) # this acts as infinity
Lrow = copy.deepcopy(R)
for k in range(self.rows):
for j in R[k]:
while j != inf and j != k:
Lrow[k].append(j)
j = parent[j]
Lrow[k] = list(sorted(set(Lrow[k])))
return Lrow
def row(self, i):
"""Returns column i from self as a row vector.
Examples
========
>>> from sympy.matrices import SparseMatrix
>>> a = SparseMatrix(((1, 2), (3, 4)))
>>> a.row(0)
Matrix([[1, 2]])
See Also
========
col
row_list
"""
return self[i,:]
def scalar_multiply(self, scalar):
"Scalar element-wise multiplication"
M = self.zeros(*self.shape)
if scalar:
for i in self._smat:
v = scalar*self._smat[i]
if v:
M._smat[i] = v
else:
M._smat.pop(i, None)
return M
def solve_least_squares(self, rhs, method='LDL'):
"""Return the least-square fit to the data.
By default the cholesky_solve routine is used (method='CH'); other
methods of matrix inversion can be used. To find out which are
available, see the docstring of the .inv() method.
Examples
========
>>> from sympy.matrices import SparseMatrix, Matrix, ones
>>> A = Matrix([1, 2, 3])
>>> B = Matrix([2, 3, 4])
>>> S = SparseMatrix(A.row_join(B))
>>> S
Matrix([
[1, 2],
[2, 3],
[3, 4]])
If each line of S represent coefficients of Ax + By
and x and y are [2, 3] then S*xy is:
>>> r = S*Matrix([2, 3]); r
Matrix([
[ 8],
[13],
[18]])
But let's add 1 to the middle value and then solve for the
least-squares value of xy:
>>> xy = S.solve_least_squares(Matrix([8, 14, 18])); xy
Matrix([
[ 5/3],
[10/3]])
The error is given by S*xy - r:
>>> S*xy - r
Matrix([
[1/3],
[1/3],
[1/3]])
>>> _.norm().n(2)
0.58
If a different xy is used, the norm will be higher:
>>> xy += ones(2, 1)/10
>>> (S*xy - r).norm().n(2)
1.5
"""
t = self.T
return (t*self).inv(method=method)*t*rhs
def solve(self, rhs, method='LDL'):
"""Return solution to self*soln = rhs using given inversion method.
For a list of possible inversion methods, see the .inv() docstring.
"""
if not self.is_square:
if self.rows < self.cols:
raise ValueError('Under-determined system.')
elif self.rows > self.cols:
raise ValueError('For over-determined system, M, having '
'more rows than columns, try M.solve_least_squares(rhs).')
else:
return self.inv(method=method)*rhs
def tolist(self):
"""Convert this sparse matrix into a list of nested Python lists.
Examples
========
>>> from sympy.matrices import SparseMatrix, ones
>>> a = SparseMatrix(((1, 2), (3, 4)))
>>> a.tolist()
[[1, 2], [3, 4]]
When there are no rows then it will not be possible to tell how
many columns were in the original matrix:
>>> SparseMatrix(ones(0, 3)).tolist()
[]
"""
if not self.rows:
return []
if not self.cols:
return [[] for i in range(self.rows)]
I, J = self.shape
return [[self[i, j] for j in range(J)] for i in range(I)]
RL = property(row_list, None, None, "Alternate faster representation")
CL = property(col_list, None, None, "Alternate faster representation")
__matmul__ = __mul__
__rmatmul__ = __rmul__
extract.__doc__ = MatrixBase.extract.__doc__
@classmethod
def zeros(cls, r, c=None):
"""Return an r x c matrix of zeros, square if c is omitted."""
c = r if c is None else c
r = as_int(r)
c = as_int(c)
return cls(r, c, {})
class MutableSparseMatrix(SparseMatrix, MatrixBase):
@classmethod
def _new(cls, *args, **kwargs):
return cls(*args)
def __setitem__(self, key, value):
"""Assign value to position designated by key.
Examples
========
>>> from sympy.matrices import SparseMatrix, ones
>>> M = SparseMatrix(2, 2, {})
>>> M[1] = 1; M
Matrix([
[0, 1],
[0, 0]])
>>> M[1, 1] = 2; M
Matrix([
[0, 1],
[0, 2]])
>>> M = SparseMatrix(2, 2, {})
>>> M[:, 1] = [1, 1]; M
Matrix([
[0, 1],
[0, 1]])
>>> M = SparseMatrix(2, 2, {})
>>> M[1, :] = [[1, 1]]; M
Matrix([
[0, 0],
[1, 1]])
To replace row r you assign to position r*m where m
is the number of columns:
>>> M = SparseMatrix(4, 4, {})
>>> m = M.cols
>>> M[3*m] = ones(1, m)*2; M
Matrix([
[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0],
[2, 2, 2, 2]])
And to replace column c you can assign to position c:
>>> M[2] = ones(m, 1)*4; M
Matrix([
[0, 0, 4, 0],
[0, 0, 4, 0],
[0, 0, 4, 0],
[2, 2, 4, 2]])
"""
rv = self._setitem(key, value)
if rv is not None:
i, j, value = rv
if value:
self._smat[(i, j)] = value
elif (i, j) in self._smat:
del self._smat[(i, j)]
def as_mutable(self):
return self.copy()
__hash__ = None
def col_del(self, k):
"""Delete the given column of the matrix.
Examples
========
>>> from sympy.matrices import SparseMatrix
>>> M = SparseMatrix([[0, 0], [0, 1]])
>>> M
Matrix([
[0, 0],
[0, 1]])
>>> M.col_del(0)
>>> M
Matrix([
[0],
[1]])
See Also
========
row_del
"""
newD = {}
k = a2idx(k, self.cols)
for (i, j) in self._smat:
if j == k:
pass
elif j > k:
newD[i, j - 1] = self._smat[i, j]
else:
newD[i, j] = self._smat[i, j]
self._smat = newD
self.cols -= 1
def col_join(self, | |
k_elongation.flatten().tolist()[:-1]
kelongs = kelongs + k_elongation.flatten().tolist()[:-1]
return kelongs
def get_k(self, nt_seq, k_init, k_elong_mean):
'''
returns all propensities for a given nucleotide sequence
*args*
**nt_seq**, nucleotide sequence as a string
**k_initiation**, initiation rate of ribosome binding
**k_elong_mean**, average rate of elgonation experimentally found
'''
codons = nt_seq
genelength = int(len(codons)/3)
seperated_codons = [codons[i:i+3] for i in range(0, len(codons), 3)] #split codons by 3
k_elongation = np.zeros((1, genelength))
tRNA_copynumber = np.zeros((1, genelength))
for i in range(len(seperated_codons)):
tRNA_copynumber[0, i] = self.strGeneCopy[seperated_codons[i]]
mean_tRNA_copynumber = np.mean(list(self.strGeneCopy.values()))
k_elongation = (tRNA_copynumber / mean_tRNA_copynumber) * k_elong_mean
all_k = [k_init] + k_elongation.flatten().tolist()[:-1] + [10]
return all_k
def get_temporal_proteins(self):
'''
gets all the temporal proteins after getting the ORFs
__.tagged_proteins = dictionary with keys of tag types and a list of proteins
__.pois = list of proteins of intrest
__.pois_seq = list of nucleotide sequences of proteins of sequences
__.proteins = dictonary with keys of 1 2 or 3 orfs
'''
self.proteins = {'1':[], '2':[], '3':[]}
self.tagged_proteins = {a:[] for a in self.tag_dict.keys()}
self.tagged_protein_seq = {a:[] for a in self.tag_dict.keys()}
for i in range(len(self.orfs)):
for j in range(len(self.orfs[str(i+1)])):
pro = self.nt2aa(self.sequence_str[self.orfs[str(i+1)][j][0]:self.orfs[str(i+1)][j][1]+3])
nt_seq = self.sequence_str[self.orfs[str(i+1)][j][0]:self.orfs[str(i+1)][j][1]+3]
self.proteins[str(i+1)].append(pro)
for tag in self.tag_dict.keys():
if self.tag_dict[tag] in pro:
self.tagged_protein_seq[tag].append(nt_seq)
self.tagged_proteins[tag].append(pro)
tags = 0
for key in self.tagged_proteins.keys():
tags += len(self.tagged_proteins[key])
self.pois = []
self.pois_seq = []
for tag in self.tag_dict.keys():
for i in range(len(self.tagged_proteins[tag])):
if self.tagged_proteins[tag][i] not in self.pois:
self.pois.append(self.tagged_proteins[tag][i])
self.pois_seq.append(self.tagged_protein_seq[tag][i])
if len(self.pois) == 0:
POIs = []
pois_s = []
pois_nt = []
for i in range(len(self.gb_obj.features)):
try:
self.gb_obj.features[i].qualifiers['translation']
if tags == 0:
POIs.append(self.gb_obj.features[i])
pois_s.append(self.nt2aa(self.tag_full['T_Flag']) + self.gb_obj.features[i].qualifiers['translation'][0])
pois_nt.append(self.tag_full['T_Flag'] + str(self.gb_obj.seq)[int(self.gb_obj.features[i].location.start):int(self.gb_obj.features[i].location.end)])
else:
POIs.append(self.gb_obj.features[i])
pois_s.append(self.gb_obj.features[i].qualifiers['translation'][0])
pois_nt.append(str(self.gb_obj.seq)[int(self.gb_obj.features[i].location.start):int(self.gb_obj.features[i].location.end)])
except:
pass
self.pois = pois_s
self.pois_seq = pois_nt
def analyze_poi(self, protein, sequence, epitope_loc = 'front'):
'''
Analyzes the protein of intrest and stores it in __.POI
*args*
**protein**, amino acid sequence as a string
**sequence**, nucleotide sequence that goes with the protein
**epitope_loc**, consider the epitope location as the front, middle or back:
DDYDDK: front: 0, middle: 3, back: 6 for epitope location
'''
self.POI = poi()
self.POI.nt_seq = sequence
self.POI.aa_seq = protein
self.POI.name = self.sequence_name
self.POI.total_length = len(protein)
'''
for key in self.tagged_proteins:
if protein in self.tagged_proteins[key]:
self.POI.tag_types.append(key)
'''
self.POI.tag_types = []
for tag in self.tag_dict.keys():
if self.tag_dict[tag] in protein:
self.POI.tag_types.append(tag)
#''.join(sms.poi[0].split('DYKDDDDK')
self.POI.tag_epitopes = {a:[] for a in self.POI.tag_types}
gs = protein
for i in range(len(self.POI.tag_types)):
try:
nt_tag = self.tag_full[self.POI.tag_types[i]]
aa_tag = self.nt2aa(nt_tag)
except:
epi = self.tag_dict[self.POI.tag_types[i]]
firstep = self.POI.aa_seq.find(epi)
lastep = len(self.POI.aa_seq) - self.POI.aa_seq[::-1].find(epi[::-1])
aa_tag = self.POI.aa_seq[firstep:lastep]
nt_tag = self.POI.nt_seq[3*firstep:3*lastep]
if epitope_loc == 'front':
offset = 0
if epitope_loc == 'middle':
offset = int(len(self.tag_dict[self.POI.tag_types[i]])/2)
if epitope_loc == 'back':
offset = len(self.tag_dict[self.POI.tag_types[i]])
self.POI.tag_epitopes[self.POI.tag_types[i]] = [m.start()+1+offset for m in re.finditer(self.tag_dict[self.POI.tag_types[i]], self.POI.aa_seq)]
gs = gs.replace(aa_tag, '')
self.POI.gene_seq = gs
self.POI.gene_length = len(gs)
codons = []
for i in range(0, len(sequence), 3):
codons.append(sequence[i:i+3])
self.POI.codons = codons
self.POI.codon_sensitivity, self.POI.CAI, self.POI.CAI_codons = self.codon_usage(self.POI.nt_seq)
def open_seq_file(self, seqfile):
'''
Reads a sequence file, either a .txt file or a .gb genbank file
*args*
**seqfile**, sequence file either in txt, gb, gbk format
'''
seq = seqfile
self.sequence_name = ''
if '.dna' in seq:
self.sequence_name = seq[:-4]
try:
seq_record = snapgene_file_to_seqrecord(seq)
except:
print('To read .dna files please install snapegenereader: pip install snapgene_reader - https://github.com/IsaacLuo/SnapGeneFileReader' )
self.sequence_str = seq_record.seq.tostring()
if '.txt' in seq:
with open(seq) as f:
raw = f.readlines()
raw = ''.join(raw)
onlychar = re.split(r'[^A-Za-z]', raw)
validt = ['A', 'G', 'T', 'C']
validu = ['A', 'G', 'U', 'C']
namelen = 0
self.sequence_str = ''
for i in range(len(onlychar)):
section = onlychar[i]
if set(section.upper()) == set(validt):
self.sequence_str += section.upper()
elif set(section.upper()) == set(validu):
self.sequence_str += section.upper()
else:
if len(section)>namelen:
self.sequence_name = section
namelen = len(section)
if '.gb' in seq:
gb_record = SeqIO.read(open(seq, "r"), "genbank")
self.sequence_str = str(gb_record.seq)
self.sequence_name = gb_record.name
self.gb_obj = gb_record
if self.sequence_name == '':
self.sequence_name = seqfile.replace('.txt','')
self.sequence_name = seqfile.replace('.gb','')
def codon_usage(self, nt_seq):
'''
Analyzes codon useage from the nucleotide sequence
*args*
**nt_seq**, nucleotide sequence as a string
*returns*
**codon_sensitivity**, a list of codon sensitivity for the nucleotide sequence
**cai**, cai value
'''
codon_usage = np.zeros((1, 21))
gene_len = len(nt_seq)/3
aa_seq = self.nt2aa(nt_seq)
for i in range(len(self.aa_keys)-1):
codon_usage[0, i] = len(re.findall(self.aa_keys[i], aa_seq))
codon_usage[0, 20] = len(re.findall('\*', aa_seq))
codon_norm = codon_usage/gene_len
codon_sensitivity = np.round(codon_norm*self.sensitivity_fast_slow, 2)
cai_codons = []
for i in range(0, len(nt_seq), 3):
cai_codons.append(self.strGeneCopy[nt_seq[i:i+3]] / self.strGeneCopy_fast[nt_seq[i:i+3]])
cai = self.geomean(cai_codons)
return codon_sensitivity, cai, cai_codons
def get_probvec(self):
'''
returns the probe vectors (epitope positions by codon position) associated with the tagged sequence stored in POI
*returns*
**probe_vec**, cumlative probe intensity vector by codon position. Ex: [0,0,0,0,1,1,1,1,2,2,2,3,3,3 etc]
**probe_loc**, epitope posistion as a binary vector, 1 for epitope pos, 0 for everything else
'''
probePositions = []
keylist = list(self.POI.tag_epitopes.keys())
for n in range(len(keylist)):
probePosition = []
key = keylist[n]
probePosition = probePosition + self.POI.tag_epitopes[key]
if probePosition != []:
probePosition = np.unique(probePosition).tolist()
probePositions.append(probePosition)
genelength = self.POI.total_length
pvfull = np.zeros((1, genelength+1)).astype(int).flatten()
if len(probePositions) > 1:
k = 0
for n in range(len(keylist)):
pv = np.zeros((1, genelength+1)).astype(int).flatten()
key = keylist[n]
probePosition = probePositions[k]
k+=1
if len(self.POI.tag_epitopes[key]) != 0:
for i in range(len(probePosition)):
pv[probePosition[i]:] = i+1
if n > 0:
pvfull = np.vstack((pvfull,pv))
else:
pvfull = pv
else:
probePosition = probePositions[0]
for n in range(len(keylist)):
pv = np.zeros((1, genelength+1)).astype(int).flatten()
key = keylist[n]
if len(self.POI.tag_epitopes[key]) != 0:
for i in range(len(probePosition)):
pv[probePosition[i]:] = i+1
if n > 0:
pvfull = np.vstack((pvfull,pv))
else:
pvfull = pv
numtags = 0
for key in keylist:
if len(self.POI.tag_epitopes[key]) != 0:
numtags += 1
ploc = np.zeros((numtags, self.POI.total_length+1)).astype(int)
numind = 0
for n in range(len(keylist)):
key = keylist[n]
if len(self.POI.tag_epitopes[key]) != 0:
ploc[numind][self.POI.tag_epitopes[key]] = 1
numind += 1
return pvfull, ploc
def simple_model(self, poi, tag, ki,ke):
'''
Simplified model
returns the analytical tau, intensity mean, and intensity variance
calculated from the simplified model
'''
L = poi.total_length #get the total length of the gene
Lm = np.mean(poi.tag_epitopes[tag]) #the mean location of the tag epitopes
L_tag = int((poi.tag_epitopes[tag][-1] - poi.tag_epitopes[tag][0]) / 2)
ke_analytical = L*ke / np.sum(self.get_ui(poi.nt_seq[:-3]))
tau_analytical = L_tag/ke_analytical #analytical tau ie autocovariance time
mean_analytical = ki*tau_analytical* (1.-Lm/float(L)) # mean intensity
var_analytical = ki*tau_analytical* (1.-Lm/float(L))**2 #var intensity
return tau_analytical,mean_analytical,var_analytical
def get_binned_k_emphasize_probes(self,k,bins,pl):
'''
evenly bins elongation rates as best it can.
'''
probe_region_start = np.where(pl > 0)[0]
probe_region_end = np.where(pl > 0)[-1]
binsize = int(np.floor(len(k)/bins))
binned_ks = []
k_binned = np.zeros(bins)
k_lens = np.ones(bins)*binsize
to_redistribute = len(k)%bins
k_lens[-to_redistribute:] = binsize+1
inds = np.hstack(([0.], np.cumsum(k_lens))).astype(int)
for i in range(0,bins):
binned_ks = binned_ks + [k[inds[i]:inds[i+1]].tolist(),]
for i in range(0,bins):
k_binned[i] = np.mean(binned_ks[i])/len(binned_ks[i])
return k_binned,k_lens
def get_binned_k(self,k,bins):
'''
evenly bins elongation rates as best it can.
'''
binsize = int(np.floor(len(k)/bins))
binned_ks = []
k_binned = np.zeros(bins)
k_lens = np.ones(bins)*binsize
to_redistribute = len(k)%bins
k_lens[-to_redistribute:] = binsize+1
inds = np.hstack(([0.], np.cumsum(k_lens))).astype(int)
for i in range(0,bins):
binned_ks = binned_ks + [k[inds[i]:inds[i+1]].tolist(),]
for i in range(0,bins):
k_binned[i] = 1/np.mean(1/np.array(binned_ks[i]))
return k_binned,k_lens
def get_binned_probe_vec(self,probe_loc,bins):
'''
bin the probe vector as even as possible
'''
probe_loc = np.atleast_2d(probe_loc)
binsize = int(np.floor(probe_loc.shape[1]/bins))
probeloc_binned = np.zeros((np.atleast_2d(probe_loc).shape[0],bins))
probe_lens = np.ones((np.atleast_2d(probe_loc).shape[0],bins))*binsize
to_redistribute = len(probe_loc)%bins
np.atleast_2d(probe_loc).shape[0]
probe_lens[-to_redistribute:] = binsize+1
inds = np.hstack(([0.], np.cumsum(probe_lens,axis=1)[0,:])).astype(int)
for i in range(0,bins):
probeloc_binned[:,i] = np.sum(probe_loc[:,inds[i]:inds[i+1]],axis=1)
probevec_binned = np.cumsum(probeloc_binned,axis=1)
return probevec_binned.astype(int), probeloc_binned.astype(int)
def ssa_binned(self,nt_seq=None, bins = 50,all_k=None, k_elong_mean=10, k_initiation=.03, probePosition=[], n_traj=100, tf=1000, start_time=0, tstep=1000, time_inhibit=0, evaluating_frap=False, evaluating_inhibitor=False,force_python = False):
if nt_seq == None: #get sequence if none was passed
nt_seq = self.POI.nt_seq
genelength = int(len(nt_seq)/3)
if len(probePosition) == 0:
pv,probePosition = self.get_probvec()
if all_k == | |
<filename>nevermined_gateway/routes.py<gh_stars>1-10
import json
import logging
from authlib.integrations.flask_oauth2 import current_token
from authlib.jose.errors import BadSignatureError
from common_utils_py.agreements.service_agreement import ServiceAgreement
from common_utils_py.agreements.service_types import ServiceTypes
from common_utils_py.did import id_to_did, NEVERMINED_PREFIX
from common_utils_py.did_resolver.did_resolver import DIDResolver
from common_utils_py.http_requests.requests_session import get_requests_session
from common_utils_py.utils.crypto import (ecdsa_encryption_from_file,
get_ecdsa_public_key_from_file,
rsa_encryption_from_file)
from eth_utils import remove_0x_prefix
from flask import Blueprint, jsonify, request
from flask.wrappers import Response
from secret_store_client.client import RPCError
from web3 import Web3
from nevermined_gateway import constants
from nevermined_gateway.conditions import fulfill_escrow_payment_condition, fulfill_for_delegate_nft_transfer_condition
from nevermined_gateway.config import upload_backends
from nevermined_gateway.identity.oauth2.authorization_server import create_authorization_server
from nevermined_gateway.identity.oauth2.resource_server import create_resource_server
from nevermined_gateway.log import setup_logging
from nevermined_gateway.myapp import app
from nevermined_gateway.util import (check_required_attributes,
do_secret_store_encrypt, get_asset_url_at_index, get_config,
get_provider_account, get_provider_key_file,
get_provider_password, get_rsa_public_key_file,
is_access_granted, is_escrow_payment_condition_fulfilled, is_nft_transfer_approved,
is_nft_transfer_condition_fulfilled, keeper_instance,
setup_keeper, used_by, verify_signature, was_compute_triggered,
get_asset, generate_random_id, is_lock_payment_condition_fulfilled,
get_upload_enabled, upload_content)
setup_logging()
services = Blueprint('services', __name__)
setup_keeper(app.config['CONFIG_FILE'])
provider_acc = get_provider_account()
requests_session = get_requests_session()
authorization = create_authorization_server(app)
require_oauth = create_resource_server()
logger = logging.getLogger(__name__)
@services.route("/encrypt", methods=['POST'])
def encrypt_content():
"""Call the execution of a workflow.
swagger_from_file: docs/encrypt.yml
"""
required_attributes = ['message', 'method']
data = request.json
msg, status = check_required_attributes(required_attributes, data, 'encrypt')
if msg:
return msg, status
try:
message = data.get('message')
method = data.get('method')
if (method == 'SecretStore'):
msg, status = check_required_attributes(['did'], data, 'encrypt')
if msg:
return msg, status
did = data.get('did').replace(NEVERMINED_PREFIX, '')
hash = do_secret_store_encrypt(
remove_0x_prefix(did),
message,
provider_acc,
get_config()
)
public_key = get_ecdsa_public_key_from_file(get_provider_key_file(),
get_provider_password())
elif (method == 'PSK-ECDSA'):
hash, public_key = ecdsa_encryption_from_file(message, get_provider_key_file(),
get_provider_password())
elif (method == 'PSK-RSA'):
hash, public_key = rsa_encryption_from_file(message, get_rsa_public_key_file())
else:
return f'Unknown method: {method}\n' \
f'Options available are (`SecretStore`, `PSK-ECDSA`, `PSK-RSA`)', 500
output = dict()
output['public-key'] = public_key
output['hash'] = hash
output['method'] = method
return jsonify(output)
except Exception as e:
logger.error(f'Error: {e}. ', exc_info=1)
return f'Error: {str(e)}', 500
@services.route('/publish', methods=['POST'])
def publish():
"""Encrypt document using the SecretStore and keyed by the given documentId.
swagger_from_file: docs/publish.yml
"""
required_attributes = [
'documentId',
'signature',
'document',
'publisherAddress'
]
data = request.json
if 'signedDocumentId' in data and 'signature' not in data:
data['signature'] = data['signedDocumentId']
msg, status = check_required_attributes(required_attributes, data, 'publish')
if msg:
return msg, status
did = data.get('documentId')
signature = data.get('signature')
document = json.dumps(json.loads(data.get('document')), separators=(',', ':'))
publisher_address = data.get('publisherAddress')
try:
if not verify_signature(keeper_instance(), publisher_address, signature, did):
msg = f'Invalid signature {signature} for ' \
f'publisherAddress {publisher_address} and documentId {did}.'
raise ValueError(msg)
print('Document: ' + document)
print('DID: ' + remove_0x_prefix(did))
encrypted_document, public_key = rsa_encryption_from_file(document, get_rsa_public_key_file())
logger.debug(f'encrypted urls {encrypted_document}, '
f'publisher {publisher_address}, '
f'documentId {did}')
return encrypted_document, 201
except (RPCError, Exception) as e:
logger.error(
f'Encryption Error: {e}. \n'
f'providerAddress={provider_acc.address}\n'
f'Payload was: documentId={did}, '
f'publisherAddress={publisher_address},'
f'signature={signature}',
exc_info=1
)
return f'Error: {str(e)}', 500
@services.route('/upload/<backend>', methods=['POST'])
def upload(backend=None):
if not get_upload_enabled():
return 'Upload not supported in this server', 501
if not upload_backends.keys().__contains__(backend):
return 'Backend not implemented', 501
file_ = request.files.get('file')
if file_ is None:
return 'No file provided in request', 400
data = request.args
try:
file_name = data.get('fileName', file_.filename)
url = upload_content(file_.read(), file_name, upload_backends[backend], app.config['CONFIG_FILE'])
return {'url': url }, 201
except Exception as e:
logger.error(f'Driver error when uploading file: {e}')
return f'Error: {str(e)}', 500
@services.route('/download/<int:index>', methods=['GET'])
@require_oauth()
def download(index=0):
"""Allows to download an asset data file.
swagger_from_file: docs/download.yml
"""
consumer_address = current_token["client_id"]
did = current_token["did"]
logger.info('Parameters:\nIndex: %d\nConsumerAddress: %s\n'
'DID: %s'
% (index, consumer_address, did))
try:
keeper = keeper_instance()
asset = DIDResolver(keeper.did_registry).resolve(did)
file_attributes = asset.metadata['main']['files'][index]
content_type = file_attributes.get('contentType', None)
try:
auth_method = asset.authorization.main['service']
except Exception:
auth_method = constants.ConfigSections.DEFAULT_DECRYPTION_METHOD
if auth_method not in constants.ConfigSections.DECRYPTION_METHODS:
msg = (
'The Authorization Method defined in the DDO is not part of the available '
'methods supported'
'by the Gateway: ' + auth_method)
logger.warning(msg)
return msg, 400
url = get_asset_url_at_index(index, asset, provider_acc, auth_method)
return get_asset(request, requests_session, content_type, url, app.config['CONFIG_FILE'])
except (ValueError, Exception) as e:
logger.error(f'Error- {str(e)}', exc_info=1)
return f'Error : {str(e)}', 500
@services.route('/access/<agreement_id>', methods=['GET'])
@services.route('/access/<agreement_id>/<int:index>', methods=['GET'])
@require_oauth()
def access(agreement_id, index=0):
"""Allows to get access to an asset data file.
swagger_from_file: docs/access.yml
"""
consumer_address = current_token["client_id"]
did = current_token["did"]
agreement_id = current_token["sub"]
logger.info('Parameters:\nAgreementId: %s\nIndex: %d\nConsumerAddress: %s\n'
'DID: %s\n'
% (agreement_id, index, consumer_address, did))
try:
keeper = keeper_instance()
asset = DIDResolver(keeper.did_registry).resolve(did)
logger.debug('AgreementID :' + agreement_id)
file_attributes = asset.metadata['main']['files'][index]
content_type = file_attributes.get('contentType', None)
try:
auth_method = asset.authorization.main['service']
except Exception:
auth_method = constants.ConfigSections.DEFAULT_DECRYPTION_METHOD
if auth_method not in constants.ConfigSections.DECRYPTION_METHODS:
msg = (
'The Authorization Method defined in the DDO is not part of the available '
'methods supported'
'by the Gateway: ' + auth_method)
logger.warning(msg)
return msg, 400
url = get_asset_url_at_index(index, asset, provider_acc, auth_method)
used_by(generate_random_id(), did, consumer_address, 'access', '0x00', 'access', provider_acc,
keeper)
return get_asset(request, requests_session, content_type, url, app.config['CONFIG_FILE'])
except (ValueError, Exception) as e:
logger.error(f'Error- {str(e)}', exc_info=1)
return f'Error : {str(e)}', 500
@services.route('/access-proof/<agreement_id>', methods=['GET'])
@services.route('/access-proof/<agreement_id>/<int:index>', methods=['GET'])
@require_oauth()
def access_proof(agreement_id, index=0):
"""Allows to get access to an asset data file.
swagger_from_file: docs/access.yml
"""
consumer_address = current_token["client_id"]
did = current_token["did"]
agreement_id = current_token["sub"]
logger.info('Parameters:\nAgreementId: %s\nIndex: %d\nConsumerAddress: %s\n'
'DID: %s\n'
% (agreement_id, index, consumer_address, did))
try:
keeper = keeper_instance()
asset = DIDResolver(keeper.did_registry).resolve(did)
logger.debug('AgreementID :' + agreement_id)
file_attributes = asset.metadata['main']['files'][index]
content_type = file_attributes.get('contentType', None)
try:
auth_method = asset.authorization.main['service']
except Exception:
auth_method = constants.ConfigSections.DEFAULT_DECRYPTION_METHOD
if auth_method not in constants.ConfigSections.DECRYPTION_METHODS:
msg = (
'The Authorization Method defined in the DDO is not part of the available '
'methods supported'
'by the Gateway: ' + auth_method)
logger.warning(msg)
return msg, 400
url = get_asset_url_at_index(index, asset, provider_acc, auth_method)
used_by(generate_random_id(), did, consumer_address, 'access', '0x00', 'access proof', provider_acc,
keeper)
return Response(
url,
'200',
content_type=content_type
)
except (ValueError, Exception) as e:
logger.error(f'Error- {str(e)}', exc_info=1)
return f'Error : {str(e)}', 500
@services.route('/nft-access/<agreement_id>', methods=['GET'])
@services.route('/nft-access/<agreement_id>/<int:index>', methods=['GET'])
@require_oauth()
def nft_access(agreement_id, index=0):
"""Allows to get access to an asset data file holding a NFT.
swagger_from_file: docs/nft_access.yml
"""
consumer_address = current_token["client_id"]
did = current_token["did"]
agreement_id = current_token["sub"]
logger.info('Parameters:\nAgreementId: %s\nIndex: %d\nConsumerAddress: %s\n'
'DID: %s\n'
% (agreement_id, index, consumer_address, did))
try:
keeper = keeper_instance()
asset = DIDResolver(keeper.did_registry).resolve(did)
file_attributes = asset.metadata['main']['files'][index]
content_type = file_attributes.get('contentType', None)
try:
auth_method = asset.authorization.main['service']
except Exception:
auth_method = constants.ConfigSections.DEFAULT_DECRYPTION_METHOD
if auth_method not in constants.ConfigSections.DECRYPTION_METHODS:
msg = (
'The Authorization Method defined in the DDO is not part of the available '
'methods supported'
'by the Gateway: ' + auth_method)
logger.warning(msg)
return msg, 400
url = get_asset_url_at_index(index, asset, provider_acc, auth_method)
used_by(generate_random_id(), did, consumer_address, 'access', '0x00', 'nft access', provider_acc,
keeper)
return get_asset(request, requests_session, content_type, url, app.config['CONFIG_FILE'])
except (ValueError, Exception) as e:
logger.error(f'Error- {str(e)}', exc_info=1)
return f'Error : {str(e)}', 500
@services.route('/nft-transfer', methods=['POST'])
def nft_transfer():
"""Allows the provider transfer and release the rewards.
swagger_from_file: docs/nft_transfer.yml
"""
required_attributes = ['agreementId', 'nftHolder', 'nftReceiver', 'nftAmount']
data = request.json
msg, status = check_required_attributes(required_attributes, data, 'nft-transfer')
if msg:
return msg, status
agreement_id = data.get('agreementId')
nft_holder_address = data.get('nftHolder')
nft_receiver_address = data.get('nftReceiver')
nft_amount = data.get('nftAmount')
keeper = keeper_instance()
agreement = keeper.agreement_manager.get_agreement(agreement_id)
did = id_to_did(agreement.did)
ddo = DIDResolver(keeper.did_registry).resolve(did)
try:
ServiceAgreement.from_ddo(ServiceTypes.NFT_SALES, ddo)
except ValueError as e:
logger.error('nft-sales service not found on ddo for %s', did)
return str(e), 400
(
lock_payment_condition_id,
nft_transfer_condition_id,
escrow_payment_condition_id
) = agreement.condition_ids
if not is_lock_payment_condition_fulfilled(lock_payment_condition_id, keeper):
msg = f'lockPayment condition for agreement_id={agreement_id} is not fulfilled'
logger.warning(msg)
return msg, 402
if not is_nft_transfer_approved(nft_holder_address, get_provider_account().address, keeper):
msg = f'Gateway ({get_provider_account().address}) is not approved to transfer nfts from {nft_holder_address}'
logger.warning(msg)
return msg, 405
# fulfill transferNFT condition
if not is_nft_transfer_condition_fulfilled(nft_transfer_condition_id, keeper):
logger.debug('NFTTransfer condition not fulfilled')
result = fulfill_for_delegate_nft_transfer_condition(
agreement_id,
agreement.did,
Web3.toChecksumAddress(nft_holder_address),
Web3.toChecksumAddress(nft_receiver_address),
nft_amount,
lock_payment_condition_id,
keeper
)
if result is False:
msg = f'There was an error fulfilling the NFTTransfer condition for agreement_id={agreement_id}'
logger.error(msg)
return msg, 500
# fulfill escrowPayment condition
if not is_escrow_payment_condition_fulfilled(escrow_payment_condition_id, keeper):
logger.debug('EscrowPayment condition not fulfilled')
result = fulfill_escrow_payment_condition(
keeper,
agreement_id,
[
nft_transfer_condition_id,
lock_payment_condition_id,
escrow_payment_condition_id
],
ddo,
get_provider_account(),
service_type=ServiceTypes.NFT_SALES
)
if result is False:
msg = f'There was an error fulfilling the EscrowPayment condition for agreement_id={agreement_id}'
logger.error(msg)
return msg, 500
return 'success', 200
@services.route('/execute/<agreement_id>', methods=['POST'])
@require_oauth()
def execute(agreement_id):
"""Call the execution of a workflow.
swagger_from_file: docs/execute.yml
"""
consumer_address = current_token["client_id"]
workflow_did = current_token["did"]
agreement_id = current_token["sub"]
try:
keeper = keeper_instance()
asset_id = keeper_instance().agreement_manager.get_agreement(agreement_id).did
did = id_to_did(asset_id)
signature = '0x00'
workflow = DIDResolver(keeper_instance().did_registry).resolve(workflow_did)
body = {"serviceAgreementId": agreement_id, "workflow": workflow.as_dictionary()}
response = requests_session.post(
get_config().compute_api_url + '/api/v1/nevermined-compute-api/init',
data=json.dumps(body),
headers={'content-type': 'application/json'})
if response.status_code != 200:
msg = f'The compute API was not able to create the workflow. {response.content}'
logger.warning(msg)
return msg, 401
used_by(generate_random_id(), did, consumer_address, 'compute', signature, 'compute', provider_acc,
keeper)
return jsonify({"workflowId": response.content.decode('utf-8')})
except Exception as e:
logger.error(f'Error- {str(e)}', exc_info=1)
return f'Error : {str(e)}', 500
@services.route('/compute/logs/<agreement_id>/<execution_id>', methods=['GET'])
@require_oauth()
def compute_logs(agreement_id, execution_id):
"""Allows to get access to an asset data file.
swagger_from_file: docs/compute_logs.yml
"""
consumer_address = current_token["client_id"]
execution_id = current_token["execution_id"]
agreement_id = current_token["sub"]
logger.info(('Parameters:\n'
'ConsumerAddress: %s\n'
'AgreementId: %s\n'
'ExecutionId: %s\n'),
consumer_address, agreement_id, execution_id)
response = requests_session.get(
get_config().compute_api_url + | |
<filename>firmware/coreboot/util/me_cleaner/me_cleaner.py
#!/usr/bin/python
# me_cleaner - Tool for partial deblobbing of Intel ME/TXE firmware images
# Copyright (C) 2016-2018 <NAME> <<EMAIL>>
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
from __future__ import division, print_function
import argparse
import binascii
import hashlib
import itertools
import shutil
import sys
from struct import pack, unpack
min_ftpr_offset = 0x400
spared_blocks = 4
unremovable_modules = ("ROMP", "BUP")
unremovable_modules_me11 = ("rbe", "kernel", "syslib", "bup")
unremovable_partitions = ("FTPR",)
pubkeys_md5 = {
"763e59ebe235e45a197a5b1a378dfa04": ("ME", ("6.x.x.x",)),
"3a98c847d609c253e145bd36512629cb": ("ME", ("6.0.50.x",)),
"0903fc25b0f6bed8c4ed724aca02124c": ("ME", ("7.x.x.x", "8.x.x.x")),
"2011ae6df87c40fba09e3f20459b1ce0": ("ME", ("9.0.x.x", "9.1.x.x")),
"e8427c5691cf8b56bc5cdd82746957ed": ("ME", ("9.5.x.x", "10.x.x.x")),
"986a78e481f185f7d54e4af06eb413f6": ("ME", ("11.x.x.x",)),
"bda0b6bb8ca0bf0cac55ac4c4d55e0f2": ("TXE", ("1.x.x.x",)),
"b726a2ab9cd59d4e62fe2bead7cf6997": ("TXE", ("1.x.x.x",)),
"0633d7f951a3e7968ae7460861be9cfb": ("TXE", ("2.x.x.x",)),
"1d0a36e9f5881540d8e4b382c6612ed8": ("TXE", ("3.x.x.x",)),
"be900fef868f770d266b1fc67e887e69": ("SPS", ("2.x.x.x",)),
"4622e3f2cb212a89c90a4de3336d88d2": ("SPS", ("3.x.x.x",)),
"31ef3d950eac99d18e187375c0764ca4": ("SPS", ("4.x.x.x",))
}
class OutOfRegionException(Exception):
pass
class RegionFile:
def __init__(self, f, region_start, region_end):
self.f = f
self.region_start = region_start
self.region_end = region_end
def read(self, n):
if f.tell() + n <= self.region_end:
return self.f.read(n)
else:
raise OutOfRegionException()
def readinto(self, b):
if f.tell() + len(b) <= self.region_end:
return self.f.readinto(b)
else:
raise OutOfRegionException()
def seek(self, offset):
if self.region_start + offset <= self.region_end:
return self.f.seek(self.region_start + offset)
else:
raise OutOfRegionException()
def write_to(self, offset, data):
if self.region_start + offset + len(data) <= self.region_end:
self.f.seek(self.region_start + offset)
return self.f.write(data)
else:
raise OutOfRegionException()
def fill_range(self, start, end, fill):
if self.region_start + end <= self.region_end:
if start < end:
block = fill * 4096
self.f.seek(self.region_start + start)
self.f.writelines(itertools.repeat(block,
(end - start) // 4096))
self.f.write(block[:(end - start) % 4096])
else:
raise OutOfRegionException()
def fill_all(self, fill):
self.fill_range(0, self.region_end - self.region_start, fill)
def move_range(self, offset_from, size, offset_to, fill):
if self.region_start + offset_from + size <= self.region_end and \
self.region_start + offset_to + size <= self.region_end:
for i in range(0, size, 4096):
self.f.seek(self.region_start + offset_from + i, 0)
block = self.f.read(min(size - i, 4096))
self.f.seek(self.region_start + offset_from + i, 0)
self.f.write(fill * len(block))
self.f.seek(self.region_start + offset_to + i, 0)
self.f.write(block)
else:
raise OutOfRegionException()
def save(self, filename, size):
if self.region_start + size <= self.region_end:
self.f.seek(self.region_start)
copyf = open(filename, "w+b")
for i in range(0, size, 4096):
copyf.write(self.f.read(min(size - i, 4096)))
return copyf
else:
raise OutOfRegionException()
def get_chunks_offsets(llut):
chunk_count = unpack("<I", llut[0x04:0x08])[0]
huffman_stream_end = sum(unpack("<II", llut[0x10:0x18]))
nonzero_offsets = [huffman_stream_end]
offsets = []
for i in range(0, chunk_count):
chunk = llut[0x40 + i * 4:0x44 + i * 4]
offset = 0
if chunk[3] != 0x80:
offset = unpack("<I", chunk[0:3] + b"\x00")[0]
offsets.append([offset, 0])
if offset != 0:
nonzero_offsets.append(offset)
nonzero_offsets.sort()
for i in offsets:
if i[0] != 0:
i[1] = nonzero_offsets[nonzero_offsets.index(i[0]) + 1]
return offsets
def remove_modules(f, mod_headers, ftpr_offset, me_end):
comp_str = ("uncomp.", "Huffman", "LZMA")
unremovable_huff_chunks = []
chunks_offsets = []
base = 0
chunk_size = 0
end_addr = 0
for mod_header in mod_headers:
name = mod_header[0x04:0x14].rstrip(b"\x00").decode("ascii")
offset = unpack("<I", mod_header[0x38:0x3C])[0] + ftpr_offset
size = unpack("<I", mod_header[0x40:0x44])[0]
flags = unpack("<I", mod_header[0x50:0x54])[0]
comp_type = (flags >> 4) & 7
print(" {:<16} ({:<7}, ".format(name, comp_str[comp_type]), end="")
if comp_type == 0x00 or comp_type == 0x02:
print("0x{:06x} - 0x{:06x} ): "
.format(offset, offset + size), end="")
if name in unremovable_modules:
end_addr = max(end_addr, offset + size)
print("NOT removed, essential")
else:
end = min(offset + size, me_end)
f.fill_range(offset, end, b"\xff")
print("removed")
elif comp_type == 0x01:
if not chunks_offsets:
f.seek(offset)
llut = f.read(4)
if llut == b"LLUT":
llut += f.read(0x3c)
chunk_count = unpack("<I", llut[0x4:0x8])[0]
base = unpack("<I", llut[0x8:0xc])[0] + 0x10000000
chunk_size = unpack("<I", llut[0x30:0x34])[0]
llut += f.read(chunk_count * 4)
chunks_offsets = get_chunks_offsets(llut)
else:
sys.exit("Huffman modules found, but LLUT is not present")
module_base = unpack("<I", mod_header[0x34:0x38])[0]
module_size = unpack("<I", mod_header[0x3c:0x40])[0]
first_chunk_num = (module_base - base) // chunk_size
last_chunk_num = first_chunk_num + module_size // chunk_size
huff_size = 0
for chunk in chunks_offsets[first_chunk_num:last_chunk_num + 1]:
huff_size += chunk[1] - chunk[0]
print("fragmented data, {:<9}): "
.format("~" + str(int(round(huff_size / 1024))) + " KiB"),
end="")
if name in unremovable_modules:
print("NOT removed, essential")
unremovable_huff_chunks += \
[x for x in chunks_offsets[first_chunk_num:
last_chunk_num + 1] if x[0] != 0]
else:
print("removed")
else:
print("0x{:06x} - 0x{:06x}): unknown compression, skipping"
.format(offset, offset + size), end="")
if chunks_offsets:
removable_huff_chunks = []
for chunk in chunks_offsets:
if all(not(unremovable_chk[0] <= chunk[0] < unremovable_chk[1] or
unremovable_chk[0] < chunk[1] <= unremovable_chk[1])
for unremovable_chk in unremovable_huff_chunks):
removable_huff_chunks.append(chunk)
for removable_chunk in removable_huff_chunks:
if removable_chunk[1] > removable_chunk[0]:
end = min(removable_chunk[1], me_end)
f.fill_range(removable_chunk[0], end, b"\xff")
end_addr = max(end_addr,
max(unremovable_huff_chunks, key=lambda x: x[1])[1])
return end_addr
def check_partition_signature(f, offset):
f.seek(offset)
header = f.read(0x80)
modulus = int(binascii.hexlify(f.read(0x100)[::-1]), 16)
public_exponent = unpack("<I", f.read(4))[0]
signature = int(binascii.hexlify(f.read(0x100)[::-1]), 16)
header_len = unpack("<I", header[0x4:0x8])[0] * 4
manifest_len = unpack("<I", header[0x18:0x1c])[0] * 4
f.seek(offset + header_len)
sha256 = hashlib.sha256()
sha256.update(header)
sha256.update(f.read(manifest_len - header_len))
decrypted_sig = pow(signature, public_exponent, modulus)
return "{:#x}".format(decrypted_sig).endswith(sha256.hexdigest()) # FIXME
def print_check_partition_signature(f, offset):
if check_partition_signature(f, offset):
print("VALID")
else:
print("INVALID!!")
sys.exit("The FTPR partition signature is not valid. Is the input "
"ME/TXE image valid?")
def relocate_partition(f, me_end, partition_header_offset,
new_offset, mod_headers):
f.seek(partition_header_offset)
name = f.read(4).rstrip(b"\x00").decode("ascii")
f.seek(partition_header_offset + 0x8)
old_offset, partition_size = unpack("<II", f.read(0x8))
llut_start = 0
for mod_header in mod_headers:
if (unpack("<I", mod_header[0x50:0x54])[0] >> 4) & 7 == 0x01:
llut_start = unpack("<I", mod_header[0x38:0x3C])[0] + old_offset
break
if mod_headers and llut_start != 0:
# Bytes 0x9:0xb of the LLUT (bytes 0x1:0x3 of the AddrBase) are added
# to the SpiBase (bytes 0xc:0x10 of the LLUT) to compute the final
# start of the LLUT. Since AddrBase is not modifiable, we can act only
# on SpiBase and here we compute the minimum allowed new_offset.
f.seek(llut_start + 0x9)
lut_start_corr = unpack("<H", f.read(2))[0]
new_offset = max(new_offset,
lut_start_corr - llut_start - 0x40 + old_offset)
new_offset = ((new_offset + 0x1f) // 0x20) * 0x20
offset_diff = new_offset - old_offset
print("Relocating {} from {:#x} - {:#x} to {:#x} - {:#x}..."
.format(name, old_offset, old_offset + partition_size,
new_offset, new_offset + partition_size))
print(" Adjusting FPT entry...")
f.write_to(partition_header_offset + 0x8,
pack("<I", new_offset))
if mod_headers:
if llut_start != 0:
f.seek(llut_start)
if f.read(4) == b"LLUT":
print(" Adjusting LUT start offset...")
lut_offset = llut_start + offset_diff + 0x40 - lut_start_corr
f.write_to(llut_start + 0x0c, pack("<I", lut_offset))
print(" Adjusting Huffman start offset...")
f.seek(llut_start + 0x14)
old_huff_offset = unpack("<I", f.read(4))[0]
f.write_to(llut_start + 0x14,
pack("<I", old_huff_offset + offset_diff))
print(" Adjusting chunks offsets...")
f.seek(llut_start + 0x4)
chunk_count = unpack("<I", f.read(4))[0]
f.seek(llut_start + 0x40)
chunks = bytearray(chunk_count * 4)
f.readinto(chunks)
for i in range(0, chunk_count * 4, 4):
if chunks[i + 3] != 0x80:
chunks[i:i + 3] = \
pack("<I", unpack("<I", chunks[i:i + 3] +
b"\x00")[0] + offset_diff)[0:3]
f.write_to(llut_start + 0x40, chunks)
else:
sys.exit("Huffman modules present but no LLUT found!")
else:
print(" No Huffman modules found")
print(" Moving data...")
partition_size = min(partition_size, me_end - old_offset)
f.move_range(old_offset, partition_size, new_offset, b"\xff")
return new_offset
def check_and_remove_modules(f, me_end, offset, min_offset,
relocate, keep_modules):
f.seek(offset + 0x20)
num_modules = unpack("<I", f.read(4))[0]
f.seek(offset + 0x290)
data = f.read(0x84)
mod_header_size = 0
if data[0x0:0x4] == b"$MME":
if data[0x60:0x64] == b"$MME" or num_modules == 1:
mod_header_size = 0x60
elif data[0x80:0x84] == b"$MME":
mod_header_size = 0x80
if mod_header_size != 0:
f.seek(offset + 0x290)
data = f.read(mod_header_size * num_modules)
mod_headers = [data[i * mod_header_size:(i + 1) * mod_header_size]
for i in range(0, num_modules)]
if all(hdr.startswith(b"$MME") for hdr in mod_headers):
if args.keep_modules:
end_addr = offset + ftpr_length
else:
end_addr = remove_modules(f, mod_headers, offset, me_end)
if args.relocate:
new_offset = relocate_partition(f, me_end, 0x30, min_offset,
mod_headers)
end_addr += new_offset - offset
offset = new_offset
return end_addr, offset
else:
print("Found less modules than expected in the FTPR "
"partition; skipping modules removal")
else:
print("Can't find the module header size; skipping "
"modules removal")
return -1, offset
def check_and_remove_modules_me11(f, me_end, partition_offset,
partition_length, min_offset, relocate,
keep_modules):
comp_str = ("LZMA/uncomp.", "Huffman")
if keep_modules:
end_data = partition_offset + partition_length
else:
end_data = 0
f.seek(partition_offset + 0x4)
module_count = unpack("<I", f.read(4))[0]
modules = []
modules.append(("end", partition_length, 0))
f.seek(partition_offset + 0x10)
for i in range(0, module_count):
data = f.read(0x18)
name = data[0x0:0xc].rstrip(b"\x00").decode("ascii")
offset_block | |
import yaml
import os
import logging
from os.path import relpath
from dc_exceptions import DcException
from copy import deepcopy
class DcMixer(object):
"""
Main class for dc-mixer
"""
__MIXER_FILE = 'docker-compose-mixer.yml'
""":type : string"""
__EXIT_STATUS_INPUT_FILE_NOT_EXISTS = 2
""":type : string"""
__input_file = '/docker-compose-mixer.yml'
""":type : string"""
__output_file = '/docker-compose.yml'
""":type : string"""
__scopes_container = None
""":type : ScopesContainer"""
def __init__(self, input_file, output_file, scope_container):
"""
:param input_file: string
:param scope_container: ScopesContainer
"""
self.__input_file = input_file
self.__output_file = output_file
self.__scopes_container = scope_container
def get_input_file(self):
"""
:return: string
"""
return self.__input_file
def process(self):
logging.log(logging.DEBUG, 'Start compiling compose file...')
logging.log(logging.DEBUG, 'Input file: ' + self.__input_file + '; output file: ' + self.__output_file)
input_file = self.get_input_file()
if not os.path.isfile(self.get_input_file()):
raise DcException('File ' + input_file + ' does not exist, can\'t continue!')
mixer_config = yaml.load(open(self.get_input_file(), 'r'))
logging.log(logging.DEBUG, 'Mixer config is below:\n\t' + str(mixer_config))
if 'includes' not in mixer_config:
logging.log(logging.WARNING, 'No includes found in' + self.__MIXER_FILE)
else:
self.flush()
self.build_scopes(mixer_config)
self.resolve_services_names()
self.resolve_paths()
self.resolve_ports()
self.add_master_scope(mixer_config)
self.apply_overrides(mixer_config)
self.save_result_scope()
def flush(self):
"""
Flush ScopesContainer
"""
self.__scopes_container.flush()
@staticmethod
def is_path_relative(path):
"""
Check if we can update path with prefix
:param path: string
:return: Bool
"""
if os.path.isabs(path) or str(path).startswith('~'):
return False
else:
return True
def build_scopes(self, mixer_config):
"""
Build scopes in scopes container
:param mixer_config: dict
"""
if 'ignores' not in mixer_config:
mixer_config['ignores'] = []
self.__scopes_container.set_ignored_services(mixer_config['ignores'])
for (prefix, include_file) in mixer_config['includes'].iteritems():
if self.is_path_relative(include_file):
include_file = os.path.normpath(os.path.join(os.path.dirname(self.__input_file), include_file))
logging.log(logging.DEBUG, 'Creating scope for file: ' + include_file + ' and prefix: ' + prefix)
scope = ServicesScope(prefix)
scope.extract_services_from_file(include_file)
self.__scopes_container.add_scope(prefix, scope)
def resolve_services_names(self):
"""
Resolve services names in all scopes
"""
logging.log(logging.DEBUG, 'Resolving services names')
self.__scopes_container.resolve_names()
def resolve_paths(self):
"""
Resolve paths to files and dirs
"""
logging.log(logging.DEBUG, 'Resolving services paths with')
self.__scopes_container.resolve_paths(os.path.dirname(self.__output_file))
def resolve_ports(self):
"""
Resolve ports which we will bind to host machine
"""
logging.log(logging.DEBUG, 'Resolving services ports')
redefined_ports = self.__scopes_container.resolve_ports()
logging.log(logging.DEBUG, 'Redefined ports:\n\t' + str(redefined_ports))
def add_master_scope(self, mixer_config):
"""
Add master services from `master_services` section
"""
if 'master_services' not in mixer_config:
return
scope = ServicesScope('')
scope.extract_services(mixer_config['master_services'])
self.__scopes_container.add_scope('', scope)
def apply_overrides(self, mixer_config):
"""
Apply overrides from `overrides` section
:param mixer_config: dict
"""
if 'overrides' not in mixer_config:
return
self.__scopes_container.apply_overrides(mixer_config['overrides'])
def save_result_scope(self):
"""
Save result scope in output file as yaml
:return: bool
"""
scope = self.__scopes_container.get_result_scope()
logging.log(logging.DEBUG, 'Result scope is:\n\t' + str(scope))
with open(self.__output_file, 'w') as outfile:
logging.log(logging.DEBUG, 'Save result scope in the file "' + self.__output_file + '"')
outfile.write(yaml.dump(scope, default_flow_style=False, indent=2))
class ScopesContainer(object):
"""
High level container for scopes
"""
__scopes = {}
""":type : dict[ServicesScope]"""
__ignored_services = []
""":type : list"""
def __init__(self):
self.__scopes = {}
self.__ignored_services = []
def set_ignored_services(self, ignored_services):
self.__ignored_services = ignored_services
def add_scope(self, scope_name, scope):
"""
Add scope to container
:param scope_name:
:param scope: ServicesScope
"""
self.__scopes[scope_name] = scope
def flush(self):
"""
Remove all scopes from container
"""
self.__scopes = {}
self.__ignored_services = []
def get_result_scope(self):
"""
Get result array of services
:return: dict
"""
services_definitions = {}
for (scope_name, scope) in self.__scopes.iteritems():
services_definitions.update(scope.get_services_definitions())
return services_definitions
def resolve_names(self):
"""
Resolve names in services and add prefixes using scopes' name
"""
for (scope_name, scope) in self.__scopes.iteritems():
scope.update_names(self.__ignored_services)
def resolve_paths(self, work_path='/'):
"""
Resolve paths in services
"""
for (scope_name, scope) in self.__scopes.iteritems():
scope.update_paths(work_path)
def resolve_ports(self):
"""
Resolve ports and return redefined in each container
{
projaphp: {
80:81 // redefine port 80 to 81 for service projaphp
}
}
:return: dict
"""
busy_ports = []
redefined_ports = {}
for (scope_name, scope) in self.__scopes.iteritems():
busy_ports, new_redefined_ports = scope.update_ports(busy_ports)
redefined_ports.update(new_redefined_ports)
return redefined_ports
def apply_overrides(self, overrides):
"""
Apply overrides
:param overrides: dict
"""
for (scope_name, scope) in self.__scopes.iteritems():
self.__scopes[scope_name].apply_overrides(overrides)
class ServicesScope(object):
"""
Class which defines services from one scope (file docker-compose.yml)
"""
__scope_name = None
""":type : string"""
__services = {}
""":type : dict[Service]"""
__services_path = None
""":type : string"""
def __init__(self, scope_name):
self.__scope_name = scope_name
self.__services = {}
self.__services_path = None
def extract_services_from_file(self, file_name):
"""
Get scope of services from one file
:param file_name: list[Service]
"""
services_file = os.path.abspath(file_name)
self.__services_path = os.path.dirname(services_file)
services_config = yaml.load(open(services_file, 'r'))
self.extract_services(services_config)
def extract_services(self, services_config):
"""
Extract services from config array
:param services_config: dict
"""
for (service_name, service) in services_config.iteritems():
self.__services[service_name] = Service(service)
def get_services_definitions(self):
"""
Get services as dictionary
:return: dict
"""
definitions = {}
for (service_name, service) in self.__services.iteritems():
if not service.is_ignored():
definitions[service_name] = service.get_definition()
return definitions
def update_names(self, ignored_services=[], prefix=None):
"""
Update services names with prefix
:param prefix: string
"""
if not prefix:
prefix = self.__scope_name
services = {}
name_map = {}
for (service_name, service) in self.__services.iteritems():
# rename
new_name = str(prefix + service_name)
name_map[service_name] = new_name
service = deepcopy(self.__services[service_name]) # deepcopy and remove old dictionary
services[new_name] = service
if new_name in ignored_services:
service.ignore()
self.__services = services
for (service_name, service) in self.__services.iteritems():
# update usages of service name
service.update_container_name(service_name)
service.update_volumes_from(name_map, ignored_services)
service.update_links(name_map, ignored_services)
service.update_extends(name_map, ignored_services)
def update_paths(self, work_path):
"""
Resolve paths in scope
"""
rel_path = relpath(self.__services_path, work_path)
for (service_name, service) in self.__services.iteritems():
# update usages of service name
service.update_build_path(rel_path)
service.update_volumes_path(rel_path)
service.update_env_file_path(rel_path)
service.update_extends_path(rel_path)
def update_ports(self, busy_ports=[]):
"""
Update ports and add busy ports to input array
:param busy_ports: dict
:return: list, dict
"""
redefined_ports = {}
for (service_name, service) in self.__services.iteritems():
if service.is_ignored(): # dont need to deal with ignored service
continue
busy_ports, service_redefined_ports = service.update_ports()
if len(service_redefined_ports):
redefined_ports[service_name] = service_redefined_ports
return busy_ports, redefined_ports
def apply_overrides(self, overrides):
"""
Override
:param overrides: dict
"""
for (service_name, service) in self.__services.iteritems():
if service_name in overrides:
service.apply_overrides(overrides[service_name])
class Service(object):
"""
Class which defines service from docker compose
"""
__definition = None
""":type : dict"""
__ignored = False
""":type : bool"""
def __init__(self, definition):
"""
:param definition: dict
"""
self.__definition = definition
self.__ignored = False
def ignore(self):
"""
Ignore service in scope
"""
self.__ignored = True
def is_ignored(self):
"""
If service ignored
:return: bool
"""
return self.__ignored
def get_definition(self):
"""
Get definition of service
:return: list
"""
return self.__definition
def update_container_name(self, name):
"""
Update container name if only exists
:param name: string
"""
if 'container_name' in self.__definition:
if self.__definition['container_name']:
self.__definition['container_name'] = name
else:
del self.__definition['container_name']
def update_volumes_from(self, name_map, ignored_services=[]):
"""
Update volumes from
:param name_map: dict
:param ignored_services: list
"""
new_volumes_from = []
if 'volumes_from' in self.__definition:
if self.__definition['volumes_from']:
for (service_name) in self.__definition['volumes_from']:
new_volume_from = name_map[service_name]
if new_volume_from not in ignored_services: # we don't need ignored services
new_volumes_from.append(new_volume_from)
self.__definition['volumes_from'] = new_volumes_from
else:
del self.__definition['volumes_from']
def update_links(self, name_map, ignored_services=[]):
"""
Update links
:param name_map: dict
:param ignored_services: list
"""
new_links = []
if 'links' in self.__definition:
if self.__definition['links']:
for (link) in self.__definition['links']:
link_parts = str(link).split(':', 1)
old_link_service=link_parts[0]
new_link_service = name_map[old_link_service]
if new_link_service not in ignored_services: # we don't need ignored services
link_parts[0] = new_link_service
if len(link_parts) == 1:
link_parts.append(old_link_service)
new_links.append(':'.join(link_parts))
self.__definition['links'] = new_links
else:
del self.__definition['volumes_from']
def update_extends(self, name_map, ignored_services):
"""
:param name_map: dict
:param ignored_services: list
"""
if 'extends' in self.__definition and self.__definition['extends'] and \
('file' not in self.__definition['extends'] or not self.__definition['extends']['file']) and \
'service' in self.__definition['extends'] and self.__definition['extends']['service']:
new_extends_service = name_map[self.__definition['extends']['service']]
if new_extends_service in ignored_services:
del self.__definition['extends']
self.ignore()
else:
self.__definition['extends']['service'] = new_extends_service
def update_build_path(self, rel_path):
"""
:param rel_path: string
"""
if 'build' in self.__definition:
if self.__definition['build']:
new_build = self.__definition['build']
if DcMixer.is_path_relative(new_build):
new_build = os.path.normpath(os.path.join(rel_path, new_build))
self.__definition['build'] = new_build
else:
del self.__definition['build']
def update_volumes_path(self, rel_path):
"""
:param rel_path: string
"""
new_volumes = []
if 'volumes' in self.__definition:
if self.__definition['volumes']:
for (volume) in self.__definition['volumes']:
volume_parts = str(volume).split(':', 1)
if DcMixer.is_path_relative(volume_parts[0]):
host_path = os.path.normpath(os.path.join(rel_path, volume_parts[0]))
if not str(volume_parts[0]).startswith('..'):
host_path = os.path.join('.', host_path)
volume_parts[0] = host_path
new_volumes.append(':'.join(volume_parts))
self.__definition['volumes'] = new_volumes
else:
del self.__definition['volumes']
def update_env_file_path(self, rel_path):
"""
Update path[s] to file with ENV variables
:param rel_path: string
"""
if 'env_file' in self.__definition:
if self.__definition['env_file']:
if isinstance(self.__definition['env_file'], str):
self.__definition['env_file'] = [self.__definition['env_file']]
new_env_files = []
for (env_file) in self.__definition['env_file']:
new_env_file = env_file
if DcMixer.is_path_relative(new_env_file):
new_env_file = os.path.normpath(os.path.join(rel_path, new_env_file))
new_env_files.append(new_env_file)
self.__definition['env_file'] = new_env_files
else:
del self.__definition['env_file']
def update_extends_path(self, rel_path):
"""
:param rel_path: string
"""
if 'extends' in self.__definition and self.__definition['extends'] and \
'file' in self.__definition['extends'] and self.__definition['extends']['file']:
new_file = self.__definition['extends']['file']
if DcMixer.is_path_relative(new_file):
self.__definition['extends']['file'] = os.path.normpath(os.path.join(rel_path, new_file))
def update_ports(self, busy_ports=[]):
"""
Update ports and return busy ports | |
current law and records modified with imputation
elecv_credit = max(0., min(ev_credit_amt, EV_credit_c))
# phaseout based on agi
posevagi = max(c00100, 0.)
ev_max = EV_credit_ps[MARS - 1]
if posevagi < ev_max:
evtc = elecv_credit
else:
evtc_reduced = max(0., evtc - EV_credit_prt * (posevagi - ev_max))
evtc = min(evtc, evtc_reduced)
return evtc
@iterate_jit(nopython=True)
def AmOppCreditParts(exact, e87521, num, c00100, CR_AmOppRefundable_hc,
CR_AmOppNonRefundable_hc, c10960, c87668):
"""
Applies a phaseout to the Form 8863, line 1, American Opportunity Credit
amount, e87521, and then applies the 0.4 refundable rate.
Logic corresponds to Form 8863, Part I.
Notes
-----
Tax Law Parameters that are not parameterized:
90000 : American Opportunity Credit phaseout income base
10000 : American Opportunity Credit phaseout income range length
1/1000 : American Opportunity Credit phaseout rate
0.4 : American Opportunity Credit refundable rate
Parameters
----------
exact : whether or not to do rounding of phaseout fraction
e87521 : total tentative American Opportunity Credit for all students,
Form 8863, line 1
num : number of people filing jointly
c00100 : AGI
CR_AmOppRefundable_hc: haircut for the refundable portion of the
American Opportunity Credit
CR_AmOppNonRefundable_hc: haircut for the nonrefundable portion of the
American Opportunity Credit
Returns
-------
c10960 : Refundable part of American Opportunity Credit
c87668 : Tentative nonrefundable part of American Opportunity Credit
"""
if e87521 > 0.:
c87658 = max(0., 90000. * num - c00100)
c87660 = 10000. * num
if exact == 1: # exact calculation as on tax forms
c87662 = 1000. * min(1., round(c87658 / c87660, 3))
else:
c87662 = 1000. * min(1., c87658 / c87660)
c87664 = c87662 * e87521 / 1000.
c10960 = 0.4 * c87664 * (1. - CR_AmOppRefundable_hc)
c87668 = c87664 - c10960 * (1. - CR_AmOppNonRefundable_hc)
else:
c10960 = 0.
c87668 = 0.
return (c10960, c87668)
@iterate_jit(nopython=True)
def SchR(age_head, age_spouse, MARS, c00100,
c05800, e07300, c07180, e02400, c02500, e01500, e01700, CR_SchR_hc,
c07200):
"""
Calculates Schedule R credit for the elderly and the disabled, c07200.
Note that no Schedule R policy parameters are inflation indexed.
Note that all Schedule R policy parameters are hard-coded, and therefore,
are not able to be changed using Policy class parameters.
Note that the CR_SchR_hc policy parameter allows the user to eliminate
or reduce total Schedule R credits.
"""
if age_head >= 65 or (MARS == 2 and age_spouse >= 65):
# calculate credit assuming nobody is disabled (so line12 = line10)
if MARS == 2:
if age_head >= 65 and age_spouse >= 65:
schr12 = 7500.
else:
schr12 = 5000.
schr15 = 10000.
elif MARS == 3:
schr12 = 3750.
schr15 = 5000.
elif MARS in (1, 4):
schr12 = 5000.
schr15 = 7500.
else:
schr12 = 0.
schr15 = 0.
# nontaxable portion of OASDI benefits, line 13a
schr13a = max(0., e02400 - c02500)
# nontaxable portion of pension benefits, line 13b
# NOTE: the following approximation (required because of inadequate IRS
# data) will be accurate if all pensions are partially taxable
# or if all pensions are fully taxable. But if a filing unit
# receives at least one partially taxable pension and at least
# one fully taxable pension, then the approximation in the
# following line is not exactly correct.
schr13b = max(0., e01500 - e01700)
schr13c = schr13a + schr13b
schr16 = max(0., c00100 - schr15)
schr17 = 0.5 * schr16
schr18 = schr13c + schr17
schr19 = max(0., schr12 - schr18)
schr20 = 0.15 * schr19
schr21 = max(0., (c05800 - e07300 - c07180))
c07200 = min(schr20, schr21) * (1. - CR_SchR_hc)
else: # if not calculating Schedule R credit
c07200 = 0.
return c07200
@iterate_jit(nopython=True)
def EducationTaxCredit(exact, e87530, MARS, c00100, num, c05800,
e07300, c07180, c07200, c87668,
LLC_Expense_c, ETC_pe_Single, ETC_pe_Married,
CR_Education_hc,
c07230):
"""
Computes Education Tax Credits (Form 8863) nonrefundable amount, c07230.
Logic corresponds to Form 8863, Part II.
Notes
-----
Tax Law Parameters that are not parameterized:
0.2 : Lifetime Learning Credit ratio against expense
Tax Law Parameters that are parameterized:
LLC_Expense_c : Lifetime Learning Credit expense limit
ETC_pe_Married : Education Tax Credit phaseout end for married
ETC_pe_Single : Education Tax Credit phaseout end for single
Taxpayer Charateristics:
exact : whether or not to do rounding of phaseout fraction
e87530 : Lifetime Learning Credit total qualified expenses,
Form 8863, line 10
e07300 : Foreign tax credit - Form 1116
c07180 : Child/dependent care expense credit - Form 2441
c07200 : Schedule R credit
Returns
-------
c07230 : Education Tax Credits (Form 8863) nonrefundable amount
"""
c87560 = 0.2 * min(e87530, LLC_Expense_c)
if MARS == 2:
c87570 = ETC_pe_Married * 1000.
else:
c87570 = ETC_pe_Single * 1000.
c87590 = max(0., c87570 - c00100)
c87600 = 10000. * num
if exact == 1: # exact calculation as on tax forms
c87610 = min(1., round(c87590 / c87600, 3))
else:
c87610 = min(1., c87590 / c87600)
c87620 = c87560 * c87610
xline4 = max(0., c05800 - (e07300 + c07180 + c07200))
xline5 = min(c87620, xline4)
xline9 = max(0., c05800 - (e07300 + c07180 + c07200 + xline5))
xline10 = min(c87668, xline9)
c87680 = xline5 + xline10
c07230 = c87680 * (1. - CR_Education_hc)
return c07230
@iterate_jit(nopython=True)
def CharityCredit(e19800, e20100, c00100, CR_Charity_rt, CR_Charity_f,
CR_Charity_frt, MARS, charity_credit):
"""
Computes nonrefundable charity credit, charity_credit.
This credit is not part of current-law policy.
"""
total_charity = e19800 + e20100
floor = max(CR_Charity_frt * c00100, CR_Charity_f[MARS - 1])
charity_cr_floored = max(total_charity - floor, 0)
charity_credit = CR_Charity_rt * (charity_cr_floored)
return charity_credit
@iterate_jit(nopython=True)
def NonrefundableCredits(c05800, e07240, e07260, e07300, e07400,
e07600, p08000, odc,
personal_nonrefundable_credit, icgtc, iratc, evtc,
CR_RetirementSavings_hc, CR_ForeignTax_hc,
CR_ResidentialEnergy_hc, CR_GeneralBusiness_hc,
CR_MinimumTax_hc, CR_OtherCredits_hc, charity_credit,
c07180, c07200, c07220, c07230, c07240,
c07260, c07300, c07400, c07600, c08000):
"""
NonRefundableCredits function sequentially limits credits to tax liability.
Parameters
----------
CR_RetirementSavings_hc: Retirement savings credit haircut
CR_ForeignTax_hc: Foreign tax credit haircut
CR_ResidentialEnergy_hc: Residential energy credit haircut
CR_GeneralBusiness_hc: General business credit haircut
CR_MinimumTax_hc: Minimum tax credit haircut
CR_OtherCredits_hc: Other credits haircut
"""
# limit tax credits to tax liability in order they are on 2015 1040 form
avail = c05800
# Foreign tax credit - Form 1116
c07300 = min(e07300 * (1. - CR_ForeignTax_hc), avail)
avail = avail - c07300
# Child & dependent care expense credit
c07180 = min(c07180, avail)
avail = avail - c07180
# Education tax credit
c07230 = min(c07230, avail)
avail = avail - c07230
# Retirement savings credit - Form 8880
c07240 = min(e07240 * (1. - CR_RetirementSavings_hc), avail)
avail = avail - c07240
# Child tax credit
c07220 = min(c07220, avail)
avail = avail - c07220
# Other dependent credit
odc = min(odc, avail)
avail = avail - odc
# Residential energy credit - Form 5695
c07260 = min(e07260 * (1. - CR_ResidentialEnergy_hc), avail)
avail = avail - c07260
# General business credit - Form 3800
c07400 = min(e07400 * (1. - CR_GeneralBusiness_hc), avail)
avail = avail - c07400
# Prior year minimum tax credit - Form 8801
c07600 = min(e07600 * (1. - CR_MinimumTax_hc), avail)
avail = avail - c07600
# Schedule R credit
c07200 = min(c07200, avail)
avail = avail - c07200
# Other credits
c08000 = min(p08000 * (1. - CR_OtherCredits_hc), avail)
avail = avail - c08000
# Charity credit
charity_credit = min(charity_credit, avail)
avail = avail - charity_credit
# Personal nonrefundable credit
personal_nonrefundable_credit = min(personal_nonrefundable_credit, avail)
avail = avail - personal_nonrefundable_credit
# ICG credit
icgtc = min(icgtc, avail)
avail = avail - icgtc
# IRA credit
iratc = min(iratc, avail)
avail = avail - iratc
# EV credit
evtc = min(evtc, avail)
avail = avail - evtc
return (c07180, c07200, c07220, c07230, c07240, odc,
c07260, c07300, c07400, c07600, c08000, charity_credit,
personal_nonrefundable_credit, icgtc, iratc, evtc)
@iterate_jit(nopython=True)
def AdditionalCTC(codtc_limited, ACTC_c, n24, earned, ACTC_Income_thd,
ACTC_rt, nu06, ACTC_rt_bonus_under6family, ACTC_ChildNum,
ptax_was, c03260, e09800, c59660, e11200,
c11070):
"""
Calculates refundable Additional Child Tax Credit (ACTC), c11070,
following 2018 Form 8812 logic.
"""
# Part I
line3 = codtc_limited
line4 = ACTC_c * n24
c11070 = 0. # line15
if line3 | |
domain where the type named typeName is created.
assemblyName: The name of the assembly where the type named typeName is sought. If assemblyName is null,the
executing assembly is searched.
typeName: The name of the preferred type.
ignoreCase: true to specify that the search for typeName is not case-sensitive; false to specify that the
search is case-sensitive.
bindingAttr: A combination of zero or more bit flags that affect the search for the typeName constructor. If
bindingAttr is zero,a case-sensitive search for public constructors is conducted.
binder: An object that uses bindingAttr and args to seek and identify the typeName constructor. If
binder is null,the default binder is used.
args: An array of arguments that match in number,order,and type the parameters of the constructor to
invoke. If args is an empty array or null,the constructor that takes no parameters (the default
constructor) is invoked.
culture: Culture-specific information that governs the coercion of args to the formal types declared for
the typeName constructor. If culture is null,the System.Globalization.CultureInfo for the
current thread is used.
activationAttributes: An array of one or more attributes that can participate in activation. This is typically an
array that contains a single System.Runtime.Remoting.Activation.UrlAttribute object. The
System.Runtime.Remoting.Activation.UrlAttribute specifies the URL that is required to activate a
remote object.
Returns: A handle that must be unwrapped to access the newly created instance.
CreateInstance(type: Type,*args: Array[object]) -> object
Creates an instance of the specified type using the constructor that best matches the specified
parameters.
type: The type of object to create.
args: An array of arguments that match in number,order,and type the parameters of the constructor to
invoke. If args is an empty array or null,the constructor that takes no parameters (the default
constructor) is invoked.
Returns: A reference to the newly created object.
CreateInstance(type: Type,args: Array[object],activationAttributes: Array[object]) -> object
Creates an instance of the specified type using the constructor that best matches the specified
parameters.
type: The type of object to create.
args: An array of arguments that match in number,order,and type the parameters of the constructor to
invoke. If args is an empty array or null,the constructor that takes no parameters (the default
constructor) is invoked.
activationAttributes: An array of one or more attributes that can participate in activation. This is typically an
array that contains a single System.Runtime.Remoting.Activation.UrlAttribute object. The
System.Runtime.Remoting.Activation.UrlAttribute specifies the URL that is required to activate a
remote object.
Returns: A reference to the newly created object.
CreateInstance(type: Type,bindingAttr: BindingFlags,binder: Binder,args: Array[object],culture: CultureInfo) -> object
Creates an instance of the specified type using the constructor that best matches the specified
parameters.
type: The type of object to create.
bindingAttr: A combination of zero or more bit flags that affect the search for the type constructor. If
bindingAttr is zero,a case-sensitive search for public constructors is conducted.
binder: An object that uses bindingAttr and args to seek and identify the type constructor. If binder is
null,the default binder is used.
args: An array of arguments that match in number,order,and type the parameters of the constructor to
invoke. If args is an empty array or null,the constructor that takes no parameters (the default
constructor) is invoked.
culture: Culture-specific information that governs the coercion of args to the formal types declared for
the type constructor. If culture is null,the System.Globalization.CultureInfo for the current
thread is used.
Returns: A reference to the newly created object.
CreateInstance(type: Type,bindingAttr: BindingFlags,binder: Binder,args: Array[object],culture: CultureInfo,activationAttributes: Array[object]) -> object
Creates an instance of the specified type using the constructor that best matches the specified
parameters.
type: The type of object to create.
bindingAttr: A combination of zero or more bit flags that affect the search for the type constructor. If
bindingAttr is zero,a case-sensitive search for public constructors is conducted.
binder: An object that uses bindingAttr and args to seek and identify the type constructor. If binder is
null,the default binder is used.
args: An array of arguments that match in number,order,and type the parameters of the constructor to
invoke. If args is an empty array or null,the constructor that takes no parameters (the default
constructor) is invoked.
culture: Culture-specific information that governs the coercion of args to the formal types declared for
the type constructor. If culture is null,the System.Globalization.CultureInfo for the current
thread is used.
activationAttributes: An array of one or more attributes that can participate in activation. This is typically an
array that contains a single System.Runtime.Remoting.Activation.UrlAttribute object. The
System.Runtime.Remoting.Activation.UrlAttribute specifies the URL that is required to activate a
remote object.
Returns: A reference to the newly created object.
CreateInstance(assemblyName: str,typeName: str,activationAttributes: Array[object]) -> ObjectHandle
Creates an instance of the type whose name is specified,using the named assembly and default
constructor.
assemblyName: The name of the assembly where the type named typeName is sought. If assemblyName is null,the
executing assembly is searched.
typeName: The name of the preferred type.
activationAttributes: An array of one or more attributes that can participate in activation. This is typically an
array that contains a single System.Runtime.Remoting.Activation.UrlAttribute object. The
System.Runtime.Remoting.Activation.UrlAttribute specifies the URL that is required to activate a
remote object.
Returns: A handle that must be unwrapped to access the newly created instance.
CreateInstance(type: Type,nonPublic: bool) -> object
Creates an instance of the specified type using that type's default constructor.
type: The type of object to create.
nonPublic: true if a public or nonpublic default constructor can match; false if only a public default
constructor can match.
Returns: A reference to the newly created object.
CreateInstance(type: Type) -> object
Creates an instance of the specified type using that type's default constructor.
type: The type of object to create.
Returns: A reference to the newly created object.
CreateInstance(assemblyName: str,typeName: str) -> ObjectHandle
Creates an instance of the type whose name is specified,using the named assembly and default
constructor.
assemblyName: The name of the assembly where the type named typeName is sought. If assemblyName is null,the
executing assembly is searched.
typeName: The name of the preferred type.
Returns: A handle that must be unwrapped to access the newly created instance.
"""
pass
@staticmethod
def CreateInstanceFrom(*__args):
"""
CreateInstanceFrom(domain: AppDomain,assemblyFile: str,typeName: str) -> ObjectHandle
Creates an instance of the type whose name is specified in the specified remote domain,using
the named assembly file and default constructor.
domain: The remote domain where the type named typeName is created.
assemblyFile: The name of a file that contains an assembly where the type named typeName is sought.
typeName: The name of the preferred type.
Returns: A handle that must be unwrapped to access the newly created instance.
CreateInstanceFrom(domain: AppDomain,assemblyFile: str,typeName: str,ignoreCase: bool,bindingAttr: BindingFlags,binder: Binder,args: Array[object],culture: CultureInfo,activationAttributes: Array[object],securityAttributes: Evidence) -> ObjectHandle
Creates an instance of the type whose name is specified in the specified remote domain,using
the named assembly file and the constructor that best matches the specified parameters.
domain: The remote domain where the type named typeName is created.
assemblyFile: The name of a file that contains an assembly where the type named typeName is sought.
typeName: The name of the preferred type.
ignoreCase: true to specify that the search for typeName is not case-sensitive; false to specify that the
search is case-sensitive.
bindingAttr: A combination of zero or more bit flags that | |
self.sessionUuid:
raise Exception('sessionUuid of action[QueryVolumeAction] cannot be None')
reply = api.sync_call(self, self.sessionUuid)
self.reply = reply
self.out = reply.inventories
return self.out
class QueryVolumeSnapshotAction(inventory.APIQueryVolumeSnapshotMsg):
def __init__(self):
super(QueryVolumeSnapshotAction, self).__init__()
self.sessionUuid = None
self.reply = None
self.out = None
def run(self):
if not self.sessionUuid:
raise Exception('sessionUuid of action[QueryVolumeSnapshotAction] cannot be None')
reply = api.sync_call(self, self.sessionUuid)
self.reply = reply
self.out = reply.inventories
return self.out
class QueryVolumeSnapshotTreeAction(inventory.APIQueryVolumeSnapshotTreeMsg):
def __init__(self):
super(QueryVolumeSnapshotTreeAction, self).__init__()
self.sessionUuid = None
self.reply = None
self.out = None
def run(self):
if not self.sessionUuid:
raise Exception('sessionUuid of action[QueryVolumeSnapshotTreeAction] cannot be None')
reply = api.sync_call(self, self.sessionUuid)
self.reply = reply
self.out = reply.inventories
return self.out
class QueryVpcIkeConfigFromLocalAction(inventory.APIQueryVpcIkeConfigFromLocalMsg):
def __init__(self):
super(QueryVpcIkeConfigFromLocalAction, self).__init__()
self.sessionUuid = None
self.reply = None
self.out = None
def run(self):
if not self.sessionUuid:
raise Exception('sessionUuid of action[QueryVpcIkeConfigFromLocalAction] cannot be None')
reply = api.sync_call(self, self.sessionUuid)
self.reply = reply
self.out = reply.inventories
return self.out
class QueryVpcIpSecConfigFromLocalAction(inventory.APIQueryVpcIpSecConfigFromLocalMsg):
def __init__(self):
super(QueryVpcIpSecConfigFromLocalAction, self).__init__()
self.sessionUuid = None
self.reply = None
self.out = None
def run(self):
if not self.sessionUuid:
raise Exception('sessionUuid of action[QueryVpcIpSecConfigFromLocalAction] cannot be None')
reply = api.sync_call(self, self.sessionUuid)
self.reply = reply
self.out = reply.inventories
return self.out
class QueryVpcUserVpnGatewayFromLocalAction(inventory.APIQueryVpcUserVpnGatewayFromLocalMsg):
def __init__(self):
super(QueryVpcUserVpnGatewayFromLocalAction, self).__init__()
self.sessionUuid = None
self.reply = None
self.out = None
def run(self):
if not self.sessionUuid:
raise Exception('sessionUuid of action[QueryVpcUserVpnGatewayFromLocalAction] cannot be None')
reply = api.sync_call(self, self.sessionUuid)
self.reply = reply
self.out = reply.inventories
return self.out
class QueryVpcVpnConnectionFromLocalAction(inventory.APIQueryVpcVpnConnectionFromLocalMsg):
def __init__(self):
super(QueryVpcVpnConnectionFromLocalAction, self).__init__()
self.sessionUuid = None
self.reply = None
self.out = None
def run(self):
if not self.sessionUuid:
raise Exception('sessionUuid of action[QueryVpcVpnConnectionFromLocalAction] cannot be None')
reply = api.sync_call(self, self.sessionUuid)
self.reply = reply
self.out = reply.inventories
return self.out
class QueryVpcVpnGatewayFromLocalAction(inventory.APIQueryVpcVpnGatewayFromLocalMsg):
def __init__(self):
super(QueryVpcVpnGatewayFromLocalAction, self).__init__()
self.sessionUuid = None
self.reply = None
self.out = None
def run(self):
if not self.sessionUuid:
raise Exception('sessionUuid of action[QueryVpcVpnGatewayFromLocalAction] cannot be None')
reply = api.sync_call(self, self.sessionUuid)
self.reply = reply
self.out = reply.inventories
return self.out
class QueryVtepAction(inventory.APIQueryVtepMsg):
def __init__(self):
super(QueryVtepAction, self).__init__()
self.sessionUuid = None
self.reply = None
self.out = None
def run(self):
if not self.sessionUuid:
raise Exception('sessionUuid of action[QueryVtepAction] cannot be None')
reply = api.sync_call(self, self.sessionUuid)
self.reply = reply
self.out = reply.inventories
return self.out
class QueryWebhookAction(inventory.APIQueryWebhookMsg):
def __init__(self):
super(QueryWebhookAction, self).__init__()
self.sessionUuid = None
self.reply = None
self.out = None
def run(self):
if not self.sessionUuid:
raise Exception('sessionUuid of action[QueryWebhookAction] cannot be None')
reply = api.sync_call(self, self.sessionUuid)
self.reply = reply
self.out = reply.inventories
return self.out
class QueryZoneAction(inventory.APIQueryZoneMsg):
def __init__(self):
super(QueryZoneAction, self).__init__()
self.sessionUuid = None
self.reply = None
self.out = None
def run(self):
if not self.sessionUuid:
raise Exception('sessionUuid of action[QueryZoneAction] cannot be None')
reply = api.sync_call(self, self.sessionUuid)
self.reply = reply
self.out = reply.inventories
return self.out
class RebootEcsInstanceAction(inventory.APIRebootEcsInstanceMsg):
def __init__(self):
super(RebootEcsInstanceAction, self).__init__()
self.sessionUuid = None
self.out = None
def run(self):
if not self.sessionUuid:
raise Exception('sessionUuid of action[RebootEcsInstanceAction] cannot be None')
evt = api.async_call(self, self.sessionUuid)
self.out = evt
return self.out
class RebootVmInstanceAction(inventory.APIRebootVmInstanceMsg):
def __init__(self):
super(RebootVmInstanceAction, self).__init__()
self.sessionUuid = None
self.out = None
def run(self):
if not self.sessionUuid:
raise Exception('sessionUuid of action[RebootVmInstanceAction] cannot be None')
evt = api.async_call(self, self.sessionUuid)
self.out = evt
return self.out
class ReclaimSpaceFromImageStoreAction(inventory.APIReclaimSpaceFromImageStoreMsg):
def __init__(self):
super(ReclaimSpaceFromImageStoreAction, self).__init__()
self.sessionUuid = None
self.out = None
def run(self):
if not self.sessionUuid:
raise Exception('sessionUuid of action[ReclaimSpaceFromImageStoreAction] cannot be None')
evt = api.async_call(self, self.sessionUuid)
self.out = evt
return self.out
class ReconnectBackupStorageAction(inventory.APIReconnectBackupStorageMsg):
def __init__(self):
super(ReconnectBackupStorageAction, self).__init__()
self.sessionUuid = None
self.out = None
def run(self):
if not self.sessionUuid:
raise Exception('sessionUuid of action[ReconnectBackupStorageAction] cannot be None')
evt = api.async_call(self, self.sessionUuid)
self.out = evt
return self.out
class ReconnectConsoleProxyAgentAction(inventory.APIReconnectConsoleProxyAgentMsg):
def __init__(self):
super(ReconnectConsoleProxyAgentAction, self).__init__()
self.sessionUuid = None
self.out = None
def run(self):
if not self.sessionUuid:
raise Exception('sessionUuid of action[ReconnectConsoleProxyAgentAction] cannot be None')
evt = api.async_call(self, self.sessionUuid)
self.out = evt
return self.out
class ReconnectHostAction(inventory.APIReconnectHostMsg):
def __init__(self):
super(ReconnectHostAction, self).__init__()
self.sessionUuid = None
self.out = None
def run(self):
if not self.sessionUuid:
raise Exception('sessionUuid of action[ReconnectHostAction] cannot be None')
evt = api.async_call(self, self.sessionUuid)
self.out = evt
return self.out
class ReconnectImageStoreBackupStorageAction(inventory.APIReconnectImageStoreBackupStorageMsg):
def __init__(self):
super(ReconnectImageStoreBackupStorageAction, self).__init__()
self.sessionUuid = None
self.out = None
def run(self):
if not self.sessionUuid:
raise Exception('sessionUuid of action[ReconnectImageStoreBackupStorageAction] cannot be None')
evt = api.async_call(self, self.sessionUuid)
self.out = evt
return self.out
class ReconnectPrimaryStorageAction(inventory.APIReconnectPrimaryStorageMsg):
def __init__(self):
super(ReconnectPrimaryStorageAction, self).__init__()
self.sessionUuid = None
self.out = None
def run(self):
if not self.sessionUuid:
raise Exception('sessionUuid of action[ReconnectPrimaryStorageAction] cannot be None')
evt = api.async_call(self, self.sessionUuid)
self.out = evt
return self.out
class ReconnectSftpBackupStorageAction(inventory.APIReconnectSftpBackupStorageMsg):
def __init__(self):
super(ReconnectSftpBackupStorageAction, self).__init__()
self.sessionUuid = None
self.out = None
def run(self):
if not self.sessionUuid:
raise Exception('sessionUuid of action[ReconnectSftpBackupStorageAction] cannot be None')
evt = api.async_call(self, self.sessionUuid)
self.out = evt
return self.out
class ReconnectVirtualRouterAction(inventory.APIReconnectVirtualRouterMsg):
def __init__(self):
super(ReconnectVirtualRouterAction, self).__init__()
self.sessionUuid = None
self.out = None
def run(self):
if not self.sessionUuid:
raise Exception('sessionUuid of action[ReconnectVirtualRouterAction] cannot be None')
evt = api.async_call(self, self.sessionUuid)
self.out = evt
return self.out
class RecoverDataVolumeAction(inventory.APIRecoverDataVolumeMsg):
def __init__(self):
super(RecoverDataVolumeAction, self).__init__()
self.sessionUuid = None
self.out = None
def run(self):
if not self.sessionUuid:
raise Exception('sessionUuid of action[RecoverDataVolumeAction] cannot be None')
evt = api.async_call(self, self.sessionUuid)
self.out = evt
return self.out
class RecoverImageAction(inventory.APIRecoverImageMsg):
def __init__(self):
super(RecoverImageAction, self).__init__()
self.sessionUuid = None
self.out = None
def run(self):
if not self.sessionUuid:
raise Exception('sessionUuid of action[RecoverImageAction] cannot be None')
evt = api.async_call(self, self.sessionUuid)
self.out = evt
return self.out
class RecoverVmInstanceAction(inventory.APIRecoverVmInstanceMsg):
def __init__(self):
super(RecoverVmInstanceAction, self).__init__()
self.sessionUuid = None
self.out = None
def run(self):
if not self.sessionUuid:
raise Exception('sessionUuid of action[RecoverVmInstanceAction] cannot be None')
evt = api.async_call(self, self.sessionUuid)
self.out = evt
return self.out
class RecoveryImageFromImageStoreBackupStorageAction(inventory.APIRecoveryImageFromImageStoreBackupStorageMsg):
def __init__(self):
super(RecoveryImageFromImageStoreBackupStorageAction, self).__init__()
self.sessionUuid = None
self.out = None
def run(self):
if not self.sessionUuid:
raise Exception('sessionUuid of action[RecoveryImageFromImageStoreBackupStorageAction] cannot be None')
evt = api.async_call(self, self.sessionUuid)
self.out = evt
return self.out
class RecoveryVirtualBorderRouterRemoteAction(inventory.APIRecoveryVirtualBorderRouterRemoteMsg):
def __init__(self):
super(RecoveryVirtualBorderRouterRemoteAction, self).__init__()
self.sessionUuid = None
self.out = None
def run(self):
if not self.sessionUuid:
raise Exception('sessionUuid of action[RecoveryVirtualBorderRouterRemoteAction] cannot be None')
evt = api.async_call(self, self.sessionUuid)
self.out = evt
return self.out
class RefreshLoadBalancerAction(inventory.APIRefreshLoadBalancerMsg):
def __init__(self):
super(RefreshLoadBalancerAction, self).__init__()
self.sessionUuid = None
self.out = None
def run(self):
if not self.sessionUuid:
raise Exception('sessionUuid of action[RefreshLoadBalancerAction] cannot be None')
evt = api.async_call(self, self.sessionUuid)
self.out = evt
return self.out
class ReimageVmInstanceAction(inventory.APIReimageVmInstanceMsg):
def __init__(self):
super(ReimageVmInstanceAction, self).__init__()
self.sessionUuid = None
self.out = None
def run(self):
if not self.sessionUuid:
raise Exception('sessionUuid of action[ReimageVmInstanceAction] cannot be None')
evt = api.async_call(self, self.sessionUuid)
self.out = evt
return self.out
class ReloadLicenseAction(inventory.APIReloadLicenseMsg):
def __init__(self):
super(ReloadLicenseAction, self).__init__()
self.sessionUuid = None
self.out = None
def run(self):
if not self.sessionUuid:
raise Exception('sessionUuid of action[ReloadLicenseAction] cannot be None')
evt = api.async_call(self, self.sessionUuid)
self.out = evt
return self.out
class RemoveActionFromAlarmAction(inventory.APIRemoveActionFromAlarmMsg):
def __init__(self):
super(RemoveActionFromAlarmAction, self).__init__()
self.sessionUuid = None
self.out = None
def run(self):
if not self.sessionUuid:
raise Exception('sessionUuid of action[RemoveActionFromAlarmAction] cannot be None')
evt = api.async_call(self, self.sessionUuid)
self.out = evt
return self.out
class RemoveActionFromEventSubscriptionAction(inventory.APIRemoveActionFromEventSubscriptionMsg):
def __init__(self):
super(RemoveActionFromEventSubscriptionAction, self).__init__()
self.sessionUuid = None
self.out = None
def run(self):
if not self.sessionUuid:
raise Exception('sessionUuid of action[RemoveActionFromEventSubscriptionAction] cannot be None')
evt = api.async_call(self, self.sessionUuid)
self.out = evt
return self.out
class RemoveDnsFromL3NetworkAction(inventory.APIRemoveDnsFromL3NetworkMsg):
def __init__(self):
super(RemoveDnsFromL3NetworkAction, self).__init__()
self.sessionUuid = None
self.out = None
def run(self):
if not self.sessionUuid:
raise Exception('sessionUuid of action[RemoveDnsFromL3NetworkAction] cannot be None')
evt = api.async_call(self, self.sessionUuid)
self.out = evt
return self.out
class RemoveLabelFromAlarmAction(inventory.APIRemoveLabelFromAlarmMsg):
def __init__(self):
super(RemoveLabelFromAlarmAction, self).__init__()
self.sessionUuid = None
self.out = None
def run(self):
if not self.sessionUuid:
raise Exception('sessionUuid of action[RemoveLabelFromAlarmAction] cannot be None')
evt = api.async_call(self, self.sessionUuid)
self.out = evt
return self.out
class RemoveLabelFromEventSubscriptionAction(inventory.APIRemoveLabelFromEventSubscriptionMsg):
def __init__(self):
super(RemoveLabelFromEventSubscriptionAction, self).__init__()
self.sessionUuid = None
self.out = None
def run(self):
if not self.sessionUuid:
raise Exception('sessionUuid of action[RemoveLabelFromEventSubscriptionAction] cannot be None')
evt = api.async_call(self, self.sessionUuid)
self.out = evt
return self.out
class RemoveMonFromCephBackupStorageAction(inventory.APIRemoveMonFromCephBackupStorageMsg):
def __init__(self):
super(RemoveMonFromCephBackupStorageAction, self).__init__()
self.sessionUuid = None
self.out = None
def run(self):
if not self.sessionUuid:
raise Exception('sessionUuid of action[RemoveMonFromCephBackupStorageAction] cannot be None')
evt = api.async_call(self, self.sessionUuid)
self.out = evt
return self.out
class RemoveMonFromCephPrimaryStorageAction(inventory.APIRemoveMonFromCephPrimaryStorageMsg):
def __init__(self):
super(RemoveMonFromCephPrimaryStorageAction, self).__init__()
self.sessionUuid = None
self.out = None
def run(self):
if not self.sessionUuid:
raise Exception('sessionUuid of action[RemoveMonFromCephPrimaryStorageAction] cannot be None')
evt = api.async_call(self, self.sessionUuid)
self.out = evt
return self.out
class RemoveMonFromFusionstorBackupStorageAction(inventory.APIRemoveMonFromFusionstorBackupStorageMsg):
def __init__(self):
super(RemoveMonFromFusionstorBackupStorageAction, self).__init__()
self.sessionUuid = None
self.out = None
def run(self):
if not self.sessionUuid:
raise Exception('sessionUuid of action[RemoveMonFromFusionstorBackupStorageAction] cannot be None')
evt = api.async_call(self, self.sessionUuid)
self.out = evt
return self.out
class RemoveMonFromFusionstorPrimaryStorageAction(inventory.APIRemoveMonFromFusionstorPrimaryStorageMsg):
def __init__(self):
super(RemoveMonFromFusionstorPrimaryStorageAction, self).__init__()
self.sessionUuid = None
self.out = None
def run(self):
if not self.sessionUuid:
raise Exception('sessionUuid of action[RemoveMonFromFusionstorPrimaryStorageAction] cannot be None')
evt = api.async_call(self, self.sessionUuid)
self.out = evt
return self.out
class RemoveRemoteCidrsFromIPsecConnectionAction(inventory.APIRemoveRemoteCidrsFromIPsecConnectionMsg):
def __init__(self):
super(RemoveRemoteCidrsFromIPsecConnectionAction, self).__init__()
self.sessionUuid = None
self.out = None
def run(self):
if not self.sessionUuid:
| |
dict(np.load(os.path.join(opts.out_dir, "word_index.npy"), allow_pickle=True).item())
vocab.word2index.update(word_index)
else:
word_set = raw_data.get_word_set(attack_surface,
use_counter_vocab=not opts.use_a3t_settings and not opts.use_none_settings)
vocab, word_mat = vocabulary.Vocabulary.read_word_vecs(word_set, opts.glove_dir, opts.glove, device)
if opts.model == "lstm-dp-general":
train_data = TextClassificationDatasetGeneral.from_raw_data(raw_data.train_data, vocab, attack_surface,
downsample_to=opts.downsample_to,
downsample_shard=opts.downsample_shard,
truncate_to=opts.truncate_to,
perturbation=opts.perturbation)
dev_data = TextClassificationDatasetGeneral.from_raw_data(raw_data.dev_data, vocab, attack_surface,
downsample_to=opts.downsample_to,
downsample_shard=opts.downsample_shard,
truncate_to=opts.truncate_to,
perturbation=opts.perturbation)
else:
train_data = data_class.from_raw_data(raw_data.train_data, vocab, attack_surface,
downsample_to=opts.downsample_to,
downsample_shard=opts.downsample_shard,
truncate_to=opts.truncate_to,
perturbation=opts.perturbation)
dev_data = data_class.from_raw_data(raw_data.dev_data, vocab, attack_surface,
downsample_to=opts.downsample_to,
downsample_shard=opts.downsample_shard,
truncate_to=opts.truncate_to,
perturbation=opts.perturbation)
if opts.data_cache_dir:
with open(os.path.join(opts.data_cache_dir, 'train_data.pkl'), 'wb') as outfile:
pickle.dump(train_data, outfile)
with open(os.path.join(opts.data_cache_dir, 'dev_data.pkl'), 'wb') as outfile:
pickle.dump(dev_data, outfile)
with open(os.path.join(opts.data_cache_dir, 'word_mat.pkl'), 'wb') as outfile:
pickle.dump(word_mat, outfile)
with open(os.path.join(opts.data_cache_dir, 'attack_surface.pkl'), 'wb') as outfile:
pickle.dump(attack_surface, outfile)
return train_data, dev_data, word_mat, attack_surface
def num_correct_multi_classes(model_output, gold_labels, num_classes):
"""
Given the output of model and gold labels returns number of correct and certified correct
predictions
Args:
- model_output: output of the model, could be ibp.IntervalBoundedTensor or torch.Tensor
- gold_labels: torch.Tensor, should be of size 1 per sample, 1 for positive 0 for negative
Returns:
- num_correct: int - number of correct predictions from the actual model output
- num_cert_correct - number of bounds-certified correct predictions if the model_output was an
IntervalBoundedTensor, 0 otherwise.
"""
if isinstance(model_output, ibp.IntervalBoundedTensor):
logits = model_output.val
num_cert_correct = 0
for i, y in enumerate(gold_labels):
y = int(y)
num_cert_correct += all(
j == y or (model_output.lb[i][y].item() > model_output.ub[i][j].item()) for j in range(num_classes))
else:
logits = model_output
num_cert_correct = 0
pred = torch.argmax(logits, dim=1)
num_correct = sum(
pred[i].item() == y.item() for i, y in enumerate(gold_labels)
)
return num_correct, num_cert_correct
def num_correct(model_output, gold_labels):
"""
Given the output of model and gold labels returns number of correct and certified correct
predictions
Args:
- model_output: output of the model, could be ibp.IntervalBoundedTensor or torch.Tensor
- gold_labels: torch.Tensor, should be of size 1 per sample, 1 for positive 0 for negative
Returns:
- num_correct: int - number of correct predictions from the actual model output
- num_cert_correct - number of bounds-certified correct predictions if the model_output was an
IntervalBoundedTensor, 0 otherwise.
"""
if isinstance(model_output, ibp.IntervalBoundedTensor):
logits = model_output.val
num_cert_correct = sum(
all((b * (2 * y - 1)).item() > 0 for b in (model_output.lb[i], model_output.ub[i]))
for i, y in enumerate(gold_labels)
)
else:
logits = model_output
num_cert_correct = 0
num_correct = sum(
(logits[i] * (2 * y - 1)).item() > 0 for i, y in enumerate(gold_labels)
)
return num_correct, num_cert_correct
def load_model(word_mat, device, opts):
"""
Try to load a model on the device given the word_mat and opts.
Tries to load a model from the given or latest checkpoint if specified in the opts.
Otherwise instantiates a new model on the device.
"""
if opts.model == 'bow':
model = BOWModel(
vocabulary.GLOVE_CONFIGS[opts.glove]['size'], opts.hidden_size, word_mat,
pool=opts.pool, dropout=opts.dropout_prob, no_wordvec_layer=opts.no_wordvec_layer).to(device)
elif opts.model == 'cnn':
model = CNNModel(
vocabulary.GLOVE_CONFIGS[opts.glove]['size'], opts.hidden_size, opts.kernel_size,
word_mat, pool=opts.pool, dropout=opts.dropout_prob, no_wordvec_layer=opts.no_wordvec_layer,
early_ibp=opts.early_ibp, relu_wordvec=not opts.no_relu_wordvec, unfreeze_wordvec=opts.unfreeze_wordvec).to(
device)
elif opts.model == 'lstm':
model = LSTMModel(
vocabulary.GLOVE_CONFIGS[opts.glove]['size'], opts.hidden_size,
word_mat, device, pool=opts.pool, dropout=opts.dropout_prob, no_wordvec_layer=opts.no_wordvec_layer).to(
device)
elif opts.model == "lstm-dp":
model = LSTMDPModel(
vocabulary.GLOVE_CONFIGS[opts.glove]['size'], opts.hidden_size,
word_mat, device, pool=opts.pool, dropout=opts.dropout_prob, no_wordvec_layer=opts.no_wordvec_layer,
perturbation=opts.perturbation, bidirectional=not opts.no_bidirectional, baseline=opts.baseline).to(device)
elif opts.model == "lstm-dp-ascc":
model = LSTMDPModelASCC(
100001, opts.hidden_size, word_mat, device, opts.out_dir, pool=opts.pool, dropout=opts.dropout_prob,
perturbation=opts.perturbation, baseline=opts.baseline).to(device)
elif opts.model == "lstm-dp-general":
model = LSTMDPGeneralModel(
vocabulary.GLOVE_CONFIGS[opts.glove]['size'], opts.hidden_size,
word_mat, device, pool=opts.pool, dropout=opts.dropout_prob, no_wordvec_layer=opts.no_wordvec_layer,
perturbation=opts.perturbation).to(device)
elif opts.model == 'lstm-final-state':
model = LSTMFinalStateModel(
vocabulary.GLOVE_CONFIGS[opts.glove]['size'], opts.hidden_size,
word_mat, device, dropout=opts.dropout_prob, no_wordvec_layer=opts.no_wordvec_layer).to(device)
if opts.load_dir:
try:
if opts.load_ckpt is None:
load_fn = sorted(glob.glob(os.path.join(opts.load_dir, 'model-checkpoint-[0-9]+.pth')))[-1]
else:
load_fn = os.path.join(opts.load_dir, 'model-checkpoint-%d.pth' % opts.load_ckpt)
print('Loading model from %s.' % load_fn)
state_dict = dict(torch.load(load_fn, map_location=torch.device('cpu')))
state_dict['embs.weight'] = model.embs.weight
model.load_state_dict(state_dict)
print('Finished loading model.')
except Exception as ex:
print("Couldn't load model, starting anew: {}".format(ex))
return model
class RawClassificationDataset(data_util.RawDataset):
"""
Dataset that only holds x,y as (str, str) tuples
"""
def get_word_set(self, attack_surface, use_counter_vocab=True):
with open(COUNTER_FITTED_FILE) as f:
counter_vocab = set([line.split(' ')[0] for line in f])
word_set = set()
for x, y in self.data:
words = [w.lower() for w in x.split(' ')]
for w in words:
word_set.add(w)
try:
swaps = attack_surface.get_swaps(words)
for cur_swaps in swaps:
for w in cur_swaps:
word_set.add(w)
except KeyError:
# For now, ignore things not in attack surface
# If we really need them, later code will throw an error
pass
if use_counter_vocab:
return word_set & counter_vocab
else:
return word_set
class TextClassificationDataset(data_util.ProcessedDataset):
"""
Dataset that holds processed example dicts
"""
@classmethod
def from_raw_data(cls, raw_data, vocab, attack_surface=None, truncate_to=None,
downsample_to=None, downsample_shard=0, perturbation=None):
if downsample_to:
raw_data = raw_data[downsample_shard * downsample_to:(downsample_shard + 1) * downsample_to]
examples = []
if perturbation is not None:
deltas = Perturbation.str2deltas(perturbation)
for x, y in raw_data:
all_words = [w.lower() for w in x.split()]
ins_delta = 0
if perturbation is not None:
perturb = Perturbation(perturbation, all_words, vocab, attack_surface=attack_surface)
ins_delta = deltas[perturb.Ins_idx]
choices = perturb.get_output_for_baseline_final_state()
choices = [[x for x in choice if x == UNK or x in vocab] for choice in choices]
words = perturb.ipt
elif attack_surface is not None:
raise AttributeError
else:
words = [w for w in all_words if w in vocab] # Delete UNK words
# truncate and add padding
if truncate_to:
words = words[:truncate_to]
if perturbation is not None:
choices = choices[:truncate_to]
for _ in range(truncate_to - len(words)):
words.append(vocabulary.UNK_TOKEN)
if perturbation is not None:
choices.append([vocabulary.UNK_TOKEN])
if len(words) == 0:
continue
word_idxs = [vocab.get_index(w) for w in words] + [0] * ins_delta # append dummy words
x_torch = torch.tensor(word_idxs).view(1, -1, 1) # (1, T, d)
if perturbation is not None:
choices = choices + [[] for _ in range(ins_delta)] # append dummy choices
unk_mask = torch.tensor([0 if UNK in c_list else 1 for c_list in choices],
dtype=torch.long).unsqueeze(0) # (1, T)
choices_word_idxs = [
torch.tensor([vocab.get_index(c) for c in c_list if c != UNK], dtype=torch.long) for c_list in
choices
]
# if any(0 in c.view(-1).tolist() for c in choices_word_idxs):
# raise ValueError("UNK tokens found")
choices_torch = pad_sequence(choices_word_idxs, batch_first=True).unsqueeze(2).unsqueeze(
0) # (1, T, C, 1)
choices_mask = (choices_torch.squeeze(-1) != 0).long() # (1, T, C)
elif attack_surface is not None:
raise AttributeError
else:
choices_torch = x_torch.view(1, -1, 1, 1) # (1, T, 1, 1)
choices_mask = torch.ones_like(x_torch.view(1, -1, 1))
unk_mask = None
mask_torch = torch.ones((1, len(word_idxs)))
for i in range(1, ins_delta + 1):
mask_torch[0][-i] = 0
if unk_mask is None:
unk_mask = torch.ones((1, len(word_idxs)))
x_bounded = ibp.DiscreteChoiceTensorWithUNK(x_torch, choices_torch, choices_mask, mask_torch, unk_mask)
y_torch = torch.tensor(y, dtype=torch.float).view(1, 1)
lengths_torch = torch.tensor(len(word_idxs)).view(1)
examples.append(dict(x=x_bounded, y=y_torch, mask=mask_torch, lengths=lengths_torch))
return cls(raw_data, vocab, examples)
@staticmethod
def example_len(example):
return example['x'].shape[1]
@staticmethod
def collate_examples(examples):
"""
Turns a list of examples into a workable batch:
"""
if len(examples) == 1:
return examples[0]
B = len(examples)
max_len = max(ex['x'].shape[1] for ex in examples)
x_vals = []
choice_mats = []
choice_masks = []
y = torch.zeros((B, 1))
lengths = torch.zeros((B,), dtype=torch.long)
masks = torch.zeros((B, max_len))
unk_masks = torch.zeros((B, max_len))
for i, ex in enumerate(examples):
x_vals.append(ex['x'].val)
choice_mats.append(ex['x'].choice_mat)
choice_masks.append(ex['x'].choice_mask)
cur_len = ex['x'].shape[1]
masks[i, :cur_len] = ex['x'].sequence_mask[0]
unk_masks[i, :cur_len] = ex['x'].unk_mask[0] if ex['x'].unk_mask is not None else 1
y[i, 0] = ex['y']
lengths[i] = ex['lengths'][0]
x_vals = data_util.multi_dim_padded_cat(x_vals, 0).long()
choice_mats = data_util.multi_dim_padded_cat(choice_mats, 0).long()
choice_masks = data_util.multi_dim_padded_cat(choice_masks, 0).long()
return {'x': ibp.DiscreteChoiceTensorWithUNK(x_vals, choice_mats, choice_masks, masks, unk_masks),
'y': y, 'mask': masks, 'lengths': lengths}
class TextClassificationDatasetGeneral(data_util.ProcessedDataset):
"""
Dataset that holds processed example dicts
"""
@classmethod
def from_raw_data(cls, raw_data, vocab, attack_surface=None, truncate_to=None,
downsample_to=None, downsample_shard=0, perturbation=None):
assert perturbation is not None
if downsample_to:
raw_data = raw_data[downsample_shard * downsample_to:(downsample_shard + 1) * downsample_to]
examples = []
for x, y in raw_data:
all_words = [w.lower() for w in x.split()]
trans_o_id = []
trans_phi = []
perturb = Perturbation(perturbation, all_words, vocab, attack_surface=attack_surface)
words = perturb.ipt
for tran in perturb.trans:
choices = tran.gen_output_for_dp()
phi = []
o = [[[] for _ in range(tran.t)] for _ in choices]
for start_pos in range(len(choices)):
phi.append(False)
for choice in choices[start_pos]:
# We give up this choice if any of the words are out of vocab
# This can vary between different implementations
if all(choice[j] in vocab for j in range(tran.t)):
phi[-1] = True # there is a valid choice
for j in range(tran.t):
o[start_pos][j].append(vocab.get_index(choice[j]))
trans_phi.append(torch.tensor(phi, dtype=torch.bool).unsqueeze(0))
trans_o_id.append(o)
# trans_o_id contains a list of o. o has length len(x) and the shape (tran.t, #choice).
if truncate_to:
words = | |
== 'blueprint':
INPUT_FASTQ_PREFIX = "out/ln/updir/mw/" + ACCESSION
if SE_OR_PE == 'se':
fq_to_rename = INPUT_FASTQ_PREFIX + ".fastq.gz"
elif SE_OR_PE == 'pe':
fq_to_rename_1 = INPUT_FASTQ_PREFIX + "_1.fastq.gz"
fq_to_rename_2 = INPUT_FASTQ_PREFIX + "_2.fastq.gz"
elif str(row['origin']) == 'fastq_absolute_path':
if SE_OR_PE == 'se':
fq_to_rename = ACCESSION + ".fastq.gz"
elif SE_OR_PE == 'pe':
fq_to_rename_1 = ACCESSION + "_1.fastq.gz"
fq_to_rename_2 = ACCESSION + "_2.fastq.gz"
elif str(row['origin']) == 'illumina_fastq_sets':
if SE_OR_PE == 'se':
samples_to_cat = str(glob.glob(ACCESSION + "_[0-9][0-9][0-9].fastq.gz"))
concat_sample = "merge-illumina-fastq-sets/" + SAMPLE_NAME + ".fastq.gz"
mwconf['ids'][concat_sample] = samples_to_cat
fq_to_rename = "out/cat/merge-illumina-fastq-sets/" + SAMPLE_NAME + ".fastq.gz"
# TODO : add PE HERE LATER
elif str(row['origin']) == 'merge_fastq':
SAMPLES_TO_MERGE = ACCESSION.split(",")
if SE_OR_PE == 'se':
samples_to_cat = str(["out/ln/alias/sst/all_samples/fastq/" + SAMPLE + ".fastq.gz" for SAMPLE in SAMPLES_TO_MERGE])
concat_sample = "merge-fastq-samples/" + SAMPLE_NAME + ".fastq.gz"
mwconf['ids'][concat_sample] = samples_to_cat
fq_to_rename = "out/cat/merge-fastq-samples/" + SAMPLE_NAME + ".fastq.gz"
elif SE_OR_PE == 'pe':
samples_to_cat_1 = str(["out/ln/alias/sst/all_samples/fastq/" + SAMPLE + "_1.fastq.gz" for SAMPLE in SAMPLES_TO_MERGE])
samples_to_cat_2 = str(["out/ln/alias/sst/all_samples/fastq/" + SAMPLE + "_2.fastq.gz" for SAMPLE in SAMPLES_TO_MERGE])
concat_sample_1 = "merge-fastq-samples/" + SAMPLE_NAME + "_1.fastq.gz"
concat_sample_2 = "merge-fastq-samples/" + SAMPLE_NAME + "_2.fastq.gz"
mwconf['ids'][concat_sample_1] = samples_to_cat_1
mwconf['ids'][concat_sample_2] = samples_to_cat_2
fq_to_rename_1 = "out/cat/merge-fastq-samples/" + SAMPLE_NAME + "_1.fastq.gz"
fq_to_rename_2 = "out/cat/merge-fastq-samples/" + SAMPLE_NAME + "_2.fastq.gz"
elif str(row['origin']) == 'subsample_fastq':
SUBSAMPLE_ARGS = ACCESSION.split(",")
SAMPLE=SUBSAMPLE_ARGS.pop(0)
N_READS_OR_FRACTION = SUBSAMPLE_ARGS.pop(0)
if len(SUBSAMPLE_ARGS) == 0:
SUBSAMPLE_SEED="123"
else:
SUBSAMPLE_SEED = SUBSAMPLE_ARGS.pop(0)
fq_to_rename_prefix = "out/seqtk/sample_-s_" + \
SUBSAMPLE_SEED + \
"_" + \
N_READS_OR_FRACTION + \
"/ln/alias/sst/all_samples/fastq/" + \
SAMPLE
if SE_OR_PE == 'se':
fq_to_rename = fq_to_rename_prefix + ".fastq.gz"
elif SE_OR_PE == 'pe':
fq_to_rename_1 = fq_to_rename_prefix + "_1.fastq.gz"
fq_to_rename_2 = fq_to_rename_prefix + "_2.fastq.gz"
# 1)
# (2
# aliases are created for fastq in order to gather all samples in the same directory
# as well as other trees defined in the base_stem_dict dict below
base_stem_dict = {
"all" : "sst/all_samples",
"by_type_and_run": "sst/by_type_and_run/" + TYPE + "/run" + RUN,
"by_type_and_exp": "sst/by_type_and_exp/" + TYPE + "/" + EXP,
"by_project" : "sst/by_project/" + PROJECT,
"by_cell_type" : "sst/by_cell_type/" + CELL_TYPE,
"by_customer" : "sst/by_customer/" + CUSTOMER,
"by_run" : "sst/by_run/run" + RUN
}
fq_stem_dict = {}
for k in base_stem_dict.keys():
fq_stem_dict[k] = base_stem_dict[k] + '/fastq/' + SAMPLE_NAME
fq_stem = fq_stem_dict['all']
trim_stem = "sickle/" + SE_OR_PE + "_-t_sanger_-q_20/ln/alias/" + fq_stem
for k in fq_stem_dict.keys():
if SE_OR_PE == 'se':
fq_suffix = fq_stem_dict[k] + ".fastq.gz"
mwconf['ids'][fq_suffix] = fq_to_rename
fq_path = "out/ln/alias/" + fq_suffix
if PROCESS == 'yes':
mwconf['targets'].append(fq_path)
elif SE_OR_PE == 'pe':
fq_suffix_1 = fq_stem_dict[k] + "_1.fastq.gz"
fq_suffix_2 = fq_stem_dict[k] + "_2.fastq.gz"
mwconf['ids'][fq_suffix_1] = fq_to_rename_1
mwconf['ids'][fq_suffix_2] = fq_to_rename_2
fq_path_1 = "out/ln/alias/" + fq_suffix_1
fq_path_2 = "out/ln/alias/" + fq_suffix_2
if PROCESS == 'yes':
mwconf['targets'].append(fq_path_1)
mwconf['targets'].append(fq_path_2)
# 2)
# (3
# Here could be a good spot to run fastqc and fastq_screen on se or pe from all_samples tree
#trim_stem
#fastqc_path_R1 = "out/fastqc/fastq.gz/ln/alias/" + fq_stem + "_1_fastqc.zip"
#fastqc_path_R2 = "out/fastqc/fastq.gz/ln/alias/" + fq_stem + "_2_fastqc.zip"
if SE_OR_PE == "se":
fastqc_path = "out/fastqc/fastq.gz/ln/alias/" + fq_stem + "_fastqc.zip"
fastq_screen_path = "out/fastq_screen/filter/" + trim_stem + "_screen.txt"
qc_paths = [fastqc_path, fastq_screen_path]
elif SE_OR_PE == "pe":
fastqc_path_1 = "out/fastqc/fastq.gz/ln/alias/" + fq_stem + "_1_fastqc.zip"
fastqc_path_2 = "out/fastqc/fastq.gz/ln/alias/" + fq_stem + "_2_fastqc.zip"
fastq_screen_path_1 = "out/fastq_screen/filter/" + trim_stem + "_1_screen.txt"
fastq_screen_path_2 = "out/fastq_screen/filter/" + trim_stem + "_2_screen.txt"
qc_paths = [fastqc_path_1, fastqc_path_2, fastq_screen_path_1, fastq_screen_path_2]
if PROCESS == 'yes':
mwconf['targets'].append(qc_paths)
# 3)
# (4
# QC log are symlinked in the alternative trees in order
# to provide a mechanism to get multiQC reports with only
# subsets of samples for each subtree.
for k in base_stem_dict.keys():
if SE_OR_PE == "se":
fastqc_suffix = base_stem_dict[k] + "/logs/fastqc/" + SAMPLE_NAME + "_fastqc.zip"
mwconf['ids'][fastqc_suffix] = fastqc_path
ln_fastqc_path = "out/ln/alias/" + fastqc_suffix
fastq_screen_suffix = base_stem_dict[k] + "/logs/fastq_screen/" + SAMPLE_NAME + "_screen.txt"
mwconf['ids'][fastq_screen_suffix] = fastq_screen_path
ln_fastq_screen_path = "out/ln/alias/" + fastq_screen_suffix
ln_qc_paths = [ln_fastqc_path, ln_fastq_screen_path]
if SE_OR_PE == "pe":
fastqc_suffix_1 = base_stem_dict[k] + "/logs/fastqc/" + SAMPLE_NAME + "_1_fastqc.zip"
mwconf['ids'][fastqc_suffix_1] = fastqc_path_1
ln_fastqc_path_1 = "out/ln/alias/" + fastqc_suffix_1
fastqc_suffix_2 = base_stem_dict[k] + "/logs/fastqc/" + SAMPLE_NAME + "_2_fastqc.zip"
mwconf['ids'][fastqc_suffix_2] = fastqc_path_2
ln_fastqc_path_2 = "out/ln/alias/" + fastqc_suffix_2
fastq_screen_suffix_1 = base_stem_dict[k] + "/logs/fastq_screen/" + SAMPLE_NAME + "_1_screen.txt"
mwconf['ids'][fastq_screen_suffix_1] = fastq_screen_path_1
ln_fastq_screen_path_1 = "out/ln/alias/" + fastq_screen_suffix_1
fastq_screen_suffix_2 = base_stem_dict[k] + "/logs/fastq_screen/" + SAMPLE_NAME + "_2_screen.txt"
mwconf['ids'][fastq_screen_suffix_2] = fastq_screen_path_2
ln_fastq_screen_path_2 = "out/ln/alias/" + fastq_screen_suffix_2
ln_qc_paths = [ln_fastqc_path_1, ln_fastqc_path_2, ln_fastq_screen_path_1, ln_fastq_screen_path_2]
if PROCESS == 'yes':
mwconf['targets'].append(ln_qc_paths)
#for k in base_stem_dict.keys():
# for qc_path in qc_paths:
# qc_suffix = qc_path.replace('out/', base_stem_dict[k] + "/logs/")
# mwconf['ids'][qc_suffix] = qc_path
# print('qc_suffix')
# print(qc_suffix)
# print('qc_path')
# print(qc_path)
# print("mwconf['ids'][qc_suffix]")
# print(mwconf['ids'][qc_suffix])
# qc_k_path = "out/ln/alias/" + qc_suffix
# if PROCESS == 'yes':
# mwconf['targets'].append(qc_k_path)
# 4)
#sst/all_samples/logs/fastqc/fastq.gz/ln/alias/sst/all_samples/fastq/RPMI_H3K4me3_fastqc.zip
# (5
# Assemblies for each specie keyword should be defined here
SPECIE = str(row['specie'])
if SPECIE in ['human', 'Human', 'Homo_sapiens']:
assembly_list = ["GRCh38", "hg19"]
gsize = "hs"
scrna_assembly = "GRCh38-2020-A"
elif SPECIE in ['mouse', 'Mouse', 'Mus_musculus']:
#assembly_list = ["GRCm38", "mm9", "GRCm38-merge-attr", "GRCm38-merge-attr-retrieve"]
#2021-03-31 Remove GRCm3[89]-merge-attr, cause redondant with GRCm3[89]-merge-attr-retrieve. The results are the same if using gtftk to retrieve the gtf from ensembl or getting it from the ensembl ftp
#2021-04-20: Remove GRCm39 and GRCm39-merge-attr-retriev. Not used by the scientific community for now.
#assembly_list = ["GRCm38", "mm9", "GRCm38-merge-attr-retrieve", "GRCm39", "GRCm39-merge-attr-retrieve"]
assembly_list = ["GRCm38", "mm9"]
gsize = "mm"
elif SPECIE in ['drosophila', 'Fruit_fly', 'Drosophila_melanogaster']:
scrna_assembly = "mm10-2020-A"
assembly_list = ["BDGP6"]
gsize = "dm"
elif SPECIE in ['Yeast', 'Saccharomyces_cerevisiae']:
assembly_list = ["R64-1-1"]
gsize = "12e6"
elif SPECIE in ['Rat']:
assembly_list = ["Rnor6"]
elif not pandas.isna(SPECIE):
assembly_list = [SPECIE]
else:
continue
# 5)
# (6
# Targets for post-alignment, experiment-type-unspecific files are produced
# I do not want to throw an error if specie is not referred and just skip sample instead.
if 'assembly_list' in locals():
for assembly in assembly_list:
aligned_stem_dict = {}
for k in base_stem_dict.keys():
aligned_stem_dict[k] = base_stem_dict[k] + "/" + assembly
if row['analysis_type'] in ['Demultiplexage_Concatenation_QC', 'Concatenation_QC']:
continue
elif row['type'] == 'RNA' and row['origin'] != "fastq_absolute_path_agilent_XT_HS2":
aligned_stem = "samtools/index/star/" + row['se_or_pe'] + "_fastq.gz_to_bam_standard_staridx-" + assembly + "-merge-attr-retrieve-ensembl_gtf-" + assembly +"-merge-attr-retrieve-ensembl/sickle/" + row['se_or_pe'] + "_-t_sanger_-q_20/ln/alias/" + fq_stem
elif row['type'] == 'RNA' and row['origin'] == "fastq_absolute_path_agilent_XT_HS2":
aligned_stem = "samtools/index/samtools/sort/agent/locatit_mbc_-i_-R/samtools/sort_-n/star/" + row['se_or_pe'] + "_fastq.gz_to_bam_standard_staridx-" + assembly + "-merge-attr-retrieve-ensembl_gtf-" + assembly +"-merge-attr-retrieve-ensembl/agent/trim_-v2/ln/alias/" + fq_stem
else:
bowtie2_stem = "bowtie2/" + row['se_or_pe'] + "_" + assembly + "/sickle/" + row['se_or_pe'] + "_-t_sanger_-q_20/ln/alias/" + fq_stem
bowtie2_log_path = "out/" + bowtie2_stem + ".log"
aligned_stem = "samtools/index/samtools/sort/samtools/view_sam_to_bam_-q_30/" + bowtie2_stem
mw_bam_path = "out/" + aligned_stem + ".bam"
mw_bai_path = mw_bam_path + ".bai"
mw_idxstat_path = "out/samtools/idxstats/" + aligned_stem + ".idxstat.tsv"
mw_bw_path = "out/deepTools/bamCoverage_--binSize_20_--minMappingQuality_0_--normalizeUsing_RPKM/" + aligned_stem + ".bw"
if row['type'] == 'RNA':
mw_bw_fwd_path = "out/deepTools/bamCoverage_--binSize_20_--minMappingQuality_0_--normalizeUsing_RPKM_--filterRNAstrand_forward/" + aligned_stem + ".bw"
mw_bw_rev_path = "out/deepTools/bamCoverage_--binSize_20_--minMappingQuality_0_--normalizeUsing_RPKM_--filterRNAstrand_reverse/" + aligned_stem + ".bw"
# 2021-03-25 Add rseqc geneBody_coverage
mw_rseqc_path = "out/rseqc/geneBody_coverage_bed-housekeeping-genes-" + assembly + "/" + aligned_stem + ".geneBodyCoverage.curves.pdf"
for k in aligned_stem_dict.keys():
bam_suffix = aligned_stem_dict[k] + "/bam/" + SAMPLE_NAME + ".bam"
mwconf['ids'][bam_suffix] = mw_bam_path
ln_bam_path = "out/ln/alias/" + bam_suffix
bai_suffix = aligned_stem_dict[k] + "/bam/" + SAMPLE_NAME + ".bam.bai"
mwconf['ids'][bai_suffix] = mw_bai_path
ln_bai_path = "out/ln/alias/" + bai_suffix
idxstat_suffix = aligned_stem_dict[k] + "/logs/samtools_idxstats/" + SAMPLE_NAME + ".idxstat.tsv"
mwconf['ids'][idxstat_suffix] = mw_idxstat_path
ln_idxstat_path = "out/ln/alias/" + idxstat_suffix
bw_suffix = aligned_stem_dict[k] + "/bw/" + SAMPLE_NAME + ".bw"
mwconf['ids'][bw_suffix] = mw_bw_path
ln_bw_path = "out/ln/alias/" + bw_suffix
ln_aligned_unspecif_paths = [ln_bam_path, ln_bai_path, ln_idxstat_path, ln_bw_path]
if row['type'] == 'RNA':
bw_fwd_suffix = aligned_stem_dict[k] + "/bw/stranded/" + SAMPLE_NAME + "_fwd.bw"
mwconf['ids'][bw_fwd_suffix] = mw_bw_fwd_path
ln_bw_fwd_path = "out/ln/alias/" + bw_fwd_suffix
bw_rev_suffix = aligned_stem_dict[k] + "/bw/stranded/" + SAMPLE_NAME + "_rev.bw"
mwconf['ids'][bw_rev_suffix] = mw_bw_rev_path
ln_bw_rev_path = "out/ln/alias/" + bw_rev_suffix
ln_aligned_unspecif_paths.append(ln_bw_fwd_path)
ln_aligned_unspecif_paths.append(ln_bw_rev_path)
#rseqc_suffix = aligned_stem_dict[k] + "/pdf/" + SAMPLE_NAME + ".pdf"
#mwconf['ids'][rseqc_suffix] = mw_rseqc_path
#ln_rseqc_path = "out/ln/alias/" + rseqc_suffix
#ln_aligned_unspecif_paths.append(ln_rseqc_path)
if PROCESS == 'yes' and row['type'] not in ['RNA_fq_only', 'ChIP_fq_only', 'scRNA', 'scRNA_HTO', 'Demultiplexage_Concatenation_QC']:
mwconf['targets'].append(ln_aligned_unspecif_paths)
# (7
# Targets for files specific of ChIP-like approaches.
if row['type'] in ['ChIP','ATAC','FAIRE','DNASE','MNase'] and row['analysis_type'] not in ['Demultiplexage_Concatenation_QC', 'Concatenation_QC']:
mw_chip_qc_fingerprint_prefix = "out/deepTools/plotFingerprint/" + aligned_stem
mw_chip_qc_fingerprint_metrics = mw_chip_qc_fingerprint_prefix + ".metrics.tsv"
mw_chip_qc_fingerprint_counts = mw_chip_qc_fingerprint_prefix + ".counts.tsv"
mw_chip_qc_phantompeakqualtools = "out/phantompeakqualtools/bam_noctrl_-savp/" + aligned_stem + '.spp.out'
mw_bed_broad = "out/macs2/noctrl_callpeak_--broad_--gsize_" + gsize + "/" + aligned_stem + "_peaks.bed"
mw_xls_broad = "out/macs2/noctrl_callpeak_--broad_--gsize_" | |
_get_times(energy) + r / v0 - (st.sonset - st.origintime)
if smooth:
plot(t, energy.data_unsmoothed, color='0.7')
plot(t, energy.data, color=c1l)
G_ = smooth_func(lambda t_: G_func(r, t_, v0, g0),
t, smooth, window=smooth_window)
Emod = get_Emod(G_, t)
index = np.argwhere(Emod < 1e-30)[-1]
Emod[index] = 1e-30
plot(t, Emod, color=c2l)
plot(tcoda[i], Ecoda[i], color=c1)
Emodcoda = get_Emod(Gcoda[i], tcoda[i])
plot(tcoda[i], Emodcoda, color=c2)
if tbulk and len(tbulk) > 0:
plot(tbulk[i], Ebulk[i], 'o', color=c1, mec=c1, ms=MS)
Emodbulk = get_Emod(Gbulk[i], tbulk[i])
plot(tbulk[i], Emodbulk, 'o', ms=MS - 1,
color=c2, mec=c2)
l = '%s\n%s' % (evid, station)
l = l + '\nr=%dkm' % (r / 1000)
ax.annotate(l, (1, 1), (-5, -5), 'axes fraction',
'offset points', ha='right', va='top', size='x-small')
_set_gridlabels(ax, i, n, n, N, xlabel='time (s)',
ylabel=r'E (Jm$^{-3}$Hz$^{-1}$)')
tmaxs.append(t[-1])
ymaxs.append(max(np.max(Emod), np.max(energy.data)))
ymins.append(min(np.min(Emodcoda), np.max(Ecoda[i])))
if share is None:
share = ax
# if True:
# save = {'t': t, 'data': energy.stats.orig_data,
# 'Eobs': energy.data, 'Emod': Emod,
# 'tcoda': tcoda[i], 'Eobscoda': Ecoda[i],
# 'Emodcoda': Emodcoda}
# if tbulk:
# save.update({'tbulk': tbulk[i], 'Eobsbulk': Ebulk[i],
# 'Emodbulk': Emodbulk})
# np.savez(fname.replace('png', '') + station + '.npz', **save)
ax.locator_params(axis='x', nbins=5, prune='upper')
loglocator = mpl.ticker.LogLocator(base=100)
ax.yaxis.set_major_locator(loglocator)
ax.yaxis.set_minor_locator(mpl.ticker.NullLocator())
ax.set_xlim(xlim or (0, max(tmaxs)))
ax.set_ylim(ylim or (0.1 * min(ymins), 1.5 * max(ymaxs)))
_savefig(fig, **kwargs)
def plot_sds(freq, result, ax=None,
annotate=False, va='bottom',
seismic_moment_method=None, seismic_moment_options={},
**kwargs):
"""Plot source displacement spectrum and fitted source model"""
freq = np.array(freq)
omM = np.array(result['sds'], dtype=np.float)
if all(np.isnan(omM)):
return
fig = None
obs = ('M0', 'fc', 'n', 'gamma')
smo = seismic_moment_options
def _get(k): return smo.get(k) or result.get(k)
smo = {k: _get(k) for k in obs if _get(k) is not None}
M0 = smo.get('M0')
fc = smo.get('fc')
if ax is None:
fig = plt.figure()
ax = fig.add_subplot(111)
if seismic_moment_method == 'mean':
ax.loglog(freq, omM, 'o-', color='gray', mec='gray')
ax.loglog(freq[freq < fc], omM[freq < fc], 'o-k')
elif seismic_moment_method in ('fit', 'robust_fit'):
ax.loglog(freq, omM, 'ok')
if M0 and fc:
f = np.linspace(freq[0] / 1.5, freq[-1] * 1.5, 100)
omM2 = source_model(f, **smo)
ax.loglog(f, omM2, '-k')
else:
ax.loglog(freq, omM, 'o-k')
if M0:
ax.axhline(M0, ls='--', color='k')
labels = OrderedDict((('M0', r'M$_0$=%.1e Nm'),
('fc', r'f$_{\rm{c}}$=%.1f Hz'),
('n', 'n=%.1f'),
('gamma', r'$\gamma$=%.2f'),
('fit_error', 'err=%.2f')))
labels = [labels[key] % np.float32(result[key])
for key in labels if key in result]
if len(labels) > 0 and annotate:
ypos = 1 if va == 'top' else 0
ax.annotate('\n'.join(labels), (1, ypos), (-5, 5 - 10 * ypos),
'axes fraction', 'offset points',
ha='right', va=va, size='x-small')
if fig:
_savefig(fig, **kwargs)
def plot_eventresult(result, v0=None, quantities=QUANTITIES_EVENT,
seismic_moment_method=None, seismic_moment_options={},
**kwargs):
"""Plot all results of one `~qopen.core.invert()` call"""
v0 = v0 or result.get('v0') or result.get('config', {}).get('v0')
freq = np.array(result['freq'])
res = copy(result)
_values_view = res.pop('events').values()
res.update((list(_values_view))[0])
N = len(quantities)
n = int(np.ceil(np.sqrt(N)))
fig = plt.figure()
gs = gridspec.GridSpec(n, n)
share = None
for i, q in enumerate(quantities):
ax = plt.subplot(gs[i // n, i % n], sharex=share)
if q == 'sds':
plot_sds(freq, res, ax=ax,
seismic_moment_method=seismic_moment_method,
seismic_moment_options=seismic_moment_options)
else:
vals = calc_dependent(q, res[DEPMAP[q]], freq, v0)
ax.loglog(freq, vals, 'o-k')
if q == 'error':
ax.set_yscale('linear')
ax.annotate(QLABELS[q], (1, 1), (-5, -5), 'axes fraction',
'offset points', ha='right', va='top')
_set_gridlabels(ax, i, n, n, N)
if share is None:
share = ax
ax.set_xlim(freq[0], freq[-1])
_savefig(fig, **kwargs)
def plot_eventsites(result, **kwargs):
"""Plot site amplification factors of one `~qopen.core.invert()` call"""
freq = np.array(result['freq'])
R = result['R']
N = len(R)
n = int(np.ceil(np.sqrt(N)))
fig = plt.figure()
gs = gridspec.GridSpec(n, n)
share = None
allR = []
for i, station in enumerate(sorted(R)):
allR.extend(R[station])
ax = plt.subplot(gs[i // n, i % n], sharex=share, sharey=share)
Rs = np.array(R[station], dtype=np.float)
if not np.all(np.isnan(Rs)):
ax.loglog(freq, Rs, 'o-k')
l = station
ax.annotate(l, (1, 1), (-5, -5), 'axes fraction',
'offset points', ha='right', va='top', size='small')
_set_gridlabels(ax, i, n, n, N, ylabel='site correction')
if share is None:
share = ax
allR = np.array(allR, dtype=np.float)
allR = allR[~np.isnan(allR)]
if np.min(allR) != np.max(allR):
ax.set_ylim(np.min(allR), np.max(allR))
ax.set_xlim(freq[0], freq[-1])
_savefig(fig, **kwargs)
def plot_results(result, v0=None, quantities=QUANTITIES, mean=None,
llim=None, Qlim=None, **kwargs):
"""Plot results"""
freq = np.array(result['freq'])
N = len(quantities)
n = int(np.ceil(np.sqrt(N)))
fig = plt.figure()
gs = gridspec.GridSpec(n, n)
share = None
# True for invert_events_simultaneously
single_inversion = 'g0' not in list(result['events'].values())[0]
if single_inversion:
colres = result
else:
colres = collect_results(result, only=('g0', 'b', 'error', 'v0'))
v0 = v0 or result['config'].get('v0') or colres['v0']
colres.pop('v0', None)
weights = 1 / np.array(colres['error']) if mean == 'weighted' else None
robust = mean == 'robust'
for i, q in enumerate(quantities):
ax = plt.subplot(gs[i // n, i % n], sharex=share)
if q == 'nobs':
if single_inversion:
nobs = 1
else:
nobs = np.sum(~np.isnan(colres['g0']), axis=0)
ax.bar(freq, nobs, width=0.1 * freq, color='gray')
else:
value = colres[DEPMAP[q]]
value = calc_dependent(q, value, freq, v0)
if not single_inversion:
freqs = np.repeat(freq[np.newaxis, :], value.shape[0], axis=0)
ax.plot(freqs, value, 'o', ms=MS, color='gray', mec='gray')
means, err1, err2 = gerr(
value, axis=0, weights=weights, robust=robust)
errs = (err1, err2)
ax.errorbar(freq, means, yerr=errs, marker='o',
mfc='k', mec='k', color='m', ecolor='m')
if q != 'error':
ax.set_yscale('log')
ax.set_xscale('log')
ax.annotate(QLABELS[q], (1, 1), (-5, -5), 'axes fraction',
'offset points', ha='right', va='top')
_set_gridlabels(ax, i, n, n, N, ylabel=None)
if share is None:
share = ax
if q in ('Qsc', 'Qi') and Qlim:
ax.set_ylim(Qlim)
if q in ('lsc', 'li') and llim:
ax.set_ylim(llim)
ax.set_xlim(freqlim(freq))
_savefig(fig, **kwargs)
def plot_sites(result, mean=None,
xlim=None, ylim=(1e-2, 1e2), nx=None,
**kwargs):
"""Plot site amplification factors"""
freq = np.array(result['freq'])
# True for invert_events_simultaneously
single_inversion = 'R' not in list(result['events'].values())[0]
if single_inversion:
colres = result
R = copy(colres['R'])
for sta in R:
R[sta] = np.array(R[sta], dtype=float)
max_nobs = 1
else:
colres = collect_results(result, only=['R', 'error'])
R = colres['R']
max_nobs = np.max([np.sum(~np.isnan(r), axis=0) for r in R.values()])
weights = 1 / np.array(colres['error']) if mean == 'weighted' else None
robust = mean == 'robust'
N = max_nobs > 1
for station in sorted(R):
if not np.all(np.isnan(R[station])):
N = N + 1
# N = len(R) + (max_nobs > 1)
fig = plt.figure()
nx, ny, gs = _get_grid(N, nx=nx)
cmap = plt.get_cmap('hot_r', max_nobs)
norm = mpl.colors.Normalize(vmin=0.5, vmax=max_nobs + 0.5)
share = None
i = 0
for station in sorted(R):
if np.all(np.isnan(R[station])):
continue
ax = plt.subplot(gs[i // nx, i % nx], sharex=share, sharey=share)
means, err1, err2 = gerr(R[station], axis=0, weights=weights,
robust=robust)
errs = (err1, err2)
# if not np.all(np.isnan(R[station])):
if max_nobs == 1:
kw = {'c': 'k'}
else:
nobs = 1. * np.sum(~np.isnan(R[station]), axis=0)
kw = {'c': nobs, 'norm': norm, 'cmap': cmap}
if not single_inversion:
freqs = np.repeat(freq[np.newaxis, :], R[station].shape[0], axis=0)
ax.plot(freqs, R[station], 'o', ms=MS, color='gray', mec='gray')
ax.errorbar(freq, means, yerr=errs, marker=None,
color='m', ecolor='m')
sc = ax.scatter(freq, means, s=4 * MS ** 2,
marker='o', zorder=10,
linewidth=0.5,
**kw)
ax.set_xscale('log')
ax.set_yscale('log')
ax.annotate(station, (1, 1), (-5, -5), 'axes fraction',
'offset points', ha='right', va='top', size='x-small')
_set_gridlabels(ax, i, nx, ny, N, ylabel='amplification factor')
if share is None:
share = ax
i += 1
ax.set_xlim(xlim or freqlim(freq))
if ylim:
ax.set_ylim(ylim)
if max_nobs != 1:
ax = plt.subplot(gs[(N - 1) // nx, (N - 1) % nx])
ax.set_axis_off()
fig.colorbar(sc, ax=ax, shrink=0.9, format='%d', label='nobs',
ticks=np.arange(0, max_nobs + 1, max(1, max_nobs // 5)))
_savefig(fig, **kwargs)
def _get_grid(N, nx=None):
if nx is None:
nx = ny = int(np.ceil(np.sqrt(N)))
else:
ny = 1 + (N-1) // nx
gs = gridspec.GridSpec(ny, nx)
return nx, ny, gs
def plot_all_sds(result, seismic_moment_method=None,
seismic_moment_options=None,
xlim=None, ylim=None, nx=None,
annotate=None, va='top',
plot_only_ids=None, **kwargs):
"""Plot all source displacement spectra with fitted source models"""
freq = np.array(result['freq'])
conf = result.get('config', {})
smm = seismic_moment_method or conf.get('seismic_moment_method')
smo = seismic_moment_options or conf.get('seismic_moment_options', {})
# fc = seismic_moment_options.pop('fc', None)
result = result['events']
if plot_only_ids:
result = {id_: r for id_, r in result.items() if id_ in plot_only_ids}
N = len(result)
# n = int(np.ceil(np.sqrt(N)))
fig = plt.figure()
# gs = gridspec.GridSpec(n, n)
nx, ny, gs = _get_grid(N, nx=nx)
share = None
if annotate is None:
annotate = nx < 7
for i, evid in enumerate(sorted(result)):
ax = plt.subplot(gs[i // nx, i % nx], sharex=share, sharey=share)
plot_sds(freq, result[evid], seismic_moment_method=smm, va=va,
seismic_moment_options=smo, ax=ax, annotate=annotate)
ax.annotate(evid, (0, 0), (5, 5), 'axes fraction',
'offset points', ha='left', va='bottom', size='x-small')
_set_gridlabels(ax, i, nx, ny, N, ylabel=r'$\omega$M (Nm)')
if share is None:
share = ax
ax.autoscale()
ax.set_xlim(xlim or freqlim(freq))
if ylim:
ax.set_ylim(ylim)
_savefig(fig, **kwargs)
def plot_mags(result, xlim=None, ylim=None, plot_only_ids=None, **kwargs):
"""Plot Qopen moment magnitudes versus catalogue magnitudes"""
fig = plt.figure()
ax = fig.add_subplot(111)
temp = [(r['Mcat'], r['Mw']) for id_, r in result['events'].items()
if r.get('Mcat') is not | |
"""
Copyright 2020 <NAME>
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
"""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import os
import inspect
import typeguard
from bunch import Bunch
from typing import Optional
import tensorflow as tf
import numpy as np
import logging
from .base_funnel import Funnel
from ..augment import augment
from ..register.register import FUNNEL
__all__ = ["BboxFunnel", "CategoricalTensorFunnel"]
"""Bbox Funnel for bounding box dataset."""
class TFDecoderMixin:
"""Tensorflow decoder."""
KEYS_TO_FEATURES = {
"image/encoded": tf.io.FixedLenFeature((), tf.string),
"image/source_id": tf.io.FixedLenFeature((), tf.string, ""),
"image/height": tf.io.FixedLenFeature((), tf.int64, -1),
"image/width": tf.io.FixedLenFeature((), tf.int64, -1),
"image/object/bbox/xmin": tf.io.VarLenFeature(tf.float32),
"image/object/bbox/xmax": tf.io.VarLenFeature(tf.float32),
"image/object/bbox/ymin": tf.io.VarLenFeature(tf.float32),
"image/object/bbox/ymax": tf.io.VarLenFeature(tf.float32),
"image/object/class/label": tf.io.VarLenFeature(tf.int64),
"image/object/area": tf.io.VarLenFeature(tf.float32),
"image/object/is_crowd": tf.io.VarLenFeature(tf.int64),
}
def _decode_image(self, parsed_tensors):
"""Decodes the image"""
image = tf.io.decode_image(parsed_tensors["image/encoded"], channels=3)
image.set_shape([None, None, 3])
return image
def _decode_boxes(self, parsed_tensors):
"""Concat box coordinates in the format of [ymin, xmin, ymax, xmax]."""
xmin = parsed_tensors["image/object/bbox/xmin"]
xmax = parsed_tensors["image/object/bbox/xmax"]
ymin = parsed_tensors["image/object/bbox/ymin"]
ymax = parsed_tensors["image/object/bbox/ymax"]
return tf.stack([ymin, xmin, ymax, xmax], axis=-1)
def decode(self, serialized_example):
"""Decode the serialized example."""
parsed_tensors = tf.io.parse_single_example(
serialized_example, self.KEYS_TO_FEATURES
)
for k in parsed_tensors:
if isinstance(parsed_tensors[k], tf.SparseTensor):
if parsed_tensors[k].dtype == tf.string:
parsed_tensors[k] = tf.sparse.to_dense(
parsed_tensors[k], default_value=""
)
else:
parsed_tensors[k] = tf.sparse.to_dense(
parsed_tensors[k], default_value=0
)
image = self._decode_image(parsed_tensors)
boxes = self._decode_boxes(parsed_tensors)
decode_image_shape = tf.logical_or(
tf.equal(parsed_tensors["image/height"], -1),
tf.equal(parsed_tensors["image/width"], -1),
)
image_shape = tf.cast(tf.shape(image), dtype=tf.int64)
parsed_tensors["image/height"] = tf.where(
decode_image_shape, image_shape[0], parsed_tensors["image/height"]
)
parsed_tensors["image/width"] = tf.where(
decode_image_shape, image_shape[1], parsed_tensors["image/width"]
)
decoded_tensors = {
"image": image,
"height": parsed_tensors["image/height"],
"width": parsed_tensors["image/width"],
"groundtruth_classes": parsed_tensors["image/object/class/label"],
"groundtruth_boxes": boxes,
}
return decoded_tensors
@FUNNEL.register_module(name="bbox")
class BboxFunnel(Funnel, TFDecoderMixin):
"""BboxFunnel.
BboxFunnel Class for Bbox dataset,This class will provide
data iterable with images,bboxs or images,targets with required
augmentations.
"""
def __init__(
self,
data_path: str,
config: Optional[dict] = None,
datatype="bbox",
training=True,
):
"""__init__.
Args:
data_path: Dataset Path ,this is required in proper structure
please see readme file for more details on structuring.
config: Config File for setting the required configuration of datapipeline.
training:Traning mode on or not?
Example::
e.g 1
>> funnel = Funnel(config=config, datatype = "bbox")
>> data = next(iter(funnel.from_tfrecords('tfrecord_data/' , type="train")))
e.g 2:
class CustomFunnel(BboxFunnel):
def __init__(self, *args):
super().__init__(*args)
def encoder(self,args):
# should be overriden if there is a need for anchors in the model.
image_id, image, bbox, classes = args
# make custom anchors and encode the image and bboxes as per
/the model need.
return image, custom_anchors, classes
funnel = CustomFunnel()
"""
# bunch the config dict.
config = Bunch(config)
if not isinstance(data_path, str):
msg = f"datapath should be str but pass {type(data_path)}."
logging.error(msg)
raise TypeError("Only str allowed")
if not os.path.exists(data_path):
msg = f"path doesnt exists"
logging.error(msg)
raise TypeError("Path doesnt exists")
self._datatype = "bbox"
self._data_path = data_path
self.config = config
self._training = training
self._drop_remainder = self.config.get("drop_remainder", True)
self.augmenter = augment.Augment(self.config, datatype)
self.numpy_function = self.config.get("numpy_function", None)
self._per_shard = self.config.get("shard", 10) # hardcoded shard size
self.max_instances_per_image = self.config.get("max_instances_per_image", 100)
self.numpy_function = self.config.get("numpy_function", None)
if self.numpy_function:
assert callable(self.numpy_function), "numpy_function should be a callable."
assert len(
inspect.getfullargspec(self.numpy_function).args
), "py_function should be having two arguments."
@property
def datatype(self):
return self._datatype
@property
def classes(self):
return self._classes
def parser(self, dataset_folder):
"""parser for reading images and bbox from tensor records."""
dataset = tf.data.Dataset.list_files(
self.tf_path_pattern(os.path.join(self.data_path, dataset_folder)),
shuffle=self._training,
)
if self._training:
dataset = dataset.repeat()
dataset = dataset.interleave(
self._fetch_records, num_parallel_calls=self.AUTOTUNE
)
dataset = dataset.with_options(self.optimized_options)
if self._training:
dataset = dataset.shuffle(self._per_shard)
return dataset
def encoder(self):
"""Method expected to be overidden by the user. """
raise NotImplementedError()
def decoder(self, value):
"""helper decoder, a wrapper around tfrecorde decoder."""
data = self.decode(value)
image_id = 1.0
image = data["image"]
boxes = data["groundtruth_boxes"]
classes = data["groundtruth_classes"]
classes = tf.reshape(tf.cast(classes, dtype=tf.float32), [-1, 1])
return (image_id, image, boxes, classes)
def from_tfrecords(self, type="train"):
"""tf_records.
Returns a iterable tf.data dataset ,which is configured
with the config file passed with require augmentations.
"""
dataset = self.parser(type)
decode_rawdata = lambda input_records: self.decoder(
input_records
) # pylint: enable=g-long-lambda
dataset = dataset.map(decode_rawdata, num_parallel_calls=self.AUTOTUNE)
dataset = dataset.prefetch(self.config.batch_size)
# custom numpy function to inject in datapipeline.
def _numpy_function(img_id, img, bbox, classes):
_output = tf.numpy_function(
func=self.numpy_function,
inp=[img, bbox],
Tout=(tf.float32, tf.float32),
)
return img_id, _output[0], _output[1], classes
if self._training:
dataset = dataset.map(
lambda image_id, image, bbox, classes: self.augmenter(
image, bbox, image_id, classes, return_image_label=False
)
)
if self.numpy_function:
dataset = dataset.map(_numpy_function, num_parallel_calls=self.AUTOTUNE)
# pad to fixed length.
dataset = dataset.map(
lambda *args: self.pad_to_fixed_len(*args),
num_parallel_calls=self.AUTOTUNE,
)
# try if encoder is implemented.
try:
self.encoder()
except NotImplementedError:
logging.info("Encoder is not implemented,giving raw output.")
else:
dataset = dataset.map(lambda *args: self.encoder(*args))
# make batches.
dataset = dataset.batch(
self.config.batch_size, drop_remainder=self._drop_remainder
)
dataset = self.pretraining(dataset)
return dataset
@property
def data_path(self):
return self._data_path
def from_dataset(self, tfrecord_path: str = None):
# TODO(kartik4949) : write me
# fetch raw data
raise NotImplementedError
def from_remote(self, remote_path: str = None):
# TODO(kartik4949) : write me
# fetch remote files
raise NotImplementedError
@FUNNEL.register_module(name="categorical")
class CategoricalTensorFunnel(Funnel):
# pylint: disable=line-too-long
"""CategoricalTensorFunnel
TensorFunnel for Categorical Data provides DataPipeline according
to config passed with required augmentations.
Example: ***********************************************
funnel = CategoricalTensorFunnel('testdata', config=config, datatype='categorical')
iterable = funnel.dataset(type = 'train')
Note: This class can only be used for categorical dataset.
i.e either multiclass or binary.
"""
# pylint: enable=line-too-long
@typeguard.typechecked
def __init__(
self,
data_path: str,
config: Optional[dict] = None,
datatype="categorical",
training=True,
):
"""__init__.
Args:
data_path: Dataset Path which should be in structure way
please see readme file for more details on structuring.
config: Config file , a dict file contains all required attributes
to configure.
datatype: Dataset Type i.e (Bbox , Labels ,Segmentations)
bbox dataset is object detection dataset which will be provided in
form of [image,bboxs] or [image, class_targets,bbox_targets].
training: is pipeline in training mode or not?
"""
# bunch the config dict.
config = Bunch(config)
if not isinstance(data_path, str):
msg = f"datapath should be str but pass {type(data_path)}."
logging.error(msg)
raise TypeError("Only str allowed")
self._datatype = datatype
self._data_path = data_path
self.config = config
self._training = training
self._shuffle_buffer = None
self._batch_size = self.config.get("batch_size", 32)
self._image_size = self.config.get("image_size", [512, 512])
self._drop_remainder = self.config.get("drop_remainder", True)
self.augmenter = augment.Augment(self.config, datatype)
self.numpy_function = self.config.get("numpy_function", None)
if self.numpy_function:
assert callable(self.numpy_function), "numpy_function should be a callable."
assert len(
inspect.getfullargspec(self.numpy_function).args
), "py_function should be having two arguments."
def categorical_encoding(self, labels):
"""categorical_encoding.
Encodes the labels with given encoding in config file.
Args:
labels: Labels to encode
"""
encoding = (
self.config.categorical_encoding
if self.config.categorical_encoding
else "onehot"
)
if encoding == "onehot":
from sklearn.preprocessing import (
OneHotEncoder,
) # pylint: disable=g-import-not-at-top
encoding = OneHotEncoder(drop="if_binary", sparse=False)
else:
from sklearn.preprocessing import (
LabelEncoder,
) # pylint: disable=g-import-not-at-top
encoding = LabelEncoder()
labels = encoding.fit_transform(labels)
return labels
@property
def get_id_to_imagefile(self):
return self._get_id_to_imagefile
@property
def classes(self):
return self._classes
@property
def data_path(self):
return self._data_path
@property
def datatype(self):
return self._datatype
def resize(self, image):
return tf.image.resize(
image,
self._image_size,
method=tf.image.ResizeMethod.BILINEAR,
preserve_aspect_ratio=False,
antialias=False,
name=None,
)
@get_id_to_imagefile.setter
def get_id_to_imagefile(self, value):
if not isinstance(value, dict):
msg = "Only dict assign is allowed"
logging.error(msg)
raise TypeError(msg)
self._get_id_to_imagefile = value
def _generate_ids(self, image_files):
"""_generate_ids.
Generate igs for the imagefiles, which will be further used
to parse image file to read.
Args:
image_files: images files list containing filename of images.
"""
# TODO: (HIGH) make get_id_to_imagefile as dataclass.
self._get_id_to_imagefile = {}
_ = [
self._get_id_to_imagefile.update({id: image_file})
for id, image_file in enumerate(image_files)
]
return list(self._get_id_to_imagefile.keys())
def _get_file_labels(self, subset):
"""_get_file_labels.
returns files, labels which will be further used for reading images.
"""
_images = []
_labels = []
for label_folder in os.listdir(self.data_path + "/" + subset):
for images in os.listdir(
self.data_path + "/" + subset + "/" + label_folder
):
_images.append(
self.data_path + "/" + subset + "/" + label_folder + "/" + images
)
_labels.append(label_folder)
self._classes = set(_labels)
_labels = np.reshape(np.asarray(_labels), (-1, 1))
_labels = self.categorical_encoding(_labels)
_labels = np.reshape(np.asarray(_labels), (-1, 1))
self._size = len(_images)
assert len(_images) == len(_labels), "Length of Images and Labels didnt match"
return _images, _labels
@typeguard.typechecked
def | |
# Audio processing tools
#
# <NAME> 2020
#
# Some code modified from original MATLAB rastamat package.
#
import numpy as np
from scipy.signal import hanning, spectrogram, resample, hilbert, butter, filtfilt
from scipy.io import wavfile
# import spectools
# from .fbtools import fft2melmx
from matplotlib import pyplot as plt
import parselmouth as pm
# from soundsig import sound
def get_meanF0s_v2(fileName, steps=1/128.0, f0min=50, f0max=300):
"""
Uses parselmouth Sound and Pitch object to generate frequency spectrum of
wavfile, 'fileName'. Mean F0 frequencies are calculated for each phoneme
in 'phoneme_times' by averaging non-zero frequencies within a given
phoneme's time segment. A range of 10 log spaced center frequencies is
calculated for pitch classes. A pitch belongs to the class of the closest
center frequency bin that falls below one standard deviation of the center
frequency range.
"""
#fileName = wav_dirs + wav_name
sound_obj = pm.Sound(fileName)
pitch = sound_obj.to_pitch(steps, f0min, f0max) #create a praat pitch object
pitch_values = pitch.selected_array['frequency']
return pitch_values
def fft2melmx(nfft, sr=8000, nfilts=0, bwidth=1.0, minfreq=0, maxfreq=4000, htkmel=False, constamp=0):
'''
# Generate a matrix of weights to combine FFT bins into Mel
# bins. nfft defines the source FFT size at sampling rate sr.
# Optional nfilts specifies the number of output bands required
# (else one per "mel/width"), and width is the constant width of each
# band relative to standard Mel (default 1).
# While wts has nfft columns, the second half are all zero.
# Hence, Mel spectrum is fft2melmx(nfft,sr)*abs(fft(xincols,nfft));
# minfreq is the frequency (in Hz) of the lowest band edge;
# default is 0, but 133.33 is a common standard (to skip LF).
# maxfreq is frequency in Hz of upper edge; default sr/2.
# You can exactly duplicate the mel matrix in Slaney's mfcc.m
# as fft2melmx(512, 8000, 40, 1, 133.33, 6855.5, 0);
# htkmel=1 means use HTK's version of the mel curve, not Slaney's.
# constamp=1 means make integration windows peak at 1, not sum to 1.
# frqs returns bin center frqs.
# 2004-09-05 <EMAIL> based on fft2barkmx
'''
if nfilts == 0:
nfilts = np.ceil(hz2mel(maxfreq, htkmel)/2);
wts = np.zeros((nfilts, nfft))
# Center freqs of each FFT bin
fftfrqs = np.arange(0,nfft/2.)/nfft*sr
# 'Center freqs' of mel bands - uniformly spaced between limits
minmel = hz2mel(minfreq, htkmel)
maxmel = hz2mel(maxfreq, htkmel)
binfrqs = mel2hz(minmel+np.arange(0.,nfilts+2)/(nfilts+2.)*(maxmel-minmel), htkmel);
binbin = np.round(binfrqs/sr*(nfft-1.))
for i in np.arange(nfilts):
fs = binfrqs[i+[0, 1, 2]]
#print fs
# scale by width
fs = fs[1]+bwidth*(fs - fs[1]);
# lower and upper slopes for all bins
loslope = (fftfrqs - fs[0])/(fs[1] - fs[0])
hislope = (fs[2] - fftfrqs)/(fs[2] - fs[1])
w = np.min((loslope, hislope), axis=0)
w[w<0] = 0
# .. then intersect them with each other and zero
wts[i, 0:np.int(nfft/2)] = w
if constamp == 0:
# Slaney-style mel is scaled to be approx constant E per channel
wts = np.dot(np.diag(2./(binfrqs[2+np.arange(nfilts)]-binfrqs[np.arange(nfilts)])),wts)
#wts = np.atleast_2d(2/(binfrqs[2+np.arange(nfilts)]-binfrqs[np.arange(nfilts)]))*wts
#wts = np.dot(2/(binfrqs[2+np.arange(nfilts)]-binfrqs[np.arange(nfilts)]),wts)
# Make sure 2nd half of FFT is zero
wts[:,np.int(nfft/2+2):np.int(nfft)] = 0
# seems like a good idea to avoid aliasing
return wts, binfrqs
def hz2mel(f,htk=False):
'''
# z = hz2mel(f,htk)
# Convert frequencies f (in Hz) to mel 'scale'.
# Optional htk = 1 uses the mel axis defined in the HTKBook
# otherwise use Slaney's formula
# 2005-04-19 <EMAIL>
'''
if htk:
z = 2595 * log10(1+f/700)
else:
# Mel fn to match Slaney's Auditory Toolbox mfcc.m
f_0 = 0.; # 133.33333;
f_sp = 200./3; # 66.66667;
brkfrq = 1000.;
brkpt = (brkfrq - f_0)/f_sp; # starting mel value for log region
logstep = np.exp(np.log(6.4)/27.); # the magic 1.0711703 which is the ratio needed to get from 1000 Hz to 6400 Hz in 27 steps, and is *almost* the ratio between 1000 Hz and the preceding linear filter center at 933.33333 Hz (actually 1000/933.33333 = 1.07142857142857 and exp(log(6.4)/27) = 1.07117028749447)
linpts = [f < brkfrq];
z = 0*f;
# fill in parts separately
if len(linpts) == 1:
if linpts[0]:
z = f - f_0/f_sp
else:
z = brkpt+(np.log(f/brkfrq))/np.log(logstep)
else:
z[linpts==True] = (f[linpts==True] - f_0)/f_sp
z[linpts==False] = brkpt+(np.log(f[linpts==False]/brkfrq))/np.log(logstep)
return z
def mel2hz(z, htk=False):
# f = mel2hz(z, htk)
# Convert 'mel scale' frequencies into Hz
# Optional htk = 1 means use the HTK formula
# else use the formula from Slaney's mfcc.m
# 2005-04-19 <EMAIL>
if htk:
f = 700.*(10**(z/2595.)-1);
else:
f_0 = 0.; # 133.33333;
f_sp = 200./3.; # 66.66667;
brkfrq = 1000.;
brkpt = (brkfrq - f_0)/f_sp; # starting mel value for log region
logstep = np.exp(np.log(6.4)/27.); # the magic 1.0711703 which is the ratio needed to get from 1000 Hz to 6400 Hz in 27 steps, and is *almost* the ratio between 1000 Hz and the preceding linear filter center at 933.33333 Hz (actually 1000/933.33333 = 1.07142857142857 and exp(log(6.4)/27) = 1.07117028749447)
linpts = [z < brkpt]
nonlinpts = [z >= brkpt]
f = 0*z;
# fill in parts separately
f[linpts] = f_0 + f_sp*z[linpts];
f[nonlinpts] = brkfrq*np.exp(np.log(logstep)*(z[nonlinpts]-brkpt));
return f
def get_envelope(audio, audio_fs, new_fs, cof=25, bef_aft=[0, 0], pad_next_pow2=False):
''' Get the envelope of a sound file
Inputs:
w [float] : audio signal vector
fs [int] : sampling rate of audio signal
new_fs [int] : desired sampling rate of the envelope (same as your EEG, for example)
Outputs:
envelope [array-like] : returns the envelope of the sound as an array
'''
if pad_next_pow2:
print("Padding the signal to the nearest power of two...this should speed things up")
orig_len = len(audio)
sound_pad = np.hstack((audio, np.zeros((2**np.int(np.ceil(np.log2(len(audio))))-len(audio),))))
audio = sound_pad
print("calculating hilbert transform")
env_hilb = np.abs(hilbert(audio))
nyq = audio_fs/2. #Nyquist frequency
b, a = butter(3, cof/nyq, 'low'); #this designs a 3-pole low-pass filter
print("Low-pass filtering hilbert transform to get audio envelope")
envelope_long = np.atleast_2d(filtfilt(b, a, env_hilb, axis=0)) #filtfilt makes it non-causal (fwd/backward)
envelope = resample(envelope_long.T, np.int(np.floor(envelope_long.shape[1]/(audio_fs/new_fs))))
if pad_next_pow2:
print("Removing padding")
final_len = np.int((orig_len/audio_fs)*new_fs)
envelope = envelope[:final_len,:]
print(envelope.shape)
if bef_aft[0] < 0:
print("Adding %.2f seconds of silence before"%bef_aft[0])
envelope = np.vstack(( np.zeros((np.int(np.abs(bef_aft[0])*new_fs), 1)), envelope ))
if bef_aft[1] > 0:
print("Adding %.2f seconds of silence after"%bef_aft[1])
envelope = np.vstack(( envelope, np.zeros((np.int(bef_aft[1]*new_fs), 1)) ))
return envelope
def get_cse_onset(audio, audio_fs, wins = [0.04], nfilts=80, pos_deriv=True, spec_noise_thresh=1.04):
"""
Get the onset based on cochlear scaled entropy
Inputs:
audio [np.array] : your audio
audio_fs [float] : audio sampling rate
wins [list] : list of windows to use in the boxcar convolution
pos_deriv [bool] : whether to detect onsets only (True) or onsets and offsets (False)
Outputs:
cse [np.array] : rectified cochlear scaled entropy over window [wins]
auddiff [np.array] : instantaneous derivative of spectrogram
"""
new_fs = 100 # Sampling frequency of spectrogram
specgram = get_mel_spectrogram(audio, audio_fs, nfilts=nfilts)
specgram[specgram<spec_noise_thresh] = 0
nfilts, ntimes = specgram.shape
if pos_deriv is False:
auddiff= np.sum(np.diff(np.hstack((np.atleast_2d(specgram[:,0]).T, specgram)))**2, axis=0)
else:
all_diff = np.diff(np.hstack((np.atleast_2d(specgram[:,0]).T, specgram)))
all_diff[all_diff<0] = 0
auddiff = np.sum(all_diff**2, axis=0)
cse = np.zeros((len(wins), ntimes))
# Get the windows over which we are summing as bins, not times
win_segments = [np.int(w*new_fs) for w in wins]
for wi, w in enumerate(win_segments):
box = np.hstack((np.atleast_2d(boxcar(w)), -np.ones((1, np.int(0.15*new_fs))))).ravel()
cse[wi,:] = convolve(auddiff, box, 'full')[:ntimes]
cse[cse<0] = 0
cse = cse/cse.max()
return cse, auddiff
def get_peak_rate(envelope):
env_diff = np.diff(np.concatenate((0, envelope), axis=None))
env_diff[env_diff<0] = 0
return env_diff
def get_mel_spectrogram(w, fs, wintime=0.025, steptime=0.010, nfilts=80, minfreq=0, maxfreq=None):
''' Make mel-band spectrogram
Inputs:
w [float] : audio signal vector
fs [int] : sampling rate of audio signal
wintime [float] : window size
steptime [float] : step size (time resolution)
nfilts [int] : number of mel-band filters
minfreq [int] : Minimum frequency to analyze (in Hz)
maxfreq [int] : Maximum frequency to analyze (in Hz). If none, defaults to fs/2
Outputs:
mel_spectrogram [array]: mel-band spectrogram
freqs [array] : array of floats, bin edges of spectrogram
'''
if maxfreq is None:
maxfreq = np.int(fs/2)
pspec, e = powspec(w, sr=fs, wintime=wintime, steptime=steptime, dither=1)
aspectrum, wts, freqs = audspec(pspec, sr=fs, nfilts=nfilts, fbtype='mel', minfreq=minfreq, maxfreq=maxfreq, sumpower=True, bwidth=1.0)
mel_spectrogram = aspectrum**0.001
return mel_spectrogram, freqs
def powspec(x, sr=8000, wintime=0.025, steptime=0.010, dither=1):
'''
# compute the powerspectrum and frame energy of the input signal.
# basically outputs a power spectrogram
#
# each column | |
<reponame>sun1638650145/text
# coding=utf-8
# Copyright 2022 TF.Text Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# encoding=utf-8
"""Tests for ngram ops."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import numpy as np
import tensorflow as tf
import tensorflow_text as tf_text
from tensorflow.lite.python import interpreter
from tensorflow.python.framework import constant_op
from tensorflow.python.framework import errors
from tensorflow.python.framework import test_util
from tensorflow.python.ops.ragged import ragged_factory_ops
from tensorflow.python.platform import test
from tensorflow_text.core.pybinds import tflite_registrar
from tensorflow_text.python.ops import ngrams_op
@test_util.run_all_in_graph_and_eager_modes
class NgramsOpTest(test_util.TensorFlowTestCase):
def testSumReduction(self):
test_data = constant_op.constant([[1.0, 2.0, 3.0], [10.0, 20.0, 30.0]])
op = ngrams_op.ngrams(
test_data, width=2, axis=1, reduction_type=ngrams_op.Reduction.SUM)
expected_values = [[3.0, 5.0], [30.0, 50.0]]
self.assertAllEqual(expected_values, op)
def testRaggedSumReduction(self):
test_data = ragged_factory_ops.constant([[1.0, 2.0, 3.0, 4.0],
[10.0, 20.0, 30.0]])
op = ngrams_op.ngrams(
test_data, width=2, axis=1, reduction_type=ngrams_op.Reduction.SUM)
expected_values = [[3.0, 5.0, 7.0], [30.0, 50.0]]
self.assertAllEqual(expected_values, op)
def testRaggedSumReductionAxisZero(self):
test_data = ragged_factory_ops.constant([[1.0, 2.0, 3.0, 4.0],
[10.0, 20.0, 30.0, 40.0]])
op = ngrams_op.ngrams(
test_data, width=2, axis=0, reduction_type=ngrams_op.Reduction.SUM)
expected_values = [[11.0, 22.0, 33.0, 44.0]]
self.assertAllEqual(expected_values, op)
def testMeanReduction(self):
test_data = constant_op.constant([[1.0, 2.0, 3.0], [10.0, 20.0, 30.0]])
op = ngrams_op.ngrams(
test_data, width=2, axis=1, reduction_type=ngrams_op.Reduction.MEAN)
expected_values = [[1.5, 2.5], [15.0, 25.0]]
self.assertAllEqual(expected_values, op)
def testRaggedMeanReduction(self):
test_data = ragged_factory_ops.constant([[1.0, 2.0, 3.0, 4.0],
[10.0, 20.0, 30.0]])
op = ngrams_op.ngrams(
test_data, width=2, axis=-1, reduction_type=ngrams_op.Reduction.MEAN)
expected_values = [[1.5, 2.5, 3.5], [15.0, 25.0]]
self.assertAllEqual(expected_values, op)
def testStringJoinReduction(self):
test_data = constant_op.constant([[b"a", b"b", b"c"],
[b"dd", b"ee", b"ff"]])
op = ngrams_op.ngrams(
test_data,
width=2,
axis=-1,
reduction_type=ngrams_op.Reduction.STRING_JOIN,
string_separator=b"|")
expected_values = [[b"a|b", b"b|c"], [b"dd|ee", b"ee|ff"]]
self.assertAllEqual(expected_values, op)
def testStringJoinReductionAxisZero(self):
test_data = constant_op.constant([b"a", b"b", b"c"])
op = ngrams_op.ngrams(
test_data,
width=2,
axis=-1, # The -1 axis is the zero axis here.
reduction_type=ngrams_op.Reduction.STRING_JOIN,
string_separator=b"|")
expected_values = [b"a|b", b"b|c"]
self.assertAllEqual(expected_values, op)
def testRaggedStringJoinReduction(self):
test_data = ragged_factory_ops.constant([[b"a", b"b", b"c"],
[b"dd", b"ee"]])
op = ngrams_op.ngrams(
test_data,
width=2,
axis=-1,
reduction_type=ngrams_op.Reduction.STRING_JOIN,
string_separator=b"|")
expected_values = [[b"a|b", b"b|c"], [b"dd|ee"]]
self.assertAllEqual(expected_values, op)
def testReductionWithNegativeAxis(self):
test_data = constant_op.constant([[1.0, 2.0, 3.0], [10.0, 20.0, 30.0]])
op = ngrams_op.ngrams(
test_data, width=2, axis=-1, reduction_type=ngrams_op.Reduction.SUM)
expected_values = [[3.0, 5.0], [30.0, 50.0]]
self.assertAllEqual(expected_values, op)
def testReductionOnInnerAxis(self):
test_data = constant_op.constant([[[1.0, 2.0, 3.0], [10.0, 20.0, 30.0]],
[[4.0, 5.0, 6.0], [40.0, 50.0, 60.0]]])
op = ngrams_op.ngrams(
test_data, width=2, axis=-2, reduction_type=ngrams_op.Reduction.SUM)
expected_values = [[[11.0, 22.0, 33.0]], [[44.0, 55.0, 66.0]]]
self.assertAllEqual(expected_values, op)
def testRaggedReductionOnInnerAxis(self):
test_data = ragged_factory_ops.constant([[[1.0, 2.0, 3.0, 4.0],
[10.0, 20.0, 30.0, 40.0]],
[[100.0, 200.0], [300.0, 400.0]]])
op = ngrams_op.ngrams(
test_data, width=2, axis=-2, reduction_type=ngrams_op.Reduction.SUM)
expected_values = [[[11.0, 22.0, 33.0, 44.0]], [[400.0, 600.0]]]
self.assertAllEqual(expected_values, op)
def testReductionOnAxisWithInsufficientValuesReturnsEmptySet(self):
test_data = constant_op.constant([[1.0, 2.0, 3.0], [10.0, 20.0, 30.0]])
op = ngrams_op.ngrams(
test_data, width=4, axis=-1, reduction_type=ngrams_op.Reduction.SUM)
expected_values = [[], []]
self.assertAllEqual(expected_values, op)
def testRaggedReductionOnAxisWithInsufficientValuesReturnsEmptySet(self):
test_data = ragged_factory_ops.constant([[1.0, 2.0, 3.0],
[10.0, 20.0, 30.0, 40.0]])
op = ngrams_op.ngrams(
test_data, width=4, axis=1, reduction_type=ngrams_op.Reduction.SUM)
expected_values = [[], [100.0]]
self.assertAllEqual(expected_values, op)
def testStringJoinReductionFailsWithImproperAxis(self):
with self.assertRaisesRegex(
errors.InvalidArgumentError,
r".*requires that ngrams' 'axis' parameter be -1."):
_ = ngrams_op.ngrams(
data=[],
width=2,
axis=0,
reduction_type=ngrams_op.Reduction.STRING_JOIN)
def testUnspecifiedReductionTypeFails(self):
with self.assertRaisesRegex(errors.InvalidArgumentError,
r"reduction_type must be specified."):
_ = ngrams_op.ngrams(data=[], width=2, axis=0)
def testBadReductionTypeFails(self):
with self.assertRaisesRegex(errors.InvalidArgumentError,
r"reduction_type must be a Reduction."):
_ = ngrams_op.ngrams(data=[], width=2, axis=0, reduction_type="SUM")
class NgramsV2OpTest(test_util.TensorFlowTestCase):
@test_util.with_forward_compatibility_horizons([2022, 11, 30])
def testSumReduction(self):
test_data = constant_op.constant([[1.0, 2.0, 3.0], [10.0, 20.0, 30.0]])
op = ngrams_op.ngrams(
test_data, width=2, axis=1, reduction_type=ngrams_op.Reduction.SUM)
expected_values = [[3.0, 5.0], [30.0, 50.0]]
self.assertAllEqual(expected_values, op)
@test_util.with_forward_compatibility_horizons([2022, 11, 30])
def testRaggedSumReduction(self):
test_data = ragged_factory_ops.constant([[1.0, 2.0, 3.0, 4.0],
[10.0, 20.0, 30.0]])
op = ngrams_op.ngrams(
test_data, width=2, axis=1, reduction_type=ngrams_op.Reduction.SUM)
expected_values = [[3.0, 5.0, 7.0], [30.0, 50.0]]
self.assertAllEqual(expected_values, op)
@test_util.with_forward_compatibility_horizons([2022, 11, 30])
def testRaggedSumReductionAxisZero(self):
test_data = ragged_factory_ops.constant([[1.0, 2.0, 3.0, 4.0],
[10.0, 20.0, 30.0, 40.0]])
op = ngrams_op.ngrams(
test_data, width=2, axis=0, reduction_type=ngrams_op.Reduction.SUM)
expected_values = [[11.0, 22.0, 33.0, 44.0]]
self.assertAllEqual(expected_values, op)
@test_util.with_forward_compatibility_horizons([2022, 11, 30])
def testMeanReduction(self):
test_data = constant_op.constant([[1.0, 2.0, 3.0], [10.0, 20.0, 30.0]])
op = ngrams_op.ngrams(
test_data, width=2, axis=1, reduction_type=ngrams_op.Reduction.MEAN)
expected_values = [[1.5, 2.5], [15.0, 25.0]]
self.assertAllEqual(expected_values, op)
@test_util.with_forward_compatibility_horizons([2022, 11, 30])
def testRaggedMeanReduction(self):
test_data = ragged_factory_ops.constant([[1.0, 2.0, 3.0, 4.0],
[10.0, 20.0, 30.0]])
op = ngrams_op.ngrams(
test_data, width=2, axis=-1, reduction_type=ngrams_op.Reduction.MEAN)
expected_values = [[1.5, 2.5, 3.5], [15.0, 25.0]]
self.assertAllEqual(expected_values, op)
@test_util.with_forward_compatibility_horizons([2022, 11, 30])
def testStringJoinReduction(self):
test_data = constant_op.constant([["a", "b", "c"], ["dd", "ee", "ff"]])
op = ngrams_op.ngrams(
test_data,
width=2,
axis=-1,
reduction_type=ngrams_op.Reduction.STRING_JOIN,
string_separator="|")
expected_values = [[b"a|b", b"b|c"], [b"dd|ee", b"ee|ff"]]
self.assertAllEqual(expected_values, op)
@test_util.with_forward_compatibility_horizons([2022, 11, 30])
def testStringJoinReductionRank3(self):
test_data = constant_op.constant([[["a", "b", "c"], ["z", "y", "x"]],
[["dd", "ee", "ff"], ["zz", "yy", "xx"]]])
op = ngrams_op.ngrams(
test_data,
width=2,
axis=-1,
reduction_type=ngrams_op.Reduction.STRING_JOIN,
string_separator="|")
expected_values = [[[b"a|b", b"b|c"], [b"z|y", b"y|x"]],
[[b"dd|ee", b"ee|ff"], [b"zz|yy", b"yy|xx"]]]
self.assertAllEqual(expected_values, op)
@test_util.with_forward_compatibility_horizons([2022, 11, 30])
def testStringJoinReductionAxisZero(self):
test_data = constant_op.constant(["a", "b", "c"])
op = ngrams_op.ngrams(
test_data,
width=2,
axis=-1, # The -1 axis is the zero axis here.
reduction_type=ngrams_op.Reduction.STRING_JOIN,
string_separator="|")
expected_values = [b"a|b", b"b|c"]
self.assertAllEqual(expected_values, op)
@test_util.with_forward_compatibility_horizons([2022, 11, 30])
def testRaggedStringJoinReduction(self):
test_data = ragged_factory_ops.constant([["a", "b", "c"], ["dd", "ee"]])
op = ngrams_op.ngrams(
test_data,
width=2,
axis=-1,
reduction_type=ngrams_op.Reduction.STRING_JOIN,
string_separator="|")
expected_values = [[b"a|b", b"b|c"], [b"dd|ee"]]
self.assertAllEqual(expected_values, op)
@test_util.with_forward_compatibility_horizons([2022, 11, 30])
def testRaggedDeepStringJoinReduction(self):
test_data = ragged_factory_ops.constant([[[["a", "b", "c"]],
[["dd", "ee"]]],
[[["f", "g"], ["h", "i", "j"]],
[["k", "l"]]]])
op = ngrams_op.ngrams(
test_data,
width=2,
axis=-1,
reduction_type=ngrams_op.Reduction.STRING_JOIN,
string_separator="|")
expected_values = [[[[b"a|b", b"b|c"]], [[b"dd|ee"]]],
[[[b"f|g"], [b"h|i", b"i|j"]], [[b"k|l"]]]]
self.assertAllEqual(expected_values, op)
@test_util.with_forward_compatibility_horizons([2022, 11, 30])
def testDoubleRaggedStringJoinReduction(self):
test_data = tf.constant([["a b c"], ["d e"]])
t = tf_text.WhitespaceTokenizer()
test_data = t.tokenize(test_data)
op = ngrams_op.ngrams(
test_data,
width=2,
axis=-1,
reduction_type=ngrams_op.Reduction.STRING_JOIN,
string_separator="|")
expected_values = [[[b"a|b", b"b|c"]], [[b"d|e"]]]
self.assertAllEqual(expected_values, op)
@test_util.with_forward_compatibility_horizons([2022, 11, 30])
def testReductionWithNegativeAxis(self):
test_data = constant_op.constant([[1.0, 2.0, 3.0], [10.0, 20.0, 30.0]])
op = ngrams_op.ngrams(
test_data, width=2, axis=-1, reduction_type=ngrams_op.Reduction.SUM)
expected_values = [[3.0, 5.0], [30.0, 50.0]]
self.assertAllEqual(expected_values, op)
@test_util.with_forward_compatibility_horizons([2022, 11, 30])
def testReductionOnInnerAxis(self):
test_data = constant_op.constant([[[1.0, 2.0, 3.0], [10.0, 20.0, 30.0]],
[[4.0, 5.0, 6.0], [40.0, 50.0, 60.0]]])
op = ngrams_op.ngrams(
test_data, width=2, axis=-2, reduction_type=ngrams_op.Reduction.SUM)
expected_values = [[[11.0, 22.0, 33.0]], [[44.0, 55.0, 66.0]]]
self.assertAllEqual(expected_values, op)
@test_util.with_forward_compatibility_horizons([2022, 11, 30])
def testRaggedReductionOnInnerAxis(self):
test_data = ragged_factory_ops.constant([[[1.0, 2.0, 3.0, 4.0],
[10.0, 20.0, 30.0, 40.0]],
[[100.0, 200.0], [300.0, 400.0]]])
op = ngrams_op.ngrams(
test_data, width=2, axis=-2, reduction_type=ngrams_op.Reduction.SUM)
expected_values = [[[11.0, 22.0, 33.0, 44.0]], [[400.0, 600.0]]]
self.assertAllEqual(expected_values, op)
@test_util.with_forward_compatibility_horizons([2022, 11, 30])
def testReductionOnAxisWithInsufficientValuesReturnsEmptySet(self):
test_data = constant_op.constant([[1.0, 2.0, 3.0], [10.0, 20.0, 30.0]])
op = ngrams_op.ngrams(
test_data, width=4, axis=-1, reduction_type=ngrams_op.Reduction.SUM)
expected_values = [[], []]
self.assertAllEqual(expected_values, op)
@test_util.with_forward_compatibility_horizons([2022, 11, 30])
def testRaggedReductionOnAxisWithInsufficientValuesReturnsEmptySet(self):
test_data = ragged_factory_ops.constant([[1.0, 2.0, 3.0],
[10.0, 20.0, 30.0, 40.0]])
op = ngrams_op.ngrams(
test_data, width=4, axis=1, reduction_type=ngrams_op.Reduction.SUM)
expected_values = [[], [100.0]]
self.assertAllEqual(expected_values, op)
@test_util.with_forward_compatibility_horizons([2022, 11, 30])
def testStringJoinReductionFailsWithImproperAxis(self):
with self.assertRaisesRegex(
errors.InvalidArgumentError,
r".*requires that ngrams' 'axis' parameter be -1."):
_ = ngrams_op.ngrams(
data=[],
width=2,
axis=0,
reduction_type=ngrams_op.Reduction.STRING_JOIN)
@test_util.with_forward_compatibility_horizons([2022, 11, 30])
def testUnspecifiedReductionTypeFails(self):
with self.assertRaisesRegex(errors.InvalidArgumentError,
r"reduction_type must be specified."):
_ = ngrams_op.ngrams(data=[], width=2, axis=0)
@test_util.with_forward_compatibility_horizons([2022, 11, 30])
def testBadReductionTypeFails(self):
with self.assertRaisesRegex(errors.InvalidArgumentError,
r"reduction_type must be a Reduction."):
_ = ngrams_op.ngrams(data=[], width=2, axis=0, reduction_type="SUM")
@test_util.with_forward_compatibility_horizons([2022, 11, 30])
def testTfLite(self):
"""Checks TFLite conversion and inference."""
class NgramModel(tf.keras.Model):
def call(self, input_tensor, **kwargs):
return ngrams_op.ngrams(input_tensor, width=2, axis=-1,
reduction_type=ngrams_op.Reduction.STRING_JOIN,
string_separator="|")
# Test input data.
input_data = np.array(["a", "b", "c"])
# Define a Keras model.
model = NgramModel()
# Do TF.Text inference.
tf_result = model(tf.constant(input_data))
# Convert to TFLite.
converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS]
converter.allow_custom_ops = True
tflite_model = converter.convert()
# Do TFLite inference.
op = tflite_registrar.AddNgramsStringJoin
interp = interpreter.InterpreterWithCustomOps(
model_content=tflite_model,
custom_op_registerers=[op])
input_details = interp.get_input_details()
interp.resize_tensor_input(input_details[0]["index"], tf.shape(input_data))
interp.allocate_tensors()
interp.set_tensor(input_details[0]["index"], input_data)
interp.invoke()
output_details = interp.get_output_details()
tflite_result = interp.get_tensor(output_details[0]["index"])
# Assert the results are identical.
self.assertAllEqual(tflite_result, tf_result)
@test_util.with_forward_compatibility_horizons([2022, 11, 30])
def testTfLiteRagged(self):
"""Checks TFLite conversion and inference."""
class NgramModel(tf.keras.Model):
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.tokenizer = tf_text.WhitespaceTokenizer()
@tf.function(input_signature=[
tf.TensorSpec(shape=[1], dtype=tf.string, name="input")
])
def call(self, input_tensor):
input_tensor = self.tokenizer.tokenize(input_tensor)
x = ngrams_op.ngrams(input_tensor, width=2, axis=-1,
reduction_type=ngrams_op.Reduction.STRING_JOIN,
string_separator="|")
return {"result": x.flat_values}
# Test input data.
input_data = np.array(["foo bar"])
# Define a Keras model.
model = NgramModel()
# Do TF.Text inference.
tf_result = model(tf.constant(input_data))["result"]
print(tf_result.shape)
# Convert to TFLite.
converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS]
converter.allow_custom_ops = True
tflite_model = converter.convert()
# Do TFLite inference.
interp = interpreter.InterpreterWithCustomOps(
model_content=tflite_model,
custom_op_registerers=tf_text.tflite_registrar.SELECT_TFTEXT_OPS)
print(interp.get_signature_list())
tn = interp.get_signature_runner("serving_default")
output = tn(input=input_data)
if tf.executing_eagerly():
tflite_result = output["result"]
| |
origins.
"""
return pulumi.get(self, "web_origins")
@web_origins.setter
def web_origins(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
pulumi.set(self, "web_origins", value)
class Client(pulumi.CustomResource):
@overload
def __init__(__self__,
resource_name: str,
opts: Optional[pulumi.ResourceOptions] = None,
access_token_lifespan: Optional[pulumi.Input[str]] = None,
access_type: Optional[pulumi.Input[str]] = None,
admin_url: Optional[pulumi.Input[str]] = None,
authentication_flow_binding_overrides: Optional[pulumi.Input[pulumi.InputType['ClientAuthenticationFlowBindingOverridesArgs']]] = None,
authorization: Optional[pulumi.Input[pulumi.InputType['ClientAuthorizationArgs']]] = None,
backchannel_logout_revoke_offline_sessions: Optional[pulumi.Input[bool]] = None,
backchannel_logout_session_required: Optional[pulumi.Input[bool]] = None,
backchannel_logout_url: Optional[pulumi.Input[str]] = None,
base_url: Optional[pulumi.Input[str]] = None,
client_id: Optional[pulumi.Input[str]] = None,
client_offline_session_idle_timeout: Optional[pulumi.Input[str]] = None,
client_offline_session_max_lifespan: Optional[pulumi.Input[str]] = None,
client_secret: Optional[pulumi.Input[str]] = None,
client_session_idle_timeout: Optional[pulumi.Input[str]] = None,
client_session_max_lifespan: Optional[pulumi.Input[str]] = None,
consent_required: Optional[pulumi.Input[bool]] = None,
description: Optional[pulumi.Input[str]] = None,
direct_access_grants_enabled: Optional[pulumi.Input[bool]] = None,
enabled: Optional[pulumi.Input[bool]] = None,
exclude_session_state_from_auth_response: Optional[pulumi.Input[bool]] = None,
extra_config: Optional[pulumi.Input[Mapping[str, Any]]] = None,
full_scope_allowed: Optional[pulumi.Input[bool]] = None,
implicit_flow_enabled: Optional[pulumi.Input[bool]] = None,
login_theme: Optional[pulumi.Input[str]] = None,
name: Optional[pulumi.Input[str]] = None,
pkce_code_challenge_method: Optional[pulumi.Input[str]] = None,
realm_id: Optional[pulumi.Input[str]] = None,
root_url: Optional[pulumi.Input[str]] = None,
service_accounts_enabled: Optional[pulumi.Input[bool]] = None,
standard_flow_enabled: Optional[pulumi.Input[bool]] = None,
use_refresh_tokens: Optional[pulumi.Input[bool]] = None,
valid_redirect_uris: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
web_origins: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
__props__=None):
"""
Allows for creating and managing Keycloak clients that use the OpenID Connect protocol.
Clients are entities that can use Keycloak for user authentication. Typically,
clients are applications that redirect users to Keycloak for authentication
in order to take advantage of Keycloak's user sessions for SSO.
## Example Usage
```python
import pulumi
import pulumi_keycloak as keycloak
realm = keycloak.Realm("realm",
realm="my-realm",
enabled=True)
openid_client = keycloak.openid.Client("openidClient",
realm_id=realm.id,
client_id="test-client",
enabled=True,
access_type="CONFIDENTIAL",
valid_redirect_uris=["http://localhost:8080/openid-callback"],
login_theme="keycloak",
extra_config={
"key1": "value1",
"key2": "value2",
})
```
## Import
Clients can be imported using the format `{{realm_id}}/{{client_keycloak_id}}`, where `client_keycloak_id` is the unique ID that Keycloak assigns to the client upon creation. This value can be found in the URI when editing this client in the GUI, and is typically a GUID. Examplebash
```sh
$ pulumi import keycloak:openid/client:Client openid_client my-realm/dcbc4c73-e478-4928-ae2e-d5e420223352
```
:param str resource_name: The name of the resource.
:param pulumi.ResourceOptions opts: Options for the resource.
:param pulumi.Input[str] access_token_lifespan: The amount of time in seconds before an access token expires. This will override the default for the realm.
:param pulumi.Input[str] access_type: Specifies the type of client, which can be one of the following:
:param pulumi.Input[str] admin_url: URL to the admin interface of the client.
:param pulumi.Input[pulumi.InputType['ClientAuthenticationFlowBindingOverridesArgs']] authentication_flow_binding_overrides: Override realm authentication flow bindings
:param pulumi.Input[pulumi.InputType['ClientAuthorizationArgs']] authorization: When this block is present, fine-grained authorization will be enabled for this client. The client's `access_type` must be `CONFIDENTIAL`, and `service_accounts_enabled` must be `true`. This block has the following arguments:
:param pulumi.Input[bool] backchannel_logout_revoke_offline_sessions: Specifying whether a "revoke_offline_access" event is included in the Logout Token when the Backchannel Logout URL is used. Keycloak will revoke offline sessions when receiving a Logout Token with this event.
:param pulumi.Input[bool] backchannel_logout_session_required: When `true`, a sid (session ID) claim will be included in the logout token when the backchannel logout URL is used. Defaults to `true`.
:param pulumi.Input[str] backchannel_logout_url: The URL that will cause the client to log itself out when a logout request is sent to this realm. If omitted, no logout request will be sent to the client is this case.
:param pulumi.Input[str] base_url: Default URL to use when the auth server needs to redirect or link back to the client.
:param pulumi.Input[str] client_id: The Client ID for this client, referenced in the URI during authentication and in issued tokens.
:param pulumi.Input[str] client_offline_session_idle_timeout: Time a client session is allowed to be idle before it expires. Tokens are invalidated when a client session is expired. If not set it uses the standard SSO Session Idle value.
:param pulumi.Input[str] client_offline_session_max_lifespan: Max time before a client session is expired. Tokens are invalidated when a client session is expired. If not set, it uses the standard SSO Session Max value.
:param pulumi.Input[str] client_secret: The secret for clients with an `access_type` of `CONFIDENTIAL` or `BEARER-ONLY`. This value is sensitive and should be treated with the same care as a password. If omitted, this will be generated by Keycloak.
:param pulumi.Input[str] client_session_idle_timeout: Time a client offline session is allowed to be idle before it expires. Offline tokens are invalidated when a client offline session is expired. If not set it uses the Offline Session Idle value.
:param pulumi.Input[str] client_session_max_lifespan: Max time before a client offline session is expired. Offline tokens are invalidated when a client offline session is expired. If not set, it uses the Offline Session Max value.
:param pulumi.Input[bool] consent_required: When `true`, users have to consent to client access.
:param pulumi.Input[str] description: The description of this client in the GUI.
:param pulumi.Input[bool] direct_access_grants_enabled: When `true`, the OAuth2 Resource Owner Password Grant will be enabled for this client. Defaults to `false`.
:param pulumi.Input[bool] enabled: When `false`, this client will not be able to initiate a login or obtain access tokens. Defaults to `true`.
:param pulumi.Input[bool] exclude_session_state_from_auth_response: When `true`, the parameter `session_state` will not be included in OpenID Connect Authentication Response.
:param pulumi.Input[bool] full_scope_allowed: Allow to include all roles mappings in the access token.
:param pulumi.Input[bool] implicit_flow_enabled: When `true`, the OAuth2 Implicit Grant will be enabled for this client. Defaults to `false`.
:param pulumi.Input[str] login_theme: The client login theme. This will override the default theme for the realm.
:param pulumi.Input[str] name: The display name of this client in the GUI.
:param pulumi.Input[str] pkce_code_challenge_method: The challenge method to use for Proof Key for Code Exchange. Can be either `plain` or `S256` or set to empty value ``.
:param pulumi.Input[str] realm_id: The realm this client is attached to.
:param pulumi.Input[str] root_url: When specified, this URL is prepended to any relative URLs found within `valid_redirect_uris`, `web_origins`, and `admin_url`. NOTE: Due to limitations in the Keycloak API, when the `root_url` attribute is used, the `valid_redirect_uris`, `web_origins`, and `admin_url` attributes will be required.
:param pulumi.Input[bool] service_accounts_enabled: When `true`, the OAuth2 Client Credentials grant will be enabled for this client. Defaults to `false`.
:param pulumi.Input[bool] standard_flow_enabled: When `true`, the OAuth2 Authorization Code Grant will be enabled for this client. Defaults to `false`.
:param pulumi.Input[bool] use_refresh_tokens: If this is `true`, a refresh_token will be created and added to the token response. If this is `false` then no refresh_token will be generated. Defaults to `true`.
:param pulumi.Input[Sequence[pulumi.Input[str]]] valid_redirect_uris: A list of valid URIs a browser is permitted to redirect to after a successful login or logout. Simple
wildcards in the form of an asterisk can be used here. This attribute must be set if either `standard_flow_enabled` or `implicit_flow_enabled`
is set to `true`.
:param pulumi.Input[Sequence[pulumi.Input[str]]] web_origins: A list of allowed CORS origins. `+` can be used to permit all valid redirect URIs, and `*` can be used to permit all origins.
"""
...
@overload
def __init__(__self__,
resource_name: str,
args: ClientArgs,
opts: Optional[pulumi.ResourceOptions] = None):
"""
Allows for creating and managing Keycloak clients that use the OpenID Connect protocol.
Clients are entities that can use Keycloak for user authentication. Typically,
clients are applications that redirect users to Keycloak for authentication
in order to take advantage of Keycloak's user sessions for SSO.
## Example Usage
```python
import pulumi
import pulumi_keycloak as keycloak
realm = keycloak.Realm("realm",
realm="my-realm",
enabled=True)
openid_client = keycloak.openid.Client("openidClient",
realm_id=realm.id,
client_id="test-client",
enabled=True,
access_type="CONFIDENTIAL",
valid_redirect_uris=["http://localhost:8080/openid-callback"],
login_theme="keycloak",
extra_config={
"key1": "value1",
"key2": "value2",
})
```
## Import
Clients can be imported using the format `{{realm_id}}/{{client_keycloak_id}}`, where `client_keycloak_id` is the unique ID that Keycloak assigns to the client upon creation. This value can be found in the URI when editing this client in the GUI, and is typically a GUID. Examplebash
```sh
$ pulumi import keycloak:openid/client:Client openid_client my-realm/dcbc4c73-e478-4928-ae2e-d5e420223352
```
:param str resource_name: The name of the resource.
:param ClientArgs args: The arguments to use to populate this resource's properties.
:param pulumi.ResourceOptions opts: Options for the resource.
"""
...
def __init__(__self__, resource_name: str, *args, **kwargs):
resource_args, opts = _utilities.get_resource_args_opts(ClientArgs, pulumi.ResourceOptions, *args, **kwargs)
if resource_args is not None:
__self__._internal_init(resource_name, opts, **resource_args.__dict__)
else:
__self__._internal_init(resource_name, *args, **kwargs)
def _internal_init(__self__,
resource_name: str,
opts: Optional[pulumi.ResourceOptions] = None,
access_token_lifespan: Optional[pulumi.Input[str]] = None,
access_type: Optional[pulumi.Input[str]] = None,
admin_url: Optional[pulumi.Input[str]] = | |
***" % interaction.action.utterance)
super().add_interaction(interaction)
interaction.action.success = 1
return # noqa R502
elif action_type == "Audio":
if interaction.agent_id == 0: # Commander
self.logger.info("*** Commander - Audio: %s ***" % interaction.action.utterance)
else:
self.logger.info("*** Driver - Audio: %s ***" % interaction.action.utterance)
super().add_interaction(interaction)
interaction.action.success = 1
return # noqa R502
else:
logger.warning("%s: Not supported" % interaction.action.action_type)
interaction.action.success = 0
return # noqa R502
def __update_custom_coffee_prop(self, event, objs_before_event=None):
"""
Check whether coffee has been made and update custom property - this uses get_parent_receptacles() for extra
reliability and checks that a container just got placed in a coffee maker and the coffee maker was on
"""
cur_objects = self.get_objects(event)
coffee_maker_ids = set(
[obj["objectId"] for obj in cur_objects if "CoffeeMachine" in obj["objectType"] and obj["isToggled"]]
)
for obj in cur_objects:
prev_filled_with_liquid = False
if objs_before_event is not None:
prev_state = self.__get_object_by_id(objs_before_event, obj["objectId"])
if prev_state:
prev_filled_with_liquid = prev_state["isFilledWithLiquid"]
parent_receptacles = self.get_parent_receptacles(obj, cur_objects)
placed_in_toggled_coffee_maker = False
if parent_receptacles is not None and len(set(parent_receptacles).intersection(coffee_maker_ids)) > 0:
placed_in_toggled_coffee_maker = True
if (
placed_in_toggled_coffee_maker
and obj["canFillWithLiquid"]
and obj["isFilledWithLiquid"]
and not prev_filled_with_liquid
):
self.__update_custom_object_metadata(obj["objectId"], "simbotIsFilledWithCoffee", True)
def __update_sink_interaction_outcomes(self, event):
"""
Force sink behaviour to be deterministic - if a faucet is turned on, clean all objects in the sink and
fill objects that can be filled with water
"""
cur_objects = self.get_objects(event)
sink_objects = list()
for obj in cur_objects:
# Check if any sink basin is filled with water and clean all dirty objects in.
if (
"SinkBasin" in obj["objectType"]
or "Sink" in obj["objectType"]
or "BathtubBasin" in obj["objectType"]
or "Bathtub" in obj["objectType"]
):
# Fetch the faucet near the sink
faucet_obj = self.__get_object_by_position(self.get_objects(event), obj["position"], obj_type="Faucet")
if faucet_obj["isToggled"]:
sink_objects.append(obj)
sink_obj_ids = set([obj["objectId"] for obj in sink_objects])
objs_in_sink = list()
for obj in cur_objects:
parent_receptacles = self.get_parent_receptacles(obj, cur_objects)
if parent_receptacles is not None:
if len(set(parent_receptacles).intersection(sink_obj_ids)) > 0:
objs_in_sink.append(obj)
for child_obj in objs_in_sink:
if child_obj["isDirty"]:
ac = dict(action="CleanObject", objectId=child_obj["objectId"], forceAction=True)
if debug_print_all_sim_steps:
logger.info("step %s", ac)
self.controller.step(ac)
if child_obj["canFillWithLiquid"]:
ac = dict(
action="FillObjectWithLiquid", objectId=child_obj["objectId"], fillLiquid="water", forceAction=True
)
if debug_print_all_sim_steps:
logger.info("step %s", ac)
self.controller.step(ac)
self.__update_custom_object_metadata(child_obj["objectId"], "simbotIsFilledWithWater", 1)
def __thor_error_to_help_message(self, msg):
"""
Translate AI2-THOR errorMessage field into something that can be shown as prompts to annotators for TEACh data
collection
"""
# Example: "Floor|+00.00|+00.00|+00.00 must have the property CanPickup to be picked up." # noqa: E800
if "CanPickup to be" in msg:
return 'Object "%s" can\'t be picked up.' % msg.split()[0].split("|")[0]
# Example: "Object ID appears to be invalid." # noqa: E800
if ("Object ID" in msg and "invalid" in msg) or "Could not retrieve object" in msg:
return "Could not determine what object was clicked."
# Example "Can't place an object if Agent isn't holding anything # noqa: E800
if "if Agent isn't holding" in msg:
return "Must be holding an object first."
# Example: "Slice: ObjectInteraction only supported for held object Knife" # noqa: E800
if "Slice: ObjectInteraction" in msg:
return "Must be holding a knife."
# Example: "object is not toggleable" # noqa: E800
if "not toggleable" in msg:
return "Object cannot be turned on or off."
# Example: "can't toggle object off if it's already off!" # noqa: E800
if "toggle object off if" in msg:
return "Object is already turned off."
# Example: "can't toggle object on if it's already on!" # noqa: E800
if "toggle object on if" in msg:
return "Object is already turned on."
# Example: "CounterTop|-00.08|+01.15|00.00 is not an Openable object" # noqa: E800
if "is not an Openable object" in msg:
return 'Object "%s" can\'t be opened.' % msg.split()[0].split("|")[0]
# Example: "CounterTop_d7cc8dfe Does not have the CanBeSliced property!" # noqa: E800
if "Does not have the CanBeSliced" in msg:
return "Object cannot be sliced."
# Example: "Object failed to open/close successfully." # noqa: E800
if "failed to open/close" in msg:
return "Something is blocking the object from opening or closing. Move farther away or remove obstruction."
# Example: "StandardIslandHeight is blocking Agent 0 from moving 0" # noqa: E800
if "is blocking" in msg:
return "Something is blocking the robot from moving in that direction."
# Example: "a held item: Book_3d15d052 with something if agent rotates Right 90 degrees" # noqa: E800
if "a held item" in msg and "if agent rotates" in msg:
return "The held item will collide with something if the robot turns that direction."
# Example: "No valid positions to place object found" # noqa: E800
if "No valid positions to place" in msg:
return "The receptacle is too full or too small to contain the held item."
# Example: "This target object is NOT a receptacle!" # noqa: E800
if "NOT a receptacle" in msg:
return "Object is not a receptacle the robot can place items in."
# Example: "Target must be OFF to open!" # noqa: E800
if "OFF to open!" in msg:
return "Object must be turned off before it can be opened."
# Example: "cracked_egg_5(Clone) is not a valid Object Type to be placed in StoveBurner_58b674c4" # noqa: E800
if "not a valid Object Type to be placed" in msg:
return "Held object cannot be placed there."
# Example: "No target found" # noqa: E800
if "No target found" in msg:
return "No reachable object at that location."
# Example: "Knife|-01.70|+01.71|+04.01 is not interactable and (perhaps it is occluded by something)." # noqa: E800
if "it is occluded by something" in msg:
return "An object is blocking you from interacting with the selected object."
# "Could not find a target object at the specified location" # noqa: E800
if "Could not find a target object" in msg:
return "No valid object at that location."
# "another object's collision is blocking held object from being placed" # noqa: E800
if "another object's collision is blocking" in msg:
return "The target area is too cluttered or the held object is already colliding with something."
# "CounterTop|+00.69|+00.95|-02.48 is too far away to be interacted with" # noqa: E800
if "too far away to" in msg:
return "That object is too far away to interact with."
# "Your partner is too far away for a handoff." # noqa: E800
if "too far away for" in msg:
return "Your partner is too far away for a handoff."
# "Place: ObjectInteraction only supported when holding an object" # noqa: E800
if "only supported when holding" in msg:
return "You are not holding an object."
# "Picking up object would cause it to collide and clip into something!" # noqa: E800
if "would cause it to collide and" in msg:
return "Cannot grab object from here without colliding with something."
# "You cannot slice something while your partner is holding it." # noqa: E800
if "cannot slice something while" in msg:
return msg
# If msg couldn't be handled, don't create a readable system message
return None
def get_hotspots(
self,
agent_id,
hotspot_pixel_width=None,
action_str=None,
object_id=None,
camera_id=None,
return_full_seg_mask=False,
):
"""
Return a segmentation mask highlighting object(s) in an egocentric image
:param agent_id: the agent whose image needs to be highlighted; 0 for Commander and 1 for Driver/ Follower
:param hotspot_pixel_width: Minimum hotspot size
:param action_str: Highlight objects on which this action can be performed
:param object_id: Specify object to be highlighted using object ID
:param camera_id: Generate segmentation mask for a disembodied camera with this ID instead of for an agent
:param return_full_seg_mask: additional flag to highlight a single object specified by object_id
"""
assert not return_full_seg_mask or object_id is not None
assert (action_str is None or object_id is None) and not (action_str is not None and object_id is not None)
assert agent_id is None or camera_id is None
if hotspot_pixel_width is None:
hotspot_pixel_width = self.hotspot_pixel_width
if agent_id is not None:
sim_agent_id = agent_id if self.commander_embodied else 0
le = (
self.controller.last_event.events[sim_agent_id]
if self.commander_embodied
else self.controller.last_event
)
# Take a no-op step to render the object segmentation frame for hotspots.
if | |
<reponame>aledelmo/3DSlicer_Plugins
import os
import string
import time
import unittest
from builtins import range
try:
from itertools import izip as zip
except ImportError:
pass
import RegistrationLib
from __main__ import vtk, qt, ctk, slicer
import MyRegistrationLib
class BonesSegmentation:
def __init__(self, parent):
parent.title = "Bones"
parent.categories = ['IMAG2', "Pelvic Segmentation"]
parent.dependencies = []
parent.contributors = ["<NAME>, <NAME>' (IMAG2)"]
parent.helpText = string.Template("""
This module performs the semiautomatic segmentation of the pelvic bones on T2w MRI.
""").substitute({'a': parent.slicerWikiUrl, 'b': slicer.app.majorVersion, 'c': slicer.app.minorVersion})
parent.acknowledgementText = """
.....
""" # replace with organization, grant and thanks.
self.parent = parent
# IMAG2: Add the corresponding icon to the module
self.moduleName = self.__class__.__name__
moduleDir = os.path.dirname(self.parent.path)
iconPath = os.path.join(moduleDir, 'Resources', 'icon.jpg')
if os.path.isfile(iconPath):
parent.icon = qt.QIcon(iconPath)
try:
slicer.selfTests
except AttributeError:
slicer.selfTests = {}
slicer.selfTests['BonesSegmentation'] = self.runTest
def runTest(self):
tester = BonesSegmentationTest()
tester.runTest()
class BonesSegmentationWidget:
"""The module GUI widget"""
def __init__(self, parent=None):
settings = qt.QSettings()
try:
self.developerMode = settings.value('Developer/DeveloperMode').lower() == 'true'
except AttributeError:
self.developerMode = settings.value('Developer/DeveloperMode') is True
self.logic = BonesSegmentationLogic()
self.logic.registationState = self.registationState
self.sliceNodesByViewName = {}
self.sliceNodesByVolumeID = {}
self.observerTags = []
self.viewNames = ("Fixed", "Moving", "Transformed")
self.volumeSelectDialog = None
self.currentRegistrationInterface = None
self.currentLocalRefinementInterface = None
if not parent:
self.parent = slicer.qMRMLWidget()
self.parent.setLayout(qt.QVBoxLayout())
self.parent.setMRMLScene(slicer.mrmlScene)
else:
self.parent = parent
self.layout = self.parent.layout()
if not parent:
self.setup()
self.parent.show()
def setup(self):
"""Instantiate and connect widgets ..."""
self.selectVolumesButton = qt.QPushButton("Show Pop-Up Selector")
self.selectVolumesButton.connect('clicked(bool)', self.enter)
self.layout.addWidget(self.selectVolumesButton)
#
# IMAG2: Apply Button (harden transform + image resampling)
#
self.applyButton = qt.QPushButton("Segment")
self.applyButton.toolTip = "Segment!"
self.applyButton.enabled = True
self.layout.addWidget(self.applyButton)
self.applyButton.connect('clicked(bool)', self.onApplyButton)
self.interfaceFrame = qt.QWidget(self.parent)
self.interfaceFrame.setLayout(qt.QVBoxLayout())
self.layout.addWidget(self.interfaceFrame)
#
# Parameters Area
#
parametersCollapsibleButton = ctk.ctkCollapsibleButton()
parametersCollapsibleButton.text = "Hips Segmentation"
self.interfaceFrame.layout().addWidget(parametersCollapsibleButton)
parametersFormLayout = qt.QFormLayout(parametersCollapsibleButton)
self.volumeSelectors = {}
for viewName in self.viewNames:
self.volumeSelectors[viewName] = slicer.qMRMLNodeComboBox()
self.volumeSelectors[viewName].nodeTypes = (("vtkMRMLScalarVolumeNode"), "")
self.volumeSelectors[viewName].selectNodeUponCreation = False
self.volumeSelectors[viewName].addEnabled = False
self.volumeSelectors[viewName].removeEnabled = True
self.volumeSelectors[viewName].noneEnabled = True
self.volumeSelectors[viewName].showHidden = False
self.volumeSelectors[viewName].showChildNodeTypes = True
self.volumeSelectors[viewName].setMRMLScene(slicer.mrmlScene)
self.volumeSelectors[viewName].setToolTip("Pick the %s volume." % viewName.lower())
self.volumeSelectors[viewName].enabled = False
# parametersFormLayout.addRow("%s Volume " % viewName, self.volumeSelectors[viewName])
self.volumeSelectors["Transformed"].addEnabled = True
self.volumeSelectors["Transformed"].selectNodeUponCreation = True
self.volumeSelectors["Transformed"].setToolTip(
"Pick the transformed volume, which is the target for the registration.")
self.transformSelector = slicer.qMRMLNodeComboBox()
self.transformSelector.nodeTypes = (("vtkMRMLTransformNode"), "")
self.transformSelector.selectNodeUponCreation = True
self.transformSelector.addEnabled = True
self.transformSelector.removeEnabled = True
self.transformSelector.noneEnabled = True
self.transformSelector.showHidden = False
self.transformSelector.showChildNodeTypes = False
self.transformSelector.setMRMLScene(slicer.mrmlScene)
self.transformSelector.setToolTip("The transform for linear registration")
self.transformSelector.enabled = False
# parametersFormLayout.addRow("Target Transform ", self.transformSelector)
self.visualizationWidget = RegistrationLib.VisualizationWidget(self.logic)
self.visualizationWidget.connect("layoutRequested(mode,volumesToShow)", self.onLayout)
parametersFormLayout.addRow(self.visualizationWidget.widget)
#
# IMAG2: Landmarks Widget - just the add button changing the RegistrationLib into MyRegistrationLib
# - manages landmarks
#
# self.landmarksWidget = MyRegistrationLib.myLandmarksWidget(self.logic)
# self.landmarksWidget.connect("landmarkPicked(landmarkName)", self.onLandmarkPicked)
# self.landmarksWidget.connect("landmarkMoved(landmarkName)", self.onLandmarkMoved)
# self.landmarksWidget.connect("landmarkEndMoving(landmarkName)", self.onLandmarkEndMoving)
# parametersFormLayout.addRow(self.landmarksWidget.widget)
self.landmarksWidget = RegistrationLib.LandmarksWidget(self.logic)
self.landmarksWidget.connect("landmarkPicked(landmarkName)", self.onLandmarkPicked)
self.landmarksWidget.connect("landmarkMoved(landmarkName)", self.onLandmarkMoved)
self.landmarksWidget.connect("landmarkEndMoving(landmarkName)", self.onLandmarkEndMoving)
parametersFormLayout.addRow(self.landmarksWidget.widget)
#
# Registration Options
#
self.registrationCollapsibleButton = ctk.ctkCollapsibleButton()
self.registrationCollapsibleButton.text = "Registration"
# self.interfaceFrame.layout().addWidget(self.registrationCollapsibleButton)
registrationFormLayout = qt.QFormLayout(self.registrationCollapsibleButton)
#
# registration type selection
# - allows selection of the active registration type to display
#
try:
slicer.modules.registrationPlugins
except AttributeError:
slicer.modules.registrationPlugins = {}
self.registrationTypeBox = qt.QGroupBox("Registration Type")
self.registrationTypeBox.setLayout(qt.QFormLayout())
self.registrationTypeButtons = {}
self.registrationTypes = slicer.modules.registrationPlugins.keys()
self.registrationTypes.sort()
for registrationType in self.registrationTypes:
plugin = slicer.modules.registrationPlugins[registrationType]
if plugin.name == "ThinPlate Registration":
self.onRegistrationType(registrationType)
# connections
for selector in self.volumeSelectors.values():
selector.connect("currentNodeChanged(vtkMRMLNode*)", self.onVolumeNodeSelect)
# listen to the scene
self.addObservers()
# Add vertical spacer
self.layout.addStretch(1)
if self.developerMode:
def create_hor_layout(elements):
widget = qt.QWidget()
row_layout = qt.QHBoxLayout()
widget.setLayout(row_layout)
for element in elements:
row_layout.addWidget(element)
return widget
"""Developer interface"""
reload_collapsible_button = ctk.ctkCollapsibleButton()
reload_collapsible_button.text = "Reload && Test"
self.layout.addWidget(reload_collapsible_button)
reload_form_layout = qt.QFormLayout(reload_collapsible_button)
reload_button = qt.QPushButton("Reload")
reload_button.toolTip = "Reload this module."
reload_button.name = "ScriptedLoadableModuleTemplate Reload"
reload_button.connect('clicked()', self.onReload)
reload_and_test_button = qt.QPushButton("Reload and Test")
reload_and_test_button.toolTip = "Reload this module and then run the self tests."
reload_and_test_button.connect('clicked()', self.onReloadAndTest)
edit_source_button = qt.QPushButton("Edit")
edit_source_button.toolTip = "Edit the module's source code."
edit_source_button.connect('clicked()', self.on_edit_source)
restart_button = qt.QPushButton("Restart Slicer")
restart_button.toolTip = "Restart Slicer"
restart_button.name = "ScriptedLoadableModuleTemplate Restart"
restart_button.connect('clicked()', slicer.app.restart)
reload_form_layout.addWidget(
create_hor_layout([reload_button, reload_and_test_button, edit_source_button, restart_button]))
def onApplyButton(self):
fix = self.volumeSelectors['Fixed'].currentNode() # fixed image
mov = self.volumeSelectors['Moving'].currentNode() # moving image
trans = self.volumeSelectors['Transformed'].currentNode() # transformed image
transName = "%s-transformed" % mov.GetName()
try:
transNode = slicer.util.getNode(transName)
except slicer.util.MRMLNodeNotFoundException:
transNode = None
fixName = fix.GetName()
fixNode = slicer.util.getNode(fixName)
slicer.util.showStatusMessage("Processing...", 2000)
# IMAG2: harden transform
transLogic = slicer.modules.transforms.logic()
transLogic.hardenTransform(transNode)
# IMAG2: resample image
resample = slicer.modules.brainsresample
parametersRes = {}
parametersRes['inputVolume'] = trans.GetID()
parametersRes['referenceVolume'] = fix.GetID()
parametersRes['outputVolume'] = trans.GetID()
parametersRes['pixelType'] = 'uint'
parametersRes['interpolationMode'] = 'NearestNeighbor'
slicer.cli.run(resample, None, parametersRes, wait_for_completion=True)
# IMAG2: reset the correct origins of the images (they were previously changed during the registration procedure)
fix.SetOrigin(self.FixOrigin)
trans.SetOrigin(self.FixOrigin)
# IMAG2: segmentation step (partial - just thresholding)
SlicerModule = slicer.modules.thresholdscalarvolume
ModelLogic = SlicerModule.cliModuleLogic()
CreateLogic = ModelLogic.CreateNode()
# inputNode=slicer.util.getNode('scanner15ansM')
inputNode = transNode
inputNodeMRI = fixNode
outputNode = slicer.vtkMRMLLabelMapVolumeNode()
# outputNode.SetName("%s-Bones-label" % inputNode.GetName())
outputNode.SetName("%s-Bones-label" % fix.GetName())
outputNode.SetScene(slicer.mrmlScene)
slicer.mrmlScene.AddNode(outputNode)
parametersTh = {}
parametersTh['InputVolume'] = inputNode.GetID()
parametersTh['OutputVolume'] = outputNode.GetID()
parametersTh['ThresholdType'] = 'Above'
parametersTh['ThresholdValue'] = 0.9
parametersTh['Lower'] = -200
parametersTh['Upper'] = 200
parametersTh['OutsideValue'] = 2
CLINode = None
CLINode = slicer.cli.run(slicer.modules.thresholdscalarvolume, None, parametersTh, wait_for_completion=True)
bonesParams = {}
bonesParams['inputvolumeMR'] = inputNodeMRI.GetID()
bonesParams['inputvolumePRE'] = inputNode.GetID()
bonesParams['outputvolume'] = outputNode.GetID()
CLINode_b = None
CLINode_b = slicer.cli.run(slicer.modules.bonesseg, None, bonesParams, wait_for_completion=True)
display = outputNode.GetDisplayNode()
try:
labelColorTable = slicer.util.getNode('GenericAnatomyColors')
except slicer.util.MRMLNodeNotFoundException:
labelColorTable = None
display.SetAndObserveColorNodeID(labelColorTable.GetID())
# IMAG2: model maker
modelParams = {}
modelParams['Name'] = fix.GetName() + '-Bones'
modelParams["InputVolume"] = outputNode.GetID()
modelParams['FilterType'] = "Sinc"
modelParams['Labels'] = 2
modelParams["StartLabel"] = -1
modelParams["EndLabel"] = -1
modelParams['GenerateAll'] = False
modelParams["JointSmoothing"] = False
modelParams["SplitNormals"] = True
modelParams["PointNormals"] = True
modelParams["SkipUnNamed"] = True
modelParams["Decimate"] = 0.25
modelParams["Smooth"] = 30
# - make a new hierarchy node if needed
#
numNodes = slicer.mrmlScene.GetNumberOfNodesByClass("vtkMRMLModelHierarchyNode")
outHierarchy = None
for n in range(numNodes):
node = slicer.mrmlScene.GetNthNodeByClass(n, "vtkMRMLModelHierarchyNode")
if node.GetName() == "Bones Models":
outHierarchy = node
break
if not outHierarchy:
outHierarchy = slicer.vtkMRMLModelHierarchyNode()
outHierarchy.SetScene(slicer.mrmlScene)
outHierarchy.SetName("Bones Models")
slicer.mrmlScene.AddNode(outHierarchy)
modelParams["ModelSceneFile"] = outHierarchy
modelMaker = slicer.modules.modelmaker
slicer.cli.run(modelMaker, None, modelParams)
slicer.util.showStatusMessage("3D Model Making Started...", 2000)
# IMAG2: switch to the four up view
LayoutWidget = slicer.qMRMLLayoutWidget()
LayoutWidget.setMRMLScene(slicer.mrmlScene)
LayoutWidget.setLayout(slicer.vtkMRMLLayoutNode.SlicerLayoutFourUpView)
# IMAG2: center 3D View
layoutManager = slicer.app.layoutManager()
threeDWidget = layoutManager.threeDWidget(0)
threeDView = threeDWidget.threeDView()
threeDView.resetFocalPoint()
# IMAG2: assign background and label volumes
red_logic = layoutManager.sliceWidget("Red").sliceLogic()
red_cn = red_logic.GetSliceCompositeNode()
red_cn.SetBackgroundVolumeID(fix.GetID())
red_cn.SetLabelVolumeID(outputNode.GetID())
red_cn.SetLabelOpacity(0.8)
green_logic = layoutManager.sliceWidget("Green").sliceLogic()
green_cn = green_logic.GetSliceCompositeNode()
green_cn.SetBackgroundVolumeID(fix.GetID())
green_cn.SetLabelVolumeID(outputNode.GetID())
green_cn.SetLabelOpacity(0.8)
yellow_logic = layoutManager.sliceWidget("Yellow").sliceLogic()
yellow_cn = yellow_logic.GetSliceCompositeNode()
yellow_cn.SetBackgroundVolumeID(fix.GetID())
yellow_cn.SetLabelVolumeID(outputNode.GetID())
yellow_cn.SetLabelOpacity(0.8)
# IMAG2: center slice views
red_logic.FitSliceToAll()
green_logic.FitSliceToAll()
yellow_logic.FitSliceToAll()
mark_nodes = slicer.mrmlScene.GetNodesByClass('vtkMRMLMarkupsFiducialNode')
mark_nodes.UnRegister(slicer.mrmlScene)
mark_nodes.InitTraversal()
mark_node = mark_nodes.GetNextItemAsObject()
while mark_node:
if mov.GetName() in mark_node.GetName() or fix.GetName() in mark_node.GetName() or mark_node == 'F':
slicer.mrmlScene.RemoveNode(mark_node)
mark_node = mark_nodes.GetNextItemAsObject()
vol_nodes = slicer.mrmlScene.GetNodesByClass('vtkMRMLVolumeNode')
vol_nodes.UnRegister(slicer.mrmlScene)
vol_nodes.InitTraversal()
vol_node = vol_nodes.GetNextItemAsObject()
while vol_node:
if mov.GetName() in vol_node.GetName():
slicer.mrmlScene.RemoveNode(vol_node)
vol_node = vol_nodes.GetNextItemAsObject()
def enter(self):
self.interfaceFrame.enabled = False
self.setupDialog()
def setupDialog(self):
"""setup dialog"""
if not self.volumeSelectDialog:
self.volumeSelectDialog = qt.QDialog(slicer.util.mainWindow())
self.volumeSelectDialog.objectName = 'BonesSegmentationVolumeSelect'
self.volumeSelectDialog.setLayout(qt.QVBoxLayout())
self.volumeSelectLabel = qt.QLabel()
self.volumeSelectDialog.layout().addWidget(self.volumeSelectLabel)
self.volumeSelectorFrame = qt.QFrame()
self.volumeSelectorFrame.objectName = 'VolumeSelectorFrame'
self.volumeSelectorFrame.setLayout(qt.QFormLayout())
self.volumeSelectDialog.layout().addWidget(self.volumeSelectorFrame)
self.volumeDialogSelectors = {}
# #IMAG2:
self.volumeDialogSelectors['Fixed'] = slicer.qMRMLNodeComboBox()
self.volumeDialogSelectors['Fixed'].nodeTypes = (("vtkMRMLScalarVolumeNode"), "")
self.volumeDialogSelectors['Fixed'].selectNodeUponCreation = False
self.volumeDialogSelectors['Fixed'].addEnabled = False
self.volumeDialogSelectors['Fixed'].removeEnabled = True
self.volumeDialogSelectors['Fixed'].noneEnabled = True
self.volumeDialogSelectors['Fixed'].showHidden = False
self.volumeDialogSelectors['Fixed'].showChildNodeTypes = True
self.volumeDialogSelectors['Fixed'].setMRMLScene(slicer.mrmlScene)
self.volumeDialogSelectors['Fixed'].setToolTip("Pick the MRI volume of the patient.")
self.volumeSelectorFrame.layout().addRow("Patient MRI", self.volumeDialogSelectors['Fixed'])
self.volumeButtonFrame = qt.QFrame()
self.volumeButtonFrame.objectName = 'VolumeButtonFrame'
self.volumeButtonFrame.setLayout(qt.QHBoxLayout())
self.volumeSelectDialog.layout().addWidget(self.volumeButtonFrame)
# IMAG2: buttons for the age and the sex selection
# Define the sex button
self.SexButton = qt.QComboBox()
self.SexButton.addItem('Male')
self.SexButton.addItem('Female')
self.volumeSelectorFrame.layout().addRow("Sex", self.SexButton)
# Define the age button
self.AgeButton = qt.QSpinBox()
self.AgeButton.setRange(0, 20)
self.volumeSelectorFrame.layout().addRow("Age", self.AgeButton)
self.volumeDialogApply = qt.QPushButton("Apply", self.volumeButtonFrame)
self.volumeDialogApply.objectName = 'VolumeDialogApply'
self.volumeDialogApply.setToolTip("Use currently selected volume nodes.")
self.volumeButtonFrame.layout().addWidget(self.volumeDialogApply)
self.volumeDialogCancel = qt.QPushButton("Cancel", self.volumeButtonFrame)
self.volumeDialogCancel.objectName = 'VolumeDialogCancel'
self.volumeDialogCancel.setToolTip("Cancel current operation.")
self.volumeButtonFrame.layout().addWidget(self.volumeDialogCancel)
self.volumeDialogApply.connect("clicked()", self.onVolumeDialogApply)
self.volumeDialogCancel.connect("clicked()", self.volumeSelectDialog.hide)
self.volumeSelectLabel.setText("Insert the patient information")
self.volumeSelectDialog.show()
def onVolumeDialogApply(self):
self.volumeSelectDialog.hide()
sexLabel = self.SexButton.currentIndex
# ageLabel=self.AgeButton.currentIndex
ageLabel = self.AgeButton.value
moduleName = 'BonesSegmentation'
filePath = eval('slicer.modules.%s.path' % moduleName.lower())
ModuleDir = os.path.dirname(filePath)
# Loading of the correct Template Volume
if sexLabel == 0: # Male patient
if 0 <= ageLabel <= 1:
VolumePath = os.path.join(ModuleDir, 'Templates', 'M_M7.nrrd')
slicer.util.loadVolume(VolumePath)
volume_nodes = slicer.mrmlScene.GetNodesByClass('vtkMRMLVolumeNode')
volume_nodes.UnRegister(slicer.mrmlScene)
volume_nodes.InitTraversal()
volume_node = volume_nodes.GetNextItemAsObject()
while volume_node:
if 'M_M7' in volume_node.GetName():
VolumeNode = volume_node
break
volume_node = volume_nodes.GetNextItemAsObject()
elif 1 < ageLabel <= 3:
VolumePath = os.path.join(ModuleDir, 'Templates', 'M_Y2.nrrd')
slicer.util.loadVolume(VolumePath)
volume_nodes = slicer.mrmlScene.GetNodesByClass('vtkMRMLVolumeNode')
volume_nodes.UnRegister(slicer.mrmlScene)
volume_nodes.InitTraversal()
volume_node = volume_nodes.GetNextItemAsObject()
while volume_node:
if 'M_Y2' in volume_node.GetName():
VolumeNode = volume_node
break
volume_node = volume_nodes.GetNextItemAsObject()
elif 3 < ageLabel <= 8:
VolumePath = os.path.join(ModuleDir, 'Templates', 'M_Y4.nrrd')
slicer.util.loadVolume(VolumePath)
volume_nodes = slicer.mrmlScene.GetNodesByClass('vtkMRMLVolumeNode')
volume_nodes.UnRegister(slicer.mrmlScene)
volume_nodes.InitTraversal()
volume_node = | |
import time
import os
import sys
from pathlib import Path
import numpy as nump
import pandas as panda
import uuid
import csv
import inspect
import re
import platform
import requests
import json
from datetime import datetime
from tir.technologies.core.config import ConfigLoader
from tir.technologies.core.logging_config import logger
class Log:
"""
This class is instantiated to create the log file and to append the results and failures to it.
Usage:
>>> # Instanted inside base.py:
>>> self.log = Log()
"""
def __init__(self, suite_datetime="", user="", station="", program="", program_date=("19800101"), version="", release="", database="", issue="", execution_id="", country="", folder="", test_type="TIR", config_path=""):
self.timestamp = time.strftime("%Y%m%d%H%M%S")
today = datetime.today()
self.config = ConfigLoader(config_path)
self.user = user
self.station = station
self.program = program
self.program_date = program_date
self.version = version
self.release = release
self.database = database
self.initial_time = datetime.today()
self.testcase_initial_time = datetime.today()
self.seconds = 0
self.testcase_seconds = 0
self.suite_datetime = suite_datetime
self.table_rows = []
self.test_case_log = []
self.csv_log = []
self.invalid_fields = []
self.table_rows.append(self.generate_header())
self.folder = folder
self.test_type = test_type
self.issue = self.config.issue
self.execution_id = self.config.execution_id
self.country = country
self.start_time = None
self.end_time = None
self.ct_method = ""
self.ct_number = ""
self.so_type = platform.system()
self.so_version = f"{self.so_type} {platform.release()}"
self.build_version = ""
self.lib_version = ""
self.webapp_version = ""
self.date = today.strftime('%Y%m%d')
self.hour = today.strftime('%H:%M:%S')
self.last_exec = today.strftime('%Y%m%d%H%M%S%f')[:-3]
self.hash_exec = ""
self.test_case = self.list_of_testcases()
self.finish_testcase = []
def generate_header(self):
"""
Generates the header line on the log file.
Usage:
>>> # Calling the method:
>>> self.log.generate_header()
"""
return ['Data','Usuário','Estação','Programa','Data Programa','Total CTs','Passou','Falhou', 'Segundos','Versão','Release', 'CTs Falhou', 'Banco de dados','Chamado','ID Execução','Pais', "Tipo de Teste"]
def new_line(self, result, message):
"""
Appends a new line with data on log file.
:param result: The result of the case.
:type result: bool
:param message: The message to be logged..
:type message: str
Usage:
>>> # Calling the method:
>>> self.log.new_line(True, "Success")
"""
line = []
total_cts = 1
passed = 1 if result else 0
failed = 0 if result else 1
printable_message = self.printable_message(message)
if not self.suite_datetime:
self.suite_datetime = time.strftime("%d/%m/%Y %X")
if self.get_testcase_stack() not in self.test_case_log:
line.extend([self.suite_datetime, self.user, self.station, self.program, self.program_date, total_cts, passed, failed, self.seconds, self.version, self.release, printable_message, self.database, self.issue, self.execution_id, self.country, self.test_type])
self.table_rows.append(line)
self.test_case_log.append(self.get_testcase_stack())
def save_file(self):
"""
Writes the log file to the file system.
Usage:
>>> # Calling the method:
>>> self.log.save_file()
"""
log_file = f"{self.user}_{uuid.uuid4().hex}_auto.csv"
if len(self.table_rows) > 0:
try:
if self.folder:
path = Path(self.folder, self.station+"_v6")
os.makedirs(path)
else:
path = Path("Log", self.station)
os.makedirs(path)
except OSError:
pass
if self.config.smart_test:
open("log_exec_file.txt", "w")
if ((len(self.table_rows[1:]) == len(self.test_case) and self.get_testcase_stack() not in self.csv_log) or (self.get_testcase_stack() == "setUpClass") and self.checks_empty_line()) :
with open( Path(path, log_file), mode="w", newline="", encoding="windows-1252") as csv_file:
csv_writer_header = csv.writer(csv_file, delimiter=';', quoting=csv.QUOTE_NONE)
csv_writer_header.writerow(self.table_rows[0])
csv_writer = csv.writer(csv_file, delimiter=';', quotechar='"', quoting=csv.QUOTE_NONNUMERIC)
for line in self.table_rows[1:]:
csv_writer.writerow(line)
logger().debug(f"Log file created successfully: {os.path.join(path, log_file)}")
self.csv_log.append(self.get_testcase_stack())
def set_seconds(self, initial_time):
"""
Sets the seconds variable through a calculation of current time minus the execution start time.
Usage:
>>> # Calling the method:
>>> self.log.set_seconds()
"""
delta = datetime.today() - initial_time
return round(delta.total_seconds(), 2)
def list_of_testcases(self):
"""
Returns a list of test cases from suite
"""
runner = next(iter(list(filter(lambda x: "runner.py" in x.filename, inspect.stack()))), None)
if runner:
try:
return list(filter(lambda x: x is not None, list(runner.frame.f_locals['test']._tests)))
except KeyError:
return []
else:
return []
def get_testcase_stack(self):
"""
Returns a string with the current testcase name
[Internal]
"""
return next(iter(list(map(lambda x: x.function, filter(lambda x: re.search('setUpClass', x.function) or re.search('test_', x.function), inspect.stack())))), None)
def checks_empty_line(self):
"""
Checks if the log file is not empty.
03 - 'Programa' 10 - 'Release' 14 - 'ID Execução' 15 - 'Pais'
[Internal]
"""
table_rows_has_line = False
if self.table_rows[1][3] == '':
self.table_rows[1][3] = 'NO PROGRAM'
if self.table_rows[1][10] == '':
self.table_rows[1][10] = '12.1.27'
if self.table_rows[1][15] == '':
self.table_rows[1][15] = 'BRA'
if self.table_rows[1][11] == '':
self.table_rows[1][11] = 'TIMEOUT'
if len(self.table_rows) > 1:
for x in [ 3, 10, 15 ]:
if (self.table_rows[1][x]):
table_rows_has_line = True
else:
table_rows_has_line = False
break
if self.config.smart_test and self.table_rows[1][14] and table_rows_has_line:
table_rows_has_line = True
elif self.config.smart_test:
table_rows_has_line = False
return table_rows_has_line
def generate_result(self, result, message):
"""
Generate a result of testcase and export to a json.
:param result: The result of the case.
:type result: bool
:param message: The message to be logged..
:type message: str
Usage:
>>> # Calling the method:
>>> self.log.generate_result(True, "Success")
"""
printable_message = self.printable_message(message)
if not self.suite_datetime:
self.suite_datetime = time.strftime("%d/%m/%Y %X")
self.generate_json(self.generate_dict(result, printable_message))
def get_file_name(self, file_name):
"""
Returns a Testsuite name
"""
testsuite_stack = next(iter(list(filter(lambda x: file_name in x.filename.lower(), inspect.stack()))), None)
if testsuite_stack:
if '/' in testsuite_stack.filename:
split_character = '/'
else:
split_character = '\\'
return testsuite_stack.filename.split(split_character)[-1].split(".")[0]
else:
return ""
def generate_dict(self, result, message):
"""
Returns a dictionary with the log information
"""
log_version = "20200814"
dict_key = {
"APPVERSION": self.build_version,
"CLIVERSION": self.webapp_version,
"COUNTRY": self.country,
"CTMETHOD": self.ct_method,
"CTNUMBER": self.ct_number,
"DBACCESS": "",
"DBTYPE": self.database,
"DBVERSION": "",
"EXECDATE": self.date,
"EXECTIME": self.hour,
"FAIL": 0 if result else 1,
"FAILMSG": message,
"IDENTI": self.issue,
"IDEXEC": self.config.execution_id,
"LASTEXEC": self.last_exec,
"LIBVERSION": self.lib_version,
"OBSERV": "",
"PASS": 1 if result else 0,
"PROGDATE": self.program_date,
"PROGRAM": self.program,
"PROGTIME": "00:00:00",
"RELEASE": self.release,
"SECONDSCT": self.testcase_seconds,
"SOTYPE": self.so_type,
"SOVERSION": self.so_version,
"STATION": self.station,
"STATUS": "", # ???
"TESTCASE": self.get_file_name('testcase'),
"TESTSUITE": self.get_file_name('testsuite'),
"TESTTYPE": "1",
"TOKEN": "TI<PASSWORD>", # ???
"TOOL": self.test_type,
"USRNAME": self.user,
"VERSION": self.version
}
return dict_key
def generate_json(self, dictionary):
"""
"""
server_address1 = self.config.logurl1
server_address2 = self.config.logurl2
success = False
data = dictionary
json_data = json.dumps(data)
endtime = time.time() + 120
while (time.time() < endtime and not success):
success = self.send_request(server_address1, json_data)
if not success:
success = self.send_request(server_address2, json_data)
time.sleep(10)
if not success:
self.save_json_file(json_data)
def send_request(self, server_address, json_data):
"""
Send a post request to server
"""
success = False
response = None
headers = {'content-type': 'application/json'}
try:
response = requests.post(server_address.strip(), data=json_data, headers=headers)
except:
pass
if response is not None:
if response.status_code == 200:
logger().debug("Log de execucao enviado com sucesso!")
success = True
elif response.status_code == 201 or response.status_code == 204:
logger().debug("Log de execucao enviado com sucesso!")
success = True
else:
self.save_response_log(response, server_address, json_data)
return False
else:
return False
return success
def save_response_log(self, response, server_address, json_data):
"""
"""
today = datetime.today()
try:
path = Path(self.folder, "new_log", self.station)
os.makedirs(path)
except OSError:
pass
try:
with open( Path(path, "response_log.csv"), mode="a", encoding="utf-8", newline='') as response_log:
csv_write = csv.writer(response_log, delimiter=';', quotechar='"', quoting=csv.QUOTE_MINIMAL)
csv_write.writerow([f"Time: {today.strftime('%Y%m%d%H%M%S%f')[:-3]}", f"URL: {server_address}", f"CT: {json.loads(json_data)['CTMETHOD']}",
{f"Status Code: {response.status_code}"}, f"Message: {response.text}"])
except:
pass
def save_json_file(self, json_data):
"""
Writes the log file to the file system.
Usage:
>>> # Calling the method:
>>> self.log.save_json_file()
"""
try:
if self.folder:
path = Path(self.folder, "new_log", self.station)
os.makedirs(path)
else:
path = Path("Log", self.station)
os.makedirs(path)
except OSError:
pass
log_file = f"{self.user}_{uuid.uuid4().hex}.json"
if self.config.smart_test:
open("log_exec_file.txt", "w")
with open( Path(path, log_file), mode="w", encoding="utf-8") as json_file:
json_file.write(json_data)
logger().debug(f"Log file created successfully: {Path(path, log_file)}")
def ident_test(self):
"""
:return:
"""
ct_method = self.get_testcase_stack()
ct_number = ''.join(list(filter(str.isdigit, f"{ct_method.split('_')[-1]}"))) if ct_method else ""
return (ct_method, ct_number)
def take_screenshot_log(self, driver, stack_item="", test_number=""):
"""
[Internal]
Takes a screenshot and saves on the log screenshot folder defined in config.
:param driver: The selenium driver.
:type: Selenium Driver
:param stack_item: test case stack
:type: str
:param test_number: test case number
:type: str
Usage:
>>> # Calling the method:
>>> self.log.take_screenshot_log()
"""
if not stack_item:
stack_item = self.get_testcase_stack()
if stack_item == "setUpClass":
stack_item = self.get_file_name("testsuite")
if not test_number:
test_number = f"{stack_item.split('_')[-1]} -" if stack_item else ""
if not self.release:
self.release = self.config.release
testsuite = self.get_file_name("testsuite")
today = datetime.today()
if self.search_stack("log_error"):
screenshot_file = self.screenshot_file_name("error", stack_item)
elif self.search_stack("CheckResult"):
screenshot_file = self.screenshot_file_name("CheckResult_result_divergence", stack_item)
else:
screenshot_file = self.screenshot_file_name(stack_item)
if self.config.debug_log:
logger().debug(f"take_screenshot_log in:{datetime.now()}\n")
try:
if self.config.log_http:
folder_path = Path(self.config.log_http, self.config.country, self.release, self.config.issue, self.config.execution_id, testsuite)
path = Path(folder_path, screenshot_file)
os.makedirs(Path(folder_path))
else:
path = Path("Log", self.station, screenshot_file)
os.makedirs(Path("Log", self.station))
except OSError:
pass
try:
driver.save_screenshot(str(path))
logger().debug(f"Screenshot file created successfully: {path}")
except Exception as e:
logger().exception(f"Warning Log Error save_screenshot exception {str(e)}")
def screenshot_file_name(self, description="", stack_item=""):
"""
:param name:
:return:
"""
today = datetime.today()
if description:
return f"{self.user}_{today.strftime('%Y%m%d%H%M%S%f')[:-3]}_{stack_item}_{description}.png"
else:
return f"{self.user}_{today.strftime('%Y%m%d%H%M%S%f')[:-3]}_{stack_item}.png"
def printable_message(self, string):
"""
:param string:
:return:
"""
return re.sub(';', ',', ''.join(filter(lambda x: x.isprintable(), string))[:600])
def search_stack(self, function):
"""
Returns True if passed function is present in the call stack.
:param function: Name of | |
<reponame>TAGC-Brun/RAINET-RNA
import shutil
import os
from os.path import basename
from fr.tagc.rainet.core.data import DataConstants
from fr.tagc.rainet.core.data.TableStatus import TableStatus
from fr.tagc.rainet.core.execution.ExecutionStrategy import ExecutionStrategy
from fr.tagc.rainet.core.util import Constants
from fr.tagc.rainet.core.util.exception.RainetException import RainetException
from fr.tagc.rainet.core.util.log.Logger import Logger
from fr.tagc.rainet.core.util.option import OptionConstants
from fr.tagc.rainet.core.util.option.OptionManager import OptionManager
from fr.tagc.rainet.core.util.parser.FastaParser import FastaParser
from fr.tagc.rainet.core.util.parser.NetworkModuleAnnotationParser import NetworkModuleAnnotationParser
from fr.tagc.rainet.core.util.parser.NetworkModuleParser import NetworkModuleParser
from fr.tagc.rainet.core.util.parser.OboParser import OboParser
from fr.tagc.rainet.core.util.parser.TSVParser import TSVParser
from fr.tagc.rainet.core.util.sql.SQLManager import SQLManager
from fr.tagc.rainet.core.util.sql.SQLUtil import SQLUtil
from fr.tagc.rainet.core.util.time.Timer import Timer
from fr.tagc.rainet.core.util.property.PropertyManager import PropertyManager
from fr.tagc.rainet.core.util.data.DataManager import DataManager
from fr.tagc.rainet.core.data.PPINetwork import PPINetwork
from fr.tagc.rainet.core.data.PPINetworkInteraction import PPINetworkInteraction
from fr.tagc.rainet.core.data.RNA import RNA
from fr.tagc.rainet.core.data.RNACrossReference import RNACrossReference
from fr.tagc.rainet.core.data.MRNA import MRNA
from fr.tagc.rainet.core.data.LncRNA import LncRNA
from fr.tagc.rainet.core.data.OtherRNA import OtherRNA
from fr.tagc.rainet.core.data.ProteinRNAInteractionCatRAPID import ProteinRNAInteractionCatRAPID
from fr.tagc.rainet.core.data.ProteinCrossReference import ProteinCrossReference
from fr.tagc.rainet.core.data.RNATissueExpression import RNATissueExpression
from fr.tagc.rainet.core.data.Tissue import Tissue
from fr.tagc.rainet.core.data.InteractingRNA import InteractingRNA
from fr.tagc.rainet.core.data.InteractingProtein import InteractingProtein
from fr.tagc.rainet.core.data.BioplexCluster import BioplexCluster
from fr.tagc.rainet.core.data.ProteinBioplexAnnotation import ProteinBioplexAnnotation
from fr.tagc.rainet.core.data.WanCluster import WanCluster
from fr.tagc.rainet.core.data.ProteinWanAnnotation import ProteinWanAnnotation
from fr.tagc.rainet.core.data.CorumCluster import CorumCluster
from fr.tagc.rainet.core.data.ProteinCorumAnnotation import ProteinCorumAnnotation
from fr.tagc.rainet.core.data.CustomCluster import CustomCluster
from fr.tagc.rainet.core.data.ProteinCustomAnnotation import ProteinCustomAnnotation
# #
# This class define the Strategy executing insertion of the various data in database
class InsertionStrategy( ExecutionStrategy ):
# #
# The Strategy execution method
def execute( self ):
self.DBPath = OptionManager.get_instance().get_option( OptionConstants.OPTION_DB_NAME )
self.forceOverride = OptionManager.get_instance().get_option( OptionConstants.OPTION_INSERTION_FORCE_OVERRIDE )
self.insert_data()
# #
# Insert the various data to the Database using file defined in the configuration file
#
def insert_data( self):
# Create Logger instance by using the first log action.
Logger.get_instance().info( "InsertionStrategy.insert_data: Starting..." )
# # Backup the database file
# try:
# Logger.get_instance().info( "InsertionStrategy.insert_data: Backuping DB file..." )
# shutil.copyfile(self.DBPath, self.DBPath + ".back")
# except IOError as ioe:
# Logger.get_instance().info( " warning : Unable to backup database file : " + self.DBPath + " : " + str( ioe))
# Create database sqlite file at the provided path
SQLManager.get_instance().build_database( self.DBPath, self.forceOverride )
self.check_database_tables()
# Retrieve the inertion properties
PropertyManager.get_instance().read_properties( OptionManager.get_instance().get_option( OptionConstants.OPTION_INSERTION_PROPERTIES_PATH, True))
# Start chrono
Timer.get_instance().start_chrono()
# Indicate insertion mode
if self.forceOverride:
Logger.get_instance().info( " -- MODE FORCE OVERRIDE -- " )
else:
Logger.get_instance().info( " -- MODE RESUME -- " )
#=======================================================================
# INSERTION OF DATA
#=======================================================================
try:
#===================================================================
# PROTEIN DEFINITION
#===================================================================
# Parse the protein file
input_file = PropertyManager.get_instance().get_property( DataConstants.PROTEIN_UNIPROT_DEFINITION_PROPERTY, True)
self.launch_insertion_TSV( input_file, True, DataConstants.PROTEIN_HEADERS, DataConstants.PROTEIN_CLASS, DataConstants.PROTEIN_PARAMS, None, DataConstants.PROTEIN_COMMENT_CHAR )
# Parse the protein cross references file
input_file = PropertyManager.get_instance().get_property( DataConstants.PROTEIN_CROSSREFERENCES_PROPERTY, True)
self.launch_insertion_TSV( input_file, False, DataConstants.PROTEIN_CROSS_REFERENCE_HEADERS, DataConstants.PROTEIN_CROSS_REFERENCE_CLASS, DataConstants.PROTEIN_CROSS_REFERENCE_PARAMS, None, DataConstants.PROTEIN_CROSS_REFERENCE_COMMENT_CHAR )
# Parse the protein isoform file
input_file = PropertyManager.get_instance().get_property( DataConstants.PROTEIN_ISOFORMS_PROPERTY, True)
self.launch_insertion_Fasta( input_file, DataConstants.ISOFORM_CLASS, DataConstants.ISOFORM_REGULAR_EXPRESSION, DataConstants.ISOFORM_GROUPS, DataConstants.ISOFORM_PARAMS, DataConstants.ISOFORM_PARAMS_VALUE_ALTERNATIVE, DataConstants.ISOFORM_COMMENT_CHAR )
# Parse the protein domain file of SMART DB
input_file = PropertyManager.get_instance().get_property( DataConstants.PROTEIN_DOMAIN_SMART_PROPERTY, True)
self.launch_insertion_TSV( input_file, True, DataConstants.PROTEIN_DOMAIN_HEADERS_SMART, DataConstants.PROTEIN_DOMAIN_CLASS, DataConstants.PROTEIN_DOMAIN_PARAM_SMART, DataConstants.PROTEIN_DOMAIN_VALUE_SMART, DataConstants.PROTEIN_DOMAIN_COMMENT_CHAR, "SMART" , False)
# Parse the protein domain file of PFAM DB
input_file = PropertyManager.get_instance().get_property( DataConstants.PROTEIN_DOMAIN_PFAM_PROPERTY, True)
self.launch_insertion_TSV( input_file, False, DataConstants.PROTEIN_DOMAIN_HEADERS_PFAM, DataConstants.PROTEIN_DOMAIN_CLASS, DataConstants.PROTEIN_DOMAIN_PARAM_PFAM, DataConstants.PROTEIN_DOMAIN_VALUE_PFAM, DataConstants.PROTEIN_DOMAIN_COMMENT_CHAR, "PFAM", False )
#===================================================================
# FUNCTION AND PATHWAY ANNOTATIONS
#===================================================================
# Parse the Gene Ontology file
input_file = PropertyManager.get_instance().get_property( DataConstants.GENE_ONTOLOGY_DEFINITION_PROPERTY, True)
self.launch_insertion_Obo( input_file, DataConstants.GENE_ONTOLOGY_CLASS, DataConstants.GENE_ONTOLOGY_ID_TAG, DataConstants.GENE_ONTOLOGY_NAME_TAG, DataConstants.GENE_ONTOLOGY_NAMESPACE_TAG )
# Parse the Protein Gene Ontology annotation file
input_file = PropertyManager.get_instance().get_property( DataConstants.GENE_ONTOLOGY_ANNOTATION_PROPERTY, True)
self.launch_insertion_TSV( input_file, False, DataConstants.PROTEIN_GO_ANNOTATION_HEADERS, DataConstants.PROTEIN_GO_ANNOTATION_CLASS, DataConstants.PROTEIN_GO_ANNOTATION_PARAMS, None, DataConstants.PROTEIN_GO_ANNOTATION_COMMENT_CHAR )
# Parse the KEGG pathway file
input_file = PropertyManager.get_instance().get_property( DataConstants.KEGG_PATHWAY_DEFINITION_PROPERTY, True)
self.launch_insertion_TSV( input_file, True, DataConstants.KEGG_PATHWAY_HEADERS, DataConstants.KEGG_PATHWAY_CLASS, DataConstants.KEGG_PATHWAY_PARAMS, None, DataConstants.KEGG_PATHWAY_COMMENT_CHAR )
# Parse the Protein KEGG Pathway annotation file
input_file = PropertyManager.get_instance().get_property( DataConstants.KEGG_PATHWAY_ANNOTATION_PROPERTY, True)
self.launch_insertion_TSV( input_file, True, DataConstants.KEGG_PATHWAY_ANNOTATION_HEADERS, DataConstants.KEGG_PATHWAY_ANNOTATION_CLASS, DataConstants.KEGG_PATHWAY_ANNOTATION_PARAMS, None, DataConstants.KEGG_PATHWAY_ANNOTATION_COMMENT_CHAR )
#===================================================================
# REACTOME
#===================================================================
# Parse the Reactome pathway file
input_file = PropertyManager.get_instance().get_property( DataConstants.REACTOME_PATHWAY_DEFINITION_PROPERTY, True)
self.launch_insertion_TSV( input_file, False, DataConstants.REACTOME_PATHWAY_HEADERS, DataConstants.REACTOME_PATHWAY_CLASS, DataConstants.REACTOME_PATHWAY_PARAMS, None, DataConstants.REACTOME_PATHWAY_COMMENT_CHAR )
# Parse the Protein Reactome Pathway annotation file
input_file = PropertyManager.get_instance().get_property( DataConstants.REACTOME_PATHWAY_ANNOTATION_PROPERTY, True)
self.launch_insertion_TSV( input_file, False, DataConstants.REACTOME_PATHWAY_ANNOTATION_HEADERS, DataConstants.REACTOME_PATHWAY_ANNOTATION_CLASS, DataConstants.REACTOME_PATHWAY_ANNOTATION_PARAMS, None, DataConstants.REACTOME_PATHWAY_ANNOTATION_COMMENT_CHAR )
#===================================================================
# BIOPLEX
#===================================================================
# Parse the file listing Bioplex clusters
input_file = PropertyManager.get_instance().get_property( DataConstants.BIOPLEX_CLUSTER_DEFINITION_PROPERTY, True)
self.launch_insertion_TSV( input_file, False, DataConstants.BIOPLEX_CLUSTER_HEADERS,
DataConstants.BIOPLEX_CLUSTER_CLASS, DataConstants.BIOPLEX_CLUSTER_PARAMS,
None, DataConstants.BIOPLEX_CLUSTER_COMMENT_CHAR )
# Parse the file with Bioplex annotations
input_file = PropertyManager.get_instance().get_property( DataConstants.BIOPLEX_ANNOTATION_PROPERTY, True)
self.launch_insertion_TSV( input_file, False, DataConstants.BIOPLEX_ANNOTATION_HEADERS,
DataConstants.BIOPLEX_ANNOTATION_CLASS, DataConstants.BIOPLEX_ANNOTATION_PARAMS,
None, DataConstants.BIOPLEX_ANNOTATION_COMMENT_CHAR )
#===================================================================
# WAN CLUSTERS
#===================================================================
# Parse the file listing Wan clusters
input_file = PropertyManager.get_instance().get_property( DataConstants.WAN_CLUSTER_DEFINITION_PROPERTY, True)
self.launch_insertion_TSV( input_file, False, DataConstants.WAN_CLUSTER_HEADERS,
DataConstants.WAN_CLUSTER_CLASS, DataConstants.WAN_CLUSTER_PARAMS,
None, DataConstants.WAN_CLUSTER_COMMENT_CHAR )
# Parse the file with Wan annotations
input_file = PropertyManager.get_instance().get_property( DataConstants.WAN_ANNOTATION_PROPERTY, True)
self.launch_insertion_TSV( input_file, False, DataConstants.WAN_ANNOTATION_HEADERS,
DataConstants.WAN_ANNOTATION_CLASS, DataConstants.WAN_ANNOTATION_PARAMS,
None, DataConstants.WAN_ANNOTATION_COMMENT_CHAR )
#===================================================================
# CORUM CLUSTERS
#===================================================================
# Parse the file listing Corum clusters
input_file = PropertyManager.get_instance().get_property( DataConstants.CORUM_CLUSTER_DEFINITION_PROPERTY, True)
self.launch_insertion_TSV( input_file, False, DataConstants.CORUM_CLUSTER_HEADERS,
DataConstants.CORUM_CLUSTER_CLASS, DataConstants.CORUM_CLUSTER_PARAMS,
None, DataConstants.CORUM_CLUSTER_COMMENT_CHAR )
# Parse the file with Corum annotations
input_file = PropertyManager.get_instance().get_property( DataConstants.CORUM_ANNOTATION_PROPERTY, True)
self.launch_insertion_TSV( input_file, False, DataConstants.CORUM_ANNOTATION_HEADERS,
DataConstants.CORUM_ANNOTATION_CLASS, DataConstants.CORUM_ANNOTATION_PARAMS,
None, DataConstants.CORUM_ANNOTATION_COMMENT_CHAR )
#===================================================================
# CUSTOM CLUSTERS
#===================================================================
# Parse the file listing Custom clusters
input_file = PropertyManager.get_instance().get_property( DataConstants.CUSTOM_CLUSTER_DEFINITION_PROPERTY, True)
self.launch_insertion_TSV( input_file, False, DataConstants.CUSTOM_CLUSTER_HEADERS,
DataConstants.CUSTOM_CLUSTER_CLASS, DataConstants.CUSTOM_CLUSTER_PARAMS,
None, DataConstants.CUSTOM_CLUSTER_COMMENT_CHAR )
# Parse the file with Custom annotations
input_file = PropertyManager.get_instance().get_property( DataConstants.CUSTOM_ANNOTATION_PROPERTY, True)
self.launch_insertion_TSV( input_file, False, DataConstants.CUSTOM_ANNOTATION_HEADERS,
DataConstants.CUSTOM_ANNOTATION_CLASS, DataConstants.CUSTOM_ANNOTATION_PARAMS,
None, DataConstants.CUSTOM_ANNOTATION_COMMENT_CHAR )
#===================================================================
# INTERACTOME
#===================================================================
# Parse the protein interaction file
input_file = PropertyManager.get_instance().get_property( DataConstants.INTERACTOME_DEFINITION_PROPERTY, True)
self.launch_insertion_TSV( input_file, False, DataConstants.INTERACTOME_HEADER, DataConstants.INTERACTOME_CLASS, DataConstants.INTERACTOME_PARAMS, None, DataConstants.INTERACTOME_COMMENT_CHAR )
# Parse the protein interaction network file
input_file = PropertyManager.get_instance().get_property( DataConstants.INTERACTOME_NETWORK_DEFINITION_PROPERTY, True)
ppi_default_values = [None, None, os.path.basename( input_file)]
self.launch_insertion_TSV( input_file, False, DataConstants.INTERACTOME_NETWORK_HEADER, DataConstants.INTERACTOME_NETWORK_CLASS, DataConstants.INTERACTOME_NETWORK_PARAMS, ppi_default_values, DataConstants.INTERACTOME_NETWORK_COMMENT_CHAR )
# Parse the Network Module file
input_file = PropertyManager.get_instance().get_property( DataConstants.INTERACTOME_NETWORK_PARTITION_DEFINITION_PROPERTY, True)
self.launch_insertion_NetworkModule( input_file, DataConstants.INTERACTOME_NETWORK_PARTITION_CLASS, DataConstants.INTERACTOME_NETWORK_PARTITION_CLASS_TAG, DataConstants.INTERACTOME_NETWORK_PARTITION_COMMENT_CHAR )
# Parse the Network Module Annotation file
input_file = PropertyManager.get_instance().get_property( DataConstants.INTERACTOME_NETWORK_PARTITION_ANNOTATION_PROPERTY, True)
self.launch_insertion_NetworkModuleAnnotation( input_file, DataConstants.INTERACTOME_NETWORK_PARTITION_ANNOTATION_CLASS, DataConstants.INTERACTOME_NETWORK_PARTITION_ANNOTATION_CLASS_TAG, DataConstants.INTERACTOME_NETWORK_PARTITION_ANNOTATION_CLASS_REGEX, DataConstants.INTERACTOME_NETWORK_PARTITION_ANNOTATION_PROTEIN_TAG, DataConstants.INTERACTOME_NETWORK_PARTITION_ANNOTATION_ANNOTATION_TAG, DataConstants.INTERACTOME_NETWORK_PARTITION_COMMENT_CHAR )
# Parse the protein redundancy file
input_file = PropertyManager.get_instance().get_property( DataConstants.INTERACTOME_NETWORK_REDUNDANCY_DEFINITION_PROPERTY, True)
interactome_network_redundancy_definition_value = [None, basename( input_file), None]
self.launch_insertion_TSV( input_file, False, DataConstants.INTERACTOME_NETWORK_REDUNDANCY_DEFINITION_HEADERS, DataConstants.INTERACTOME_NETWORK_REDUNDANCY_DEFINITION_CLASS, DataConstants.INTERACTOME_NETWORK_REDUNDANCY_DEFINITION_PARAMS, interactome_network_redundancy_definition_value, DataConstants.INTERACTOME_NETWORK_REDUNDANCY_DEFINITION_COMMENT_CHAR, "Redundancy", False )
#===================================================================
# RNA DEFINITION
#===================================================================
# Make query of specific type of protein cross references to speed up insertion
DataManager.get_instance().perform_query( DataConstants.PROTEIN_ENSP_XREF_KW,
"query( ProteinCrossReference.protein_id,ProteinCrossReference.crossReferenceID ).filter(ProteinCrossReference.sourceDB == DataConstants.PROTEIN_ENSP_XREF_DB).all()")
# Convert query into a dictionary
DataManager.get_instance().query_to_dict( DataConstants.PROTEIN_ENSP_XREF_KW, 1, 0)
# Parse the RNA file
input_file = PropertyManager.get_instance().get_property( DataConstants.RNA_DEFINITION_PROPERTY, True)
self.launch_insertion_TSV( input_file, True, DataConstants.RNA_HEADERS, DataConstants.RNA_CLASS, DataConstants.RNA_PARAMS, None, DataConstants.RNA_COMMENT_CHAR )
# Parse the RNA cross references file
input_file = PropertyManager.get_instance().get_property( DataConstants.RNA_CROSS_REFERENCE_PROPERTY, True)
self.launch_insertion_TSV( input_file, False, DataConstants.RNA_CROSS_REFERENCE_HEADERS, DataConstants.RNA_CROSS_REFERENCE_CLASS, DataConstants.RNA_CROSS_REFERENCE_PARAMS, None, DataConstants.RNA_CROSS_REFERENCE_COMMENT_CHAR )
#===================================================================
# RNA TISSUE EXPRESSION
#===================================================================
# Make query of all RNA IDs to speed up insertion
DataManager.get_instance().perform_query( DataConstants.RNA_ALL_KW, "query( RNA ).all()")
# Format query into dict data structure
DataManager.get_instance().query_to_object_dict( DataConstants.RNA_ALL_KW, "transcriptID")
# Make query of all Protein IDs (uniprotAC) to speed up insertion
DataManager.get_instance().perform_query( DataConstants.PROT_ALL_KW, "query( Protein ).all()")
# Format query into dict data structure
DataManager.get_instance().query_to_object_dict( DataConstants.PROT_ALL_KW, "uniprotAC")
# Parse the RNA tissue expression file
input_file = PropertyManager.get_instance().get_property( DataConstants.RNA_TISSUE_EXPRESSION_PROPERTY, True)
self.launch_insertion_TSV( input_file, True, DataConstants.RNA_TISSUE_EXPRESSION_HEADERS, DataConstants.RNA_TISSUE_EXPRESSION_CLASS,
DataConstants.RNA_TISSUE_EXPRESSION_PARAMS, DataConstants.RNA_TISSUE_EXPRESSION_VALUE,
DataConstants.RNA_TISSUE_EXPRESSION_COMMENT_CHAR )
#===================================================================
# PROTEIN RNA INTERACTION
#===================================================================
self.forceOverride = 1
# Parse the file listing RNA with catRAPID data
input_file = PropertyManager.get_instance().get_property( DataConstants.INTERACTING_RNA_DEFINITION_PROPERTY, True)
self.launch_insertion_TSV( input_file, True, DataConstants.INTERACTING_RNA_DEFINITION_HEADERS,
DataConstants.INTERACTING_RNA_DEFINITION_CLASS, DataConstants.INTERACTING_RNA_DEFINITION_PARAMS,
None, DataConstants.INTERACTING_RNA_DEFINITION_COMMENT_CHAR )
# Parse the file listing Proteins with catRAPID data
input_file = PropertyManager.get_instance().get_property( DataConstants.INTERACTING_PROTEIN_DEFINITION_PROPERTY, True)
self.launch_insertion_TSV( input_file, True, DataConstants.INTERACTING_PROTEIN_DEFINITION_HEADERS,
DataConstants.INTERACTING_PROTEIN_DEFINITION_CLASS, DataConstants.INTERACTING_PROTEIN_DEFINITION_PARAMS,
None, DataConstants.INTERACTING_PROTEIN_DEFINITION_COMMENT_CHAR )
# Initialize data items to store missing interactions
if DataConstants.PROTEIN_RNA_INTERACTION_CATRAPID_MISSING_RNA_KW not in DataManager.get_instance().data:
DataManager.get_instance().store_data(DataConstants.PROTEIN_RNA_INTERACTION_CATRAPID_MISSING_RNA_KW,[])
if DataConstants.PROTEIN_RNA_INTERACTION_CATRAPID_MISSING_PROT_KW not in DataManager.get_instance().data:
DataManager.get_instance().store_data(DataConstants.PROTEIN_RNA_INTERACTION_CATRAPID_MISSING_PROT_KW,[])
# Parse the ProteinRNAInteractionCatRAPID file
input_file = PropertyManager.get_instance().get_property( DataConstants.PROTEIN_RNA_INTERACTION_CATRAPID_DEFINITION_PROPERTY, True)
self.launch_insertion_TSV( input_file, False, DataConstants.PROTEIN_RNA_INTERACTION_CATRAPID_HEADERS,
DataConstants.PROTEIN_RNA_INTERACTION_CATRAPID_CLASS, DataConstants.PROTEIN_RNA_INTERACTION_CATRAPID_PARAMS,
None, DataConstants.PROTEIN_RNA_INTERACTION_CATRAPID_COMMENT_CHAR )
self.forceOverride = 0
# Remove data that will no longer be used to reduce memory usage
DataManager.get_instance().delete_data(DataConstants.PROTEIN_ENSP_XREF_KW)
DataManager.get_instance().delete_data(DataConstants.RNA_ALL_KW)
DataManager.get_instance().delete_data(DataConstants.PROT_ALL_KW)
except RainetException as re:
Logger.get_instance().error( re.to_string() )
Timer.get_instance().stop_chrono( "ERROR : Data insertion FAILED" )
return
# # Report on potential missing data
# self.check_missing_data()
# Stop the chrono
Timer.get_instance().stop_chrono( "Data insertion finished" )
# #
# Insert data linked to a TSV (tab separated) file
#
# @param file_path : string - The path to the data file
# @param has_headers : boolean - Indicates if the file has a header line as first line
# @param headers : list<string> - the list of headers name
# @param class_name : string - The | |
Criteria:** Includes only relevant concepts associated with diagnoses that represent frailty. This is a grouping of ICD10CM and SNOMEDCT codes.
**Exclusion Criteria:** No exclusions.
"""
OID = '2.16.840.1.113883.3.464.1003.113.12.1074'
VALUE_SET_NAME = 'Frailty Diagnosis'
EXPANSION_VERSION = 'eCQM Update 2020-05-07'
ICD10CM = {
'L89119',
'L89139',
'L89149',
'L89159',
'L89209',
'L89309',
'L89899',
'L8990',
'M6250',
'M6281',
'M6284',
'W010XXA',
'W010XXD',
'W010XXS',
'W0110XA',
'W0110XD',
'W0110XS',
'W01110A',
'W01110D',
'W01110S',
'W01111A',
'W01111D',
'W01111S',
'W01118A',
'W01118D',
'W01118S',
'W01119A',
'W01119D',
'W01119S',
'W01190A',
'W01190D',
'W01190S',
'W01198A',
'W01198D',
'W01198S',
'W06XXXA',
'W06XXXD',
'W06XXXS',
'W07XXXA',
'W07XXXD',
'W07XXXS',
'W08XXXA',
'W08XXXD',
'W08XXXS',
'W100XXA',
'W100XXD',
'W100XXS',
'W101XXA',
'W101XXD',
'W101XXS',
'W102XXA',
'W102XXD',
'W102XXS',
'W108XXA',
'W108XXD',
'W108XXS',
'W109XXA',
'W109XXD',
'W109XXS',
'W1800XA',
'W1800XD',
'W1800XS',
'W1802XA',
'W1802XD',
'W1802XS',
'W1809XA',
'W1809XD',
'W1809XS',
'W1811XA',
'W1811XD',
'W1811XS',
'W1812XA',
'W1812XD',
'W1812XS',
'W182XXA',
'W182XXD',
'W182XXS',
'W1830XA',
'W1830XD',
'W1830XS',
'W1831XA',
'W1831XD',
'W1831XS',
'W1839XA',
'W1839XD',
'W1839XS',
'W19XXXA',
'W19XXXD',
'W19XXXS',
'Y92199',
'Z593',
'Z736',
'Z7401',
'Z7409',
'Z741',
'Z742',
'Z743',
'Z748',
'Z749',
'Z9181',
'Z9911',
'Z993',
'Z9981',
'Z9989'
}
SNOMEDCT = {
'10637031000119106',
'10637071000119109',
'10637111000119102',
'10637151000119101',
'129588001',
'138371000119104',
'162845004',
'17886000',
'20902002',
'217082002',
'217083007',
'217084001',
'217086004',
'217088003',
'217090002',
'217092005',
'217093000',
'217094006',
'217142006',
'217154006',
'217155007',
'217156008',
'217157004',
'217158009',
'217173005',
'225558004',
'225562005',
'225563000',
'242388006',
'242389003',
'242390007',
'242391006',
'242392004',
'242393009',
'242394003',
'242395002',
'242396001',
'242402009',
'242404005',
'242405006',
'242406007',
'242407003',
'242413007',
'242414001',
'242419006',
'250054005',
'269699007',
'274918000',
'274919008',
'288296009',
'33036003',
'40104005',
'414188008',
'414189000',
'414190009',
'427849003',
'428484005',
'429621003',
'44188002',
'54840006',
'56307009',
'67223001',
'699214007',
'699215008',
'699216009',
'699218005',
'715504003',
'736313002',
'74541001',
'83468000',
'8960001000004106',
'90619006',
'92341000119107'
}
class GenitalHerpes(ValueSet):
"""
**Clinical Focus:** This value set contains concepts that represent genital herpes infections.
**Data Element Scope:** This value set may use the Quality Data Model (QDM) category related to Diagnosis.
**Inclusion Criteria:** Includes only relevant concepts associated with female genital herpes infections. This is a grouping of ICD-10-CM and SNOMED CT codes.
**Exclusion Criteria:** Excludes codes that indicate male genital herpes infections.
"""
OID = '2.16.840.1.113883.3.464.1003.110.12.1049'
VALUE_SET_NAME = '<NAME>'
EXPANSION_VERSION = 'eCQM Update 2020-05-07'
ICD10CM = {
'A6000',
'A6003',
'A6004',
'A6009'
}
SNOMEDCT = {
'129670002',
'27420004',
'278068003',
'33839006',
'402888002',
'402890001',
'402894005',
'402896007',
'423391007',
'427578006',
'439912007',
'439913002',
'440714005',
'59819007'
}
class Glaucoma(ValueSet):
"""
**Clinical Focus:** This value set contains concepts that represent a diagnosis of glaucoma.
**Data Element Scope:** This value set may use the Quality Data Model (QDM) category related to Diagnosis.
**Inclusion Criteria:** Includes only relevant concepts associated with a diagnosis of glaucoma.
**Exclusion Criteria:** Excludes concepts that pertain to 'unspecified eye.'
"""
OID = '2.16.840.1.113883.3.526.3.1423'
VALUE_SET_NAME = 'Glaucoma'
EXPANSION_VERSION = 'eCQM Update 2020-05-07'
ICD10CM = {
'H4010X0',
'H4010X1',
'H4010X2',
'H4010X3',
'H4010X4',
'H401110',
'H401111',
'H401112',
'H401113',
'H401114',
'H401120',
'H401121',
'H401122',
'H401123',
'H401124',
'H401130',
'H401131',
'H401132',
'H401133',
'H401134',
'H401210',
'H401211',
'H401212',
'H401213',
'H401214',
'H401220',
'H401221',
'H401222',
'H401223',
'H401224',
'H401230',
'H401231',
'H401232',
'H401233',
'H401234',
'H401310',
'H401311',
'H401312',
'H401313',
'H401314',
'H401320',
'H401321',
'H401322',
'H401323',
'H401324',
'H401330',
'H401331',
'H401332',
'H401333',
'H401334',
'H401410',
'H401411',
'H401412',
'H401413',
'H401414',
'H401420',
'H401421',
'H401422',
'H401423',
'H401424',
'H401430',
'H401431',
'H401432',
'H401433',
'H401434',
'H40151',
'H40152',
'H40153',
'H4020X0',
'H4020X1',
'H4020X2',
'H4020X3',
'H4020X4',
'H40211',
'H40212',
'H40213',
'H402210',
'H402211',
'H402212',
'H402213',
'H402214',
'H402220',
'H402221',
'H402222',
'H402223',
'H402224',
'H402230',
'H402231',
'H402232',
'H402233',
'H402234',
'H40231',
'H40232',
'H40233',
'H40241',
'H40242',
'H40243',
'H4031X0',
'H4031X1',
'H4031X2',
'H4031X3',
'H4031X4',
'H4032X0',
'H4032X1',
'H4032X2',
'H4032X3',
'H4032X4',
'H4033X0',
'H4033X1',
'H4033X2',
'H4033X3',
'H4033X4',
'H4041X0',
'H4041X1',
'H4041X2',
'H4041X3',
'H4041X4',
'H4042X0',
'H4042X1',
'H4042X2',
'H4042X3',
'H4042X4',
'H4043X0',
'H4043X1',
'H4043X2',
'H4043X3',
'H4043X4',
'H4051X0',
'H4051X1',
'H4051X2',
'H4051X3',
'H4051X4',
'H4052X0',
'H4052X1',
'H4052X2',
'H4052X3',
'H4052X4',
'H4053X0',
'H4053X1',
'H4053X2',
'H4053X3',
'H4053X4',
'H4061X0',
'H4061X1',
'H4061X2',
'H4061X3',
'H4061X4',
'H4062X0',
'H4062X1',
'H4062X2',
'H4062X3',
'H4062X4',
'H4063X0',
'H4063X1',
'H4063X2',
'H4063X3',
'H4063X4',
'H40811',
'H40812',
'H40813',
'H40821',
'H40822',
'H40823',
'H40831',
'H40832',
'H40833',
'H4089',
'Q150'
}
SNOMEDCT = {
'10100008',
'111513000',
'111514006',
'12239301000119102',
'12239421000119101',
'12239461000119106',
'12239501000119106',
'15374009',
'15633281000119103',
'15633321000119108',
'15640441000119104',
'15673001000119103',
'15673081000119106',
'15736441000119108',
'15736481000119103',
'15736521000119103',
'15736561000119108',
'15736601000119108',
'15736641000119105',
'15736681000119100',
'15736721000119106',
'15736761000119101',
'15738841000119105',
'15738881000119100',
'15738921000119107',
'15739041000119106',
'15739081000119101',
'15739121000119104',
'15739161000119109',
'15739201000119104',
'15739241000119102',
'15739281000119107',
'15739321000119102',
'15739361000119107',
'15739401000119103',
'15739441000119101',
'15739481000119106',
'15739561000119101',
'15739641000119104',
'15739681000119109',
'15739721000119103',
'15739761000119108',
'15993671000119108',
'15993711000119107',
'15993751000119108',
'15996831000119101',
'1654001',
'19144002',
'19309007',
'193546005',
'193548006',
'193549003',
'193552006',
'193553001',
'193555008',
'193561006',
'193562004',
'204113001',
'206248004',
'21571006',
'21928008',
'232081005',
'232082003',
'232083008',
'232086000',
'232087009',
'232088004',
'232090003',
'23986001',
'24151000119106',
'267625001',
'275477002',
'27735002',
'29369005',
'30041005',
'314017009',
'314033007',
'314784002',
'32893002',
'33647009',
'336611000119109',
'336631000119104',
'342221000119104',
'342241000119105',
'34623005',
'347381000119106',
'347401000119106',
'367360002',
'37155002',
'392030001',
'392288006',
'392291006',
'392300000',
'392352004',
'404634005',
'404648005',
'415176004',
'41911000119107',
'444863008',
'45623002',
'46168003',
'50485007',
'53667005',
'55129006',
'60981000119103',
'65460003',
'66725002',
'66747002',
'66990007',
'68241007',
'698840003',
'713457002',
'715144004',
'716166002',
'721898008',
'722321001',
'722329004',
'77075001',
'787051000',
'787052007',
'84333006',
'84494001',
'89215000',
'92829008',
'95213001',
'95250000',
'95717004'
}
class GlaucomaAssociatedWithCongenitalAnomaliesDystrophiesAndSystemicSyndromes(ValueSet):
"""
**Clinical Focus:** This value set contains concepts that represent a diagnosis of glaucoma that is associated with congenital anomalies, dystrophies, and systemic syndromes.
**Data Element Scope:** This value set may use the Quality Data Model (QDM) category related to Diagnosis.
**Inclusion Criteria:** Includes only relevant concepts associated with a diagnosis of glaucoma that may be due to congenital anomalies, dystrophies, or other systemic syndromes, including trauma, or a secondary diagnosis.
**Exclusion Criteria:** Excludes concepts that pertain to 'unspecified eye.'
"""
OID = '2.16.840.1.113883.3.526.3.1461'
VALUE_SET_NAME = 'Glaucoma Associated with Congenital Anomalies, Dystrophies, and Systemic Syndromes'
EXPANSION_VERSION = 'eCQM Update 2020-05-07'
ICD10CM = {
'H4031X0',
'H4031X1',
'H4031X2',
'H4031X3',
'H4031X4',
'H4032X0',
'H4032X1',
'H4032X2',
'H4032X3',
'H4032X4',
'H4033X0',
'H4033X1',
'H4033X2',
'H4033X3',
'H4033X4',
'H4041X0',
'H4041X1',
'H4041X2',
'H4041X3',
'H4041X4',
'H4042X0',
'H4042X1',
'H4042X2',
'H4042X3',
'H4042X4',
'H4043X0',
'H4043X1',
'H4043X2',
'H4043X3',
'H4043X4',
'H4051X0',
'H4051X1',
'H4051X2',
'H4051X3',
'H4051X4',
'H4052X0',
'H4052X1',
'H4052X2',
'H4052X3',
'H4052X4',
'H4053X0',
'H4053X1',
'H4053X2',
'H4053X3',
'H4053X4',
'H40811',
'H40812',
'H40813',
'H40821',
'H40822',
'H40823',
'H40831',
'H40832',
'H40833',
'H4089',
'H409',
'H42'
}
SNOMEDCT = {
'15736561000119108',
'15736601000119108',
'15736641000119105',
'15739041000119106',
'15739081000119101',
'15739121000119104',
'15739161000119109',
'15739321000119102',
'15739361000119107',
'15739401000119103',
'15739441000119101',
'15739481000119106',
'15739561000119101',
'15739681000119109',
'15739721000119103',
'15739761000119108',
'19309007',
'193552006',
'193553001',
'193555008',
'193556009',
'193561006',
'206248004',
'232083008',
'232086000',
'29538005',
'314033007',
'32893002',
'37155002',
'392300000',
'392352004',
'404634005',
'404648005',
'418435001',
'45623002',
'46168003',
'66725002',
'66747002',
'68241007',
'84333006',
'95717004'
}
class GlomerulonephritisAndNephroticSyndrome(ValueSet):
"""
**Clinical Focus:** This value set contains concepts that represent a diagnosis of glomerulonephritis and nephrotic syndrome.
**Data Element Scope:** This value set may use the Quality Data Model (QDM) category related to Diagnosis.
**Inclusion Criteria:** Includes only relevant concepts associated with identifying patients who are diagnosed with glomerulonephritis and nephrotic syndrome.
**Exclusion Criteria:** No exclusions.
"""
OID = '2.16.840.1.113883.3.464.1003.109.12.1018'
VALUE_SET_NAME = 'Glomerulonephritis and Nephrotic Syndrome'
EXPANSION_VERSION = 'eCQM Update 2020-05-07'
ICD10CM = {
'N000',
'N001',
'N002',
'N003',
'N004',
'N005',
'N006',
'N007',
'N008',
'N009',
'N010',
'N011',
'N012',
'N013',
'N014',
'N015',
'N016',
'N017',
'N018',
'N019',
'N020',
'N021',
'N022',
'N023',
'N024',
'N025',
'N026',
'N027',
'N028',
'N029',
'N030',
'N031',
'N032',
'N033',
'N034',
'N035',
'N036',
'N037',
'N038',
'N039',
'N040',
'N041',
'N042',
'N043',
'N044',
'N045',
'N046',
'N047',
'N048',
'N049',
'N050',
'N051',
'N052',
'N053',
'N054',
'N055',
'N056',
'N057',
'N058',
'N059',
'N060',
'N061',
'N062',
'N063',
'N064',
'N065',
'N066',
'N067',
'N068',
'N069',
'N070',
'N071',
'N072',
'N073',
'N074',
'N075',
'N076',
'N077',
'N078',
'N079',
'N08',
'N140',
'N141',
'N142',
'N143',
'N144',
'N250',
'N251',
'N2581',
'N2589',
'N259',
'N261',
'N262',
'N269',
'Q600',
'Q601',
'Q602',
'Q603',
'Q604',
'Q605',
'Q606',
'Q6100',
'Q6101',
'Q6102',
'Q6111',
'Q6119',
'Q612',
'Q613',
'Q614',
'Q615',
'Q618',
'Q619'
}
ICD9CM = {
'5804',
'58081',
'58089',
'5809',
'5810',
'5811',
'5812',
'5813',
'58181',
'58189',
'5819',
'5820',
'5821',
'5822',
'5824',
'58281',
'58289',
'5829',
'5830',
'5831',
'5832',
'5834',
'5836',
'5837',
'58381',
'58389',
'5839',
'5880',
'5881',
'58881',
'58889',
'5889'
}
SNOMEDCT = {
'101711000119105',
'110996009',
'111395007',
'118951003',
'123609007',
'123610002',
'123752003',
'12491000132101',
'12511000132108',
'13335004',
'1426004',
'16726004',
'1776003',
'19351000',
'194909006',
'195353004',
'197579006',
'197580009',
'197582001',
'197584000',
'197585004',
'197589005',
'197590001',
'197591002',
'197593004',
'197594005',
'197595006',
'197596007',
'197597003',
'197598008',
'197599000',
'197600002',
'197601003',
'197603000',
'197605007',
'197607004',
'197613008',
'197616000',
'197617009',
'197618004',
'197619007',
'197626007',
'197628008',
'197629000',
'197632002',
'197661001',
'197663003',
'197664009',
'197671004',
'197679002',
'197681000',
'197682007',
'197683002',
'197684008',
'197685009',
'197686005',
'197687001',
'197688006',
'197689003',
'197690007',
'197691006',
'197692004',
'197693009',
'197694003',
'197695002',
'197696001',
'197697005',
'197707007',
'197708002',
'197709005',
'197712008',
'197713003',
'197714009',
'197715005',
'197716006',
'197717002',
'197719004',
'197720005',
'197721009',
'197722002',
'197723007',
'197724001',
'197725000',
'197738008',
'197739000',
'197769007',
'20917003',
'22702000',
'232369001',
'232460001',
'234485006',
'235000001',
'236380004',
'236381000',
'236382007',
'236383002',
'236384008',
'236385009',
'236392004',
'236393009',
'236394003',
'236395002',
'236397005',
'236398000',
'236399008',
'236400001',
'236401002',
'236402009',
'236403004',
'236404005',
'236405006',
'236407003',
'236409000',
'236410005',
'236411009',
'236412002',
'236413007',
'236414001',
'236415000',
'236416004',
'236417008',
'236418003',
'236419006',
'236422008',
'236460004',
'236461000',
'236463002',
'236479001',
'236480003',
'236508005',
'236534002',
'236535001',
'236587002',
'236588007',
'236589004',
'236590008',
'239932005',
'239935007',
'239936008',
'24790002',
'253864004',
'25821008',
'266549004',
'276585000',
'282364005',
'309426007',
'35546006',
'359694003',
'36171008',
'363234001',
'3704008',
'370494002',
'37085009',
'38046004',
'399190000',
| |
lagged_regressor_df],
axis=1,
sort=False)
if value_col in features_df_fut.columns:
# This is to remove duplicate ``value_col`` generated by building features.
# The duplicates happen during calculating extended fitted values
# when we intentionally include ``value_col``.
del features_df_fut[value_col]
features_df_fut[value_col] = 0.0
if trained_model["uncertainty_dict"] is None:
# predictions are stored to ``value_col``
pred_res = predict_ml(
fut_df=features_df_fut,
trained_model=trained_model)
fut_df = pred_res["fut_df"]
x_mat = pred_res["x_mat"]
else:
# predictions are stored to ``value_col``
# quantiles are stored to ``f"{value_col}_quantile_summary"``
pred_res = predict_ml_with_uncertainty(
fut_df=features_df_fut,
trained_model=trained_model)
fut_df = pred_res["fut_df"]
x_mat = pred_res["x_mat"]
# Makes sure to return only necessary columns
potential_forecast_cols = [time_col, value_col, f"{value_col}_quantile_summary", ERR_STD_COL]
existing_forecast_cols = [col for col in potential_forecast_cols if col in fut_df.columns]
fut_df = fut_df[existing_forecast_cols]
return {
"fut_df": fut_df,
"x_mat": x_mat}
def predict_n_no_sim(
self,
fut_time_num,
trained_model,
freq,
new_external_regressor_df=None,
time_features_ready=False,
regressors_ready=False):
"""This is the forecast function which can be used to forecast.
It accepts extra regressors (``extra_pred_cols``) originally in
``df`` via ``new_external_regressor_df``.
Parameters
----------
fut_time_num : `int`
number of needed future values
trained_model : `dict`
A fitted silverkite model which is the output of ``self.forecast``
freq : `str`
Frequency of future predictions.
Accepts any valid frequency for ``pd.date_range``.
new_external_regressor_df : `pandas.DataFrame` or None
Contains the extra regressors if specified.
time_features_ready : `bool`
Boolean to denote if time features are already given in df or not.
regressors_ready : `bool`
Boolean to denote if regressors are already added to data (``fut_df``).
Returns
-------
result: `dict`
A dictionary with following items
- "fut_df": `pandas.DataFrame`
The same as input dataframe with an added column for the response.
If value_col already appears in ``fut_df``, it will be over-written.
If ``uncertainty_dict`` is provided as input,
it will also contain a ``{value_col}_quantile_summary`` column.
- "x_mat": `pandas.DataFrame`
Design matrix of the predictive machine-learning model
"""
# creates the future time grid
dates = pd.date_range(
start=trained_model["last_date_for_fit"],
periods=fut_time_num + 1,
freq=freq)
dates = dates[dates > trained_model["last_date_for_fit"]] # drops values up to last_date_for_fit
fut_df = pd.DataFrame({trained_model["time_col"]: dates.tolist()})
return self.predict_no_sim(
fut_df=fut_df,
trained_model=trained_model,
past_df=trained_model["df"].copy(), # observed data used for training the model
new_external_regressor_df=new_external_regressor_df,
time_features_ready=time_features_ready,
regressors_ready=regressors_ready)
def simulate(
self,
fut_df,
trained_model,
past_df=None,
new_external_regressor_df=None,
include_err=True,
time_features_ready=False,
regressors_ready=False):
"""A function to simulate future series.
If the fitted model supports uncertainty e.g. via ``uncertainty_dict``,
errors are incorporated into the simulations.
Parameters
----------
fut_df : `pandas.DataFrame`
The data frame which includes the timestamps
for prediction and any regressors.
trained_model : `dict`
A fitted silverkite model which is the output of ``self.forecast``.
past_df : `pandas.DataFrame`, optional
A data frame with past values if autoregressive methods are called
via ``autoreg_dict`` parameter of ``greykite.algo.forecast.silverkite.SilverkiteForecast.py``
new_external_regressor_df: `pandas.DataFrame`, optional
Contains the regressors not already included in ``fut_df``.
include_err : `bool`
Boolean to determine if errors are to be incorporated in the simulations.
time_features_ready : `bool`
Boolean to denote if time features are already given in df or not.
regressors_ready : `bool`
Boolean to denote if regressors are already added to data (``fut_df``).
Returns
-------
result: `dict`
A dictionary with following items
- "fut_df": `pandas.DataFrame`
The same as input dataframe with an added column for the response.
If value_col already appears in ``fut_df``, it will be over-written.
If ``uncertainty_dict`` is provided as input,
it will also contain a ``{value_col}_quantile_summary`` column.
Here are the expected columns:
(1) A time column with the column name being ``trained_model["time_col"]``
(2) The predicted response in ``value_col`` column.
(3) Quantile summary response in ``f"{value_col}_quantile_summary`` column.
This column only appears if the model includes uncertainty.
(4) Error std in `ERR_STD_COL` column.
This column only appears if the model includes uncertainty.
- "x_mat": `pandas.DataFrame`
Design matrix of the predictive machine-learning model
"""
n = fut_df.shape[0]
past_df_sim = None if past_df is None else past_df.copy()
fut_df = fut_df.copy()
fut_df_sim = fut_df.copy()
time_col = trained_model["time_col"]
value_col = trained_model["value_col"]
fut_df_sim[value_col] = np.nan
fut_df_sim = fut_df_sim.astype({value_col: "float64"})
# adds the other features
if time_features_ready is not True:
fut_df = self.__build_silverkite_features(
df=fut_df,
time_col=time_col,
origin_for_time_vars=trained_model["origin_for_time_vars"],
daily_event_df_dict=trained_model["daily_event_df_dict"],
changepoint_values=trained_model["changepoint_values"],
continuous_time_col=trained_model["continuous_time_col"],
growth_func=trained_model["growth_func"],
fs_func=trained_model["fs_func"],
seasonality_changepoint_result=trained_model["seasonality_changepoint_result"],
changepoint_dates=trained_model["trend_changepoint_dates"])
if new_external_regressor_df is not None and not regressors_ready:
new_external_regressor_df = new_external_regressor_df.reset_index(
drop=True)
fut_df = pd.concat(
[fut_df, new_external_regressor_df],
axis=1,
sort=False)
x_mat_list = []
for i in range(n):
fut_df_sub = fut_df.iloc[[i]].reset_index(drop=True)
pred_res = self.predict_no_sim(
fut_df=fut_df_sub,
trained_model=trained_model,
past_df=past_df_sim,
new_external_regressor_df=None,
time_features_ready=True,
regressors_ready=True)
fut_df_sub = pred_res["fut_df"]
x_mat = pred_res["x_mat"]
x_mat_list.append(x_mat)
fut_df_sim.at[i, value_col] = fut_df_sub[value_col].values[0]
if include_err:
if ERR_STD_COL in list(fut_df_sub.columns):
scale = fut_df_sub[ERR_STD_COL].values[0]
err = np.random.normal(
loc=0.0,
scale=scale)
fut_df_sim.at[i, value_col] = (
fut_df_sub[value_col].values[0]
+ err)
else:
raise ValueError(
"Error is requested via ``include_err = True``. "
f"However the std column ({ERR_STD_COL}) "
"does not appear in the prediction")
past_df_increment = fut_df_sim[[value_col]]
if past_df_sim is None:
past_df_sim = past_df_increment
else:
past_df_sim = pd.concat(
[past_df_sim, past_df_increment],
axis=0,
sort=False)
x_mat = pd.concat(
x_mat_list,
axis=0,
ignore_index=True, # The index does not matter as we simply want to stack up the data
sort=False)
return {
"sim_df": fut_df_sim[[time_col, value_col]],
"x_mat": x_mat}
def simulate_multi(
self,
fut_df,
trained_model,
simulation_num=10,
past_df=None,
new_external_regressor_df=None,
include_err=None):
"""A function to simulate future series.
If the fitted model supports uncertainty e.g. via ``uncertainty_dict``,
errors are incorporated into the simulations.
Parameters
----------
fut_df : `pandas.DataFrame`
The data frame which includes the timestamps
for prediction and any regressors.
trained_model : `dict`
A fitted silverkite model which is the output of ``self.forecast``.
simulation_num : `int`
The number of simulated series,
(each of which have the same number of rows as ``fut_df``)
to be stacked up row-wise.
past_df : `pandas.DataFrame`, optional
A data frame with past values if autoregressive methods are called
via ``autoreg_dict`` parameter of ``greykite.algo.forecast.silverkite.SilverkiteForecast.py``.
new_external_regressor_df: `pandas.DataFrame`, optional
Contains the regressors not already included in ``fut_df``.
include_err : `bool`, optional, default None
Boolean to determine if errors are to be incorporated in the simulations.
If None, it will be set to True if uncertainty is passed to the model and
otherwise will be set to False.
Returns
-------
result: `dict`
A dictionary with follwing items
- "fut_df_sim" : `pandas.DataFrame`
Row-wise concatenation of dataframes each being the same as
input dataframe (``fut_df``) with an added column for the response
and a new column: "sim_label" to differentiate various simulations.
The row number of the returned dataframe is:
``simulation_num`` times the row number of ``fut_df``.
If ``value_col`` already appears in ``fut_df``, it will be over-written.
- "x_mat": `pandas.DataFrame`
``simulation_num`` copies of design matrix of the predictive machine-learning model
concatenated. An extra index column ("original_row_index") is also added
for aggregation when needed.
Note that the all copies will be the same except for the case where
auto-regression is utilized.
"""
if include_err is None:
include_err = trained_model["uncertainty_dict"] is not None
if trained_model["uncertainty_dict"] is None and include_err:
raise ValueError(
"`include_err=True` was passed. "
"However model does not support uncertainty. "
"To support uncertainty pass `uncertainty_dict` to the model.")
value_col = trained_model["value_col"]
fut_df = fut_df.reset_index(drop=True) # reset_index returns a copy
fut_df = self.__build_silverkite_features(
df=fut_df,
time_col=trained_model["time_col"],
origin_for_time_vars=trained_model["origin_for_time_vars"],
daily_event_df_dict=trained_model["daily_event_df_dict"],
changepoint_values=trained_model["changepoint_values"],
continuous_time_col=trained_model["continuous_time_col"],
growth_func=trained_model["growth_func"],
fs_func=trained_model["fs_func"],
seasonality_changepoint_result=trained_model["seasonality_changepoint_result"],
changepoint_dates=trained_model["trend_changepoint_dates"])
if new_external_regressor_df is not None:
new_external_regressor_df = new_external_regressor_df.reset_index(
drop=True)
fut_df = pd.concat(
[fut_df, new_external_regressor_df],
axis=1)
def one_sim_func(label):
"""Creates one simulation and labels it with ``label`` in an added
column : "sim_label"
"""
sim_res = self.simulate(
fut_df=fut_df,
trained_model=trained_model,
past_df=past_df,
new_external_regressor_df=None,
include_err=include_err,
time_features_ready=True,
regressors_ready=True)
sim_df = sim_res["sim_df"]
x_mat = sim_res["x_mat"]
sim_df["sim_label"] = label
# ``x_mat`` does not necessarily have an index column
# we keet track of the original index, to be able to aggregate
# across simulations later
x_mat["original_row_index"] = range(len(fut_df))
return {
"sim_df": sim_df,
"x_mat": x_mat}
sim_res_list = [one_sim_func(i) for i in range(simulation_num)]
sim_df_list = [sim_res_list[i]["sim_df"] for i in range(simulation_num)]
x_mat_list = [sim_res_list[i]["x_mat"] for i in range(simulation_num)]
sim_df = pd.concat(
sim_df_list,
axis=0,
ignore_index=True, # The index does not matter as we simply want to stack up the data
sort=False)
sim_df[value_col] = sim_df[value_col].astype(float)
x_mat = pd.concat(
x_mat_list,
axis=0,
ignore_index=True, # The index does not matter as we simply want to stack up the data
sort=False)
sim_df[value_col] = sim_df[value_col].astype(float)
assert len(sim_df) == len(fut_df) * simulation_num
assert len(x_mat) == len(fut_df) * simulation_num
return {
"sim_df": sim_df,
"x_mat": x_mat}
def predict_via_sim(
self,
fut_df,
trained_model,
past_df=None,
new_external_regressor_df=None,
simulation_num=10,
include_err=None):
"""Performs | |
import sys, os, random, scipy
import numpy as np
import pandas as pd
from numba.typed import List
import statsmodels.api as sm
from statsmodels.stats.multitest import multipletests
from tqdm import tqdm
from sklearn.cluster import AgglomerativeClustering
from anndata import AnnData
from .base import lr, calc_neighbours, get_spot_lrs, get_lrs_scores, get_scores
from .merge import merge
from .perm_utils import get_lr_features, get_lr_bg
# Newest method #
def perform_spot_testing(
adata: AnnData,
lr_scores: np.ndarray,
lrs: np.array,
n_pairs: int,
neighbours: List,
het_vals: np.array,
min_expr: float,
adj_method: str = "fdr_bh",
pval_adj_cutoff: float = 0.05,
verbose: bool = True,
save_bg=False,
neg_binom=False,
quantiles=(0.5, 0.75, 0.85, 0.9, 0.95, 0.97, 0.98, 0.99, 0.995, 0.9975, 0.999, 1),
):
"""Calls significant spots by creating random gene pairs with similar
expression to given LR pair; only generate background for spots
which have score for given LR.
"""
quantiles = np.array(quantiles)
lr_genes = np.unique([lr_.split("_") for lr_ in lrs])
genes = np.array([gene for gene in adata.var_names if gene not in lr_genes])
candidate_expr = adata[:, genes].to_df().values
n_genes = round(np.sqrt(n_pairs) * 2)
if len(genes) < n_genes:
print(
"Exiting since need atleast "
f"{n_genes} genes to generate {n_pairs} pairs."
)
return
if n_pairs < 100:
print(
"Exiting since n_pairs<100, need much larger number of pairs to "
"get accurate backgrounds (e.g. 1000)."
)
return
####### Quantiles to select similar gene to LRs to gen. rand-pairs #######
lr_expr = adata[:, lr_genes].to_df()
lr_feats = get_lr_features(adata, lr_expr, lrs, quantiles)
l_quants = lr_feats.loc[
lrs, [col for col in lr_feats.columns if "L_" in col]
].values
r_quants = lr_feats.loc[
lrs, [col for col in lr_feats.columns if "R_" in col]
].values
candidate_quants = np.apply_along_axis(
np.quantile, 0, candidate_expr, q=quantiles, interpolation="nearest"
)
# Ensuring consistent typing to prevent numba errors #
l_quants = l_quants.astype("<f4")
r_quants = r_quants.astype("<f4")
candidate_quants = candidate_quants.astype("<f4")
######## Background per LR, but only for spots where LR has a score ########
# Determine the indices of the spots where each LR has a score #
cols = ["n_spots", "n_spots_sig", "n_spots_sig_pval"]
lr_summary = np.zeros((lr_scores.shape[1], 3), np.int)
pvals = np.ones(lr_scores.shape, dtype=np.float64)
pvals_adj = np.ones(lr_scores.shape, dtype=np.float64)
log10pvals_adj = np.zeros(lr_scores.shape, dtype=np.float64)
lr_sig_scores = lr_scores.copy()
# If we are saving the backgrounds #
if save_bg:
adata.uns["lrs_to_bg"] = {}
adata.uns["lr_spot_indices"] = {}
with tqdm(
total=lr_scores.shape[1],
desc="Generating backgrounds & testing each LR pair...",
bar_format="{l_bar}{bar} [ time left: {remaining} ]",
disable=verbose == False,
) as pbar:
gene_bg_genes = {} # Keep track of genes which can be used to gen. rand-pairs.
spot_lr_indices = [
[] for i in range(lr_scores.shape[0])
] # tracks the lrs tested in a given spot for MHT !!!!
for lr_j in range(lr_scores.shape[1]):
lr_ = lrs[lr_j]
background, spot_indices = get_lr_bg(
adata,
neighbours,
het_vals,
min_expr,
lr_,
lr_scores[:, lr_j],
l_quants[lr_j, :],
r_quants[lr_j, :],
genes,
candidate_quants,
gene_bg_genes,
n_genes,
n_pairs,
)
if save_bg:
adata.uns["lrs_to_bg"][lr_] = background
adata.uns["lr_spot_indices"][lr_] = spot_indices
if not neg_binom: # Calculate empirical p-values per-spot
for spot_i, spot_index in enumerate(spot_indices):
n_greater = len(
np.where(background[spot_i, :] >= lr_scores[spot_index, lr_j])[
0
]
)
n_greater = n_greater if n_greater != 0 else 1 # pseudocount
pvals[spot_index, lr_j] = n_greater / background.shape[1]
spot_lr_indices[spot_index].append(lr_j)
else: # Fitting NB per LR
lr_j_scores = lr_scores[spot_indices, lr_j]
bg_ = background.ravel()
bg_wScore = np.array(list(lr_j_scores) + list(bg_))
##### 1) rounding discretisation
# First multiple to get minimum value to be one before rounding #
bg_1 = bg_wScore * (1 / min(bg_wScore[bg_wScore != 0]))
bg_1 = np.round(bg_1)
lr_j_scores_1 = bg_1[0 : len(lr_j_scores)]
bg_1 = bg_1[len(lr_j_scores) : len(bg_1)]
###### Getting the pvalue from negative binomial approach
round_pvals, _, _, _ = get_stats(
lr_j_scores_1,
bg_1,
len(bg_1),
neg_binom=True,
return_negbinom_params=False,
)
pvals[spot_indices, lr_j] = round_pvals
for spot_index in spot_indices:
spot_lr_indices[spot_index].append(lr_j)
pbar.update(1)
# MHT correction # filling in other stats #
for spot_i in range(lr_scores.shape[0]):
lr_indices = spot_lr_indices[spot_i]
if len(lr_indices) != 0:
pvals_adj[spot_i, lr_indices] = multipletests(
pvals[spot_i, lr_indices], method=adj_method
)[1]
log10pvals_adj[spot_i, :] = -np.log10(pvals_adj[spot_i, :])
# Recording per lr results for this LR #
lrs_in_spot = lr_scores[spot_i] > min_expr
sig_lrs_in_spot = pvals_adj[spot_i, :] < pval_adj_cutoff
sigpval_lrs_in_spot = pvals[spot_i, :] < pval_adj_cutoff
lr_summary[lrs_in_spot, 0] += 1
lr_summary[sig_lrs_in_spot, 1] += 1
lr_summary[sigpval_lrs_in_spot, 2] += 1
lr_sig_scores[spot_i, sig_lrs_in_spot == False] = 0
# Ordering the results according to number of significant spots per LR#
order = np.argsort(-lr_summary[:, 1])
lrs_ordered = lrs[order]
lr_summary = lr_summary[order, :]
lr_summary = pd.DataFrame(lr_summary, index=lrs_ordered, columns=cols)
lr_scores = lr_scores[:, order]
pvals = pvals[:, order]
pvals_adj = pvals_adj[:, order]
log10pvals_adj = log10pvals_adj[:, order]
lr_sig_scores = lr_sig_scores[:, order]
# Saving the results in AnnData #
if verbose:
print("\nStoring results:\n")
adata.uns["lr_summary"] = lr_summary
res_info = ["lr_scores", "p_vals", "p_adjs", "-log10(p_adjs)", "lr_sig_scores"]
mats = [lr_scores, pvals, pvals_adj, log10pvals_adj, lr_sig_scores]
for i, info_name in enumerate(res_info):
adata.obsm[info_name] = mats[i]
if verbose:
print(f"{info_name} stored in adata.obsm['{info_name}'].")
if verbose:
print(
"\nPer-spot results in adata.obsm have columns in same order as "
"rows in adata.uns['lr_summary']."
)
print("Summary of LR results in adata.uns['lr_summary'].")
# Version 2, no longer in use, see above for newest method #
def perform_perm_testing(
adata: AnnData,
lr_scores: np.ndarray,
n_pairs: int,
lrs: np.array,
lr_mid_dist: int,
verbose: float,
neighbours: List,
het_vals: np.array,
min_expr: float,
neg_binom: bool,
adj_method: str,
pval_adj_cutoff: float,
):
"""Performs the grouped permutation testing when taking the stats approach."""
if n_pairs != 0: # Perform permutation testing
# Grouping spots with similar mean expression point #
genes = get_valid_genes(adata, n_pairs)
means_ordered, genes_ordered = get_ordered(adata, genes)
ims = np.array(
[
get_median_index(
lr_.split("_")[0],
lr_.split("_")[1],
means_ordered.values,
genes_ordered,
)
for lr_ in lrs
]
).reshape(-1, 1)
if len(lrs) > 1: # Multi-LR pair mode, group LRs to generate backgrounds
clusterer = AgglomerativeClustering(
n_clusters=None,
distance_threshold=lr_mid_dist,
affinity="manhattan",
linkage="single",
)
lr_groups = clusterer.fit_predict(ims)
lr_group_set = np.unique(lr_groups)
if verbose:
print(f"{len(lr_group_set)} lr groups with similar expression levels.")
else: # Single LR pair mode, generate background for the LR.
lr_groups = np.array([0])
lr_group_set = lr_groups
res_info = ["lr_scores", "p_val", "p_adj", "-log10(p_adj)", "lr_sig_scores"]
n_, n_sigs = np.array([0] * len(lrs)), np.array([0] * len(lrs))
per_lr_results = {}
with tqdm(
total=len(lr_group_set),
desc="Generating background distributions for the LR pair groups..",
bar_format="{l_bar}{bar} [ time left: {remaining} ]",
) as pbar:
for group in lr_group_set:
# Determining common mid-point for each group #
group_bool = lr_groups == group
group_im = int(np.median(ims[group_bool, 0]))
# Calculating the background #
rand_pairs = get_rand_pairs(adata, genes, n_pairs, lrs=lrs, im=group_im)
background = get_lrs_scores(
adata,
rand_pairs,
neighbours,
het_vals,
min_expr,
filter_pairs=False,
).ravel()
total_bg = len(background)
background = background[background != 0] # Filtering for increase speed
# Getting stats for each lr in group #
group_lr_indices = np.where(group_bool)[0]
for lr_i in group_lr_indices:
lr_ = lrs[lr_i]
lr_results = pd.DataFrame(index=adata.obs_names, columns=res_info)
scores = lr_scores[:, lr_i]
stats = get_stats(
scores,
background,
total_bg,
neg_binom,
adj_method,
pval_adj_cutoff=pval_adj_cutoff,
)
full_stats = [scores] + list(stats)
for vals, colname in zip(full_stats, res_info):
lr_results[colname] = vals
n_[lr_i] = len(np.where(scores > 0)[0])
n_sigs[lr_i] = len(
np.where(lr_results["p_adj"].values < pval_adj_cutoff)[0]
)
if n_sigs[lr_i] > 0:
per_lr_results[lr_] = lr_results
pbar.update(1)
print(f"{len(per_lr_results)} LR pairs with significant interactions.")
lr_summary = pd.DataFrame(index=lrs, columns=["n_spots", "n_spots_sig"])
lr_summary["n_spots"] = n_
lr_summary["n_spots_sig"] = n_sigs
lr_summary = lr_summary.iloc[np.argsort(-n_sigs)]
else: # Simply store the scores
per_lr_results = {}
lr_summary = pd.DataFrame(index=lrs, columns=["n_spots"])
for i, lr_ in enumerate(lrs):
lr_results = pd.DataFrame(index=adata.obs_names, columns=["lr_scores"])
lr_results["lr_scores"] = lr_scores[:, i]
per_lr_results[lr_] = lr_results
lr_summary.loc[lr_, "n_spots"] = len(np.where(lr_scores[:, i] > 0)[0])
lr_summary = lr_summary.iloc[np.argsort(-lr_summary.values[:, 0]), :]
adata.uns["lr_summary"] = lr_summary
adata.uns["per_lr_results"] = per_lr_results
if verbose:
print(
"Summary of significant spots for each lr pair in adata.uns['lr_summary']."
)
print(
"Spot enrichment statistics of LR interactions in adata.uns['per_lr_results']"
)
# No longer in use #
def permutation(
adata: AnnData,
n_pairs: int = 200,
distance: int = None,
use_lr: str = "cci_lr",
use_het: str = None,
neg_binom: bool = False,
adj_method: str = "fdr",
neighbours: list = None,
run_fast: bool = True,
bg_pairs: list = None,
background: np.array = None,
**kwargs,
) -> AnnData:
"""Permutation test for merged result
Parameters
----------
adata: AnnData The data object including the cell types to count
n_pairs: int Number of gene pairs to run permutation test (default: 1000)
distance: int Distance between spots (default: 30)
use_lr: str LR cluster used for permutation test (default: 'lr_neighbours_louvain_max')
use_het: str cell type diversity counts used for permutation test (default 'het')
neg_binom: bool Whether to fit neg binomial paramaters to bg distribution for p-val est.
adj_method: str Method used by statsmodels.stats.multitest.multipletests for MHT correction.
neighbours: | |
f.read() == "hello"
@pytest.mark.datafiles(DATA_DIR)
def test_open_force_different_workspace(cli, tmpdir, datafiles):
_, project, workspace = open_workspace(cli, tmpdir, datafiles, "git", "-alpha")
# Assert the workspace dir exists
assert os.path.exists(workspace)
hello_path = os.path.join(workspace, "usr", "bin", "hello")
hello1_path = os.path.join(workspace, "usr", "bin", "hello1")
tmpdir = os.path.join(str(tmpdir), "-beta")
shutil.move(hello_path, hello1_path)
element_name2, _, workspace2 = open_workspace(cli, tmpdir, datafiles, "git", "-beta")
# Assert the workspace dir exists
assert os.path.exists(workspace2)
# Assert that workspace 1 contains the modified file
assert os.path.exists(hello1_path)
# Assert that workspace 2 contains the unmodified file
assert os.path.exists(os.path.join(workspace2, "usr", "bin", "hello"))
result = cli.run(project=project, args=["workspace", "close", element_name2])
result.assert_success()
# Now open the workspace again with --force, this should happily succeed
result = cli.run(project=project, args=["workspace", "open", "--force", "--directory", workspace, element_name2])
result.assert_success()
# Assert that the file in workspace 1 has been replaced
# With the file from workspace 2
assert os.path.exists(hello_path)
assert not os.path.exists(hello1_path)
@pytest.mark.datafiles(DATA_DIR)
def test_close(cli, tmpdir, datafiles):
element_name, project, workspace = open_workspace(cli, tmpdir, datafiles, "git")
# Close the workspace
result = cli.run(project=project, args=["workspace", "close", "--remove-dir", element_name])
result.assert_success()
# Assert the workspace dir has been deleted
assert not os.path.exists(workspace)
@pytest.mark.datafiles(DATA_DIR)
def test_close_external_after_move_project(cli, tmpdir, datafiles):
workspace_dir = os.path.join(str(tmpdir), "workspace")
project_path = os.path.join(str(tmpdir), "initial_project")
element_name, _, _ = open_workspace(cli, tmpdir, datafiles, "git", "", workspace_dir, project_path)
assert os.path.exists(workspace_dir)
moved_dir = os.path.join(str(tmpdir), "external_project")
shutil.move(project_path, moved_dir)
assert os.path.exists(moved_dir)
# Close the workspace
result = cli.run(project=moved_dir, args=["workspace", "close", "--remove-dir", element_name])
result.assert_success()
# Assert the workspace dir has been deleted
assert not os.path.exists(workspace_dir)
@pytest.mark.datafiles(DATA_DIR)
def test_close_internal_after_move_project(cli, tmpdir, datafiles):
initial_dir = os.path.join(str(tmpdir), "initial_project")
initial_workspace = os.path.join(initial_dir, "workspace")
element_name, _, _ = open_workspace(
cli, tmpdir, datafiles, "git", workspace_dir=initial_workspace, project_path=initial_dir
)
moved_dir = os.path.join(str(tmpdir), "internal_project")
shutil.move(initial_dir, moved_dir)
assert os.path.exists(moved_dir)
# Close the workspace
result = cli.run(project=moved_dir, args=["workspace", "close", "--remove-dir", element_name])
result.assert_success()
# Assert the workspace dir has been deleted
workspace = os.path.join(moved_dir, "workspace")
assert not os.path.exists(workspace)
@pytest.mark.datafiles(DATA_DIR)
def test_close_removed(cli, tmpdir, datafiles):
element_name, project, workspace = open_workspace(cli, tmpdir, datafiles, "git")
# Remove it first, closing the workspace should work
shutil.rmtree(workspace)
# Close the workspace
result = cli.run(project=project, args=["workspace", "close", element_name])
result.assert_success()
# Assert the workspace dir has been deleted
assert not os.path.exists(workspace)
@pytest.mark.datafiles(DATA_DIR)
def test_close_nonexistant_element(cli, tmpdir, datafiles):
element_name, project, workspace = open_workspace(cli, tmpdir, datafiles, "git")
element_path = os.path.join(datafiles.dirname, datafiles.basename, "elements", element_name)
# First brutally remove the element.bst file, ensuring that
# the element does not exist anymore in the project where
# we want to close the workspace.
os.remove(element_path)
# Close the workspace
result = cli.run(project=project, args=["workspace", "close", "--remove-dir", element_name])
result.assert_success()
# Assert the workspace dir has been deleted
assert not os.path.exists(workspace)
@pytest.mark.datafiles(DATA_DIR)
def test_close_multiple(cli, tmpdir, datafiles):
tmpdir_alpha = os.path.join(str(tmpdir), "alpha")
tmpdir_beta = os.path.join(str(tmpdir), "beta")
alpha, project, workspace_alpha = open_workspace(cli, tmpdir_alpha, datafiles, "git", suffix="-alpha")
beta, project, workspace_beta = open_workspace(cli, tmpdir_beta, datafiles, "git", suffix="-beta")
# Close the workspaces
result = cli.run(project=project, args=["workspace", "close", "--remove-dir", alpha, beta])
result.assert_success()
# Assert the workspace dirs have been deleted
assert not os.path.exists(workspace_alpha)
assert not os.path.exists(workspace_beta)
@pytest.mark.datafiles(DATA_DIR)
def test_close_all(cli, tmpdir, datafiles):
tmpdir_alpha = os.path.join(str(tmpdir), "alpha")
tmpdir_beta = os.path.join(str(tmpdir), "beta")
_, project, workspace_alpha = open_workspace(cli, tmpdir_alpha, datafiles, "git", suffix="-alpha")
_, project, workspace_beta = open_workspace(cli, tmpdir_beta, datafiles, "git", suffix="-beta")
# Close the workspaces
result = cli.run(project=project, args=["workspace", "close", "--remove-dir", "--all"])
result.assert_success()
# Assert the workspace dirs have been deleted
assert not os.path.exists(workspace_alpha)
assert not os.path.exists(workspace_beta)
@pytest.mark.datafiles(DATA_DIR)
def test_reset(cli, tmpdir, datafiles):
# Open the workspace
element_name, project, workspace = open_workspace(cli, tmpdir, datafiles, "git")
# Modify workspace
shutil.rmtree(os.path.join(workspace, "usr", "bin"))
os.makedirs(os.path.join(workspace, "etc"))
with open(os.path.join(workspace, "etc", "pony.conf"), "w", encoding="utf-8") as f:
f.write("PONY='pink'")
# Now reset the open workspace, this should have the
# effect of reverting our changes.
result = cli.run(project=project, args=["workspace", "reset", element_name])
result.assert_success()
assert os.path.exists(os.path.join(workspace, "usr", "bin", "hello"))
assert not os.path.exists(os.path.join(workspace, "etc", "pony.conf"))
@pytest.mark.datafiles(DATA_DIR)
def test_reset_soft(cli, tmpdir, datafiles):
# Open the workspace
element_name, project, workspace = open_workspace(cli, tmpdir, datafiles, "git")
assert cli.get_element_state(project, element_name) == "buildable"
hello_path = os.path.join(workspace, "usr", "bin", "hello")
pony_path = os.path.join(workspace, "etc", "pony.conf")
assert os.path.exists(os.path.join(workspace, "usr", "bin"))
assert os.path.exists(hello_path)
assert not os.path.exists(pony_path)
key_1 = cli.get_element_key(project, element_name)
assert key_1 != "{:?<64}".format("")
result = cli.run(project=project, args=["build", element_name])
result.assert_success()
assert cli.get_element_state(project, element_name) == "cached"
key_2 = cli.get_element_key(project, element_name)
assert key_2 != "{:?<64}".format("")
# workspace keys are not recalculated
assert key_1 == key_2
wait_for_cache_granularity()
# Modify workspace
shutil.rmtree(os.path.join(workspace, "usr", "bin"))
os.makedirs(os.path.join(workspace, "etc"))
with open(os.path.join(workspace, "etc", "pony.conf"), "w", encoding="utf-8") as f:
f.write("PONY='pink'")
assert not os.path.exists(os.path.join(workspace, "usr", "bin"))
assert os.path.exists(pony_path)
# Now soft-reset the open workspace, this should not revert the changes
result = cli.run(project=project, args=["workspace", "reset", "--soft", element_name])
result.assert_success()
# we removed this dir
assert not os.path.exists(os.path.join(workspace, "usr", "bin"))
# and added this one
assert os.path.exists(os.path.join(workspace, "etc", "pony.conf"))
assert cli.get_element_state(project, element_name) == "buildable"
key_3 = cli.get_element_key(project, element_name)
assert key_3 != "{:?<64}".format("")
assert key_1 != key_3
@pytest.mark.datafiles(DATA_DIR)
def test_reset_multiple(cli, tmpdir, datafiles):
# Open the workspaces
tmpdir_alpha = os.path.join(str(tmpdir), "alpha")
tmpdir_beta = os.path.join(str(tmpdir), "beta")
alpha, project, workspace_alpha = open_workspace(cli, tmpdir_alpha, datafiles, "git", suffix="-alpha")
beta, project, workspace_beta = open_workspace(cli, tmpdir_beta, datafiles, "git", suffix="-beta")
# Modify workspaces
shutil.rmtree(os.path.join(workspace_alpha, "usr", "bin"))
os.makedirs(os.path.join(workspace_beta, "etc"))
with open(os.path.join(workspace_beta, "etc", "pony.conf"), "w", encoding="utf-8") as f:
f.write("PONY='pink'")
# Now reset the open workspaces, this should have the
# effect of reverting our changes.
result = cli.run(project=project, args=["workspace", "reset", alpha, beta,])
result.assert_success()
assert os.path.exists(os.path.join(workspace_alpha, "usr", "bin", "hello"))
assert not os.path.exists(os.path.join(workspace_beta, "etc", "pony.conf"))
@pytest.mark.datafiles(DATA_DIR)
def test_reset_all(cli, tmpdir, datafiles):
# Open the workspaces
tmpdir_alpha = os.path.join(str(tmpdir), "alpha")
tmpdir_beta = os.path.join(str(tmpdir), "beta")
_, project, workspace_alpha = open_workspace(cli, tmpdir_alpha, datafiles, "git", suffix="-alpha")
_, project, workspace_beta = open_workspace(cli, tmpdir_beta, datafiles, "git", suffix="-beta")
# Modify workspaces
shutil.rmtree(os.path.join(workspace_alpha, "usr", "bin"))
os.makedirs(os.path.join(workspace_beta, "etc"))
with open(os.path.join(workspace_beta, "etc", "pony.conf"), "w", encoding="utf-8") as f:
f.write("PONY='pink'")
# Now reset the open workspace, this should have the
# effect of reverting our changes.
result = cli.run(project=project, args=["workspace", "reset", "--all"])
result.assert_success()
assert os.path.exists(os.path.join(workspace_alpha, "usr", "bin", "hello"))
assert not os.path.exists(os.path.join(workspace_beta, "etc", "pony.conf"))
@pytest.mark.datafiles(DATA_DIR)
def test_list(cli, tmpdir, datafiles):
element_name, project, workspace = open_workspace(cli, tmpdir, datafiles, "git")
# Now list the workspaces
result = cli.run(project=project, args=["workspace", "list"])
result.assert_success()
loaded = _yaml.load_data(result.output)
workspaces = loaded.get_sequence("workspaces")
assert len(workspaces) == 1
space = workspaces.mapping_at(0)
assert space.get_str("element") == element_name
assert space.get_str("directory") == workspace
@pytest.mark.datafiles(DATA_DIR)
@pytest.mark.parametrize("kind", repo_kinds)
@pytest.mark.parametrize("strict", [("strict"), ("non-strict")])
@pytest.mark.parametrize(
"from_workspace,guess_element",
[(False, False), (True, True), (True, False)],
ids=["project-no-guess", "workspace-guess", "workspace-no-guess"],
)
def test_build(cli, tmpdir_factory, datafiles, kind, strict, from_workspace, guess_element):
tmpdir = tmpdir_factory.mktemp(BASE_FILENAME)
element_name, project, workspace = open_workspace(cli, tmpdir, datafiles, kind, False)
checkout = os.path.join(str(tmpdir), "checkout")
args_dir = ["-C", workspace] if from_workspace else []
args_elm = [element_name] if not guess_element else []
# Modify workspace
shutil.rmtree(os.path.join(workspace, "usr", "bin"))
os.makedirs(os.path.join(workspace, "etc"))
with open(os.path.join(workspace, "etc", "pony.conf"), "w", encoding="utf-8") as f:
f.write("PONY='pink'")
# Configure strict mode
strict_mode = True
if strict != "strict":
strict_mode = False
cli.configure({"projects": {"test": {"strict": strict_mode}}})
# Build modified workspace
assert cli.get_element_state(project, element_name) == "buildable"
key_1 = cli.get_element_key(project, element_name)
assert key_1 != "{:?<64}".format("")
result = cli.run(project=project, args=args_dir + ["build", *args_elm])
result.assert_success()
assert cli.get_element_state(project, element_name) == "cached"
key_2 = cli.get_element_key(project, element_name)
assert key_2 != "{:?<64}".format("")
# workspace keys are not recalculated
assert key_1 == key_2
# Checkout the result
result = cli.run(project=project, args=args_dir + ["artifact", "checkout", "--directory", checkout, *args_elm])
result.assert_success()
# Check that the pony.conf from the modified workspace exists
filename = os.path.join(checkout, "etc", "pony.conf")
assert os.path.exists(filename)
# Check that the original /usr/bin/hello is not in the checkout
assert not os.path.exists(os.path.join(checkout, "usr", "bin", "hello"))
@pytest.mark.datafiles(DATA_DIR)
def test_buildable_no_ref(cli, tmpdir, datafiles):
project = str(datafiles)
element_name = "workspace-test-no-ref.bst"
element_path = os.path.join(project, "elements")
# Write out our test target without any source ref
repo = create_repo("git", str(tmpdir))
element = {"kind": "import", "sources": [repo.source_config()]}
_yaml.roundtrip_dump(element, os.path.join(element_path, element_name))
# Assert that this target is not buildable when no workspace is associated.
assert cli.get_element_state(project, element_name) == "no reference"
# Now open the workspace. We don't need to checkout the source though.
workspace = os.path.join(str(tmpdir), "workspace-no-ref")
os.makedirs(workspace)
args = ["workspace", "open", "--no-checkout", "--directory", workspace, element_name]
result = cli.run(project=project, args=args)
result.assert_success()
# Assert that the target is now buildable.
assert cli.get_element_state(project, element_name) == "buildable"
@pytest.mark.datafiles(DATA_DIR)
@pytest.mark.parametrize("modification", [("addfile"), ("removefile"), ("modifyfile")])
@pytest.mark.parametrize("strict", [("strict"), ("non-strict")])
def test_detect_modifications(cli, tmpdir, datafiles, modification, strict):
element_name, project, workspace = open_workspace(cli, tmpdir, datafiles, "git")
checkout = os.path.join(str(tmpdir), "checkout")
# Configure strict mode
strict_mode = True
if strict != "strict":
strict_mode = False
cli.configure({"projects": {"test": {"strict": strict_mode}}})
# Build clean workspace
assert cli.get_element_state(project, element_name) == "buildable"
key_1 = cli.get_element_key(project, element_name)
assert key_1 != "{:?<64}".format("")
result = cli.run(project=project, | |
<filename>awxkit/test/test_dependency_resolver.py
import pytest
from awxkit.utils import filter_by_class
from awxkit.utils.toposort import CircularDependencyError
from awxkit.api.mixins import has_create
class MockHasCreate(has_create.HasCreate):
connection = None
def __str__(self):
return "instance of {0.__class__.__name__} ({1})".format(self, hex(id(self)))
def __init__(self, *a, **kw):
self.cleaned = False
super(MockHasCreate, self).__init__()
def silent_cleanup(self):
self.cleaned = True
class A(MockHasCreate):
def create(self, **kw):
return self
class B(MockHasCreate):
optional_dependencies = [A]
def create(self, a=None, **kw):
self.create_and_update_dependencies(*filter_by_class((a, A)))
return self
class C(MockHasCreate):
dependencies = [A, B]
def create(self, a=A, b=B, **kw):
self.create_and_update_dependencies(b, a)
return self
class D(MockHasCreate):
dependencies = [A]
optional_dependencies = [B]
def create(self, a=A, b=None, **kw):
self.create_and_update_dependencies(*filter_by_class((a, A), (b, B)))
return self
class E(MockHasCreate):
dependencies = [D, C]
def create(self, c=C, d=D, **kw):
self.create_and_update_dependencies(d, c)
return self
class F(MockHasCreate):
dependencies = [B]
optional_dependencies = [E]
def create(self, b=B, e=None, **kw):
self.create_and_update_dependencies(*filter_by_class((b, B), (e, E)))
return self
class G(MockHasCreate):
dependencies = [D]
optional_dependencies = [F, E]
def create(self, d=D, f=None, e=None, **kw):
self.create_and_update_dependencies(*filter_by_class((d, D), (f, F), (e, E)))
return self
class H(MockHasCreate):
optional_dependencies = [E, A]
def create(self, a=None, e=None, **kw):
self.create_and_update_dependencies(*filter_by_class((a, A), (e, E)))
return self
class MultipleWordClassName(MockHasCreate):
def create(self, **kw):
return self
class AnotherMultipleWordClassName(MockHasCreate):
optional_dependencies = [MultipleWordClassName]
def create(self, multiple_word_class_name=None, **kw):
self.create_and_update_dependencies(*filter_by_class((multiple_word_class_name, MultipleWordClassName)))
return self
def test_dependency_graph_single_page():
"""confirms that `dependency_graph(Base)` will return a dependency graph
consisting of only dependencies and dependencies of dependencies (if any)
"""
desired = {}
desired[G] = set([D])
desired[D] = set([A])
desired[A] = set()
assert has_create.dependency_graph(G) == desired
def test_dependency_graph_page_with_optional():
"""confirms that `dependency_graph(Base, OptionalBase)` will return a dependency
graph consisting of only dependencies and dependencies of dependencies (if any)
with the exception that the OptionalBase and its dependencies are included as well.
"""
desired = {}
desired[G] = set([D])
desired[E] = set([D, C])
desired[C] = set([A, B])
desired[D] = set([A])
desired[B] = set()
desired[A] = set()
assert has_create.dependency_graph(G, E) == desired
def test_dependency_graph_page_with_additionals():
"""confirms that `dependency_graph(Base, AdditionalBaseOne, AdditionalBaseTwo)`
will return a dependency graph consisting of only dependencies and dependencies
of dependencies (if any) with the exception that the AdditionalBases
are treated as a dependencies of Base (when they aren't) and their dependencies
are included as well.
"""
desired = {}
desired[E] = set([D, C])
desired[D] = set([A])
desired[C] = set([A, B])
desired[F] = set([B])
desired[G] = set([D])
desired[A] = set()
desired[B] = set()
assert has_create.dependency_graph(E, F, G) == desired
def test_optional_dependency_graph_single_page():
"""confirms that has_create._optional_dependency_graph(Base) returns a complete dependency tree
including all optional_dependencies
"""
desired = {}
desired[H] = set([E, A])
desired[E] = set([D, C])
desired[D] = set([A, B])
desired[C] = set([A, B])
desired[B] = set([A])
desired[A] = set()
assert has_create.optional_dependency_graph(H) == desired
def test_optional_dependency_graph_with_additional():
"""confirms that has_create._optional_dependency_graph(Base) returns a complete dependency tree
including all optional_dependencies with the AdditionalBases treated as a dependencies
of Base (when they aren't) and their dependencies and optional_dependencies included as well.
"""
desired = {}
desired[F] = set([B, E])
desired[H] = set([E, A])
desired[E] = set([D, C])
desired[D] = set([A, B])
desired[C] = set([A, B])
desired[B] = set([A])
desired[A] = set()
assert has_create.optional_dependency_graph(F, H, A) == desired
def test_creation_order():
"""confirms that `has_create.creation_order()` returns a valid creation order in the desired list of sets format"""
dependency_graph = dict(eight=set(['seven', 'six']),
seven=set(['five']),
six=set(),
five=set(['two', 'one']),
four=set(['one']),
three=set(['two']),
two=set(['one']),
one=set())
desired = [set(['one', 'six']),
set(['two', 'four']),
set(['three', 'five']),
set(['seven']),
set(['eight'])]
assert has_create.creation_order(dependency_graph) == desired
def test_creation_order_with_loop():
"""confirms that `has_create.creation_order()` raises toposort.CircularDependencyError when evaluating
a cyclic dependency graph
"""
dependency_graph = dict(eight=set(['seven', 'six']),
seven=set(['five']),
six=set(),
five=set(['two', 'one']),
four=set(['one']),
three=set(['two']),
two=set(['one']),
one=set(['eight']))
with pytest.raises(CircularDependencyError):
assert has_create.creation_order(dependency_graph)
class One(MockHasCreate):
pass
class Two(MockHasCreate):
dependencies = [One]
class Three(MockHasCreate):
dependencies = [Two, One]
class Four(MockHasCreate):
optional_dependencies = [Two]
class Five(MockHasCreate):
dependencies = [Two]
optional_dependencies = [One]
class IsntAHasCreate(object):
pass
class Six(MockHasCreate, IsntAHasCreate):
dependencies = [Two]
class Seven(MockHasCreate):
dependencies = [IsntAHasCreate]
def test_separate_async_optionals_none_exist():
"""confirms that when creation group classes have no async optional dependencies the order is unchanged"""
order = has_create.creation_order(has_create.optional_dependency_graph(Three, Two, One))
assert has_create.separate_async_optionals(order) == order
def test_separate_async_optionals_two_exist():
"""confirms that when two creation group classes have async dependencies
the class that has shared item as a dependency occurs first in a separate creation group
"""
order = has_create.creation_order(has_create.optional_dependency_graph(Four, Three, Two))
assert has_create.separate_async_optionals(order) == [set([One]), set([Two]), set([Three]), set([Four])]
def test_separate_async_optionals_three_exist():
"""confirms that when three creation group classes have async dependencies
the class that has shared item as a dependency occurs first in a separate creation group
"""
order = has_create.creation_order(has_create.optional_dependency_graph(Five, Four, Three))
assert has_create.separate_async_optionals(order) == [set([One]), set([Two]), set([Three]),
set([Five]), set([Four])]
def test_separate_async_optionals_not_has_create():
"""confirms that when a dependency isn't a HasCreate has_create.separate_aysnc_optionals doesn't
unnecessarily move it from the initial creation group
"""
order = has_create.creation_order(has_create.optional_dependency_graph(Seven, Six))
assert has_create.separate_async_optionals(order) == [set([One, IsntAHasCreate]), set([Two, Seven]), set([Six])]
def test_page_creation_order_single_page():
"""confirms that `has_create.page_creation_order()` returns a valid creation order"""
desired = [set([A]), set([D]), set([G])]
assert has_create.page_creation_order(G) == desired
def test_page_creation_order_optionals_provided():
"""confirms that `has_create.page_creation_order()` returns a valid creation order
when optional_dependencies are included
"""
desired = [set([A]), set([B]), set([C]), set([D]), set([E]), set([H])]
assert has_create.page_creation_order(H, A, E) == desired
def test_page_creation_order_additionals_provided():
"""confirms that `has_create.page_creation_order()` returns a valid creation order
when additional pages are included
"""
desired = [set([A]), set([B]), set([D]), set([F, H]), set([G])]
assert has_create.page_creation_order(F, H, G) == desired
def test_all_instantiated_dependencies_single_page():
f = F().create()
b = f._dependency_store[B]
desired = set([b, f])
assert set(has_create.all_instantiated_dependencies(f, A, B, C, D, E, F, G, H)) == desired
def test_all_instantiated_dependencies_single_page_are_ordered():
f = F().create()
b = f._dependency_store[B]
desired = [b, f]
assert has_create.all_instantiated_dependencies(f, A, B, C, D, E, F, G, H) == desired
def test_all_instantiated_dependencies_optionals():
a = A().create()
b = B().create(a=a)
c = C().create(a=a, b=b)
d = D().create(a=a, b=b)
e = E().create(c=c, d=d)
h = H().create(a=a, e=e)
desired = set([a, b, c, d, e, h])
assert set(has_create.all_instantiated_dependencies(h, A, B, C, D, E, F, G, H)) == desired
def test_all_instantiated_dependencies_optionals_are_ordered():
a = A().create()
b = B().create(a=a)
c = C().create(a=a, b=b)
d = D().create(a=a, b=b)
e = E().create(c=c, d=d)
h = H().create(a=a, e=e)
desired = [a, b, c, d, e, h]
assert has_create.all_instantiated_dependencies(h, A, B, C, D, E, F, G, H) == desired
def test_dependency_resolution_complete():
h = H().create(a=True, e=True)
a = h._dependency_store[A]
e = h._dependency_store[E]
c = e._dependency_store[C]
d = e._dependency_store[D]
b = c._dependency_store[B]
for item in (h, a, e, d, c, b):
if item._dependency_store:
assert all(item._dependency_store.values()
), "{0} missing dependency: {0._dependency_store}".format(item)
assert a == b._dependency_store[A], "Duplicate dependency detected"
assert a == c._dependency_store[A], "Duplicate dependency detected"
assert a == d._dependency_store[A], "Duplicate dependency detected"
assert b == c._dependency_store[B], "Duplicate dependency detected"
assert b == d._dependency_store[B], "Duplicate dependency detected"
def test_ds_mapping():
h = H().create(a=True, e=True)
a = h._dependency_store[A]
e = h._dependency_store[E]
c = e._dependency_store[C]
d = e._dependency_store[D]
b = c._dependency_store[B]
assert a == h.ds.a
assert e == h.ds.e
assert c == e.ds.c
assert d == e.ds.d
assert b == c.ds.b
def test_ds_multiple_word_class_and_attribute_name():
amwcn = AnotherMultipleWordClassName().create(multiple_word_class_name=True)
mwcn = amwcn._dependency_store[MultipleWordClassName]
assert amwcn.ds.multiple_word_class_name == mwcn
def test_ds_missing_dependency():
a = A().create()
with pytest.raises(AttributeError):
a.ds.b
def test_teardown_calls_silent_cleanup():
g = G().create(f=True, e=True)
f = g._dependency_store[F]
e = g._dependency_store[E]
b = f._dependency_store[B]
d = e._dependency_store[D]
c = e._dependency_store[C]
a = c._dependency_store[A]
instances = [g, f, e, b, d, c, a]
for instance in instances:
assert not instance.cleaned
g.teardown()
for instance in instances:
assert instance.cleaned
def test_teardown_dependency_store_cleared():
g = G().create(f=True, e=True)
f = g._dependency_store[F]
e = g._dependency_store[E]
b = f._dependency_store[B]
d = e._dependency_store[D]
c = e._dependency_store[C]
a = c._dependency_store[A]
g.teardown()
assert not g._dependency_store[F]
assert not g._dependency_store[E]
assert not f._dependency_store[B]
assert not e._dependency_store[D]
assert not e._dependency_store[C]
assert not c._dependency_store[A]
def test_idempotent_teardown_dependency_store_cleared():
g = G().create(f=True, e=True)
f = g._dependency_store[F]
e = g._dependency_store[E]
b = f._dependency_store[B]
d = e._dependency_store[D]
c = e._dependency_store[C]
a = c._dependency_store[A]
for item in (g, f, e, b, d, c, a):
item.teardown()
item.teardown()
assert not g._dependency_store[F]
assert not g._dependency_store[E]
assert not f._dependency_store[B]
assert not e._dependency_store[D]
assert not e._dependency_store[C]
assert not c._dependency_store[A]
def test_teardown_ds_cleared():
g = G().create(f=True, e=True)
f = g._dependency_store[F]
e = g._dependency_store[E]
b = f._dependency_store[B]
d = e._dependency_store[D]
c = e._dependency_store[C]
a = c._dependency_store[A]
g.teardown()
for former_dep in ('f', 'e'):
with pytest.raises(AttributeError):
getattr(g.ds, former_dep)
with pytest.raises(AttributeError):
getattr(f.ds, 'b')
for former_dep in ('d', 'c'):
with pytest.raises(AttributeError):
getattr(e.ds, former_dep)
with pytest.raises(AttributeError):
getattr(c.ds, 'a')
class OneWithArgs(MockHasCreate):
def create(self, **kw):
self.kw = kw
return self
class TwoWithArgs(MockHasCreate):
dependencies = [OneWithArgs]
def create(self, one_with_args=OneWithArgs, **kw):
if not one_with_args and kw.pop('make_one_with_args', False):
one_with_args = (OneWithArgs, dict(a='a', b='b', c='c'))
self.create_and_update_dependencies(one_with_args)
self.kw = kw
return self
class ThreeWithArgs(MockHasCreate):
dependencies = [OneWithArgs]
optional_dependencies = [TwoWithArgs]
def create(self, one_with_args=OneWithArgs, two_with_args=None, **kw):
self.create_and_update_dependencies(*filter_by_class((one_with_args, OneWithArgs),
| |
The size of the image to generate in [Nx, Ny, Nz] where N is
the number of voxels in each direction. For a 2D image, use
[Nx, Ny].
radius : int
The radius of spheres (circles) in the packing.
spacing : int or List[int]
The spacing between unit cells. If the spacing is too small then
spheres may overlap. If an ``int`` is given it will be applied
in all directions, while a list of ``int`` will be interpreted
to apply along each axis.
offset : int or List[int]
The amount offset to add between sphere centers and the edges of
the image. A single ``int`` will be applied in all directions,
while a list of ``int`` will be interpreted to apply along each
axis.
smooth : bool, default=True
If ``True`` (default) the outer extremities of the sphere will
not have the little bumps on each face.
lattice : str
Specifies the type of lattice to create. Options are:
'sc'
Simple Cubic (default)
'fcc'
Face Centered Cubic
'bcc'
Body Centered Cubic
Returns
-------
image : ndarray
A boolean array with ``True`` values denoting the pore space.
Notes
-----
For 2D images, 'sc' gives a square lattice and both 'fcc' and
'bcc' give a triangular lattice.
Examples
--------
`Click here
<https://porespy.org/examples/generators/howtos/lattice_spheres.html>`_
to view online example.
"""
logger.debug(f"Generating {lattice} lattice")
shape = np.array(shape)
im = np.zeros(shape, dtype=bool)
# Parse lattice type
lattice = lattice.lower()
if im.ndim == 2:
if lattice in ['sc', 'square', 'cubic', 'simple cubic']:
lattice = 'sq'
elif lattice in ['tri', 'triangular']:
lattice = 'tri'
else:
raise Exception(f'Unrecognized mode: {lattice}')
else:
if lattice in ['sc', 'cubic', 'simple cubic']:
lattice = 'sc'
elif lattice in ['bcc', 'body centered cubic']:
lattice = 'bcc'
elif lattice in ['fcc', 'face centered cubic']:
lattice = 'fcc'
else:
raise Exception(f'Unrecognized mode: {lattice}')
# Parse offset and spacing args
if spacing is None:
spacing = 2*r
if isinstance(spacing, int):
spacing = [spacing]*im.ndim
if offset is None:
offset = r
if isinstance(offset, int):
offset = [offset]*im.ndim
if lattice == 'sq':
im[offset[0]::spacing[0],
offset[1]::spacing[1]] = True
elif lattice == 'tri':
im[offset[0]::spacing[0],
offset[1]::spacing[1]] = True
im[offset[0]+int(spacing[0]/2)::spacing[0],
offset[1]+int(spacing[1]/2)::spacing[1]] = True
elif lattice == 'sc':
im[offset[0]::spacing[0],
offset[1]::spacing[1],
offset[2]::spacing[2]] = True
elif lattice == 'bcc':
im[offset[0]::spacing[0],
offset[1]::spacing[1],
offset[2]::spacing[2]] = True
im[offset[0]+int(spacing[0]/2)::spacing[0],
offset[1]+int(spacing[1]/2)::spacing[1],
offset[2]+int(spacing[2]/2)::spacing[2]] = True
elif lattice == 'fcc':
im[offset[0]::spacing[0],
offset[1]::spacing[1],
offset[2]::spacing[2]] = True
# xy-plane
im[offset[0]+int(spacing[0]/2)::spacing[0],
offset[1]+int(spacing[1]/2)::spacing[1],
offset[2]::spacing[2]] = True
# xz-plane
im[offset[0]+int(spacing[0]/2)::spacing[0],
offset[1]::spacing[1],
offset[2]+int(spacing[2]/2)::spacing[2]] = True
# yz-plane
im[offset[0]::spacing[0],
offset[1]+int(spacing[1]/2)::spacing[1],
offset[2]+int(spacing[2]/2)::spacing[2]] = True
if smooth:
im = ~(edt(~im) < r)
else:
im = ~(edt(~im) <= r)
return im
def overlapping_spheres(shape: List[int],
r: int,
porosity: float,
maxiter: int = 10,
tol: float = 0.01):
r"""
Generate a packing of overlapping mono-disperse spheres
Parameters
----------
shape : list
The size of the image to generate in [Nx, Ny, Nz] where Ni is the
number of voxels in the i-th direction.
r : scalar
The radius of spheres in the packing.
porosity : scalar
The porosity of the final image, accurate to the given tolerance.
maxiter : int
Maximum number of iterations for the iterative algorithm that improves
the porosity of the final image to match the given value.
tol : float
Tolerance for porosity of the final image compared to the given value.
Returns
-------
image : ndarray
A boolean array with ``True`` values denoting the pore space
Notes
-----
This method can also be used to generate a dispersion of hollows by
treating ``porosity`` as solid volume fraction and inverting the
returned image.
Examples
--------
`Click here
<https://porespy.org/examples/generators/howtos/overlapping_spheres.html>`_
to view online example.
"""
shape = np.array(shape)
if np.size(shape) == 1:
shape = np.full((3, ), int(shape))
ndim = (shape != 1).sum()
s_vol = ps_disk(r).sum() if ndim == 2 else ps_ball(r).sum()
bulk_vol = np.prod(shape)
N = int(np.ceil((1 - porosity) * bulk_vol / s_vol))
im = np.random.random(size=shape)
# Helper functions for calculating porosity: phi = g(f(N))
def f(N):
return edt(im > N / bulk_vol) < r
def g(im):
r"""Returns fraction of 0s, given a binary image"""
return 1 - im.sum() / np.prod(shape)
# # Newton's method for getting image porosity match the given
# w = 1.0 # Damping factor
# dN = 5 if ndim == 2 else 25 # Perturbation
# for i in range(maxiter):
# err = g(f(N)) - porosity
# d_err = (g(f(N+dN)) - g(f(N))) / dN
# if d_err == 0:
# break
# if abs(err) <= tol:
# break
# N2 = N - int(err/d_err) # xnew = xold - f/df
# N = w * N2 + (1-w) * N
# Bisection search: N is always undershoot (bc. of overlaps)
N_low, N_high = N, 4 * N
for i in range(maxiter):
N = np.mean([N_high, N_low], dtype=int)
err = g(f(N)) - porosity
if err > 0:
N_low = N
else:
N_high = N
if abs(err) <= tol:
break
return ~f(N)
def blobs(shape: List[int], porosity: float = 0.5, blobiness: int = 1,
divs: int = 1):
"""
Generates an image containing amorphous blobs
Parameters
----------
shape : list
The size of the image to generate in [Nx, Ny, Nz] where N is the
number of voxels
porosity : float
If specified, this will threshold the image to the specified value
prior to returning. If ``None`` is specified, then the scalar
noise field is converted to a uniform distribution and returned
without thresholding.
blobiness : int or list of ints(default = 1)
Controls the morphology of the blobs. A higher number results in
a larger number of small blobs. If a list is supplied then the
blobs are anisotropic.
divs : int or array_like
The number of times to divide the image for parallel processing.
If ``1`` then parallel processing does not occur. ``2`` is
equivalent to ``[2, 2, 2]`` for a 3D image. The number of cores
used is specified in ``porespy.settings.ncores`` and defaults to
all cores.
Returns
-------
image : ndarray
A boolean array with ``True`` values denoting the pore space
See Also
--------
norm_to_uniform
Notes
-----
This function generates random noise, the applies a gaussian blur to
the noise with a sigma controlled by the blobiness argument as:
$$ np.mean(shape) / (40 * blobiness) $$
The value of 40 was chosen so that a ``blobiness`` of 1 gave a
reasonable result.
Examples
--------
`Click here
<https://porespy.org/examples/generators/howtos/blobs.html>`_
to view online example.
"""
if isinstance(shape, int):
shape = [shape]*3
if len(shape) == 1:
shape = [shape[0]]*3
shape = np.array(shape)
if isinstance(blobiness, int):
blobiness = [blobiness]*len(shape)
blobiness = np.array(blobiness)
parallel = False
if isinstance(divs, int):
divs = [divs]*len(shape)
if max(divs) > 1:
parallel = True
logger.info(f'Performing {insp.currentframe().f_code.co_name} in parallel')
sigma = np.mean(shape) / (40 * blobiness)
im = np.random.random(shape)
if parallel:
overlap = max([int(s*4) for s in sigma])
im = ps.filters.chunked_func(func=spim.gaussian_filter,
input=im, sigma=sigma,
divs=divs, overlap=overlap)
else:
im = spim.gaussian_filter(im, sigma=sigma)
im = norm_to_uniform(im, scale=[0, 1])
if porosity:
im = im < porosity
return im
def _cylinders(shape: List[int],
r: int,
ncylinders: int,
phi_max: float = 0,
theta_max: float = 90,
length: float = None,
verbose: bool = True):
r"""
Generates a binary image of overlapping cylinders.
This is a good approximation of a fibrous mat.
Parameters
----------
shape : list
The size of the image to generate in [Nx, Ny, Nz] where N is the
number of voxels. 2D images are not permitted.
r : int
The radius of the cylinders in voxels
ncylinders : int
The number of cylinders to add to the domain. Adjust this value to
control the final porosity, which is not easily specified since
cylinders overlap and intersect different fractions of the domain.
phi_max : int
A value between 0 and 90 that controls the amount that the
cylinders lie *out of* the XY plane, with 0 meaning all cylinders
lie in the XY plane, and 90 meaning that cylinders are randomly
oriented out of the plane by as much as | |
Specific pending changes are identified by subelements.
- **MasterUserPassword** *(string) --*
The pending or in-progress change of the master user password for the cluster.
- **NodeType** *(string) --*
The pending or in-progress change of the cluster's node type.
- **NumberOfNodes** *(integer) --*
The pending or in-progress change of the number of nodes in the cluster.
- **ClusterType** *(string) --*
The pending or in-progress change of the cluster type.
- **ClusterVersion** *(string) --*
The pending or in-progress change of the service version.
- **AutomatedSnapshotRetentionPeriod** *(integer) --*
The pending or in-progress change of the automated snapshot retention period.
- **ClusterIdentifier** *(string) --*
The pending or in-progress change of the new identifier for the cluster.
- **PubliclyAccessible** *(boolean) --*
The pending or in-progress change of the ability to connect to the cluster from the public network.
- **EnhancedVpcRouting** *(boolean) --*
An option that specifies whether to create the cluster with enhanced VPC routing enabled. To create a cluster that uses enhanced VPC routing, the cluster must be in a VPC. For more information, see `Enhanced VPC Routing <https://docs.aws.amazon.com/redshift/latest/mgmt/enhanced-vpc-routing.html>`__ in the Amazon Redshift Cluster Management Guide.
If this option is ``true`` , enhanced VPC routing is enabled.
Default: false
- **MaintenanceTrackName** *(string) --*
The name of the maintenance track that the cluster will change to during the next maintenance window.
- **EncryptionType** *(string) --*
The encryption type for a cluster. Possible values are: KMS and None. For the China region the possible values are None, and Legacy.
- **ClusterVersion** *(string) --*
The version ID of the Amazon Redshift engine that is running on the cluster.
- **AllowVersionUpgrade** *(boolean) --*
A boolean value that, if ``true`` , indicates that major version upgrades will be applied automatically to the cluster during the maintenance window.
- **NumberOfNodes** *(integer) --*
The number of compute nodes in the cluster.
- **PubliclyAccessible** *(boolean) --*
A boolean value that, if ``true`` , indicates that the cluster can be accessed from a public network.
- **Encrypted** *(boolean) --*
A boolean value that, if ``true`` , indicates that data in the cluster is encrypted at rest.
- **RestoreStatus** *(dict) --*
A value that describes the status of a cluster restore action. This parameter returns null if the cluster was not created by restoring a snapshot.
- **Status** *(string) --*
The status of the restore action. Returns starting, restoring, completed, or failed.
- **CurrentRestoreRateInMegaBytesPerSecond** *(float) --*
The number of megabytes per second being transferred from the backup storage. Returns the average rate for a completed backup.
- **SnapshotSizeInMegaBytes** *(integer) --*
The size of the set of snapshot data used to restore the cluster.
- **ProgressInMegaBytes** *(integer) --*
The number of megabytes that have been transferred from snapshot storage.
- **ElapsedTimeInSeconds** *(integer) --*
The amount of time an in-progress restore has been running, or the amount of time it took a completed restore to finish.
- **EstimatedTimeToCompletionInSeconds** *(integer) --*
The estimate of the time remaining before the restore will complete. Returns 0 for a completed restore.
- **DataTransferProgress** *(dict) --*
- **Status** *(string) --*
Describes the status of the cluster. While the transfer is in progress the status is ``transferringdata`` .
- **CurrentRateInMegaBytesPerSecond** *(float) --*
Describes the data transfer rate in MB's per second.
- **TotalDataInMegaBytes** *(integer) --*
Describes the total amount of data to be transfered in megabytes.
- **DataTransferredInMegaBytes** *(integer) --*
Describes the total amount of data that has been transfered in MB's.
- **EstimatedTimeToCompletionInSeconds** *(integer) --*
Describes the estimated number of seconds remaining to complete the transfer.
- **ElapsedTimeInSeconds** *(integer) --*
Describes the number of seconds that have elapsed during the data transfer.
- **HsmStatus** *(dict) --*
A value that reports whether the Amazon Redshift cluster has finished applying any hardware security module (HSM) settings changes specified in a modify cluster command.
Values: active, applying
- **HsmClientCertificateIdentifier** *(string) --*
Specifies the name of the HSM client certificate the Amazon Redshift cluster uses to retrieve the data encryption keys stored in an HSM.
- **HsmConfigurationIdentifier** *(string) --*
Specifies the name of the HSM configuration that contains the information the Amazon Redshift cluster can use to retrieve and store keys in an HSM.
- **Status** *(string) --*
Reports whether the Amazon Redshift cluster has finished applying any HSM settings changes specified in a modify cluster command.
Values: active, applying
- **ClusterSnapshotCopyStatus** *(dict) --*
A value that returns the destination region and retention period that are configured for cross-region snapshot copy.
- **DestinationRegion** *(string) --*
The destination region that snapshots are automatically copied to when cross-region snapshot copy is enabled.
- **RetentionPeriod** *(integer) --*
The number of days that automated snapshots are retained in the destination region after they are copied from a source region.
- **ManualSnapshotRetentionPeriod** *(integer) --*
The number of days that automated snapshots are retained in the destination region after they are copied from a source region. If the value is -1, the manual snapshot is retained indefinitely.
The value must be either -1 or an integer between 1 and 3,653.
- **SnapshotCopyGrantName** *(string) --*
The name of the snapshot copy grant.
- **ClusterPublicKey** *(string) --*
The public key for the cluster.
- **ClusterNodes** *(list) --*
The nodes in the cluster.
- *(dict) --*
The identifier of a node in a cluster.
- **NodeRole** *(string) --*
Whether the node is a leader node or a compute node.
- **PrivateIPAddress** *(string) --*
The private IP address of a node within a cluster.
- **PublicIPAddress** *(string) --*
The public IP address of a node within a cluster.
- **ElasticIpStatus** *(dict) --*
The status of the elastic IP (EIP) address.
- **ElasticIp** *(string) --*
The elastic IP (EIP) address for the cluster.
- **Status** *(string) --*
The status of the elastic IP (EIP) address.
- **ClusterRevisionNumber** *(string) --*
The specific revision number of the database in the cluster.
- **Tags** *(list) --*
The list of tags for the cluster.
- *(dict) --*
A tag consisting of a name/value pair for a resource.
- **Key** *(string) --*
The key, or name, for the resource tag.
- **Value** *(string) --*
The value for the resource tag.
- **KmsKeyId** *(string) --*
The AWS Key Management Service (AWS KMS) key ID of the encryption key used to encrypt data in the cluster.
- **EnhancedVpcRouting** *(boolean) --*
An option that specifies whether to create the cluster with enhanced VPC routing enabled. To create a cluster that uses enhanced VPC routing, the cluster must be in a VPC. For more information, see `Enhanced VPC Routing <https://docs.aws.amazon.com/redshift/latest/mgmt/enhanced-vpc-routing.html>`__ in the Amazon Redshift Cluster Management Guide.
If this option is ``true`` , enhanced VPC routing is enabled.
Default: false
- **IamRoles** *(list) --*
A list of AWS Identity and Access Management (IAM) roles that can be used by the cluster to access other AWS services.
- *(dict) --*
An AWS Identity and Access Management (IAM) role that can be used by the associated Amazon Redshift cluster to access other AWS services.
- **IamRoleArn** *(string) --*
The Amazon Resource Name (ARN) of the IAM role, for example, ``arn:aws:iam::123456789012:role/RedshiftCopyUnload`` .
- **ApplyStatus** *(string) --*
A value that describes the status of the IAM role's association with an Amazon Redshift cluster.
The following are possible statuses and descriptions.
* ``in-sync`` : The role is available for use by the cluster.
* ``adding`` : The role is in the process of being associated with the cluster.
* ``removing`` : The role |